@wrongstack/acp 0.257.2 → 0.264.0

package/dist/agent.js

@@ -205,182 +205,366 @@ function toolToPriority(tool) {
   return "low";
 }
 
+// src/types/acp-v1.ts
+var ACP_PROTOCOL_VERSION = 1;
+
 // src/agent/protocol-handler.ts
-var WRONGSTACK_VERSION = "0.1.0";
-var WRONGSTACK_CAPABILITIES = [
-  "code-generation",
-  "async-tools",
-  "streaming",
-  "progress"
+function toWire(msg) {
+  return msg;
+}
+var WRONGSTACK_VERSION = "0.263.0";
+var DEFAULT_MODE_ID = "code";
+var DEFAULT_MODES = [
+  {
+    id: DEFAULT_MODE_ID,
+    name: "Code",
+    description: "Default agent mode for code-generation tasks."
+  }
 ];
 var ACPProtocolHandler = class {
-  constructor(transport, registry, context) {
-    this.transport = transport;
-    this.registry = registry;
-    this.context = context;
-  }
   transport;
-  registry;
-  context;
+  defaultCwd;
+  runTurn;
+  onSessionNew;
+  modes;
+  configOptions;
+  agentName;
   initialized = false;
-  signal = new AbortController();
-  pendingCalls = /* @__PURE__ */ new Map();
-  /** Wire an external abort signal from the ACP client */
-  wireAbortController(abortController) {
-    abortController.signal.addEventListener("abort", () => {
-      for (const id of this.pendingCalls.keys()) {
-        this.transport.send({ id, method: "cancel", result: { ok: true } }).catch((err) => console.debug(`[protocol-handler] cancel send failed: ${err}`));
-      }
+  sessions = /* @__PURE__ */ new Map();
+  nextId = 1;
+  constructor(opts) {
+    this.transport = opts.transport;
+    this.defaultCwd = opts.defaultCwd;
+    this.runTurn = opts.runTurn;
+    this.onSessionNew = opts.onSessionNew ?? (() => {
     });
+    this.modes = opts.modes ?? DEFAULT_MODES;
+    this.configOptions = opts.configOptions ?? [];
+    this.agentName = opts.agentName ?? "wrongstack";
   }
-  /** Process one inbound message. Returns true if this was a terminal message. */
+  /**
+   * Process one inbound message. Returns true if this was a terminal
+   * message (rare; reserved for future use by the server's own
+   * shutdown signal).
+   */
   async handleMessage(msg) {
-    if (msg.id !== void 0) {
-      return this.handleRequest(msg);
+    if (typeof msg !== "object" || msg === null) return false;
+    const m = msg;
+    if (m.id !== void 0 && (m.result !== void 0 || m.error !== void 0)) {
+      return false;
     }
-    return this.handleNotification(msg);
+    if (m.id !== void 0 && typeof m.method === "string") {
+      return this.handleRequest(m.id, m.method, m.params);
+    }
+    if (typeof m.method === "string") {
+      return this.handleNotification(m.method, m.params);
+    }
+    return false;
   }
-  async handleRequest(req) {
-    if (req.method !== "initialize" && !this.initialized) {
-      await this.sendError(req.id ?? null, -32e3, "Not initialized");
+  /** Abort all active turns and drop session state. */
+  close() {
+    for (const [, session] of this.sessions) {
+      session.abort.abort();
+    }
+    this.sessions.clear();
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // Requests
+  // ────────────────────────────────────────────────────────────────────
+  async handleRequest(id, method, params) {
+    if (method !== "initialize" && !this.initialized) {
+      await this.sendError(id, -32e3, "Not initialized");
       return false;
     }
-    const id = req.id;
-    switch (req.method) {
-      case "initialize":
-        return this.handleInitialize(req, id);
-      case "ping":
-        await this.transport.send({ id, method: "ping", result: { pong: true } });
-        return false;
-      case "tools/call":
-        return this.handleToolCall(req, id);
-      case "tools/list":
-        return this.handleToolsList(id);
-      case "cancel":
-        return this.handleCancel(id);
-      case "session/list":
-        return this.handleSessionList(id);
-      case "sessionInfoUpdate":
-        await this.transport.send({ id, method: "sessionInfoUpdate", result: { ok: true } });
-        return false;
-      default:
-        await this.sendError(id, -32601, `Unknown method: ${req.method}`);
-        return false;
+    try {
+      switch (method) {
+        case "initialize":
+          return await this.handleInitialize(id, params);
+        case "authenticate":
+          return await this.handleAuthenticate(id, params);
+        case "session/new":
+          return await this.handleSessionNew(id, params);
+        case "session/load":
+          return await this.handleSessionLoad(id, params);
+        case "session/prompt":
+          return await this.handleSessionPrompt(id, params);
+        case "session/set_mode":
+          return await this.handleSetMode(id, params);
+        case "session/set_config_option":
+          return await this.handleSetConfigOption(id, params);
+        case "session/list":
+          return await this.handleSessionList(id);
+        default:
+          await this.sendError(id, -32601, `Unknown method: ${method}`);
+          return false;
+      }
+    } catch (err) {
+      const { code, message, data } = errorToJsonRpc(err);
+      await this.sendError(id, code, message, data);
+      return false;
     }
   }
-  async handleNotification(n) {
-    if (n.method === "cancel") {
-      this.handleCancelNotification(n);
+  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;
     }
-    return false;
-  }
-  async handleInitialize(req, id) {
     this.initialized = true;
-    const result = {
-      capabilities: WRONGSTACK_CAPABILITIES,
-      agentName: "WrongStack",
-      agentVersion: WRONGSTACK_VERSION,
-      protocolVersion: req.params?.protocolVersion ?? "2024-11",
-      ...this.registry.buildToolList()
-    };
-    await this.transport.send({ id, method: "initialize", result });
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        agentCapabilities: {
+          loadSession: true,
+          promptCapabilities: {
+            image: false,
+            audio: false,
+            embeddedContext: true
+          }
+        },
+        agentInfo: {
+          name: this.agentName,
+          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: [],
+        modes: this.modes,
+        configOptions: this.configOptions
+      }
+    }));
     return false;
   }
-  async handleToolsList(id) {
-    await this.transport.send({
+  async handleAuthenticate(id, _params) {
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
       id,
-      method: "tools/list",
-      result: this.registry.buildToolList()
-    });
+      result: { outcome: "unauthenticated" }
+    }));
     return false;
   }
-  async handleToolCall(req, id) {
-    const { name, arguments: args } = req.params;
-    const runPromise = (async () => {
-      if (!this.registry.has(name)) {
-        return {
-          content: [{ type: "text", text: `Tool not found: ${name}` }],
-          isError: true
-        };
+  async handleSessionNew(id, params) {
+    const p = params ?? {};
+    const cwd = typeof p.cwd === "string" ? p.cwd : this.defaultCwd;
+    const sessionId = `sess_${this.allocId()}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const state = {
+      id: sessionId,
+      cwd,
+      abort: new AbortController(),
+      modeId: DEFAULT_MODE_ID,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.sessions.set(sessionId, state);
+    this.onSessionNew(state);
+    await this.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        modeId: this.modes[0]?.id ?? DEFAULT_MODE_ID
       }
-      const result = await this.registry.execute(
-        name,
-        args,
-        this.context,
-        this.signal.signal
-      );
-      return result ?? { content: [{ type: "text", text: "Tool returned null" }], isError: false };
-    })();
-    this.pendingCalls.set(id, runPromise);
+    });
+    if (this.configOptions.length > 0) {
+      await this.sendNotification({
+        sessionId,
+        update: {
+          sessionUpdate: "config_option_update",
+          configOptions: [...this.configOptions]
+        }
+      });
+    }
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: {
+        sessionId,
+        modes: this.modes,
+        configOptions: this.configOptions
+      }
+    }));
+    return false;
+  }
+  async handleSessionLoad(id, params) {
+    return this.handleSessionNew(id, params);
+  }
+  async handleSessionPrompt(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    if (!sessionId || !this.sessions.has(sessionId)) {
+      await this.sendError(id, -32e3, "unknown or missing sessionId");
+      return false;
+    }
+    if (!Array.isArray(p.prompt)) {
+      await this.sendError(id, -32602, "prompt must be an array of content blocks");
+      return false;
+    }
+    const session = this.sessions.get(sessionId);
+    if (session.abort.signal.aborted) {
+      session.abort = new AbortController();
+    }
+    const turnSignal = new AbortController();
+    const onCancel = () => turnSignal.abort();
+    session.abort.signal.addEventListener("abort", onCancel, { once: true });
+    let result;
     try {
-      const toolResult = await runPromise;
-      this.pendingCalls.delete(id);
-      const response = { method: "tools/call", id, result: toolResult };
-      await this.transport.send(response);
+      result = await this.runTurn(
+        { sessionId, prompt: p.prompt, signal: turnSignal.signal },
+        (update) => this.sendNotification({ sessionId, update })
+      );
     } catch (err) {
-      this.pendingCalls.delete(id);
-      const msg = err instanceof Error ? err.message : String(err);
-      await this.transport.send({
-        id,
-        method: "tools/call",
-        result: { content: [{ type: "text", text: msg }], isError: true }
-      });
+      session.abort.signal.removeEventListener("abort", onCancel);
+      const { code, message, data } = errorToJsonRpc(err);
+      await this.sendError(id, code, message, data);
+      return false;
     }
+    session.abort.signal.removeEventListener("abort", onCancel);
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: { stopReason: result.stopReason }
+    }));
     return false;
   }
-  async handleCancel(id) {
-    this.pendingCalls.delete(id);
-    await this.transport.send({ id, method: "cancel", result: { ok: true } });
+  async handleSetMode(id, params) {
+    const p = params ?? {};
+    const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+    const modeId = typeof p.modeId === "string" ? p.modeId : null;
+    const session = sessionId ? this.sessions.get(sessionId) : void 0;
+    if (!session || !modeId || !this.modes.some((m) => m.id === modeId)) {
+      await this.sendError(id, -32602, "invalid sessionId or modeId");
+      return false;
+    }
+    session.modeId = modeId;
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.sendNotification({
+      sessionId,
+      update: { sessionUpdate: "current_mode_update", modeId }
+    });
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
     return false;
   }
-  handleCancelNotification(_n) {
+  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 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");
+      return false;
+    }
+    option.currentValue = value;
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.sendNotification({
+      sessionId,
+      update: {
+        sessionUpdate: "config_option_update",
+        configOptions: [...this.configOptions]
+      }
+    });
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, result: {} }));
+    return false;
   }
   async handleSessionList(id) {
-    await this.transport.send({
-      id,
-      method: "session/list",
-      result: { sessions: [] }
+    const sessions = Array.from(this.sessions.values()).map((s) => {
+      const out = {
+        sessionId: s.id,
+        cwd: s.cwd,
+        updatedAt: s.updatedAt
+      };
+      if (s.title !== void 0) out.title = s.title;
+      return out;
     });
+    await this.transport.send(toWire({
+      jsonrpc: "2.0",
+      id,
+      result: { sessions }
+    }));
     return false;
   }
-  async sendError(id, code, message) {
-    if (id === null) return;
-    await this.transport.send({ id, method: "", error: { code, message } });
+  // ────────────────────────────────────────────────────────────────────
+  // Notifications
+  // ────────────────────────────────────────────────────────────────────
+  async handleNotification(method, params) {
+    switch (method) {
+      case "session/cancel": {
+        const p = params ?? {};
+        const sessionId = typeof p.sessionId === "string" ? p.sessionId : null;
+        const session = sessionId ? this.sessions.get(sessionId) : void 0;
+        if (session) {
+          session.abort.abort();
+        }
+        return false;
+      }
+      case "exit":
+        this.close();
+        return true;
+      default:
+        return false;
+    }
+  }
+  // ────────────────────────────────────────────────────────────────────
+  // Wire helpers
+  // ────────────────────────────────────────────────────────────────────
+  async sendNotification(params) {
+    await this.transport.send(toWire({ jsonrpc: "2.0", method: "session/update", params }));
+  }
+  async sendError(id, code, message, data) {
+    const error = { code, message };
+    if (data !== void 0) error.data = data;
+    await this.transport.send(toWire({ jsonrpc: "2.0", id, error }));
+  }
+  allocId() {
+    return this.nextId++;
   }
 };
+function errorToJsonRpc(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (typeof e.code === "number" && typeof e.message === "string") {
+      const result = {
+        code: e.code,
+        message: e.message
+      };
+      if (e.data !== void 0) result.data = e.data;
+      return result;
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return { code: -32603, message };
+}
 var WrongStackACPServer = class {
   transport;
-  registry;
   handler;
   running = false;
-  constructor(opts) {
+  constructor(opts = {}) {
     this.transport = new StdioTransport();
-    this.registry = new ACPToolsRegistry(opts.owner);
-    this.registry.register(opts.tools);
-    this.handler = new ACPProtocolHandler(
-      this.transport,
-      this.registry,
-      // Future: WrongStack session/memory context for tool execution.
-      // When wired, this would carry session state, memory entries, and
-      // project metadata so ACP tools can self-contextualise.
-      // Tracked in docs/notes/refactor-2026-06-05.md §5.1.
-      {}
-    );
+    const runTurn = opts.runTurn ?? defaultEchoRunTurn;
+    this.handler = new ACPProtocolHandler({
+      transport: this.transport,
+      defaultCwd: opts.defaultCwd ?? process.cwd(),
+      runTurn,
+      agentName: opts.agentName
+    });
   }
   /**
    * Start the server. Blocks until the client disconnects.
    *
-   * 1. Send the startup marker `[wstack-acp]` so the client
-   *    knows which stdout line is the protocol boundary.
-   * 2. Loop: read messages, dispatch to handler, until EOF or error.
-   *
-   * Single dispatch path: every inbound message is read exactly once
-   * from the transport and passed to the protocol handler exactly once.
-   * An earlier version combined a `transport.onMessage` callback with
-   * this read loop, which caused every message to be processed twice
-   * (once by the callback, once by the loop) — duplicate tool calls
-   * and duplicate responses to the client. See the ACP double-dispatch
-   * fix in the security audit (P1-001).
+   * 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.
    */
   async start() {
     this.transport.sendStartupMarker();
@@ -399,8 +583,11 @@ var WrongStackACPServer = class {
     this.transport.close();
   }
 };
+var defaultEchoRunTurn = async (_input, _emit) => {
+  return { stopReason: "end_turn" };
+};
 async function main() {
-  const server = new WrongStackACPServer({ tools: [] });
+  const server = new WrongStackACPServer();
   await server.start();
 }
 var isEntrypoint = process.argv[1] !== void 0 && fileURLToPath(import.meta.url) === process.argv[1];
@@ -412,6 +599,88 @@ if (isEntrypoint) {
   });
 }
 
-export { ACPProtocolHandler, ACPToolsRegistry, StdioTransport, WrongStackACPServer };
+// src/agent/server-agent-turn.ts
+function makeACPServerAgentTurn(opts) {
+  const agents = /* @__PURE__ */ new Map();
+  const timeouts = /* @__PURE__ */ new Map();
+  const timeoutMs = opts.timeoutMs ?? 5 * 6e4;
+  return async (input, emit) => {
+    let agent = agents.get(input.sessionId);
+    if (!agent) {
+      agent = await opts.agentFor(input.sessionId, process.cwd());
+      agents.set(input.sessionId, agent);
+    }
+    const timer = setTimeout(() => {
+      timeouts.delete(input.sessionId);
+    }, timeoutMs);
+    timeouts.set(input.sessionId, timer);
+    try {
+      const userMessage = promptToText(input.prompt);
+      const result = await agent.run(userMessage, { signal: input.signal });
+      const text = extractText(result);
+      if (text) {
+        emit({
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text }
+        });
+      }
+      const result_out = {
+        stopReason: pickStopReason(result, input.signal)
+      };
+      if (text) result_out.text = text;
+      return result_out;
+    } finally {
+      clearTimeout(timer);
+      timeouts.delete(input.sessionId);
+    }
+  };
+}
+function promptToText(blocks) {
+  const parts = [];
+  for (const b of blocks) {
+    if (b.type === "text") {
+      parts.push(b.text);
+    } else if (b.type === "image") {
+      parts.push(`[image: ${b.mimeType}]`);
+    } else if (b.type === "audio") {
+      parts.push(`[audio: ${b.mimeType}]`);
+    } else if (b.type === "resource") {
+      parts.push(`[embedded resource: ${b.resource.uri}]`);
+    } else if (b.type === "resource_link") {
+      parts.push(`[resource link: ${b.uri}]`);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function extractText(result) {
+  if (typeof result !== "object" || result === null) return "";
+  const r = result;
+  if (typeof r.text === "string") return r.text;
+  if (Array.isArray(r.content)) {
+    const parts = [];
+    for (const c of r.content) {
+      if (typeof c === "object" && c !== null) {
+        const cb = c;
+        if (cb.type === "text" && typeof cb.text === "string") parts.push(cb.text);
+      }
+    }
+    return parts.join("");
+  }
+  return "";
+}
+function pickStopReason(result, signal) {
+  if (signal.aborted) return "cancelled";
+  if (typeof result !== "object" || result === null) return "end_turn";
+  const r = result;
+  if (r.error) {
+    return "end_turn";
+  }
+  if (typeof r.stopReason === "string" && r.stopReason) {
+    return r.stopReason;
+  }
+  return "end_turn";
+}
+
+export { ACPProtocolHandler, ACPToolsRegistry, StdioTransport, WrongStackACPServer, makeACPServerAgentTurn };
 //# sourceMappingURL=agent.js.map
 //# sourceMappingURL=agent.js.map