From 42c8c3b5dd7a2975e8d8620ae283da79552e70de Mon Sep 17 00:00:00 2001 From: Adamulek123 Date: Sun, 4 Oct 2026 23:59:57 +0200 Subject: [PATCH 1/3] fix(server): OpenCode forks keep the selected permission mode Apply the runtime permission policy to native forks and resumed sessions before exposing them as ready. Forward an existing thread policy through ensureThread and cover policy overrides and update failures. Implemented with gpt-6.1-sol through the Codex harness. --- .../Adapters/OpenCodeAdapterV2.test.ts | 160 ++++++++++++++++++ .../Adapters/OpenCodeAdapterV2.ts | 18 ++ 2 files changed, 178 insertions(+) diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts index a53c9b20bf412..ddb50e01e428b 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.test.ts @@ -2380,6 +2380,166 @@ describe("OpenCodeAdapterV2", () => { }); }); +describe("OpenCode fork and resume permissions", () => { + const policies = [ + { + name: "session policy", + policy: undefined, + bash: "allow", + edit: "allow", + external: "allow", + }, + { + name: "supervised override", + policy: runtimePolicy("approval-required"), + bash: "ask", + edit: "ask", + external: "ask", + }, + { + name: "auto-accept edits override", + policy: runtimePolicy("auto-accept-edits"), + bash: "ask", + edit: "allow", + external: "ask", + }, + { + name: "read-only override", + policy: runtimePolicy("full-access", { + approvalPolicy: "never", + sandboxPolicy: { type: "readOnly", access: { type: "fullAccess" } }, + }), + bash: "deny", + edit: "deny", + external: "allow", + }, + ] as const; + + const operations = ["fork", "resume", "ensure"] as const; + it.effect.each( + operations.flatMap((operation) => policies.map((test) => ({ operation, ...test }))), + )("applies $name before returning from $operation", (test) => + Effect.gen(function* () { + const { operation } = test; + const nativeEvents = asyncEventStream(); + const permissions = new Map>(); + const nativeSession = (id: string) => ({ id, time: { created: 1, updated: 2 } }); + const harness = yield* makeOpenCodeRuntimeHarness(`permissions-${operation}`, "source", { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async ({ + permission, + }: { + permission: ReturnType; + }) => { + permissions.set("source", permission); + return { data: nativeSession("source") }; + }, + get: async ({ sessionID }: { sessionID: string }) => ({ + data: nativeSession(sessionID), + }), + // Native forks copy messages but leave their permission policy unset. + fork: async () => ({ data: nativeSession("target") }), + update: async (input: { + sessionID: string; + permission: ReturnType; + }) => { + permissions.set(input.sessionID, input.permission); + return { data: nativeSession(input.sessionID) }; + }, + }, + }); + const restored = { + ...harness.providerThread, + nativeThreadRef: { ...harness.providerThread.nativeThreadRef!, nativeId: "target" }, + }; + const policy = test.policy; + const result = + operation === "fork" + ? yield* harness.runtime.forkThread({ + sourceProviderThread: harness.providerThread, + targetThreadId: ThreadId.make("permission-target"), + ...(policy === undefined ? {} : { runtimePolicy: policy }), + }) + : operation === "resume" + ? yield* harness.runtime.resumeThread({ + providerThread: restored, + ...(policy === undefined ? {} : { runtimePolicy: policy }), + }) + : yield* harness.runtime.ensureThread({ + threadId: harness.threadId, + modelSelection: { + instanceId: harness.runtime.instanceId, + model: "anthropic/claude-sonnet", + options: [], + }, + existingProviderThread: restored, + runtimePolicy: policy ?? harness.policy, + }); + assert.equal(result.nativeThreadRef?.nativeId, "target"); + const installed = permissions.get("target"); + assert.isDefined(installed); + assert.equal(permissionAction(installed!, "bash"), test.bash); + assert.equal(permissionAction(installed!, "edit"), test.edit); + assert.equal(permissionAction(installed!, "external_directory"), test.external); + assert.equal(permissionAction(permissions.get("source")!, "bash"), "allow"); + }).pipe(Effect.provide(IdAllocator.layer), Effect.scoped), + ); + + it.effect.each(operations)("fails %s if the native permission update is rejected", (operation) => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + const nativeSession = (id: string) => ({ id, time: { created: 1, updated: 2 } }); + const harness = yield* makeOpenCodeRuntimeHarness( + `permissions-error-${operation}`, + "source", + { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ data: nativeSession("source") }), + get: async () => ({ data: nativeSession("target") }), + fork: async () => ({ data: nativeSession("target") }), + update: async () => { + throw new Error("Permission update rejected"); + }, + }, + }, + ); + const restored = { + ...harness.providerThread, + nativeThreadRef: { ...harness.providerThread.nativeThreadRef!, nativeId: "target" }, + }; + const effect = + operation === "fork" + ? harness.runtime.forkThread({ + sourceProviderThread: harness.providerThread, + targetThreadId: ThreadId.make("permission-target"), + }) + : operation === "resume" + ? harness.runtime.resumeThread({ providerThread: restored }) + : harness.runtime.ensureThread({ + threadId: harness.threadId, + modelSelection: { + instanceId: harness.runtime.instanceId, + model: "anthropic/claude-sonnet", + options: [], + }, + existingProviderThread: restored, + runtimePolicy: harness.policy, + }); + const error = yield* effect.pipe(Effect.flip); + assert.equal( + error._tag, + operation === "fork" + ? "ProviderAdapterForkThreadError" + : operation === "resume" + ? "ProviderAdapterResumeThreadError" + : "ProviderAdapterEnsureThreadError", + ); + }).pipe(Effect.provide(IdAllocator.layer), Effect.scoped), + ); +}); + it.effect.each([false, true])( "OpenCode rewind forks history and validates the retained boundary, invalid=%s", (invalid) => diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts index 11d6da13c7d5c..c94b605831c09 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCodeAdapterV2.ts @@ -3001,6 +3001,7 @@ export function makeOpenCodeAdapterV2( if (threadInput.existingProviderThread?.nativeThreadRef != null) { return yield* runtimeSession.resumeThread({ providerThread: threadInput.existingProviderThread, + runtimePolicy: threadInput.runtimePolicy, }); } // No title: OpenCode generates one from the first prompt only when @@ -3057,6 +3058,14 @@ export function makeOpenCodeAdapterV2( client.session.get({ sessionID: sessionId }), ); const nativeSession = unwrapData("session.get", response); + yield* sdkCall("session.update", { sessionID: sessionId }, () => + client.session.update({ + sessionID: sessionId, + permission: openCodePermissionRules( + threadInput.runtimePolicy ?? input.runtimePolicy, + ), + }), + ); const resumedAt = yield* DateTime.now; const providerThread = { ...threadInput.providerThread, @@ -3638,6 +3647,15 @@ export function makeOpenCodeAdapterV2( }), ); const nativeSession = unwrapData("session.fork", response); + // OpenCode forks history without retaining the session permission policy. + yield* sdkCall("session.update", { sessionID: nativeSession.id }, () => + client.session.update({ + sessionID: nativeSession.id, + permission: openCodePermissionRules( + forkInput.runtimePolicy ?? input.runtimePolicy, + ), + }), + ); const forkedAt = yield* DateTime.now; const providerThread = makeProviderThread({ idAllocator, From 2f0817a1a75390a3b675a6f7430ff8540723650f Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 01:38:01 +0000 Subject: [PATCH 2/3] fix(opencode): fork and resume install the selected permission policy Native session.fork copies history but leaves the permission policy unset, and resume never re-applied it. Share one helper between rewind, fork and resume so the selected runtime mode reaches every native session. Co-Authored-By: Claude Fable 5.1 --- .../src/server/adapter.test.ts | 259 +++++++----------- .../provider-opencode/src/server/adapter.ts | 39 ++- 2 files changed, 109 insertions(+), 189 deletions(-) diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 370cc49cd9c83..d9f133f072ff4 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -2788,172 +2788,6 @@ describe("OpenCodeAdapterV2", () => { }); }); -describe("OpenCode fork and resume permissions", () => { - const policies = [ - { - name: "session policy", - policy: undefined, - bash: "allow", - edit: "allow", - external: "allow", - }, - { - name: "supervised override", - policy: runtimePolicy("approval-required"), - bash: "ask", - edit: "ask", - external: "ask", - }, - { - name: "auto-accept edits override", - policy: runtimePolicy("auto-accept-edits"), - bash: "ask", - edit: "allow", - external: "ask", - }, - { - name: "read-only override", - policy: runtimePolicy("full-access", { - approvalPolicy: "never", - sandboxPolicy: { type: "readOnly", access: { type: "fullAccess" } }, - }), - bash: "deny", - edit: "deny", - external: "allow", - }, - ] as const; - - const operations = ["fork", "resume", "ensure"] as const; - it.effect.each( - operations.flatMap((operation) => policies.map((test) => ({ operation, ...test }))), - )("applies $name before returning from $operation", (test) => - Effect.gen(function* () { - const { operation } = test; - const nativeEvents = asyncEventStream(); - const permissions = new Map>(); - const nativeSession = (id: string) => ({ id, time: { created: 1, updated: 2 } }); - const harness = yield* makeOpenCodeRuntimeHarness(`permissions-${operation}`, "source", { - event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, - session: { - create: async ({ - permission, - }: { - permission: ReturnType; - }) => { - permissions.set("source", permission); - return { data: nativeSession("source") }; - }, - get: async ({ sessionID }: { sessionID: string }) => ({ - data: nativeSession(sessionID), - }), - // Native forks copy messages but leave their permission policy unset. - fork: async () => ({ data: nativeSession("target") }), - update: async (input: { - sessionID: string; - permission: ReturnType; - }) => { - permissions.set(input.sessionID, input.permission); - return { data: nativeSession(input.sessionID) }; - }, - }, - }); - const restored = { - ...harness.providerThread, - nativeThreadRef: { ...harness.providerThread.nativeThreadRef!, nativeId: "target" }, - }; - const policy = test.policy; - const result = - operation === "fork" - ? yield* harness.runtime.forkThread({ - sourceProviderThread: harness.providerThread, - targetThreadId: ThreadId.make("permission-target"), - ...(policy === undefined ? {} : { runtimePolicy: policy }), - }) - : operation === "resume" - ? yield* harness.runtime.resumeThread({ - providerThread: restored, - ...(policy === undefined ? {} : { runtimePolicy: policy }), - }) - : yield* harness.runtime.ensureThread({ - threadId: harness.threadId, - modelSelection: { - instanceId: harness.runtime.instanceId, - model: "anthropic/claude-sonnet", - options: [], - }, - existingProviderThread: restored, - runtimePolicy: policy ?? harness.policy, - }); - assert.equal(result.nativeThreadRef?.nativeId, "target"); - const installed = permissions.get("target"); - assert.isDefined(installed); - assert.equal(permissionAction(installed!, "bash"), test.bash); - assert.equal(permissionAction(installed!, "edit"), test.edit); - assert.equal(permissionAction(installed!, "external_directory"), test.external); - assert.equal(permissionAction(permissions.get("source")!, "bash"), "allow"); - }).pipe( - Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), - Effect.scoped, - ), - ); - - it.effect.each(operations)("fails %s if the native permission update is rejected", (operation) => - Effect.gen(function* () { - const nativeEvents = asyncEventStream(); - const nativeSession = (id: string) => ({ id, time: { created: 1, updated: 2 } }); - const harness = yield* makeOpenCodeRuntimeHarness( - `permissions-error-${operation}`, - "source", - { - event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, - session: { - create: async () => ({ data: nativeSession("source") }), - get: async () => ({ data: nativeSession("target") }), - fork: async () => ({ data: nativeSession("target") }), - update: async () => { - throw new Error("Permission update rejected"); - }, - }, - }, - ); - const restored = { - ...harness.providerThread, - nativeThreadRef: { ...harness.providerThread.nativeThreadRef!, nativeId: "target" }, - }; - const effect = - operation === "fork" - ? harness.runtime.forkThread({ - sourceProviderThread: harness.providerThread, - targetThreadId: ThreadId.make("permission-target"), - }) - : operation === "resume" - ? harness.runtime.resumeThread({ providerThread: restored }) - : harness.runtime.ensureThread({ - threadId: harness.threadId, - modelSelection: { - instanceId: harness.runtime.instanceId, - model: "anthropic/claude-sonnet", - options: [], - }, - existingProviderThread: restored, - runtimePolicy: harness.policy, - }); - const error = yield* effect.pipe(Effect.flip); - assert.equal( - error._tag, - operation === "fork" - ? "ProviderAdapterForkThreadError" - : operation === "resume" - ? "ProviderAdapterResumeThreadError" - : "ProviderAdapterEnsureThreadError", - ); - }).pipe( - Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), - Effect.scoped, - ), - ); -}); - it.effect.each([false, true])( "OpenCode rewind forks history and validates the retained boundary, invalid=%s", (invalid) => @@ -3020,3 +2854,96 @@ it.effect.each([false, true])( Effect.scoped, ), ); + +const runOpenCodePermissionOperation = Effect.fn("runOpenCodePermissionOperation")(function* ( + operation: "fork" | "resume" | "ensure", + explicitPolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy | undefined, + update: (input: { + sessionID: string; + permission: ReturnType; + }) => Promise, +) { + const nativeSession = (id: string) => ({ id, time: { created: 1, updated: 2 } }); + const harness = yield* makeOpenCodeRuntimeHarness(`permissions-${operation}`, "source", { + event: { subscribe: async () => ({ stream: asyncEventStream().stream }) }, + session: { + create: async () => ({ data: nativeSession("source") }), + get: async ({ sessionID }: { sessionID: string }) => ({ data: nativeSession(sessionID) }), + fork: async () => ({ data: nativeSession("target") }), + update, + }, + }); + const restored = { + ...harness.providerThread, + nativeThreadRef: { ...harness.providerThread.nativeThreadRef!, nativeId: "target" }, + }; + const policy = explicitPolicy === undefined ? {} : { runtimePolicy: explicitPolicy }; + if (operation === "fork") + return yield* harness.runtime.forkThread({ + sourceProviderThread: harness.providerThread, + targetThreadId: ThreadId.make("permission-target"), + ...policy, + }); + if (operation === "resume") + return yield* harness.runtime.resumeThread({ providerThread: restored, ...policy }); + return yield* harness.runtime.ensureThread({ + threadId: harness.threadId, + modelSelection: { + instanceId: harness.runtime.instanceId, + model: "anthropic/claude-sonnet", + options: [], + }, + existingProviderThread: restored, + runtimePolicy: explicitPolicy ?? harness.policy, + }); +}); + +it.effect.each([ + { operation: "fork", explicit: true }, + { operation: "resume", explicit: true }, + { operation: "ensure", explicit: true }, + { operation: "fork", explicit: false }, + { operation: "resume", explicit: false }, +] as const)( + "OpenCode $operation installs the selected permission policy, explicit=$explicit", + ({ operation, explicit }) => + Effect.gen(function* () { + // The harness session runs full-access, so a supervised override is distinguishable. + const expected = explicit + ? runtimePolicy("approval-required") + : runtimePolicy("full-access", { cwd: "/workspace" }); + const installed = new Map>(); + const result = yield* runOpenCodePermissionOperation( + operation, + explicit ? expected : undefined, + async ({ sessionID, permission }) => { + installed.set(sessionID, permission); + return { data: {} }; + }, + ); + assert.equal(result.nativeThreadRef?.nativeId, "target"); + assert.deepEqual(installed.get("target"), openCodePermissionRules(expected)); + }).pipe( + Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), + Effect.scoped, + ), +); + +it.effect.each(["fork", "resume", "ensure"] as const)( + "OpenCode %s fails when the native permission update is rejected", + (operation) => + Effect.gen(function* () { + const error = yield* runOpenCodePermissionOperation(operation, undefined, async () => { + throw new Error("Permission update rejected"); + }).pipe(Effect.flip); + const expectedTag = { + fork: "ProviderAdapterForkThreadError", + resume: "ProviderAdapterResumeThreadError", + ensure: "ProviderAdapterEnsureThreadError", + }[operation]; + assert.equal(error._tag, expectedTag); + }).pipe( + Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), + Effect.scoped, + ), +); diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index bae97487629f2..147af8def3c08 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -2991,6 +2991,19 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function ); }); + // Native session.fork copies history but leaves the permission policy unset, + // and a resumed session may still carry rules from an earlier selection. + const installPermissionRules = ( + sessionID: string, + runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy = input.runtimePolicy, + ) => + sdkCall("session.update", { sessionID }, () => + client.session.update({ + sessionID, + permission: openCodePermissionRules(runtimePolicy), + }), + ); + const runtimeSession: ProviderAdapter.ProviderAdapterV2SessionRuntime = { instanceId: options.instanceId, driver: OPENCODE_PROVIDER, @@ -3057,14 +3070,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function client.session.get({ sessionID: sessionId }), ); const nativeSession = unwrapData("session.get", response); - yield* sdkCall("session.update", { sessionID: sessionId }, () => - client.session.update({ - sessionID: sessionId, - permission: openCodePermissionRules( - threadInput.runtimePolicy ?? input.runtimePolicy, - ), - }), - ); + yield* installPermissionRules(sessionId, threadInput.runtimePolicy); const resumedAt = yield* DateTime.now; const providerThread = { ...threadInput.providerThread, @@ -3569,12 +3575,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function return yield* protocolError( "OpenCode did not preserve the requested rewind boundary.", ); - yield* sdkCall("session.update", { sessionID: fork.id }, () => - client.session.update({ - sessionID: fork.id, - permission: openCodePermissionRules(input.runtimePolicy), - }), - ); + yield* installPermissionRules(fork.id); retainedThread = { ...rollbackInput.providerThread, nativeThreadRef: providerRef(fork.id), @@ -3636,15 +3637,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }), ); const nativeSession = unwrapData("session.fork", response); - // OpenCode forks history without retaining the session permission policy. - yield* sdkCall("session.update", { sessionID: nativeSession.id }, () => - client.session.update({ - sessionID: nativeSession.id, - permission: openCodePermissionRules( - forkInput.runtimePolicy ?? input.runtimePolicy, - ), - }), - ); + yield* installPermissionRules(nativeSession.id, forkInput.runtimePolicy); const forkedAt = yield* DateTime.now; const providerThread = makeProviderThread({ idAllocator, From 247d17f17f944cccca904e2892b6229accb2dd8c Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 01:41:45 +0000 Subject: [PATCH 3/3] test(opencode): drop the ensure failure row that only re-proves resume Co-Authored-By: Claude Fable 5.1 --- packages/provider-opencode/src/server/adapter.test.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index d9f133f072ff4..73b611f2031a1 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -2929,7 +2929,7 @@ it.effect.each([ ), ); -it.effect.each(["fork", "resume", "ensure"] as const)( +it.effect.each(["fork", "resume"] as const)( "OpenCode %s fails when the native permission update is rejected", (operation) => Effect.gen(function* () { @@ -2939,7 +2939,6 @@ it.effect.each(["fork", "resume", "ensure"] as const)( const expectedTag = { fork: "ProviderAdapterForkThreadError", resume: "ProviderAdapterResumeThreadError", - ensure: "ProviderAdapterEnsureThreadError", }[operation]; assert.equal(error._tag, expectedTag); }).pipe(