opencara 0.102.0 → 0.104.0

package/dist/claude-acp.js

@@ -0,0 +1,281 @@
+#!/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") {
+    const message = msg["message"];
+    const blocks = message?.content ?? [];
+    for (const block of blocks) {
+      if (block?.type !== "text") continue;
+      const text = typeof block.text === "string" ? block.text : "";
+      if (text.length === 0) continue;
+      notify("session/update", {
+        sessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        }
+      });
+    }
+    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
+    );
+  }
+}