@jskit-ai/assistant-core 0.2.2 → 0.2.4

package/test/openCodeConnectionChange.test.js

@@ -0,0 +1,166 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
+import { createOpenCodeSharedRuntime, openCodeServerForDirectory } from "../src/server/conversation/openCodeRuntime.js";
+
+// One shared server whose native directories record what OpenCode is asked to do.
+function sharedServer() {
+  const calls = [], rows = new Map(), loaded = new Set();
+  const client = (directory = "/work/server") => ({
+    async health() { return { healthy: true }; },
+    async authenticateApiKey(providerId, key) { calls.push(["key", providerId, key]); },
+    async removeAuthentication(providerId) { calls.push(["remove", providerId]); },
+    async disposeInstance() { calls.push(["reload", directory]); loaded.delete(directory); },
+    instanceDirectories: () => [...loaded],
+    forDirectory(next) { loaded.add(next); return client(next); },
+    async prompt(conversationId, input) {
+      calls.push(["prompt", directory, conversationId]);
+      rows.set(conversationId, [{ id: input.id, type: "user", time: { created: 1 } },
+        { id: `${input.id}:answer`, type: "assistant", text: "Done.", time: { created: 2, completed: 3 } }]);
+      return { id: input.id };
+    },
+    async messages(conversationId) { return rows.get(conversationId) || []; },
+    async sessionStatus() { return { type: "idle" }; },
+    async interrupt() { return true; }
+  });
+  const stops = [];
+  const server = { client: client(), async stop() { stops.push(server); return { exited: true }; } };
+  return { server, calls, rows, stops };
+}
+
+const deepseek = (fingerprint, apiKey) => ({ modelProviderId: "deepseek", canonicalUrl: "", endpointCode: "native", fingerprint, apiKey });
+
+async function startedRuntime(saved) {
+  const runtime = createOpenCodeSharedRuntime();
+  const native = sharedServer();
+  const shared = await runtime.ensure(saved[0], async () => ({ server: native.server, connections: [...saved] }), async () => saved);
+  return { runtime, native, shared };
+}
+
+// A main-conversation turn in flight until its answer arrives.
+function runningTurn(t, runtime, shared, workdir, { failure = "", completeResult = async (_turn, { failure: value }) => value } = {}) {
+  const target = { key: workdir, workdir, upstreamSessionId: `${workdir}:thread`, abortController: new AbortController(),
+    server: openCodeServerForDirectory(shared.server, workdir) };
+  const turn = { id: "input", inputMessageId: "input", threadId: target.upstreamSessionId, active: true, state: "active",
+    eventStartedAt: 1, abortController: new AbortController() };
+  let observedFailure = null;
+  const monitor = runtime.beginMonitor(workdir, target, turn, {
+    observe: () => ({ readFailure: () => observedFailure, close: async () => {} }),
+    finalResponse: { agent: "agent", model: { providerID: "deepseek", id: "model" }, recoveryMessageId: "recovery", readError: () => "" },
+    projectMessages: async () => ({ failure: "", providerApiFailure: false, finalAssistantResult: null }),
+    writeRun: async () => {},
+    completeResult,
+    onRetired() {}
+  });
+  t.after(async () => { turn.abortController.abort(); await monitor.catch(() => null); });
+  return {
+    target, turn, monitor,
+    answer(native) {
+      native.rows.set(target.upstreamSessionId, [{ id: "input", type: "user", time: { created: 1 } },
+        { id: "answer", type: "assistant", text: "Done.", time: { created: 2, completed: 3 } }]);
+    },
+    fail(native) {
+      native.rows.set(target.upstreamSessionId, [{ id: "input", type: "user", time: { created: 1 } }]);
+      observedFailure = Object.assign(new Error(failure), { name: "UnknownError" });
+    }
+  };
+}
+
+function temporaryTurn(runtime, target, conversationId) {
+  return runtime.runConversationTurn(target, conversationId, { active: false },
+    { id: `${conversationId}:input`, agent: "agent", model: { providerID: "deepseek", id: "model" }, prompt: { text: "Hello" } }, {
+      observe: () => ({ waitUntilReady: async () => {}, readFailure: () => null, close: async () => {} }),
+      completion: { projectResult: value => value, readError: () => "" },
+      onCompletion() {}
+    });
+}
+
+test("an OpenCode connection change leaves running work alone and reloads idle directories at once", { timeout: 15_000 }, async t => {
+  const saved = [deepseek("old", "old-key"), { ...deepseek("zai-account", "zai-key"), modelProviderId: "zai" }];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const running = runningTurn(t, runtime, shared, "/work/busy");
+  // Another provider's retained conversation, which once refused the change.
+  const peer = await runtime.acquire("peer", async () => ({ key: "peer", workdir: "/work/idle", modelProviderId: "zai",
+    abortController: new AbortController(), server: openCodeServerForDirectory(shared.server, "/work/idle") }));
+  saved[0] = deepseek("new", "new-key");
+  let published = false;
+  const changed = await runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } },
+    { release: {}, connections: async () => saved });
+  await delay(10);
+  assert.deepEqual(changed, { closed: 0, ok: true });
+  assert.equal(published, true);
+  assert.deepEqual(native.calls, [["key", "deepseek", "new-key"], ["reload", "/work/idle"]]);
+  assert.deepEqual(native.stops, []);
+  assert.equal(runtime.current, shared);
+  assert.equal(running.turn.active, true);
+  assert.equal(running.target.abortController.signal.aborted, false);
+  assert.equal(runtime.processes.get("peer"), peer);
+  assert.equal(peer.abortController.signal.aborted, false);
+  running.answer(native);
+  assert.equal((await running.monitor).state, "completed");
+  await delay(10);
+  assert.deepEqual(native.calls.slice(2), [["reload", "/work/busy"]], "The busy directory reloads once its turn ends.");
+});
+
+test("new work in a directory with a turn in flight starts after that turn ends and the directory reloads", { timeout: 15_000 }, async t => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const running = runningTurn(t, runtime, shared, "/work/busy");
+  saved[0] = deepseek("new", "new-key");
+  await runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() {} }, { release: {}, connections: async () => saved });
+  const target = { workdir: "/work/busy", abortController: new AbortController(),
+    server: openCodeServerForDirectory(shared.server, "/work/busy") };
+  const elsewhere = { workdir: "/work/other", abortController: new AbortController(),
+    server: openCodeServerForDirectory(shared.server, "/work/other") };
+  const waiting = temporaryTurn(runtime, target, "temporary");
+  assert.equal((await temporaryTurn(runtime, elsewhere, "unrelated")).status, "inProgress",
+    "Another directory's new work does not wait.");
+  await delay(30);
+  assert.equal(native.calls.some(([kind, , id]) => kind === "prompt" && id === "temporary"), false);
+  running.answer(native);
+  await running.monitor;
+  assert.equal((await waiting).status, "inProgress");
+  const order = native.calls.map(call => call.join(" "));
+  assert.ok(order.indexOf("reload /work/busy") < order.indexOf("prompt /work/busy temporary"), order.join("\n"));
+});
+
+test("a stale preparation cannot restore an older key, and a saved change reaches the server at the next use", async () => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const start = async () => assert.fail("A changed key does not start another server.");
+  saved[0] = deepseek("new", "new-key");
+  assert.equal(await runtime.ensure(saved[0], start, async () => saved), shared);
+  assert.equal(await runtime.ensure(deepseek("old", "old-key"), start, async () => saved), shared);
+  assert.deepEqual(native.calls, [["key", "deepseek", "new-key"]]);
+  assert.deepEqual(native.stops, []);
+});
+
+test("Disconnect removes the key, and a turn whose connection is gone ends with a reconnect message", { timeout: 15_000 }, async t => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native, shared } = await startedRuntime(saved);
+  const outcomes = [];
+  const running = runningTurn(t, runtime, shared, "/work/busy", {
+    failure: "Model not found: deepseek/model. Did you mean: model?",
+    async completeResult(_turn, outcome) { outcomes.push(outcome); return outcome.failure; }
+  });
+  saved.length = 0;
+  await runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() {} }, { release: {}, connections: async () => saved });
+  assert.deepEqual(native.calls, [["remove", "deepseek"]]);
+  running.fail(native);
+  const result = await running.monitor;
+  assert.equal(result.state, "failed");
+  assert.equal(result.error, "deepseek isn't connected. Connect it again, then send your message again.");
+  assert.equal(outcomes[0].credentialFailure, true);
+});
+
+test("an open native terminal still refuses the change before anything is published", async () => {
+  const saved = [deepseek("old", "old-key")];
+  const { runtime, native } = await startedRuntime(saved);
+  let published = false;
+  saved[0] = deepseek("new", "new-key");
+  await assert.rejects(runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
+    release: { assertConnectionChange() { throw new Error("Close OpenCode native terminals."); } }, connections: async () => saved
+  }), /Close OpenCode native terminals/u);
+  assert.equal(published, false);
+  assert.deepEqual(native.calls, []);
+});

