@jskit-ai/assistant-core 0.2.2 → 0.2.3

package/src/server/conversation/codexSessionReconciliation.js

@@ -12,8 +12,9 @@ export function createCodexSessionReconciliation({
     projectContextRoot = ""
   } = {}) {
     const normalizedProjectContextRoot = normalizeText(projectContextRoot);
+    const failed = [];
     if (!normalizedProjectContextRoot) {
-      return;
+      return failed;
     }
     for (const [providerKey, managed] of [...providerSessions.managed.entries()]) {
       if (keepProviderKeys.has(providerKey)) {
@@ -21,9 +22,22 @@ export function createCodexSessionReconciliation({
       }
       if (providerSessions.owner.providers.get(providerKey)?.observationFailure) continue;
       if (normalizeText(managed.projectContext?.targetRoot) === normalizedProjectContextRoot) {
-        await lifecycle.retireProvider(providerKey);
+        // One provider that cannot retire does not keep the others running.
+        try {
+          await lifecycle.retireProvider(providerKey);
+        } catch (error) {
+          failed.push({
+            code: normalizeText(error?.code),
+            error: errorMessage(error),
+            providerKey,
+            retryable: error?.retryable === true,
+            sessionId: normalizeText(managed.sessionId)
+          });
+          debugLog("appServerThread.reconcile.prune.error", { error: debugError(error), providerKey });
+        }
       }
     }
+    return failed;
   }
 
   async function retireAndCloseCodexAppServerProviderForSession(sessionId = "", options = null) {
@@ -233,10 +247,10 @@ export function createCodexSessionReconciliation({
       });
     }
     if (reconcileGeneration === lifecycle.reconcileGeneration) {
-      await pruneCodexAppServerManagedSessions({
+      failed.push(...await pruneCodexAppServerManagedSessions({
         keepProviderKeys,
         projectContextRoot
-      });
+      }));
     } else {
       debugLog("appServerThread.reconcile.pruneSkipped", {
         reason: "stale_reconcile",

package/src/server/conversation/codexTurn.js

@@ -108,6 +108,10 @@ export function createCodexAppServerRunOwner({
   onNotificationSignal = async () => null,
   captureContext = () => null,
   runInContext = (_context, operation) => operation(),
+  // Resumes a goal an account change paused, once the previous account's
+  // runtime has stopped: `(sessionId, { threadId })`. Without it the goal stays
+  // paused for the person to resume.
+  continueGoalAfterAccountChange = null,
   notificationQueue = null,
   activeReconcileMs = 2000,
   finalizingGraceMs = 10000,
@@ -314,8 +318,8 @@ export function createCodexAppServerRunOwner({
     interruptFailedCode,
     namespace,
     providerSessions,
-    sessionConnection: codexProviderSelection.sessionConnection,
     ensureSessionProvider: codexProviderSelection.ensureSessionProvider,
+    borrowSessionProvider: codexProviderSelection.borrowSessionProvider,
     steerFailedCode,
     turnOutcomes
   });
@@ -416,7 +420,9 @@ export function createCodexAppServerRunOwner({
     const connection = prepared.connection;
     const { workdir, threadId } = connection;
     if (threadId && connection.available && turnState(session).state !== "starting") {
-      const providerKey = codexProviderSelection.managedProviderKeyForThread(sessionId, workdir, threadId);
+      const providerKey = codexProviderSelection.managedProviderKeyForThread(sessionId, workdir, threadId, {
+        turnActive: turnState(session).active
+      });
       if (providerKey !== null) {
         const observed = await codexThreadReadiness.checkManagedConnection(providerKey, { reconnect: false });
         if (!observed.requiresPreparation) {
@@ -547,6 +553,7 @@ export function createCodexAppServerRunOwner({
       helperLifecycle,
       captureContext,
       runInContext,
+      continueGoalAfterAccountChange,
       debugLog,
       debugError,
       closingError: serverClosingError

package/src/server/conversation/continuity.js

@@ -316,7 +316,19 @@ export function createConversationChangeover({ state, transcript, agent, identit
     return delivered;
   }
 
-  return { readState, remember, replace, send };
+  // Cancel drops the message's pending native attempt in every engine, so no
+  // later send replays it or waits on its unknown receipt. Native history an
+  // engine already admitted stays; the transcript remains authoritative.
+  async function discard({ messageId }) {
+    const value = await state.read();
+    const bindings = Object.values(value?.engines || {}).filter(binding => binding.pending?.messageId === messageId);
+    if (!bindings.length) return false;
+    for (const binding of bindings) delete binding.pending;
+    await state.write(value);
+    return true;
+  }
+
+  return { readState, remember, replace, send, discard };
 }
 
 function writtenMessages(history, native = false) {

package/src/server/conversation/openCodeClient.js

@@ -298,11 +298,17 @@ function decodeOpenCodeEventData(value = "") {
   return parsedJson(first) ?? first;
 }
 
+// OpenCode loads one instance per directory and keeps it, with the credentials it
+// read, until that directory is disposed. Every client derived from one server
+// shares the record of the directories it has addressed; `defaultDirectory` is
+// the server's working directory, which requests without a directory reach.
 function createOpenCodeServerClient({
   allowAttachmentDirectories = false,
   baseUrl = "",
+  defaultDirectory = "",
   directory = "",
   fetchImpl = globalThis.fetch,
+  instances = { addressed: new Map(), sequence: 0 },
   password = "",
   username = "opencode"
 } = {}) {
@@ -316,6 +322,17 @@ function createOpenCodeServerClient({
   const authorization = `Basic ${Buffer.from(`${text(username) || "opencode"}:${String(password)}`).toString("base64")}`;
   const scopedDirectory = text(directory);
 
+  function instanceDirectory(requestDirectory = scopedDirectory) {
+    const value = text(requestDirectory) || text(defaultDirectory);
+    return value ? path.resolve(value) : "";
+  }
+
+  function addressInstance(requestPath, requestDirectory) {
+    // Global routes and disposal itself load no directory instance.
+    const instance = /^\/(?:global|instance)\//u.test(requestPath) ? "" : instanceDirectory(requestDirectory);
+    if (instance) instances.addressed.set(instance, ++instances.sequence);
+  }
+
   function requestHeaders(accept = "application/json", body = undefined, directory = scopedDirectory) {
     return {
       accept,
@@ -331,6 +348,7 @@ function createOpenCodeServerClient({
     limitBytes = OPENCODE_RESPONSE_LIMIT_BYTES,
     signal
   } = {}) {
+    addressInstance(requestPath, directory);
     const response = await fetchImpl(new URL(requestPath, origin), {
       body: body === undefined ? undefined : JSON.stringify(body),
       headers: requestHeaders("application/json", body, directory),
@@ -381,6 +399,7 @@ function createOpenCodeServerClient({
 
   async function *events(sessionId = "", { onReady = null, signal } = {}) {
     const requestPath = "/event";
+    addressInstance(requestPath, scopedDirectory);
     const response = await fetchImpl(new URL(requestPath, origin), {
       headers: requestHeaders("text/event-stream"),
       method: "GET",
@@ -550,6 +569,15 @@ function createOpenCodeServerClient({
       if (!text(messageId)) throw new TypeError("OpenCode message deletion requires a message id.");
       return request("DELETE", stableSessionPath(sessionId, `/message/${encodeURIComponent(text(messageId))}`), { signal });
     },
+    // The next request to this client's directory loads a new instance, which
+    // reads the server's current credentials. A turn in flight there is aborted.
+    async disposeInstance({ signal } = {}) {
+      const instance = instanceDirectory();
+      const sequence = instances.sequence;
+      await request("POST", "/instance/dispose", { signal });
+      // A request that reached the directory during disposal may have loaded it again.
+      if (instance && (instances.addressed.get(instance) ?? 0) <= sequence) instances.addressed.delete(instance);
+    },
     events,
     forDirectory(nextDirectory = "") {
       const normalizedDirectory = text(nextDirectory);
@@ -559,12 +587,18 @@ function createOpenCodeServerClient({
       return createOpenCodeServerClient({
         allowAttachmentDirectories,
         baseUrl: origin.toString(),
+        defaultDirectory,
         directory: normalizedDirectory,
         fetchImpl,
+        instances,
         password,
         username
       });
     },
+    // Absolute directories whose loaded instances may hold older credentials.
+    instanceDirectories() {
+      return [...instances.addressed.keys()];
+    },
     async health({ signal } = {}) {
       return request("GET", "/global/health", { signal });
     },

package/src/server/conversation/openCodeProcess.js

@@ -80,6 +80,23 @@ async function availableLoopbackPort() {
   });
 }
 
+const OPENCODE_EXIT_REASON_MAX_CHARACTERS = 300;
+
+// OpenCode's last stderr line, as one bounded line of plain text.
+function openCodeExitReason(logs) {
+  const line = String(logs?.stderr || "")
+    // eslint-disable-next-line no-control-regex -- Strip terminal escape sequences from captured stderr.
+    .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/gu, "")
+    .split(/\r?\n/u)
+    // eslint-disable-next-line no-control-regex -- The reason becomes one line of plain text.
+    .map((candidate) => candidate.replace(/[\u0000-\u001f\u007f]/gu, " ").trim())
+    .filter(Boolean)
+    .at(-1) || "";
+  return line.length > OPENCODE_EXIT_REASON_MAX_CHARACTERS
+    ? `${line.slice(0, OPENCODE_EXIT_REASON_MAX_CHARACTERS - 1)}…`
+    : line;
+}
+
 async function waitForOpenCodeReady({
   client,
   expectedVersion = OPENCODE_EXPECTED_VERSION,
@@ -92,7 +109,13 @@ async function waitForOpenCodeReady({
   while (Date.now() < deadline) {
     signal?.throwIfAborted();
     if (processHandle.exited) {
-      throw new Error("OpenCode exited before its server became ready.");
+      let logs = null;
+      // The exit is the failure; output that cannot be read only loses its reason.
+      try { logs = processHandle.readLogs(); } catch { logs = null; }
+      const reason = openCodeExitReason(logs);
+      throw new Error(reason
+        ? `OpenCode exited before its server became ready: ${reason}`
+        : "OpenCode exited before its server became ready.");
     }
     try {
       const probe = AbortSignal.timeout(Math.max(100, Math.min(2_000, deadline - Date.now())));
@@ -216,15 +239,18 @@ export async function createOpenCodeServerProcess({
   const baseUrl = `http://${OPENCODE_HOST}:${selectedPort}`;
   const password = randomBytes(32).toString("base64url");
   const environment = { ...env, OPENCODE_SERVER_USERNAME: "opencode", OPENCODE_SERVER_PASSWORD: password };
-  const client = createOpenCodeServerClient({ baseUrl, password, directory, fetchImpl, allowAttachmentDirectories });
+  const client = createOpenCodeServerClient({ baseUrl, password, directory, defaultDirectory: workdir, fetchImpl,
+    allowAttachmentDirectories });
   let native;
   let executionId;
   let closing = false;
   let stopped = false;
   let stopPromise = null;
+  const unexpectedExit = Promise.withResolvers();
   const logPath = path.join(privateRoot, "opencode-server.log");
   const processHandle = {
     get exited() { return stopped || native?.running === false; },
+    readLogs: () => native?.readLogs?.() || { stderr: "", stdout: "" },
     async stop() {
       const proof = await execution.stop(executionId, {
         allowMissingRecordScopeRecovery: true,
@@ -268,7 +294,11 @@ export async function createOpenCodeServerProcess({
       logPath, args: ["serve", "--hostname", OPENCODE_HOST, "--port", String(selectedPort), "--mdns=false"] });
     executionId = native.id;
     await onStarted?.(native.id);
-    const fail = error => { if (!closing) Promise.resolve().then(() => onFailure?.(error)).catch(() => {}); };
+    const fail = error => {
+      if (closing) return;
+      unexpectedExit.resolve(error);
+      Promise.resolve().then(() => onFailure?.(error)).catch(() => {});
+    };
     native.exited.then(() => fail(new Error("The owned OpenCode process exited."))).catch(fail);
     const health = await waitForOpenCodeReady({ client, expectedVersion, processHandle, timeoutMs: readinessTimeoutMs, signal });
     const authenticated = new Set();
@@ -283,7 +313,9 @@ export async function createOpenCodeServerProcess({
     }
     return Object.freeze({ client, executionId: native.id, privateRoot, pid: native.pid, port: selectedPort,
       environment, health: Object.freeze({ ...health }), modelProviderIds: Object.freeze([...authenticated]),
-      readLogs: () => native.readLogs?.() || { stderr: "", stdout: "" }, stop,
+      readLogs: processHandle.readLogs, stop,
+      // Resolves when the process exits without being stopped.
+      unexpectedExit: unexpectedExit.promise,
       attachArguments({ conversationId, directory }) {
         if (!conversationId || !path.isAbsolute(directory || "")) throw new TypeError("An OpenCode terminal requires a conversation and absolute directory.");
         return ["attach", baseUrl, "--dir", directory, "--session", conversationId, "--pure"];
@@ -297,7 +329,7 @@ export async function createOpenCodeServerProcess({
       try { await onStarted?.(executionId); }
       catch (bindingError) { error.bindingError = bindingError; }
     }
-    try { error.details = native?.readLogs?.() || { stderr: "", stdout: "" }; }
+    try { error.details = processHandle.readLogs(); }
     catch (logError) { error.logError = logError; }
     try { error.stopProof = await stop(); }
     catch (cleanupError) { error.cleanupError = cleanupError; error.stopProof = { scopeEmpty: false }; }