teapot-coding-agent 0.23.0 → 0.24.1

package/dist/acp/adapter.js

@@ -0,0 +1,198 @@
+import { readEvents } from "../log/events.js";
+import path from "node:path";
+export const ACP_PROTOCOL_VERSION = 1;
+/** JSON-RPC error codes we use (the standard set plus JSON-RPC's own). */
+const PARSE_ERROR = -32700;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const INTERNAL_ERROR = -32603;
+/**
+ * Run the ACP adapter until stdin closes.
+ *
+ * Kept as a class rather than free functions so the session map and the pending
+ * request bookkeeping have somewhere to live, and so it is directly testable
+ * with an in-memory stream pair.
+ */
+export class AcpAdapter {
+    master;
+    input;
+    output;
+    defaultCwd;
+    sessions = new Map();
+    /** id -> notification params, so a prompt turn can stream updates */
+    turnUpdates = new Map();
+    buffer = "";
+    nextSession = 1;
+    initialized = false;
+    constructor(opts) {
+        this.master = opts.master;
+        this.input = opts.input ?? process.stdin;
+        this.output = opts.output ?? process.stdout;
+        this.defaultCwd = opts.defaultCwd ?? process.cwd();
+    }
+    /** Attach to the stream. Resolves when stdin ends. */
+    listen() {
+        return new Promise((resolve) => {
+            this.input.on("data", (chunk) => this.onData(String(chunk)));
+            this.input.on("end", () => resolve());
+            this.input.on("error", () => resolve());
+            if (typeof this.input.resume === "function")
+                this.input.resume();
+        });
+    }
+    /* ---------- transport ---------- */
+    onData(chunk) {
+        this.buffer += chunk;
+        // NDJSON: one JSON object per line
+        let nl;
+        while ((nl = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, nl).trim();
+            this.buffer = this.buffer.slice(nl + 1);
+            if (line)
+                this.handleLine(line);
+        }
+    }
+    handleLine(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            // a parse error has no id to answer
+            this.send({ jsonrpc: "2.0", id: null, error: { code: PARSE_ERROR, message: "invalid JSON" } });
+            return;
+        }
+        void this.dispatch(msg);
+    }
+    send(res) {
+        this.output.write(JSON.stringify(res) + "\n");
+    }
+    notify(method, params) {
+        this.send({ jsonrpc: "2.0", method, params });
+    }
+    ok(id, result) {
+        this.send({ jsonrpc: "2.0", id, result });
+    }
+    fail(id, code, message) {
+        this.send({ jsonrpc: "2.0", id, error: { code, message } });
+    }
+    /* ---------- dispatch ---------- */
+    async dispatch(msg) {
+        const { method, id, params } = msg;
+        const isNotification = id === undefined || id === null;
+        try {
+            switch (method) {
+                case "initialize":
+                    return this.ok(id ?? null, this.initialize());
+                case "authenticate":
+                    return this.ok(id ?? null, {});
+                case "session/new":
+                    return this.ok(id ?? null, await this.newSession(params));
+                case "session/load":
+                    return this.ok(id ?? null, await this.loadSession(params));
+                case "session/prompt":
+                    return await this.prompt(id ?? null, params);
+                case "session/cancel":
+                    this.cancel(params);
+                    if (!isNotification)
+                        return this.ok(id ?? null, {});
+                    return;
+                default:
+                    // notifications for unknown methods get NO response at all
+                    if (isNotification)
+                        return;
+                    return this.fail(id ?? null, METHOD_NOT_FOUND, `unknown method: ${method}`);
+            }
+        }
+        catch (err) {
+            if (isNotification)
+                return; // never answer a notification
+            return this.fail(id ?? null, INTERNAL_ERROR, err.message);
+        }
+    }
+    initialize() {
+        this.initialized = true;
+        return {
+            protocolVersion: ACP_PROTOCOL_VERSION,
+            // Only capabilities we actually implement. Terminal/fs are deliberately
+            // absent: a client calls what we advertise, and a partial implementation
+            // would be worse than an honest omission.
+            agentCapabilities: { loadSession: true, promptCapabilities: { image: false, audio: false } },
+            authMethods: [],
+        };
+    }
+    /* ---------- sessions ---------- */
+    async newSession(params) {
+        const p = (params ?? {});
+        const cwd = p.cwd ? path.resolve(String(p.cwd)) : this.defaultCwd;
+        const id = `acp-${this.nextSession++}`;
+        const agent = await this.master.addAgent({ id, workspace: cwd }, { persist: false, fresh: true });
+        this.sessions.set(id, { id, cwd, agent });
+        return { sessionId: id };
+    }
+    async loadSession(params) {
+        const p = (params ?? {});
+        const id = String(p.sessionId ?? "");
+        const existing = this.sessions.get(id);
+        if (existing)
+            return null; // already live
+        const cwd = p.cwd ? path.resolve(String(p.cwd)) : this.defaultCwd;
+        // resuming means the agent's own log is restored, not a fresh session
+        const agent = await this.master.addAgent({ id, workspace: cwd }, { persist: false, fresh: false });
+        this.sessions.set(id, { id, cwd, agent });
+        return null;
+    }
+    cancel(params) {
+        const p = (params ?? {});
+        const s = p.sessionId ? this.sessions.get(String(p.sessionId)) : undefined;
+        s?.agent.stop("cancelled via ACP");
+    }
+    /* ---------- prompt turn ---------- */
+    async prompt(id, params) {
+        const p = (params ?? {});
+        const s = p.sessionId ? this.sessions.get(String(p.sessionId)) : undefined;
+        if (!s)
+            return this.fail(id, INVALID_PARAMS, `unknown session: ${String(p.sessionId)}`);
+        const text = (p.prompt ?? [])
+            .map((c) => String(c?.text ?? ""))
+            .join("\n")
+            .trim();
+        if (!text)
+            return this.fail(id, INVALID_PARAMS, "prompt must contain text");
+        this.turnUpdates.set(id, { sessionId: s.id });
+        try {
+            s.agent.enqueuePrompt(text, "user");
+            if (s.agent.status !== "running")
+                s.agent.start("acp prompt");
+            await s.agent.settled();
+            const stopReason = s.agent.goal.status === "done" ? "end_turn" : "end_turn";
+            return this.ok(id, { stopReason });
+        }
+        finally {
+            this.turnUpdates.delete(id);
+        }
+    }
+    /** Stream a session's events to the client as session/update notifications. */
+    async drainOnce(sessionId, afterSeq = 0) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            return afterSeq;
+        const events = await readEvents(s.agent.log.filePath).catch(() => []);
+        for (const e of events) {
+            if (e.seq <= afterSeq)
+                continue;
+            this.notify("session/update", {
+                sessionId,
+                update: {
+                    sessionUpdate: e.type === "message" ? "agent_message_chunk" : "tool_call",
+                    content: { type: "text", text: String(e.data?.content ?? "") },
+                },
+            });
+        }
+        const max = events.reduce((m, e) => Math.max(m, e.seq), afterSeq);
+        return max;
+    }
+    get initialized_() {
+        return this.initialized;
+    }
+}