opencara 0.103.0 → 0.104.1

package/dist/bin.js

@@ -458,6 +458,11 @@ var WsClient = class {
 // src/runner/spawn.ts
 import { spawn as spawn3 } from "node:child_process";
 
+// src/runner/acpRunner.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname2, resolve as pathResolve3 } from "node:path";
+
 // src/acp/client.ts
 import { spawn as spawn2 } from "node:child_process";
 import { EventEmitter } from "node:events";
@@ -1049,9 +1054,10 @@ function runAcpJob(opts) {
     sendRequest: handlers.sendAgentCall
   });
   const host = new McpHost({ runId, router: bridge.router });
+  const resolved = resolveLocalAcpAdapter(spec.command, spec.args);
   const client = new AcpClient({
-    command: spec.command,
-    args: spec.args,
+    command: resolved.command,
+    args: resolved.args,
     env: spec.env,
     cwd: spec.cwd
   });
@@ -1164,6 +1170,22 @@ function textOfContent(content) {
   if (content.type !== "text") return "";
   return content.text ?? "";
 }
+var LOCAL_ACP_ADAPTERS = /* @__PURE__ */ new Set(["claude-acp"]);
+function resolveLocalAcpAdapter(command, args) {
+  if (!LOCAL_ACP_ADAPTERS.has(command)) {
+    return { command, args: [...args] };
+  }
+  const here = dirname2(fileURLToPath2(import.meta.url));
+  const sourceBin = pathResolve3(here, "..", "bin", `${command}.ts`);
+  if (existsSync3(sourceBin)) {
+    return { command: "tsx", args: [sourceBin, ...args] };
+  }
+  const distBin = pathResolve3(here, `${command}.js`);
+  if (existsSync3(distBin)) {
+    return { command: "node", args: [distBin, ...args] };
+  }
+  return { command, args: [...args] };
+}
 
 // src/runner/spawn.ts
 function runJob(spec, stdinJson, handlers) {
@@ -1258,7 +1280,7 @@ var AgentCallParser = class {
 };
 
 // src/commands/run.ts
-var PKG_VERSION = "0.103.0";
+var PKG_VERSION = "0.104.1";
 var LOG_FLUSH_MS = 800;
 var MAX_CHUNK_SIZE = 4 * 1024;
 async function run(opts = {}) {
@@ -1501,7 +1523,7 @@ import {
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync2,
   rmSync,
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   realpathSync,
   writeFileSync as writeFileSync2,
   renameSync
@@ -1556,7 +1578,7 @@ function worktreeCreate(args) {
   const HELPER_SNIPPET = '!f() { echo username=x-access-token; echo "password=$GH_TOKEN"; }; f';
   const cleanUrl = `https://github.com/${repo}.git`;
   mkdirSync2(sessionDir, { recursive: true });
-  if (existsSync3(join2(checkoutDir, ".git"))) {
+  if (existsSync4(join2(checkoutDir, ".git"))) {
     git(checkoutDir, ["fetch", "origin"]);
     git(checkoutDir, ["checkout", "-B", branch, `origin/${branch}`]);
   } else {
@@ -1584,7 +1606,7 @@ function worktreeCreate(args) {
   }
   let priorSession = null;
   const sessionFile = join2(sessionDir, "agent-session.json");
-  if (existsSync3(sessionFile)) {
+  if (existsSync4(sessionFile)) {
     try {
       const parsed = JSON.parse(readFileSync2(sessionFile, "utf8"));
       if (typeof parsed.kind === "string" && typeof parsed.id === "string") {
@@ -1643,7 +1665,7 @@ function worktreeRemove(args) {
   const opencaraRoot = realpathSync(OPENCARA_ROOT);
   for (const subtreeRoot of [WORK_ROOT, SESSION_ROOT]) {
     const target = join2(subtreeRoot, key);
-    if (!existsSync3(target)) continue;
+    if (!existsSync4(target)) continue;
     let resolved;
     try {
       resolved = realpathSync(target);

package/dist/claude-acp.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+// src/bin/claude-acp.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { stdin, stdout, stderr, exit } from "node:process";
+
+// src/acp/framing.ts
+function encodeFrame(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+var FrameDecoder = class {
+  buffer = "";
+  /** Feed a chunk. Returns parsed messages and any malformed lines. */
+  feed(chunk) {
+    this.buffer += chunk;
+    const messages = [];
+    const malformed = [];
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (isPlainObject(parsed)) {
+          messages.push(parsed);
+        } else {
+          malformed.push(trimmed);
+        }
+      } catch {
+        malformed.push(trimmed);
+      }
+    }
+    return { messages, malformed };
+  }
+  /** Whatever's still buffered (a partial line awaiting more data). */
+  remainder() {
+    return this.buffer;
+  }
+};
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/acp/jsonrpc.ts
+var JSON_RPC_ERROR_METHOD_NOT_FOUND = -32601;
+var JSON_RPC_ERROR_INVALID_PARAMS = -32602;
+var JSON_RPC_ERROR_INTERNAL = -32603;
+
+// src/bin/claude-acp.ts
+function send(msg) {
+  stdout.write(encodeFrame(msg));
+}
+function reply(id, result) {
+  send({ jsonrpc: "2.0", id, result });
+}
+function replyError(id, code, message) {
+  send({ jsonrpc: "2.0", id, error: { code, message } });
+}
+function notify(method, params) {
+  send({ jsonrpc: "2.0", method, params });
+}
+var sessions = /* @__PURE__ */ new Map();
+async function runClaudeTurn(sessionId, state, promptText) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-p",
+      "--output-format",
+      "stream-json",
+      // Required for stream-json output per Claude's CLI contract —
+      // without it Claude refuses on the grounds that streaming makes
+      // sense only when stdin can be partial too.
+      "--include-partial-messages",
+      "--verbose",
+      "--session-id",
+      state.claudeSessionId,
+      // Headless: no human in the loop to approve tool use. Matches the
+      // legacy `claudeAdapter` posture in agents/kinds.ts.
+      "--dangerously-skip-permissions",
+      promptText
+    ];
+    const child = spawn("claude", args, {
+      cwd: state.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const decoder2 = new FrameDecoder();
+    let resolved = false;
+    let stopReason = "end_turn";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      const { messages, malformed } = decoder2.feed(chunk);
+      for (const line of malformed) {
+        stderr.write(`[claude-acp] malformed: ${line}
+`);
+      }
+      for (const msg of messages) {
+        handleClaudeEvent(sessionId, msg, (sr) => {
+          if (resolved) return;
+          resolved = true;
+          stopReason = sr;
+        });
+      }
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr.write(chunk);
+    });
+    child.on("error", (err) => {
+      if (!resolved) {
+        resolved = true;
+        reject(err);
+      }
+    });
+    child.on("close", (code) => {
+      if (!resolved) {
+        resolved = true;
+        if (code !== 0) {
+          stderr.write(`[claude-acp] claude exited code=${code} without result event
+`);
+          resolve({ stopReason: "refusal" });
+          return;
+        }
+      }
+      resolve({ stopReason });
+    });
+  });
+}
+function handleClaudeEvent(sessionId, raw, done) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return;
+  const msg = raw;
+  const type = typeof msg["type"] === "string" ? msg["type"] : "";
+  if (type === "assistant") {
+    return;
+  }
+  if (type === "stream_event") {
+    const event = msg["event"];
+    if (event?.type !== "content_block_delta") return;
+    if (event.delta?.type !== "text_delta") return;
+    const text = typeof event.delta.text === "string" ? event.delta.text : "";
+    if (text.length === 0) return;
+    notify("session/update", {
+      sessionId,
+      update: {
+        sessionUpdate: "agent_message_chunk",
+        content: { type: "text", text }
+      }
+    });
+    return;
+  }
+  if (type === "result") {
+    const subtype = typeof msg["subtype"] === "string" ? msg["subtype"] : "";
+    const isError = msg["is_error"] === true;
+    if (isError) {
+      const resultText = typeof msg["result"] === "string" ? msg["result"] : "";
+      if (resultText.length > 0) {
+        notify("session/update", {
+          sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `
+
+[claude error: ${resultText}]` }
+          }
+        });
+      }
+      done("refusal");
+      return;
+    }
+    if (subtype === "error_max_turns") {
+      done("max_turn_requests");
+      return;
+    }
+    if (subtype === "error_max_tokens") {
+      done("max_tokens");
+      return;
+    }
+    done("end_turn");
+    return;
+  }
+}
+function handleInitialize(_params) {
+  return {
+    protocolVersion: 1,
+    agentInfo: {
+      name: "opencara-claude-acp",
+      title: "opencara Claude shim",
+      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,
+      mcpCapabilities: {},
+      promptCapabilities: { embeddedContext: false, image: false, audio: false }
+    },
+    authMethods: []
+  };
+}
+function handleNewSession(params) {
+  const sessionId = randomUUID();
+  sessions.set(sessionId, {
+    claudeSessionId: randomUUID(),
+    cwd: params.cwd ?? process.cwd()
+  });
+  return { sessionId };
+}
+async function handlePrompt(params) {
+  const state = sessions.get(params.sessionId);
+  if (!state) {
+    throw new Error(`unknown sessionId: ${params.sessionId}`);
+  }
+  const promptText = params.prompt.filter((b) => b.type === "text").map((b) => typeof b.text === "string" ? b.text : "").join("\n\n");
+  if (promptText.length === 0) {
+    throw new Error("session/prompt: no text content blocks");
+  }
+  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}
+`);
+  }
+  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;
+  const req = msg;
+  try {
+    switch (req.method) {
+      case "initialize":
+        reply(req.id, handleInitialize(req.params));
+        return;
+      case "session/new":
+        reply(req.id, handleNewSession(req.params));
+        return;
+      case "session/prompt": {
+        const result = await handlePrompt(req.params);
+        reply(req.id, result);
+        return;
+      }
+      default:
+        replyError(
+          req.id,
+          JSON_RPC_ERROR_METHOD_NOT_FOUND,
+          `method not implemented: ${req.method}`
+        );
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    replyError(
+      req.id,
+      err instanceof Error && message.startsWith("session/prompt:") ? JSON_RPC_ERROR_INVALID_PARAMS : JSON_RPC_ERROR_INTERNAL,
+      message
+    );
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.103.0",
+  "version": "0.104.1",
   "description": "OpenCara agent-host CLI: register a machine as an agent host and run dispatched agents.",
   "license": "MIT",
   "repository": {
@@ -12,12 +12,14 @@
   "type": "module",
   "bin": {
     "opencara": "./dist/bin.js",
-    "opencara-mcp": "./dist/opencara-mcp.js"
+    "opencara-mcp": "./dist/opencara-mcp.js",
+    "claude-acp": "./dist/claude-acp.js"
   },
   "main": "./dist/bin.js",
   "files": [
     "dist/bin.js",
-    "dist/opencara-mcp.js"
+    "dist/opencara-mcp.js",
+    "dist/claude-acp.js"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",