fix(opencode): persist and reuse session cursor

apps/server/src/provider/Layers/OpenCodeAdapter.test.ts

@@ -15,6 +15,7 @@ import { beforeEach } from "vite-plus/test";
 
 import {
   OpenCodeSettings,
+  ApprovalRequestId,
   ProviderDriverKind,
   ProviderInstanceId,
   ThreadId,
@@ -54,10 +55,16 @@ const runtimeMock = {
   state: {
     startCalls: [] as string[],
     sessionCreateUrls: [] as string[],
+    sessionCreateDelay: null as Promise<void> | null,
+    sessionGetCalls: [] as string[],
+    sessionGetError: null as Error | null,
+    sessionGetDataById: new Map<string, { id: string }>(),
+    sessionGetDelay: null as Promise<void> | null,
     authHeaders: [] as Array<string | null>,
     abortCalls: [] as string[],
     closeCalls: [] as string[],
     revertCalls: [] as Array<{ sessionID: string; messageID?: string }>,
+    permissionReplyCalls: [] as Array<{ requestID: string; reply: string }>,
     promptCalls: [] as Array<unknown>,
     promptAsyncError: null as Error | null,
     closeError: null as Error | null,
@@ -67,10 +74,16 @@ const runtimeMock = {
   reset() {
     this.state.startCalls.length = 0;
     this.state.sessionCreateUrls.length = 0;
+    this.state.sessionCreateDelay = null;
+    this.state.sessionGetCalls.length = 0;
+    this.state.sessionGetError = null;
+    this.state.sessionGetDataById = new Map();
+    this.state.sessionGetDelay = null;
     this.state.authHeaders.length = 0;
     this.state.abortCalls.length = 0;
     this.state.closeCalls.length = 0;
     this.state.revertCalls.length = 0;
+    this.state.permissionReplyCalls.length = 0;
     this.state.promptCalls.length = 0;
     this.state.promptAsyncError = null;
     this.state.closeError = null;
@@ -124,11 +137,26 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = {
       session: {
         create: async () => {
           runtimeMock.state.sessionCreateUrls.push(baseUrl);
+          if (runtimeMock.state.sessionCreateDelay) {
+            await runtimeMock.state.sessionCreateDelay;
+          }
           runtimeMock.state.authHeaders.push(
             serverPassword ? `Basic ${btoa(`opencode:${serverPassword}`)}` : null,
           );
           return { data: { id: `${baseUrl}/session` } };
         },
+        get: async ({ sessionID }: { sessionID: string }) => {
+          runtimeMock.state.sessionGetCalls.push(sessionID);
+          if (runtimeMock.state.sessionGetDelay) {
+            await runtimeMock.state.sessionGetDelay;
+          }
+          if (runtimeMock.state.sessionGetError) {
+            throw runtimeMock.state.sessionGetError;
+          }
+          return {
+            data: runtimeMock.state.sessionGetDataById.get(sessionID) ?? { id: sessionID },
+          };
+        },
         abort: async ({ sessionID }: { sessionID: string }) => {
           runtimeMock.state.abortCalls.push(sessionID);
         },
@@ -158,6 +186,11 @@ const OpenCodeRuntimeTestDouble: OpenCodeRuntimeShape = {
               : runtimeMock.state.messages;
         },
       },
+      permission: {
+        reply: async ({ requestID, reply }: { requestID: string; reply: string }) => {
+          runtimeMock.state.permissionReplyCalls.push({ requestID, reply });
+        },
+      },
       event: {
         subscribe: async () => ({
           stream: (async function* () {
@@ -227,6 +260,11 @@ beforeEach(() => {
 const advanceTestClock = (ms: number) =>
   TestClock.adjust(`${ms} millis`).pipe(Effect.andThen(Effect.yieldNow));
 
+const waitUntil = (predicate: () => boolean): Effect.Effect<void> =>
+  Effect.suspend(() =>
+    predicate() ? Effect.void : Effect.sleep("1 millis").pipe(Effect.andThen(waitUntil(predicate))),
+  );
+
 it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
   it.effect("reuses a configured OpenCode server URL instead of spawning a local server", () =>
     Effect.gen(function* () {
@@ -248,6 +286,264 @@ it.layer(OpenCodeAdapterTestLayer)("OpenCodeAdapterLive", (it) => {
     }),
   );
 
+  it.effect("returns a resume cursor for a fresh OpenCode session", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+
+      const session = yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId: asThreadId("thread-opencode-cursor"),
+        runtimeMode: "full-access",
+      });
+
+      NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
+      NodeAssert.deepEqual(session.resumeCursor, {
+        schemaVersion: 1,
+        sessionId: "http://127.0.0.1:9999/session",
+      });
+      yield* adapter.stopSession(asThreadId("thread-opencode-cursor"));
+    }),
+  );
+
+  it.effect("resumes an existing OpenCode session from a persisted cursor", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+      runtimeMock.state.sessionGetDataById.set("ses_existing", { id: "ses_existing" });
+
+      const session = yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId: asThreadId("thread-opencode-resume"),
+        runtimeMode: "full-access",
+        resumeCursor: { schemaVersion: 1, sessionId: "ses_existing" },
+      });
+
+      NodeAssert.deepEqual(runtimeMock.state.sessionGetCalls, ["ses_existing"]);
+      NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+      NodeAssert.deepEqual(session.resumeCursor, {
+        schemaVersion: 1,
+        sessionId: "ses_existing",
+      });
+      yield* adapter.stopSession(asThreadId("thread-opencode-resume"));
+    }),
+  );
+
+  it.effect("preserves an existing upstream session when restarting with its resume cursor", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+      const threadId = asThreadId("thread-opencode-restart-with-cursor");
+
+      const first = yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId,
+        runtimeMode: "full-access",
+      });
+
+      const cursor = first.resumeCursor;
+      NodeAssert.deepEqual(cursor, {
+        schemaVersion: 1,
+        sessionId: "http://127.0.0.1:9999/session",
+      });
+
+      const second = yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId,
+        runtimeMode: "full-access",
+        resumeCursor: cursor,
+      });
+
+      NodeAssert.deepEqual(runtimeMock.state.abortCalls, []);
+      NodeAssert.deepEqual(runtimeMock.state.sessionGetCalls, ["http://127.0.0.1:9999/session"]);
+      NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
+      NodeAssert.deepEqual(second.resumeCursor, cursor);
+
+      yield* adapter.stopSession(threadId);
+    }),
+  );
+
+  it.effect("preserves pending permissions when restarting with the same resume cursor", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+      const threadId = asThreadId("thread-opencode-restart-with-permission");
+      const sessionID = "http://127.0.0.1:9999/session";
+      runtimeMock.state.subscribedEvents = [
+        {
+          type: "permission.asked",
+          properties: {
+            id: "perm-restart",
+            sessionID,
+            permission: "bash",
+            patterns: ["npm test"],
+            metadata: {},
+            always: [],
+          },
+        },
+      ];
+
+      const first = yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId,
+        runtimeMode: "full-access",
+      });
+      yield* advanceTestClock(10);
+
+      runtimeMock.state.subscribedEvents = [];
+      yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId,
+        runtimeMode: "full-access",
+        resumeCursor: first.resumeCursor,
+      });
+
+      yield* adapter.respondToRequest(threadId, ApprovalRequestId.make("perm-restart"), "accept");
+
+      NodeAssert.deepEqual(runtimeMock.state.abortCalls, []);
+      NodeAssert.deepEqual(runtimeMock.state.sessionGetCalls, [sessionID]);
+      NodeAssert.deepEqual(runtimeMock.state.permissionReplyCalls, [
+        { requestID: "perm-restart", reply: "once" },
+      ]);
+
+      yield* adapter.stopSession(threadId);
+    }),
+  );
+
+  it.effect("sends follow-up prompts to the resumed OpenCode session", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+      const threadId = asThreadId("thread-opencode-resume-follow-up");
+      runtimeMock.state.sessionGetDataById.set("ses_existing", { id: "ses_existing" });
+      yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId,
+        runtimeMode: "full-access",
+        resumeCursor: { schemaVersion: 1, sessionId: "ses_existing" },
+      });
+
+      yield* adapter.sendTurn({
+        threadId,
+        input: "Continue",
+        modelSelection: {
+          instanceId: ProviderInstanceId.make("opencode"),
+          model: "openai/gpt-5",
+        },
+      });
+
+      NodeAssert.deepEqual(runtimeMock.state.promptCalls.at(-1), {
+        sessionID: "ses_existing",
+        model: { providerID: "openai", modelID: "gpt-5" },
+        parts: [{ type: "text", text: "Continue" }],
+      });
+      yield* adapter.stopSession(threadId);
+    }),
+  );
+
+  it.effect("fails a valid resume cursor instead of creating an empty replacement session", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+      runtimeMock.state.sessionGetError = new Error("resume failed");
+
+      const error = yield* adapter
+        .startSession({
+          provider: ProviderDriverKind.make("opencode"),
+          threadId: asThreadId("thread-opencode-resume-failure"),
+          runtimeMode: "full-access",
+          resumeCursor: { schemaVersion: 1, sessionId: "ses_missing" },
+        })
+        .pipe(Effect.flip);
+
+      NodeAssert.equal(error._tag, "ProviderAdapterProcessError");
+      NodeAssert.deepEqual(runtimeMock.state.sessionGetCalls, ["ses_missing"]);
+      NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, []);
+    }),
+  );
+
+  it.effect("treats malformed OpenCode resume cursors as absent", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+
+      const session = yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId: asThreadId("thread-opencode-malformed-cursor"),
+        runtimeMode: "full-access",
+        resumeCursor: { sessionId: "ses_existing" },
+      });
+
+      NodeAssert.deepEqual(runtimeMock.state.sessionGetCalls, []);
+      NodeAssert.deepEqual(runtimeMock.state.sessionCreateUrls, ["http://127.0.0.1:9999"]);
+      NodeAssert.deepEqual(session.resumeCursor, {
+        schemaVersion: 1,
+        sessionId: "http://127.0.0.1:9999/session",
+      });
+      yield* adapter.stopSession(asThreadId("thread-opencode-malformed-cursor"));
+    }),
+  );
+
+  it.effect(
+    "does not abort an adopted OpenCode session when a concurrent start wins the race",
+    () =>
+      Effect.gen(function* () {
+        const adapter = yield* OpenCodeAdapter;
+        const threadId = asThreadId("thread-opencode-resume-race");
+        let releaseResume!: () => void;
+        runtimeMock.state.sessionGetDelay = new Promise((resolve) => {
+          releaseResume = resolve;
+        });
+
+        const resumedFiber = yield* adapter
+          .startSession({
+            provider: ProviderDriverKind.make("opencode"),
+            threadId,
+            runtimeMode: "full-access",
+            resumeCursor: { schemaVersion: 1, sessionId: "ses_existing" },
+          })
+          .pipe(Effect.forkChild({ startImmediately: true }));
+        yield* waitUntil(() => runtimeMock.state.sessionGetCalls.length === 1);
+
+        const raceWinner = yield* adapter.startSession({
+          provider: ProviderDriverKind.make("opencode"),
+          threadId,
+          runtimeMode: "full-access",
+        });
+        releaseResume();
+        const resumedResult = yield* Fiber.join(resumedFiber);
+
+        NodeAssert.equal(resumedResult, raceWinner);
+        NodeAssert.deepEqual(runtimeMock.state.abortCalls, []);
+        yield* adapter.stopSession(threadId);
+      }),
+  );
+
+  it.effect("aborts a newly-created OpenCode session when a concurrent start wins the race", () =>
+    Effect.gen(function* () {
+      const adapter = yield* OpenCodeAdapter;
+      const threadId = asThreadId("thread-opencode-create-race");
+      let releaseCreate!: () => void;
+      runtimeMock.state.sessionCreateDelay = new Promise((resolve) => {
+        releaseCreate = resolve;
+      });
+
+      const losingFiber = yield* adapter
+        .startSession({
+          provider: ProviderDriverKind.make("opencode"),
+          threadId,
+          runtimeMode: "full-access",
+        })
+        .pipe(Effect.forkChild({ startImmediately: true }));
+      yield* waitUntil(() => runtimeMock.state.sessionCreateUrls.length === 1);
+
+      runtimeMock.state.sessionCreateDelay = null;
+      yield* adapter.startSession({
+        provider: ProviderDriverKind.make("opencode"),
+        threadId,
+        runtimeMode: "full-access",
+      });
+      releaseCreate();
+      yield* Fiber.join(losingFiber);
+
+      NodeAssert.deepEqual(runtimeMock.state.abortCalls, ["http://127.0.0.1:9999/session"]);
+      yield* adapter.stopSession(threadId);
+    }),
+  );
+
   it.effect("stops a configured-server session without trying to own server lifecycle", () =>
     Effect.gen(function* () {
       const adapter = yield* OpenCodeAdapter;