package/test/openCodeProcess.test.js

@@ -3,7 +3,9 @@ import { access, mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
 import { createOpenCodeServerProcess, openCodeProcessEnvironment } from "../src/server/conversation/openCodeProcess.js";
+import { createOpenCodeSharedRuntime } from "../src/server/conversation/openCodeRuntime.js";
 
 async function fixture(t, options = {}) {
   const workdir = await mkdtemp(path.join(os.tmpdir(), "jskit-opencode-process-"));
@@ -41,6 +43,8 @@ test("the shared OpenCode server authenticates selected accounts and drains its
   ] });
   assert.deepEqual(native.modelProviderIds, ["first", "second"]);
   assert.deepEqual(f.requests.map(({ url }) => url.pathname), ["/global/health", "/auth/first", "/auth/second"]);
+  // Requests without a directory reach the server's working directory, which a credential change reloads.
+  assert.deepEqual(native.client.instanceDirectories(), [f.config.workdir]);
   assert.notEqual(native.environment.OPENCODE_SERVER_PASSWORD, "obsolete-password");
   assert.equal(native.executionId, "owned-process");
   assert.deepEqual(native.attachArguments({ conversationId: "ses_one", directory: f.config.workdir }),
@@ -51,6 +55,22 @@ test("the shared OpenCode server authenticates selected accounts and drains its
   await assert.rejects(access(f.config.privateRoot), { code: "ENOENT" });
 });
 
