@infomity/remogent 0.0.0-stage → 0.2.0

package/dist/adapters/claude.js

@@ -0,0 +1,393 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { findOnPath, killTree, spawnCli } from "./util.js";
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
+/** Cap on tool output / diff stored in a transcript event. */
+const MAX_OUTPUT = 64 * 1024;
+const INIT_TIMEOUT_MS = 15_000;
+const STDERR_RECENT_MS = 5_000;
+const MODE_IDS = {
+    ask: "default",
+    plan: "plan",
+    auto_edit: "acceptEdits",
+    auto: "bypassPermissions",
+};
+function riskOf(tool) {
+    switch (tool) {
+        case "Read":
+        case "Glob":
+        case "Grep":
+        case "LS":
+        case "NotebookRead":
+            return "read";
+        case "Edit":
+        case "MultiEdit":
+        case "Write":
+        case "NotebookEdit":
+            return "edit";
+        case "Bash":
+        case "BashOutput":
+        case "KillShell":
+            return "shell";
+        case "WebFetch":
+        case "WebSearch":
+            return "network";
+        default:
+            return "other";
+    }
+}
+function summaryOf(tool, input) {
+    const i = isObj(input) ? input : {};
+    const detail = str(i["command"]) ?? str(i["file_path"]) ?? str(i["notebook_path"]) ?? str(i["url"]) ?? str(i["pattern"]) ?? str(i["query"]);
+    return (detail ? `${tool}: ${detail}` : tool).slice(0, 300);
+}
+/** Not a strict unified diff (no hunks); old lines prefixed "-", new lines "+". Enough for a phone review sheet. */
+function simpleDiff(path, oldText, newText) {
+    const lines = (v, p) => (typeof v === "string" && v ? v.split("\n").map((l) => p + l) : []);
+    return [`--- ${path}`, `+++ ${path}`, ...lines(oldText, "-"), ...lines(newText, "+")].join("\n");
+}
+function diffOf(tool, input) {
+    if (!isObj(input))
+        return undefined;
+    const path = str(input["file_path"]) ?? str(input["notebook_path"]);
+    if (!path)
+        return undefined;
+    let d;
+    if (tool === "Edit")
+        d = simpleDiff(path, input["old_string"], input["new_string"]);
+    else if (tool === "Write")
+        d = simpleDiff(path, undefined, input["content"]);
+    else if (tool === "MultiEdit" && Array.isArray(input["edits"])) {
+        d = input["edits"]
+            .filter(isObj)
+            .map((e) => simpleDiff(path, e["old_string"], e["new_string"]))
+            .join("\n\n");
+    }
+    return d ? d.slice(0, MAX_OUTPUT) : undefined;
+}
+/** tool_result content is a string or an array of {type:"text"} blocks. */
+function resultText(content) {
+    if (typeof content === "string")
+        return content ? content.slice(0, MAX_OUTPUT) : undefined;
+    if (!Array.isArray(content))
+        return undefined;
+    const t = content
+        .filter(isObj)
+        .map((c) => (c["type"] === "text" ? str(c["text"]) : undefined))
+        .filter((x) => !!x)
+        .join("\n");
+    return t ? t.slice(0, MAX_OUTPUT) : undefined;
+}
+function lastLine(s) {
+    const lines = s.trim().split(/\r?\n/);
+    return lines[lines.length - 1] ?? "";
+}
+/** Path of the `claude` executable if it is installed on this host. */
+export function findClaude() {
+    // PATH first, then the usual install locations (the native installer's ~/.local/bin included): see findOnPath.
+    return findOnPath("claude");
+}
+/**
+ * Only the `env` block of the host user's ~/.claude/settings.json (custom base URL, model, ...). User-level settings are
+ * NOT loaded by the CLI for Remogent sessions (see --setting-sources below), so this keeps the user's routing/auth
+ * setup working without importing their permission allow-rules.
+ */
+function userSettingsEnv() {
+    try {
+        const raw = JSON.parse(readFileSync(join(homedir(), ".claude", "settings.json"), "utf8"));
+        const env = isObj(raw) && isObj(raw["env"]) ? raw["env"] : {};
+        return Object.fromEntries(Object.entries(env).filter((e) => typeof e[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+export function createClaudeAdapter(binary) {
+    /** Spawns one `claude` process (optionally resuming an earlier conversation) and completes the initialize handshake. */
+    async function launch({ cwd, permissionMode }, sink, resumeId, onSessionId) {
+        // User-level settings are NOT loaded: a blanket allow-list there (e.g. `Bash(*)`) made tools run with no
+        // can_use_tool request, so a phone user's approvals would silently not gate anything (seen live, 2026-11-13).
+        // Project/local settings (the repo's own .claude/) still apply. The user's `env` block is passed through.
+        const args = [
+            "-p",
+            "--input-format", "stream-json",
+            "--output-format", "stream-json",
+            "--verbose",
+            "--setting-sources", "project,local",
+            "--permission-prompt-tool", "stdio",
+            "--permission-mode", MODE_IDS[permissionMode],
+            ...(resumeId ? ["--resume", resumeId] : []),
+        ];
+        const child = spawnCli(binary, args, cwd, userSettingsEnv());
+        let started = false; // initialize handshake finished (or timed out)
+        let closed = false; // set once the session is intentionally closed or has died
+        let cancelling = false; // an interrupt was sent for the running turn
+        let stderrTail = "";
+        let lastStderrAt = 0;
+        let dead = false; // the process exited on its own
+        let reqSeq = 0;
+        let turn;
+        let initAck;
+        child.stdin.on("error", () => { });
+        child.stderr.on("data", (d) => {
+            lastStderrAt = Date.now();
+            stderrTail = (stderrTail + d.toString()).slice(-2000); // kept only for exit diagnostics; never logged
+        });
+        const send = (o) => {
+            if (child.stdin.writable)
+                child.stdin.write(JSON.stringify(o) + "\n");
+        };
+        const reply = (requestId, response) => {
+            if ("error" in response) {
+                send({ type: "control_response", response: { subtype: "error", request_id: requestId, error: response.error } });
+            }
+            else {
+                send({ type: "control_response", response: { subtype: "success", request_id: requestId, response } });
+            }
+        };
+        const died = (why) => {
+            dead = true;
+            // Only quote stderr that is recent: an old line (e.g. a rejected background request) is not why it exited.
+            const recent = stderrTail && Date.now() - lastStderrAt < STDERR_RECENT_MS;
+            const err = new Error(recent ? `${why}: ${lastLine(stderrTail)}` : why);
+            const t = turn;
+            turn = undefined;
+            if (closed || !started) {
+                closed = true;
+                t?.reject(err);
+                return;
+            }
+            closed = true;
+            if (t)
+                t.reject(err);
+            else
+                sink.emit({ kind: "error", message: err.message });
+            sink.emit({ kind: "status", status: "error" });
+        };
+        const exited = new Promise((_, reject) => {
+            child.once("exit", (code) => reject(new Error(`claude exited (code ${code})`)));
+            child.once("error", (e) => reject(new Error(`claude failed to start: ${e.message}`)));
+        });
+        exited.catch((e) => died(e.message));
+        const handleControlRequest = (m) => {
+            const requestId = str(m["request_id"]);
+            const req = isObj(m["request"]) ? m["request"] : {};
+            if (!requestId)
+                return;
+            if (req["subtype"] !== "can_use_tool") {
+                reply(requestId, { error: `unsupported control request: ${String(req["subtype"])}` });
+                return;
+            }
+            const tool = str(req["tool_name"]) ?? "tool";
+            const input = req["input"] ?? {};
+            const toolUseId = str(req["tool_use_id"]);
+            const diff = diffOf(tool, input);
+            // `tool` is the Claude tool name, so a host-side allow_session covers that tool (e.g. every Bash command).
+            sink
+                .requestPermission({
+                ...(toolUseId ? { toolCallId: toolUseId } : {}),
+                tool,
+                risk: riskOf(tool),
+                summary: summaryOf(tool, input),
+                input,
+                ...(diff ? { diff } : {}),
+            })
+                .then((decision) => reply(requestId, decision === "deny"
+                ? { behavior: "deny", message: "Denied from Remogent" }
+                : { behavior: "allow", updatedInput: input }), (e) => reply(requestId, { error: e instanceof Error ? e.message : String(e) }));
+        };
+        const handleResult = (m) => {
+            const subtype = str(m["subtype"]);
+            const isError = m["is_error"] === true;
+            let stopReason = "end_turn";
+            if (cancelling)
+                stopReason = "cancelled";
+            else if (subtype === "error_max_turns" || subtype === "error_max_budget_usd")
+                stopReason = "max_budget";
+            else if (isError || (subtype && subtype.startsWith("error"))) {
+                stopReason = "error";
+                sink.emit({ kind: "error", message: str(m["result"]) ?? subtype ?? "claude reported an error" });
+            }
+            const usage = m["usage"] !== undefined || m["total_cost_usd"] !== undefined
+                ? { usage: m["usage"], total_cost_usd: m["total_cost_usd"] }
+                : undefined;
+            sink.emit({ kind: "turn_end", stopReason, ...(usage ? { usage } : {}) });
+            cancelling = false;
+            const t = turn;
+            turn = undefined;
+            t?.resolve();
+        };
+        const handleMessage = (m) => {
+            const claudeSessionId = str(m["session_id"]);
+            if (claudeSessionId)
+                onSessionId(claudeSessionId);
+            switch (m["type"]) {
+                case "control_response": {
+                    const r = isObj(m["response"]) ? m["response"] : {};
+                    if (r["request_id"] === "init-1")
+                        initAck?.();
+                    return;
+                }
+                case "control_request":
+                    handleControlRequest(m);
+                    return;
+                case "assistant": {
+                    const content = isObj(m["message"]) ? m["message"]["content"] : undefined;
+                    if (!Array.isArray(content))
+                        return;
+                    for (const b of content.filter(isObj)) {
+                        if (b["type"] === "text") {
+                            const text = str(b["text"]);
+                            if (text)
+                                sink.emit({ kind: "agent_text_delta", text });
+                        }
+                        else if (b["type"] === "thinking") {
+                            const text = str(b["thinking"]);
+                            if (text)
+                                sink.emit({ kind: "agent_thought_delta", text });
+                        }
+                        else if (b["type"] === "tool_use") {
+                            const toolCallId = str(b["id"]);
+                            const name = str(b["name"]) ?? "tool";
+                            if (!toolCallId)
+                                continue;
+                            sink.emit({
+                                kind: "tool_call",
+                                toolCallId,
+                                name,
+                                title: summaryOf(name, b["input"]),
+                                risk: riskOf(name),
+                                input: b["input"] ?? {},
+                            });
+                        }
+                    }
+                    return;
+                }
+                case "user": {
+                    const content = isObj(m["message"]) ? m["message"]["content"] : undefined;
+                    if (!Array.isArray(content))
+                        return;
+                    for (const b of content.filter(isObj)) {
+                        if (b["type"] !== "tool_result")
+                            continue;
+                        const toolCallId = str(b["tool_use_id"]);
+                        if (!toolCallId)
+                            continue;
+                        const output = resultText(b["content"]);
+                        sink.emit({
+                            kind: "tool_call_update",
+                            toolCallId,
+                            status: b["is_error"] === true ? "failed" : "completed",
+                            ...(output ? { output } : {}),
+                        });
+                    }
+                    return;
+                }
+                case "result":
+                    handleResult(m);
+                    return;
+                default:
+                    return; // system (init, status, thinking_tokens), stream_event, keep_alive, ...
+            }
+        };
+        createInterface({ input: child.stdout }).on("line", (line) => {
+            const t = line.trim();
+            if (!t.startsWith("{"))
+                return; // ignore any non-JSON noise on stdout
+            let m;
+            try {
+                m = JSON.parse(t);
+            }
+            catch {
+                return;
+            }
+            if (isObj(m))
+                handleMessage(m);
+        });
+        // Handshake: ask the CLI to initialize and wait (bounded) for the ack, so a broken install or a missing login
+        // fails `session_create` instead of the first prompt. A timeout is not fatal: the CLI may only ack lazily.
+        try {
+            const ack = new Promise((resolve) => {
+                initAck = resolve;
+            });
+            send({ type: "control_request", request_id: "init-1", request: { subtype: "initialize" } });
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(resolve, INIT_TIMEOUT_MS);
+            });
+            try {
+                await Promise.race([ack, exited, timeout]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+            started = true;
+        }
+        catch (e) {
+            closed = true;
+            killTree(child);
+            throw e instanceof Error ? e : new Error(String(e));
+        }
+        return {
+            hasDied: () => dead,
+            handle: {
+                prompt(text) {
+                    if (closed)
+                        return Promise.reject(new Error("claude process is not running"));
+                    if (turn)
+                        return Promise.reject(new Error("a turn is already running"));
+                    return new Promise((resolve, reject) => {
+                        turn = { resolve, reject };
+                        cancelling = false;
+                        send({ type: "user", message: { role: "user", content: [{ type: "text", text }] } });
+                    });
+                },
+                cancel() {
+                    if (closed || !turn)
+                        return;
+                    cancelling = true;
+                    send({ type: "control_request", request_id: `i${++reqSeq}`, request: { subtype: "interrupt" } });
+                },
+                close() {
+                    closed = true;
+                    killTree(child);
+                },
+            },
+        };
+    }
+    return {
+        engine: "claude",
+        resumable: true,
+        async start(opts, sink) {
+            let claudeSessionId = opts.resumeId;
+            let closedByUser = false;
+            const remember = (id) => {
+                claudeSessionId = id;
+            };
+            // Resuming (after a host restart): spawn lazily on the first prompt instead of keeping an idle process per old chat.
+            let current = opts.resumeId ? undefined : await launch(opts, sink, undefined, remember);
+            return {
+                async prompt(text) {
+                    if (closedByUser)
+                        throw new Error("claude process is not running");
+                    if (!current || (current.hasDied() && claudeSessionId)) {
+                        // No process yet (restored chat) or it exited on its own (killed, crashed): continue the same conversation.
+                        current = await launch(opts, sink, claudeSessionId, remember);
+                    }
+                    return current.handle.prompt(text);
+                },
+                cancel: () => current?.handle.cancel(),
+                close() {
+                    closedByUser = true;
+                    current?.handle.close();
+                },
+                engineSessionId: () => claudeSessionId,
+            };
+        },
+    };
+}
+//# sourceMappingURL=claude.js.map