opencara 0.105.0 → 0.105.2

package/dist/bin.js

@@ -13,6 +13,7 @@ import {
   uptime
 } from "node:os";
 import { statfsSync } from "node:fs";
+import { spawn as spawn3 } from "node:child_process";
 
 // src/config/store.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
@@ -85,7 +86,8 @@ var AcpSpecSchema = z3.object({
   systemPromptMd: z3.string(),
   userPromptMd: z3.string(),
   history: z3.array(AcpHistoryTurnSchema).default([]),
-  pageContextJson: z3.string().optional()
+  pageContextJson: z3.string().optional(),
+  priorSessionId: z3.string().optional()
 });
 var AgentSpecSchema = z3.object({
   kind: z3.string(),
@@ -184,7 +186,12 @@ var RunDoneSchema = z4.object({
   runId: z4.string(),
   status: z4.enum(["succeeded", "failed", "cancelled"]),
   exitCode: z4.number().int().nullable().optional(),
-  errorMessage: z4.string().optional()
+  errorMessage: z4.string().optional(),
+  /** ACP session id the agent ran under (fresh from session/new, or
+   *  echoed from session/load). The orchestrator persists this per
+   *  (repo, branch) so the next iteration can resume via session/load.
+   *  Null/absent for non-ACP runs (worktree-allocate, write-session). */
+  acpSessionId: z4.string().nullable().optional()
 });
 var HelloAckSchema = z4.object({
   type: z4.literal("hello-ack"),
@@ -561,6 +568,9 @@ var AcpConnection = class {
   newSession(req) {
     return this.request(ACP_METHODS.session_new, req);
   }
+  loadSession(req) {
+    return this.request(ACP_METHODS.session_load, req);
+  }
   prompt(req) {
     return this.request(ACP_METHODS.session_prompt, req);
   }
@@ -722,6 +732,9 @@ var AcpClient = class {
   newSession(req) {
     return this.must().newSession(req);
   }
+  loadSession(req) {
+    return this.must().loadSession(req);
+  }
   prompt(req) {
     return this.must().prompt(req);
   }
@@ -1065,26 +1078,35 @@ function runAcpJob(opts) {
     }
   };
   const promise = (async () => {
-    let result = { exitCode: 1, stopReason: "uninitialized" };
+    let result = { exitCode: 1, stopReason: "uninitialized", sessionId: "" };
     try {
       await host.start();
       client.start();
-      await client.initialize({
+      const initResult = await client.initialize({
         protocolVersion: ACP_PROTOCOL_VERSION,
         clientCapabilities: {}
       });
-      const session = await client.newSession({
-        cwd: spec.cwd ?? process.cwd(),
-        mcpServers: [host.acpServerEntry()]
-      });
+      const cwd = spec.cwd ?? process.cwd();
+      const mcpServers = [host.acpServerEntry()];
+      const shimSupportsLoad = initResult.agentCapabilities?.loadSession === true;
+      let sessionId;
+      if (acpSpec.priorSessionId && shimSupportsLoad) {
+        await client.loadSession({
+          sessionId: acpSpec.priorSessionId,
+          cwd,
+          mcpServers
+        });
+        sessionId = acpSpec.priorSessionId;
+      } else {
+        const session = await client.newSession({ cwd, mcpServers });
+        sessionId = session.sessionId;
+      }
       const prompt = buildPromptContent(acpSpec);
-      const promptResult = await client.prompt({
-        sessionId: session.sessionId,
-        prompt
-      });
+      const promptResult = await client.prompt({ sessionId, prompt });
       result = {
         exitCode: promptResult.stopReason === "end_turn" ? 0 : 1,
-        stopReason: promptResult.stopReason
+        stopReason: promptResult.stopReason,
+        sessionId
       };
       return result;
     } finally {
@@ -1184,7 +1206,7 @@ function resolveLocalAcpAdapter(command, args) {
 }
 
 // src/commands/run.ts
-var PKG_VERSION = "0.105.0";
+var PKG_VERSION = "0.105.2";
 var LOG_FLUSH_MS = 800;
 var MAX_CHUNK_SIZE = 4 * 1024;
 async function run(opts = {}) {
@@ -1260,6 +1282,11 @@ async function executeJob(job, client) {
     if (flushTimer) return;
     flushTimer = setTimeout(flush, LOG_FLUSH_MS);
   };
+  if (isInternalCommand(job.spec)) {
+    flush();
+    await runInternalCommand(job, client);
+    return;
+  }
   if (!job.spec.acp) {
     flush();
     const message = `legacy stdin-JSON dispatch removed in v0.30 \u2014 orchestrator must send spec.acp. Got command: ${job.spec.command}.`;
@@ -1286,7 +1313,8 @@ async function executeJob(job, client) {
       type: "done",
       runId,
       status: result.exitCode === 0 ? "succeeded" : "failed",
-      exitCode: result.exitCode
+      exitCode: result.exitCode,
+      acpSessionId: result.sessionId || null
     });
     console.log(
       `[opencara] job ${runId.slice(-8)} (acp) \u2192 ${result.stopReason} exit=${result.exitCode}`
@@ -1300,6 +1328,63 @@ async function executeJob(job, client) {
     acpControllers.delete(runId);
   }
 }
+function isInternalCommand(spec) {
+  return spec.command === "opencara" && Array.isArray(spec.args) && spec.args[0] === "internal";
+}
+async function runInternalCommand(job, client, opts = {}) {
+  const runId = job.run.id;
+  const args = job.spec.args ?? [];
+  const binPath = opts.binPath ?? process.argv[1];
+  const nodePath = opts.nodePath ?? process.execPath;
+  if (!binPath) {
+    client.send({
+      type: "done",
+      runId,
+      status: "failed",
+      errorMessage: "internal: process.argv[1] missing \u2014 cannot re-invoke bin"
+    });
+    return;
+  }
+  let seq = 0;
+  const emit = (stream, chunk) => {
+    let remaining = chunk;
+    while (remaining.length > 0) {
+      const take = remaining.slice(0, MAX_CHUNK_SIZE);
+      client.send({ type: "log", runId, seq: seq++, stream, chunk: take });
+      remaining = remaining.slice(MAX_CHUNK_SIZE);
+    }
+  };
+  const child = spawn3(nodePath, [binPath, ...args], {
+    cwd: job.spec.cwd,
+    env: job.spec.env ? { ...process.env, ...job.spec.env } : process.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (c) => emit("stdout", c));
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (c) => emit("stderr", c));
+  const { exitCode, errorMessage } = await new Promise((resolve) => {
+    let done = false;
+    child.on("error", (err) => {
+      if (done) return;
+      done = true;
+      resolve({ exitCode: 1, errorMessage: `internal spawn error: ${err.message}` });
+    });
+    child.on("close", (code, signal) => {
+      if (done) return;
+      done = true;
+      resolve({ exitCode: code ?? (signal ? 1 : 0) });
+    });
+  });
+  client.send({
+    type: "done",
+    runId,
+    status: exitCode === 0 ? "succeeded" : "failed",
+    exitCode,
+    ...errorMessage ? { errorMessage } : {}
+  });
+  console.log(`[opencara] job ${runId.slice(-8)} (internal) \u2192 exit=${exitCode}`);
+}
 function collectSystemInfo() {
   try {
     const cpuList = cpus();

package/dist/claude-acp.js

@@ -74,23 +74,25 @@ async function runClaudeTurn(sessionId, state, promptText) {
       "--include-partial-messages",
       "--verbose",
       "--session-id",
-      state.claudeSessionId,
+      sessionId,
       // Headless: no human in the loop to approve tool use. Matches the
       // legacy `claudeAdapter` posture in agents/kinds.ts.
-      "--dangerously-skip-permissions",
-      promptText
+      "--dangerously-skip-permissions"
     ];
     const child = spawn("claude", args, {
       cwd: state.cwd,
       env: process.env,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdin.on("error", () => {
     });
-    const decoder2 = new FrameDecoder();
+    child.stdin.end(promptText);
+    const decoder = new FrameDecoder();
     let resolved = false;
     let stopReason = "end_turn";
     child.stdout.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
-      const { messages, malformed } = decoder2.feed(chunk);
+      const { messages, malformed } = decoder.feed(chunk);
       for (const line of malformed) {
         stderr.write(`[claude-acp] malformed: ${line}
 `);
@@ -189,10 +191,12 @@ function handleInitialize(_params) {
       version: "0.0.1"
     },
     agentCapabilities: {
-      // No session resume yet (follow-up). MCP via stdio works because
-      // the `claude` CLI itself supports `mcpServers` in settings.json
-      // but we don't propagate ACP's mcpServers config in this MVP.
-      loadSession: false,
+      // Session resume works by passing the ACP sessionId back as
+      // `claude --session-id <uuid>` on the next prompt — Claude CLI
+      // replays its own JSONL internally. MCP via stdio is not yet
+      // propagated from ACP's mcpServers config (the `claude` CLI uses
+      // settings.json for that today; bridging is a separate change).
+      loadSession: true,
       mcpCapabilities: {},
       promptCapabilities: { embeddedContext: false, image: false, audio: false }
     },
@@ -201,12 +205,16 @@ function handleInitialize(_params) {
 }
 function handleNewSession(params) {
   const sessionId = randomUUID();
-  sessions.set(sessionId, {
-    claudeSessionId: randomUUID(),
-    cwd: params.cwd ?? process.cwd()
-  });
+  sessions.set(sessionId, { cwd: params.cwd ?? process.cwd() });
   return { sessionId };
 }
+function handleLoadSession(params) {
+  if (typeof params.sessionId !== "string" || params.sessionId.length === 0) {
+    throw new Error("session/load: sessionId required");
+  }
+  sessions.set(params.sessionId, { cwd: params.cwd ?? process.cwd() });
+  return {};
+}
 async function handlePrompt(params) {
   const state = sessions.get(params.sessionId);
   if (!state) {
@@ -219,19 +227,22 @@ async function handlePrompt(params) {
   const result = await runClaudeTurn(params.sessionId, state, promptText);
   return { stopReason: result.stopReason };
 }
-var decoder = new FrameDecoder();
-stdin.setEncoding("utf8");
-stdin.on("data", (chunk) => {
-  const { messages, malformed } = decoder.feed(chunk);
-  for (const line of malformed) {
-    stderr.write(`[claude-acp] malformed inbound: ${line}
+var isMainModule = import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith("claude-acp.ts") === true || process.argv[1]?.endsWith("claude-acp.js") === true;
+if (isMainModule) {
+  const decoder = new FrameDecoder();
+  stdin.setEncoding("utf8");
+  stdin.on("data", (chunk) => {
+    const { messages, malformed } = decoder.feed(chunk);
+    for (const line of malformed) {
+      stderr.write(`[claude-acp] malformed inbound: ${line}
 `);
-  }
-  for (const msg of messages) void dispatch(msg);
-});
-stdin.on("end", () => {
-  exit(0);
-});
+    }
+    for (const msg of messages) void dispatch(msg);
+  });
+  stdin.on("end", () => {
+    exit(0);
+  });
+}
 async function dispatch(msg) {
   if (!("id" in msg) || msg.id == null) return;
   if ("result" in msg || "error" in msg) return;
@@ -244,6 +255,9 @@ async function dispatch(msg) {
       case "session/new":
         reply(req.id, handleNewSession(req.params));
         return;
+      case "session/load":
+        reply(req.id, handleLoadSession(req.params));
+        return;
       case "session/prompt": {
         const result = await handlePrompt(req.params);
         reply(req.id, result);
@@ -258,10 +272,17 @@ async function dispatch(msg) {
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
+    const isParamsError = err instanceof Error && (message.startsWith("session/prompt:") || message.startsWith("session/load:"));
     replyError(
       req.id,
-      err instanceof Error && message.startsWith("session/prompt:") ? JSON_RPC_ERROR_INVALID_PARAMS : JSON_RPC_ERROR_INTERNAL,
+      isParamsError ? JSON_RPC_ERROR_INVALID_PARAMS : JSON_RPC_ERROR_INTERNAL,
       message
     );
   }
 }
+export {
+  handleInitialize,
+  handleLoadSession,
+  handleNewSession,
+  sessions
+};

package/dist/opencara-mcp.js

@@ -127,7 +127,8 @@ var AcpSpecSchema = z2.object({
   systemPromptMd: z2.string(),
   userPromptMd: z2.string(),
   history: z2.array(AcpHistoryTurnSchema).default([]),
-  pageContextJson: z2.string().optional()
+  pageContextJson: z2.string().optional(),
+  priorSessionId: z2.string().optional()
 });
 var AgentSpecSchema = z2.object({
   kind: z2.string(),
@@ -226,7 +227,12 @@ var RunDoneSchema = z3.object({
   runId: z3.string(),
   status: z3.enum(["succeeded", "failed", "cancelled"]),
   exitCode: z3.number().int().nullable().optional(),
-  errorMessage: z3.string().optional()
+  errorMessage: z3.string().optional(),
+  /** ACP session id the agent ran under (fresh from session/new, or
+   *  echoed from session/load). The orchestrator persists this per
+   *  (repo, branch) so the next iteration can resume via session/load.
+   *  Null/absent for non-ACP runs (worktree-allocate, write-session). */
+  acpSessionId: z3.string().nullable().optional()
 });
 var HelloAckSchema = z3.object({
   type: z3.literal("hello-ack"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.105.0",
+  "version": "0.105.2",
   "description": "OpenCara agent-host CLI: register a machine as an agent host and run dispatched agents.",
   "license": "MIT",
   "repository": {
@@ -38,7 +38,7 @@
     "dev": "tsx watch src/bin.ts",
     "start": "node dist/bin.js",
     "typecheck": "tsc -b",
-    "test": "node --import tsx --test --test-reporter=spec src/acp/__tests__/*.test.ts src/mcp/__tests__/*.test.ts src/runner/__tests__/*.test.ts",
+    "test": "node --import tsx --test --test-reporter=spec src/acp/__tests__/*.test.ts src/mcp/__tests__/*.test.ts src/runner/__tests__/*.test.ts src/bin/__tests__/*.test.ts src/commands/__tests__/*.test.ts",
     "acp:spike": "tsx src/acp/spike.ts",
     "mcp:smoke": "tsx src/mcp/smoke.ts",
     "clean": "rm -rf dist *.tsbuildinfo"