+test("the shared owner stops a server that exits without being stopped at once", async t => {
+  const f = await fixture(t);
+  const reasons = [];
+  const runtime = createOpenCodeSharedRuntime({ onStop: ({ reason }) => reasons.push(reason) });
+  // The host wires no failure callback: the owner watches the exit itself.
+  const shared = await runtime.ensure(null, async () => ({ server: await createOpenCodeServerProcess(f.config), connections: [] }));
+  assert.equal(runtime.current, shared);
+  f.exited.resolve({ code: 1 });
+  for (let attempt = 0; attempt < 50 && f.stops.length === 0; attempt += 1) await delay(10);
+  await delay(20);
+  assert.deepEqual(f.stops, ["owned-process"]);
+  assert.deepEqual(reasons, ["opencode-server-exited"]);
+  assert.equal(runtime.current, null);
+  await assert.rejects(access(f.config.privateRoot), { code: "ENOENT" });
+});
+
 test("version mismatch preserves startup evidence and the owned identity if cleanup is unconfirmed", async t => {
   let confirmed = false;
   let failure;
@@ -97,6 +117,22 @@ test("an unexpected native exit reports failure after readiness", async t => {
   await native.stop();
 });
 
+test("an OpenCode server that exits before readiness says why", async t => {
+  const f = await fixture(t);
+  f.config.execution.start = async request => {
+    f.starts.push(request);
+    return { id: "owned-process", pid: 123, running: false, exited: Promise.resolve({ code: 1 }),
+      readLogs: () => ({ stdout: "", stderr: `INFO starting\n\u001b[31mError: Unexpected token in ${"x".repeat(600)}\u001b[0m\n\n` }) };
+  };
+  await assert.rejects(createOpenCodeServerProcess(f.config), error => {
+    assert.equal(error.code, "assistant_opencode_start_failed");
+    assert.match(error.message, /^OpenCode exited before its server became ready: Error: Unexpected token in x+…$/u);
+    assert.ok(error.message.length < 400, "the reason is one bounded line");
+    assert.match(error.details.stderr, /INFO starting/u);
+    return true;
+  });
+});
+
 test("failed host startup retains its execution identity until cleanup is proven", async t => {
   const f = await fixture(t, { stop: () => ({ scopeEmpty: false }) });
   const bindings = [];

package/test/openCodeRuntime.test.js

@@ -224,6 +224,31 @@ test("an acquired OpenCode process without a main conversation can close without
   assert.equal(f.stops.length, 1);
 });
 
+test("deleting a scoped OpenCode conversation returns its scope's exit proof and keeps none", async () => {
+  const f = fixture();
+  const target = await f.acquire("ephemeral\0reasoning_1");
+  target.sessionId = "reasoning_1";
+  const deleted = [];
+  target.server = { ...target.server, client: { ...target.server.client, async deleteSession(id) { deleted.push(id); } } };
+  const application = {
+    closeTerminals: async () => ({ ok: true, closed: 0 }),
+    beforeRelease: async () => {},
+    onRemoved: async () => {},
+    afterRelease: async () => {},
+    failure: error => { throw error; }
+  };
+  const result = await f.runtime.deletePreparedConversation({
+    key: "ephemeral\0reasoning_1", conversationId: "native-1", persistent: false, scoped: true,
+    process: () => assert.fail("deleting must not start OpenCode"), onRemoved: async () => {},
+    cleanupAfterDelete: { sessionId: "reasoning_1", options: {}, application }
+  }, { persistent: false });
+  assert.deepEqual(deleted, ["native-1"]);
+  assert.equal(result.deleted, true);
+  assert.equal(result.providerExit.processExitProof.exited, true);
+  // A scope is never renewed, so nothing would ever release a kept proof.
+  assert.equal(f.runtime.releaseProcessExitProof("reasoning_1").processExitProof, null);
+});
+
 test("an active OpenCode turn with missing native identity still fails instead of claiming Stop", async () => {
   const runtime = createOpenCodeSharedRuntime();
   const client = createOpenCodeServerClient({ baseUrl: "http://127.0.0.1:1",
@@ -762,81 +787,3 @@ test("original message monitor clone retains only its registered target's final
   assert.equal(modelPrompts, 0);
   assert.deepEqual(errors, []);
 });
-
-test("credential publication refuses another provider and unowned consumers before stopping or writing", async () => {
-  for (const unowned of [false, true]) {
-    const { runtime, acquire, stops } = fixture();
-    const selected = await acquire("selected"); selected.modelProviderId = "deepseek";
-    const peer = await acquire("peer"); peer.modelProviderId = unowned ? "deepseek" : "zai";
-    let published = false;
-    const effects = [];
-    await assert.rejects(runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
-      release: { ownsTarget: target => !unowned || target !== peer,
-        beforeRelease: async target => effects.push(target.key), onRemoved: async () => {}, failure: error => { throw error; } }
-    }), { code: "assistant_opencode_connection_in_use", message: /^Close the other OpenCode conversations that use this connection, then retry/u });
-    assert.equal(published, false);
-    assert.deepEqual(effects, []);
-    assert.deepEqual(stops, []);
-    assert.equal(runtime.processes.get("peer"), peer);
-    assert.equal(peer.abortController.signal.aborted, false);
-    assert.equal(selected.abortController.signal.aborted, false);
-  }
-});
-
-test("credential publication fences new acquisition and ensure across native cleanup and private publication", async () => {
-  const { runtime, acquire, connection, starts, stops } = fixture();
-  const selected = await acquire("selected"); selected.modelProviderId = "deepseek";
-  const publishing = Promise.withResolvers(), finish = Promise.withResolvers();
-  let saved = "old";
-  const changed = runtime.invalidateRuntimes({ modelProviderId: "deepseek", async publish() {
-    assert.equal(stops.length, 1); publishing.resolve(); await finish.promise; saved = "new";
-  } }, { release: { ownsTarget: () => true, beforeRelease: async () => {}, onRemoved: async () => {}, failure: error => { throw error; } } });
-  await publishing.promise;
-  assert.equal(saved, "old");
-  await assert.rejects(acquire("late"), { code: "assistant_opencode_connection_changing" });
-  await assert.rejects(runtime.ensure(connection, async () => { throw new Error("must not start"); }), { code: "assistant_opencode_connection_changing" });
-  assert.equal(starts.length, 1);
-  finish.resolve();
-  assert.equal((await changed).ok, true);
-  assert.equal(saved, "new");
-  await acquire("retry");
-  assert.equal(starts.length, 2);
-});
-
-test("credential barrier drains admitted acquisitions and refuses a late peer without native effects", async () => {
-  const { runtime, stops } = fixture();
-  const started = Promise.withResolvers(), finish = Promise.withResolvers();
-  const pending = runtime.acquire("late-peer", async () => {
-    started.resolve(); await finish.promise;
-    return { key: "late-peer", modelProviderId: "zai", abortController: new AbortController() };
-  });
-  await started.promise;
-  let published = false;
-  const changed = runtime.invalidateRuntimes({ modelProviderId: "deepseek", publish() { published = true; } }, {
-    release: { ownsTarget: () => true, beforeRelease: async () => { throw new Error("must not release"); } }
-  });
-  const rejected = assert.rejects(changed, { code: "assistant_opencode_connection_in_use" });
-  finish.resolve(); await pending; await rejected;
-  assert.equal(published, false);
-  assert.deepEqual(stops, []);
-});
-
-test("unconfirmed terminal and failed verified stop keep the prior credential and permit safe retry", async () => {
-  let terminalOpen = true, stopFails = true, published = false;
-  const { runtime, acquire, stops } = fixture({ stop: async () => ({ exited: !stopFails }) });
-  const target = await acquire("selected"); target.modelProviderId = "deepseek";
-  const input = { modelProviderId: "deepseek", publish() { published = true; } };
-  const preparation = { release: { ownsTarget: () => true,
-    assertConnectionChange() { if (terminalOpen) throw new Error("close terminal"); },
-    beforeRelease: async () => {}, onRemoved: async () => {}, failure: error => { throw error; } } };
-  await assert.rejects(runtime.invalidateRuntimes(input, preparation), /close terminal/);
-  assert.equal(target.abortController.signal.aborted, false);
-  assert.equal(stops.length, 0);
-  terminalOpen = false;
-  await assert.rejects(runtime.invalidateRuntimes(input, preparation), { code: "assistant_opencode_stop_unverified" });
-  assert.equal(published, false);
-  stopFails = false;
-  assert.equal((await runtime.invalidateRuntimes(input, preparation)).ok, true);
-  assert.equal(published, true);
-  assert.equal(stops.length, 2);
-});