diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 72348b98aa779..73b611f2031a1 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -2854,3 +2854,95 @@ 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"] 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", + }[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 71144f24dd70c..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, @@ -3003,6 +3016,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function 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 @@ -3056,6 +3070,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function client.session.get({ sessionID: sessionId }), ); const nativeSession = unwrapData("session.get", response); + yield* installPermissionRules(sessionId, threadInput.runtimePolicy); const resumedAt = yield* DateTime.now; const providerThread = { ...threadInput.providerThread, @@ -3560,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), @@ -3627,6 +3637,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }), ); const nativeSession = unwrapData("session.fork", response); + yield* installPermissionRules(nativeSession.id, forkInput.runtimePolicy); const forkedAt = yield* DateTime.now; const providerThread = makeProviderThread({ idAllocator,