@wrongstack/acp 0.273.1 → 0.275.0

package/dist/wrongstack-acp-agent.js

@@ -1,4 +1,5 @@
 import { fileURLToPath } from 'url';
+import { createServer } from 'http';
 import { writeErr, expectDefined } from '@wrongstack/core';
 
 // src/agent/wrongstack-acp-agent.ts
@@ -10,7 +11,16 @@ var ACP_PROTOCOL_VERSION = 1;
 function toWire(msg) {
   return msg;
 }
-var WRONGSTACK_VERSION = "0.263.0";
+var WRONGSTACK_VERSION = "0.274.1";
+var WRONGSTACK_AUTH_METHODS = [
+  {
+    id: "wrongstack-auth",
+    name: "Run wstack auth",
+    description: "Configure a WrongStack model provider in an interactive terminal.",
+    type: "terminal",
+    args: ["auth"]
+  }
+];
 var DEFAULT_MODE_ID = "code";
 var DEFAULT_MODES = [
   {
@@ -27,9 +37,17 @@ var ACPProtocolHandler = class {
   modes;
   configOptions;
   agentName;
+  replayFor;
+  seedFor;
+  store;
   initialized = false;
+  clientCapabilities = {};
   sessions = /* @__PURE__ */ new Map();
   nextId = 1;
+  // Outbound request correlation (server → client requests, e.g.
+  // session/request_permission). Keyed by our own `srv_N` ids.
+  pendingOut = /* @__PURE__ */ new Map();
+  nextOutId = 1;
   constructor(opts) {
     this.transport = opts.transport;
     this.defaultCwd = opts.defaultCwd;
@@ -39,6 +57,43 @@ var ACPProtocolHandler = class {
     this.modes = opts.modes ?? DEFAULT_MODES;
     this.configOptions = opts.configOptions ?? [];
     this.agentName = opts.agentName ?? "wrongstack";
+    this.replayFor = opts.replayFor;
+    this.seedFor = opts.seedFor;
+    this.store = opts.store;
+    if (typeof this.transport.onMessage === "function") {
+      this.transport.onMessage((m) => this.maybeResolvePending(m));
+    }
+  }
+  /**
+   * Send a request to the client and await its response. Used for
+   * server-initiated calls like `session/request_permission`. Rejects on
+   * timeout or transport error so the caller can pick a safe fallback.
+   */
+  request(method, params, timeoutMs = 6e4) {
+    const id = `srv_${this.nextOutId++}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingOut.delete(id);
+        reject(new Error(`${method} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pendingOut.set(id, { resolve, reject, timer });
+      this.transport.send(toWire({ jsonrpc: "2.0", id, method, params })).catch((e) => {
+        clearTimeout(timer);
+        this.pendingOut.delete(id);
+        reject(e instanceof Error ? e : new Error(String(e)));
+      });
+    });
+  }
+  maybeResolvePending(m) {
+    const id = m.id;
+    if (typeof id !== "string") return;
+    const pending = this.pendingOut.get(id);
+    if (!pending) return;
+    this.pendingOut.delete(id);
+    clearTimeout(pending.timer);
+    const err = m.error;
+    if (err) pending.reject(new Error(err.message ?? "client request failed"));
+    else pending.resolve(m.result);
   }
   /**
    * Process one inbound message. Returns true if this was a terminal
@@ -65,6 +120,11 @@ var ACPProtocolHandler = class {
       session.abort.abort();
     }
     this.sessions.clear();
+    for (const [, p] of this.pendingOut) {
+      clearTimeout(p.timer);
+      p.reject(new Error("protocol handler closed"));
+    }
+    this.pendingOut.clear();
   }
   // ────────────────────────────────────────────────────────────────────
   // Requests
@@ -80,10 +140,18 @@ var ACPProtocolHandler = class {
           return await this.handleInitialize(id, params);
         case "authenticate":
           return await this.handleAuthenticate(id, params);
+        case "logout":
+          return await this.handleLogout(id, params);
         case "session/new":
           return await this.handleSessionNew(id, params);
         case "session/load":
           return await this.handleSessionLoad(id, params);
+        case "session/resume":
+          return await this.handleSessionResume(id, params);
+        case "session/close":
+          return await this.handleSessionClose(id, params);
+        case "session/delete":
+          return await this.handleSessionDelete(id, params);
         case "session/prompt":
           return await this.handleSessionPrompt(id, params);
         case "session/set_mode":
@@ -92,6 +160,16 @@ var ACPProtocolHandler = class {
           return await this.handleSetConfigOption(id, params);
         case "session/list":
           return await this.handleSessionList(id);
+        case "session/fork":
+          return await this.handleSessionFork(id, params);
+        case "providers/list":
+          return await this.handleProvidersList(id, params);
+        case "providers/set":
+          return await this.handleProvidersSet(id, params);
+        case "providers/disable":
+          return await this.handleProvidersDisable(id, params);
+        case "mcp/message":
+          return await this.handleMcpMessage(id, params);
         default:
           await this.sendError(id, -32601, `Unknown method: ${method}`);
           return false;
@@ -104,14 +182,8 @@ var ACPProtocolHandler = class {
   }
   async handleInitialize(id, params) {
     const p = params ?? {};
-    const requested = typeof p.protocolVersion === "number" ? p.protocolVersion : 1;
-    if (requested !== ACP_PROTOCOL_VERSION) {
-      await this.sendError(
-        id,
-        -32e3,
-        `server speaks protocolVersion=${ACP_PROTOCOL_VERSION}, client requested ${requested}`
-      );
-      return false;
+    if (p.clientCapabilities && typeof p.clientCapabilities === "object") {
+      this.clientCapabilities = p.clientCapabilities;
     }
     this.initialized = true;
     await this.transport.send(toWire({
@@ -122,9 +194,25 @@ var ACPProtocolHandler = class {
         agentCapabilities: {
           loadSession: true,
           promptCapabilities: {
-            image: false,
+            // We route ACP image blocks into the core agent's multimodal
+            // input (server-agent-turn.promptToAgentInput); whether the
+            // model can see them is the configured provider's concern.
+            image: true,
             audio: false,
             embeddedContext: true
+          },
+          mcpCapabilities: {
+            http: false,
+            sse: false
+          },
+          sessionCapabilities: {
+            close: {},
+            list: {},
+            delete: {},
+            resume: {}
+          },
+          auth: {
+            logout: {}
           }
         },
         agentInfo: {
@@ -132,10 +220,7 @@ var ACPProtocolHandler = class {
           title: "WrongStack",
           version: WRONGSTACK_VERSION
         },
-        // Static options advertised at handshake. They are also
-        // re-sent on every `current_mode_update` / `config_option_update`
-        // notification so late-joining clients see them.
-        authMethods: [],
+        authMethods: WRONGSTACK_AUTH_METHODS,
         modes: this.modes,
         configOptions: this.configOptions
       }
@@ -150,6 +235,14 @@ var ACPProtocolHandler = class {
     }));
     return false;
   }
+  async handleLogout(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
   async handleSessionNew(id, params) {
     const p = params ?? {};
     const cwd = typeof p.cwd === "string" ? p.cwd : this.defaultCwd;
@@ -165,6 +258,7 @@ var ACPProtocolHandler = class {
     };
     this.sessions.set(sessionId, state);
     this.onSessionNew(state);
+    await this.persist(state);
     await this.sendNotification({
       sessionId,
       update: {
@@ -193,7 +287,173 @@ var ACPProtocolHandler = class {
     return false;
   }
   async handleSessionLoad(id, params) {
-    return this.handleSessionNew(id, params);
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const loadCwd = typeof p.cwd === "string" ? p.cwd : void 0;
+    let existing = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!existing && sessionId && this.store) {
+      const persisted = await this.store.load(sessionId);
+      if (persisted) {
+        const restored = {
+          id: sessionId,
+          cwd: persisted.cwd ?? loadCwd ?? this.defaultCwd,
+          abort: new AbortController(),
+          modeId: persisted.modeId ?? DEFAULT_MODE_ID,
+          createdAt: persisted.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          ...persisted.title !== void 0 ? { title: persisted.title } : {}
+        };
+        this.sessions.set(sessionId, restored);
+        this.seedFor?.(sessionId, persisted.history ?? []);
+        for (const update of persisted.history ?? []) {
+          await this.sendNotification({ sessionId, update });
+        }
+        await this.sendNotification({
+          sessionId,
+          update: { sessionUpdate: "current_mode_update", modeId: restored.modeId }
+        });
+        await this.transport.send(toWire({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            initialMode: { currentModeId: restored.modeId, availableModes: this.modes }
+          }
+        }));
+        return false;
+      }
+    }
+    if (existing) {
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const replay = sessionId ? this.replayFor?.(sessionId) : void 0;
+      if (replay) {
+        for (const update of replay) {
+          await this.sendNotification({ sessionId, update });
+        }
+      }
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          updatedAt: existing.updatedAt
+        }
+      });
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "current_mode_update",
+          modeId: existing.modeId
+        }
+      });
+      await this.transport.send(toWire({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          initialMode: {
+            currentModeId: existing.modeId,
+            availableModes: this.modes
+          }
+        }
+      }));
+      return false;
+    }
+    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+    return false;
+  }
+  async handleSessionResume(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const existing = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (existing) {
+      existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await this.transport.send(toWire({
+        jsonrpc: "2.0",
+        id,
+        result: {
+          initialMode: {
+            currentModeId: existing.modeId,
+            availableModes: this.modes
+          }
+        }
+      }));
+      return false;
+    }
+    await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+    return false;
+  }
+  async handleSessionClose(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const session = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!session) {
+      await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+      return false;
+    }
+    session.abort.abort();
+    if (sessionId) this.sessions.delete(sessionId);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleSessionDelete(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sessionId) {
+      await this.sendError(id, -32e3, `session not found: ${sessionId}`);
+      return false;
+    }
+    if (!this.sessions.has(sessionId)) {
+      await this.transport.send(toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } }));
+      return false;
+    }
+    const session = this.sessions.get(sessionId);
+    session.abort.abort();
+    this.sessions.delete(sessionId);
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleSessionFork(id, params) {
+    const p = params ?? {};
+    const sourceId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sourceId || !this.sessions.has(sourceId)) {
+      await this.sendError(id, -32e3, `session not found: ${sourceId}`);
+      return false;
+    }
+    const forkParams = params;
+    return this.handleSessionNew(id, { ...forkParams, cwd: p.cwd ?? this.defaultCwd });
+  }
+  async handleProvidersList(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        providers: [],
+        currentProviderId: null
+      }
+    }));
+    return false;
+  }
+  async handleProvidersSet(id, _params) {
+    await this.sendError(id, -32e3, "provider configuration not available through ACP; use wstack auth");
+    return false;
+  }
+  async handleProvidersDisable(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {}
+    }));
+    return false;
+  }
+  async handleMcpMessage(id, _params) {
+    await this.sendError(id, -32e3, "MCP message routing not available through ACP");
+    return false;
   }
   async handleSessionPrompt(id, params) {
     const p = params ?? {};
@@ -213,11 +473,54 @@ var ACPProtocolHandler = class {
     const turnSignal = new AbortController();
     const onCancel = () => turnSignal.abort();
     session.abort.signal.addEventListener("abort", onCancel, { once: true });
+    const api = {
+      clientCapabilities: this.clientCapabilities,
+      requestPermission: async (req) => {
+        const res = await this.request("session/request_permission", {
+          sessionId,
+          toolCall: req.toolCall,
+          options: req.options
+        });
+        const outcome = res?.outcome;
+        return outcome ?? { outcome: "cancelled" };
+      },
+      readTextFile: async (params2) => {
+        const res = await this.request("fs/read_text_file", { sessionId, ...params2 });
+        return String(res?.content ?? "");
+      },
+      writeTextFile: async (params2) => {
+        await this.request("fs/write_text_file", { sessionId, ...params2 });
+      },
+      runTerminal: async ({ command, args, cwd }) => {
+        const created = await this.request("terminal/create", {
+          sessionId,
+          command,
+          ...args ? { args } : {},
+          ...cwd ? { cwd } : {}
+        });
+        const terminalId = created?.terminalId;
+        if (!terminalId) return { output: "", exitCode: null };
+        try {
+          const exit = await this.request("terminal/wait_for_exit", { sessionId, terminalId });
+          const out = await this.request("terminal/output", { sessionId, terminalId });
+          return {
+            output: String(out?.output ?? ""),
+            exitCode: typeof exit?.exitCode === "number" ? exit.exitCode : null
+          };
+        } finally {
+          try {
+            await this.request("terminal/release", { sessionId, terminalId });
+          } catch {
+          }
+        }
+      }
+    };
     let result;
     try {
       result = await this.runTurn(
         { sessionId, prompt: p.prompt, signal: turnSignal.signal },
-        (update) => this.sendNotification({ sessionId, update })
+        (update) => this.sendNotification({ sessionId, update }),
+        api
       );
     } catch (err) {
       session.abort.signal.removeEventListener("abort", onCancel);
@@ -227,6 +530,7 @@ var ACPProtocolHandler = class {
     }
     session.abort.signal.removeEventListener("abort", onCancel);
     session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.persist(session);
     await this.transport.send(toWire({
       jsonrpc: "2.0",
       id,
@@ -255,12 +559,12 @@ var ACPProtocolHandler = class {
   async handleSetConfigOption(id, params) {
     const p = params ?? {};
     const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
-    const optionId = typeof p.configOptionId === "string" ? p.configOptionId : null;
+    const optionId = typeof p.configId === "string" ? p.configId : null;
     const value = typeof p.value === "string" ? p.value : null;
     const session = sessionId ? this.sessions.get(sessionId) : void 0;
     const option = optionId ? this.configOptions.find((o) => o.id === optionId) : void 0;
     if (!session || !option || value === null || !option.options.some((o) => o.value === value)) {
-      await this.sendError(id, -32602, "invalid sessionId, configOptionId, or value");
+      await this.sendError(id, -32602, "invalid sessionId, configId, or value");
       return false;
     }
     option.currentValue = value;
@@ -272,7 +576,7 @@ var ACPProtocolHandler = class {
         configOptions: [...this.configOptions]
       }
     });
-    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: { configOptions: [...this.configOptions] } }));
     return false;
   }
   async handleSessionList(id) {
@@ -306,6 +610,9 @@ var ACPProtocolHandler = class {
         }
         return false;
       }
+      case "$/cancel_request": {
+        return false;
+      }
       case "exit":
         this.close();
         return true;
@@ -319,6 +626,14 @@ var ACPProtocolHandler = class {
   async sendNotification(params) {
     await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
   }
+  /** Best-effort durable persistence of a session + its recorded history. */
+  async persist(state) {
+    if (!this.store) return;
+    try {
+      await this.store.save(state, this.replayFor?.(state.id));
+    } catch {
+    }
+  }
   async sendError(id, code, message, data) {
     const error = { code, message };
     if (data !== void 0) error.data = data;
@@ -436,26 +751,41 @@ var StdioTransport = class {
 var WrongStackACPServer = class {
   transport;
   handler;
+  options;
+  /** HTTP server when transport mode is HTTP. */
+  httpServer = null;
   running = false;
   constructor(opts = {}) {
+    this.options = opts;
     this.transport = new StdioTransport();
     const runTurn = opts.runTurn ?? defaultEchoRunTurn;
     this.handler = new ACPProtocolHandler({
       transport: this.transport,
       defaultCwd: opts.defaultCwd ?? process.cwd(),
       runTurn,
-      agentName: opts.agentName
+      agentName: opts.agentName,
+      ...opts.replayFor ? { replayFor: opts.replayFor } : {},
+      ...opts.seedFor ? { seedFor: opts.seedFor } : {},
+      ...opts.store ? { store: opts.store } : {}
     });
   }
   /**
-   * Start the server. Blocks until the client disconnects.
-   *
-   * 1. Print the legacy `[wstack-acp]\n` marker so the client knows the
-   *    process is the ACP server (the old `StdioTransport` handshake).
-   * 2. Loop: read messages, dispatch to the handler, until EOF / error.
+   * Start the server. Mode depends on `options.transport`:
+   * - 'stdio' (default): reads JSON-RPC from stdin, writes to stdout.
+   * - number: listens as HTTP on the given port.
    */
   async start() {
-    this.transport.sendStartupMarker();
+    const transportMode = this.options.transport;
+    if (typeof transportMode === "number") {
+      await this.startHttp(transportMode);
+    } else {
+      await this.startStdio();
+    }
+  }
+  async startStdio() {
+    if (this.options.legacyStartupMarker) {
+      this.transport.sendStartupMarker();
+    }
     this.running = true;
     while (this.running) {
       const msg = await this.transport.read();
@@ -465,10 +795,80 @@ var WrongStackACPServer = class {
     }
     this.transport.close();
   }
+  async startHttp(port) {
+    const host = this.options.host ?? "127.0.0.1";
+    const handler = this.handler;
+    this.httpServer = createServer(async (req, res) => {
+      const selfOrigin = `http://${host}:${port}`;
+      const reqOrigin = Array.isArray(req.headers.origin) ? req.headers.origin[0] : req.headers.origin;
+      if (reqOrigin && reqOrigin !== selfOrigin) {
+        res.writeHead(403);
+        res.end(JSON.stringify({ error: "cross-origin request forbidden" }));
+        return;
+      }
+      if (reqOrigin) res.setHeader("Access-Control-Allow-Origin", reqOrigin);
+      res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (req.method !== "POST") {
+        res.writeHead(405);
+        res.end(JSON.stringify({ error: "method not allowed" }));
+        return;
+      }
+      let body = "";
+      for await (const chunk of req) {
+        body += chunk;
+      }
+      let msg;
+      try {
+        msg = JSON.parse(body);
+      } catch {
+        res.writeHead(400);
+        res.end(JSON.stringify({ error: { code: -32700, message: "Parse error" } }));
+        return;
+      }
+      const notifications = [];
+      let response = null;
+      const originalSend = this.transport.send.bind(this.transport);
+      this.transport.send = async (m) => {
+        if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+          response = m;
+        } else if (m.method === "session/update") {
+          notifications.push(m.params);
+        } else {
+          notifications.push(m);
+        }
+      };
+      try {
+        await handler.handleMessage(msg);
+      } finally {
+        this.transport.send = originalSend;
+      }
+      res.writeHead(200, { "Content-Type": "application/json" });
+      const responseBody = response !== null ? { ...response, notifications } : { notifications };
+      res.end(JSON.stringify(responseBody));
+    });
+    return new Promise((resolve) => {
+      this.httpServer.listen(port, host, () => {
+        writeErr(`[wstack-acp] HTTP server listening on http://${host}:${port}
+`);
+        this.running = true;
+        resolve();
+      });
+    });
+  }
   /** Stop the server. */
   stop() {
     this.running = false;
     this.transport.close();
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
+    }
   }
 };
 var defaultEchoRunTurn = async (_input, _emit) => {