@engineeros/connector 0.9.2 → 0.10.2

package/src/acp-client.mjs

@@ -1,373 +1,381 @@
-import { spawn } from "node:child_process";
-import { Readable, Writable } from "node:stream";
-import * as acp from "@agentclientprotocol/sdk";
-
-const RUNTIME_IDLE_MS = 30 * 60 * 1_000;
-const runtimes = new Map();
-
-export function permissionOutcome(options = [], allow = false) {
-  if (!allow) return { outcome: { outcome: "cancelled" } };
-  const selected =
-    options.find((option) => option.kind === "allow_once") ??
-    options.find((option) => option.kind === "allow_always");
-  return selected
-    ? { outcome: { outcome: "selected", optionId: selected.optionId } }
-    : { outcome: { outcome: "cancelled" } };
-}
-
-export function launchAcpAgent(
-  workspace,
-  prompt,
-  config,
-  callbacks = {},
-  options = {},
-) {
-  if (!config.agent_command) {
-    throw new Error(
-      "No ACP coding agent is configured. Pair again with --agent or --agent-command and optional --agent-args JSON.",
-    );
-  }
-  const persistent = options.persistent === true;
-  const runtimeKey = persistent ? acpRuntimeKey(workspace, config) : null;
-  let runtime = runtimeKey ? runtimes.get(runtimeKey) : null;
-  if (!runtime?.isRunning()) {
-    runtime = new AcpRuntime(workspace, config, () => {
-      if (runtimeKey && runtimes.get(runtimeKey) === runtime) {
-        runtimes.delete(runtimeKey);
-      }
-    });
-    if (runtimeKey) runtimes.set(runtimeKey, runtime);
-  }
-  const sessionKey = options.sessionKey || `isolated-${crypto.randomUUID()}`;
-  const completed = runtime
-    .prompt({
-      sessionKey,
-      prompt,
-      previousSessionId: options.previousSessionId,
-      sandbox: options.sandbox,
-      profile: options.profile,
-      callbacks,
-    })
-    .finally(async () => {
-      if (!persistent) await runtime.dispose();
-    });
-  return {
-    child: runtime.child,
-    completed,
-    cancel: () => runtime.cancel(sessionKey),
-  };
-}
-
-export async function disposeAcpRuntimes() {
-  const active = [...runtimes.values()];
-  runtimes.clear();
-  await Promise.all(active.map((runtime) => runtime.dispose()));
-}
-
-export function activeAcpRuntimeCount() {
-  return runtimes.size;
-}
-
-class AcpRuntime {
-  constructor(workspace, config, onClose) {
-    this.workspace = workspace;
-    this.config = config;
-    this.onClose = onClose;
-    this.sessions = new Map();
-    this.turns = new Map();
-    this.stderr = "";
-    this.disposed = false;
-    this.idleTimer = null;
-    this.child = spawn(
-      config.agent_command,
-      Array.isArray(config.agent_args) ? config.agent_args : [],
-      {
-        cwd: workspace,
-        env: { ...process.env, ...(config.agent_env || {}) },
-        shell:
-          process.platform === "win32" &&
-          /\.(cmd|bat)$/i.test(config.agent_command),
-        stdio: ["pipe", "pipe", "pipe"],
-      },
-    );
-    this.child.stderr.setEncoding("utf8");
-    this.child.stderr.on("data", (chunk) => {
-      this.stderr = `${this.stderr}${chunk}`.slice(-4_000);
-      for (const turn of this.turns.values()) {
-        turn.callbacks.onEvent?.({
-          type: "agent.stderr",
-          message: String(chunk).trim().slice(0, 500),
-        });
-      }
-    });
-    this.child.once("error", (error) => {
-      this.spawnError = error;
-    });
-    const stream = acp.ndJsonStream(
-      Writable.toWeb(this.child.stdin),
-      Readable.toWeb(this.child.stdout),
-    );
-    this.connection = acp
-      .client({ name: "EngineerOS" })
-      .onRequest(acp.methods.client.session.requestPermission, (ctx) =>
-        this.permissionOutcome(ctx.params),
-      )
-      .onNotification(acp.methods.client.session.update, (ctx) =>
-        this.handleUpdate(ctx.params),
-      )
-      .connect(stream);
-    this.context = this.connection.agent;
-    this.ready = this.initialize();
-    void this.ready.catch(() => {
-      void this.dispose();
-    });
-    this.child.once("exit", () => this.closed());
-    void this.connection.closed.then(
-      () => this.closed(),
-      () => this.closed(),
-    );
-  }
-
-  async initialize() {
-    try {
-      const initialized = await this.context.request(
-        acp.methods.agent.initialize,
-        {
-          protocolVersion: acp.PROTOCOL_VERSION,
-          clientCapabilities: {
-            session: { configOptions: { boolean: {} } },
-          },
-        },
-      );
-      this.capabilities = initialized.agentCapabilities ?? {};
-      return initialized;
-    } catch (error) {
-      throw this.failure("could not initialize", error);
-    }
-  }
-
-  async prompt({
-    sessionKey,
-    prompt,
-    previousSessionId,
-    sandbox = "read-only",
-    profile = {},
-    callbacks,
-  }) {
-    this.clearIdleTimer();
-    const initialized = await this.ready;
-    let session = this.sessions.get(sessionKey);
-    if (!session) {
-      session = await this.openSession(
-        sessionKey,
-        previousSessionId,
-        sandbox,
-        profile,
-      );
-      callbacks.onEvent?.({
-        type: "agent.connected",
-        message: `Agent connected with protocol ${initialized.protocolVersion}`,
-      });
-    }
-    if (this.turns.has(session.sessionId)) {
-      throw new Error(
-        "The agent is already answering another prompt in this session.",
-      );
-    }
-    const turn = { callbacks, finalMessage: "", sandbox };
-    this.turns.set(session.sessionId, turn);
-    try {
-      const response = await this.context.request(
-        acp.methods.agent.session.prompt,
-        {
-          sessionId: session.sessionId,
-          prompt: [{ type: "text", text: prompt }],
-        },
-      );
-      if (response.stopReason === "error") {
-        throw new Error("The ACP agent ended the task with an error.");
-      }
-      return {
-        finalMessage: turn.finalMessage,
-        model: profile.model || this.config.agent_name || "acp-agent",
-        sessionId: session.sessionId,
-      };
-    } catch (error) {
-      throw this.failure("failed", error);
-    } finally {
-      this.turns.delete(session.sessionId);
-      this.scheduleIdleDisposal();
-    }
-  }
-
-  async openSession(sessionKey, previousSessionId, sandbox, profile) {
-    let response;
-    let sessionId;
-    if (previousSessionId && this.capabilities?.loadSession === true) {
-      response = await this.context.request(acp.methods.agent.session.load, {
-        sessionId: previousSessionId,
-        cwd: this.workspace,
-        mcpServers: [],
-      });
-      sessionId = previousSessionId;
-    } else {
-      response = await this.context.request(acp.methods.agent.session.new, {
-        cwd: this.workspace,
-        mcpServers: [],
-      });
-      sessionId = response.sessionId;
-    }
-    await this.applyMode(sessionId, response.modes, sandbox);
-    await this.applyProfile(sessionId, response.configOptions, profile);
-    const session = { sessionId };
-    this.sessions.set(sessionKey, session);
-    return session;
-  }
-
-  async applyMode(sessionId, modes, sandbox) {
-    const modeId = this.config.agent_modes?.[sandbox];
-    if (!modeId) return;
-    if (!modes?.availableModes?.some((mode) => mode.id === modeId)) {
-      throw new Error(
-        `${this.config.agent_name || "This ACP agent"} does not advertise the required '${modeId}' mode for ${sandbox} prompts.`,
-      );
-    }
-    await this.context.request(acp.methods.agent.session.setMode, {
-      sessionId,
-      modeId,
-    });
-  }
-
-  async applyProfile(sessionId, configOptions = [], profile = {}) {
-    const requested = [
-      ["model", profile.model],
-      ["thought_level", profile.reasoning_effort],
-    ];
-    for (const [category, value] of requested) {
-      if (!value) continue;
-      const option = configOptions?.find(
-        (candidate) => candidate.category === category,
-      );
-      if (!option || option.type !== "select") {
-        throw new Error(
-          `This ACP agent does not advertise ${category.replace("_", " ")} selection.`,
-        );
-      }
-      const available = option.options.flatMap((candidate) =>
-        Array.isArray(candidate.options) ? candidate.options : [candidate],
-      );
-      const selected = available.find(
-        (candidate) =>
-          candidate.value === value ||
-          candidate.name?.toLowerCase() === String(value).toLowerCase(),
-      );
-      if (!selected) {
-        throw new Error(
-          `${option.name} does not offer '${value}'. Available values: ${available
-            .map((candidate) => candidate.value)
-            .join(", ")}.`,
-        );
-      }
-      await this.context.request(acp.methods.agent.session.setConfigOption, {
-        sessionId,
-        configId: option.id,
-        value: selected.value,
-      });
-    }
-  }
-
-  async handleUpdate(notification) {
-    const turn = this.turns.get(notification.sessionId);
-    if (!turn) return;
-    const update = notification.update;
-    if (
-      update.sessionUpdate === "agent_message_chunk" &&
-      update.content?.type === "text"
-    ) {
-      turn.finalMessage += update.content.text;
-    }
-    turn.callbacks.onEvent?.({
-      type: `acp.${update.sessionUpdate}`,
-      update,
-    });
-  }
-
-  permissionOutcome(request) {
-    const turn = this.turns.get(request.sessionId);
-    return permissionOutcome(
-      request.options,
-      turn?.sandbox === "workspace-write",
-    );
-  }
-
-  async cancel(sessionKey) {
-    const session = this.sessions.get(sessionKey);
-    if (!session || !this.isRunning()) return;
-    await this.context.notify(acp.methods.agent.session.cancel, {
-      sessionId: session.sessionId,
-    });
-  }
-
-  isRunning() {
-    return (
-      !this.disposed &&
-      this.child.exitCode === null &&
-      !this.connection.signal.aborted
-    );
-  }
-
-  scheduleIdleDisposal() {
-    if (this.turns.size || this.disposed) return;
-    this.clearIdleTimer();
-    this.idleTimer = setTimeout(() => void this.dispose(), RUNTIME_IDLE_MS);
-    this.idleTimer.unref?.();
-  }
-
-  clearIdleTimer() {
-    clearTimeout(this.idleTimer);
-    this.idleTimer = null;
-  }
-
-  failure(action, error) {
-    const detail = this.stderr.trim().slice(-1_000);
-    const cause = this.spawnError || error;
-    return new Error(
-      `ACP agent ${action}: ${cause instanceof Error ? cause.message : String(cause)}${detail ? ` ${detail}` : ""}`,
-    );
-  }
-
-  closed() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.clearIdleTimer();
-    this.onClose?.();
-  }
-
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.clearIdleTimer();
-    this.onClose?.();
-    this.connection.close();
-    if (this.child.exitCode === null) {
-      this.child.kill("SIGTERM");
-      await Promise.race([
-        new Promise((resolve) => this.child.once("exit", resolve)),
-        new Promise((resolve) => setTimeout(resolve, 500)),
-      ]);
-    }
-    if (this.child.exitCode === null) this.child.kill("SIGKILL");
-    this.child.stdin.destroy();
-    this.child.stdout.destroy();
-    this.child.stderr.destroy();
-  }
-}
-
-function acpRuntimeKey(workspace, config) {
-  return JSON.stringify([
-    workspace,
-    config.agent_command,
-    config.agent_args || [],
-    config.agent_env || {},
-  ]);
-}
+import { spawn } from "node:child_process";
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+
+const RUNTIME_IDLE_MS = 30 * 60 * 1_000;
+const runtimes = new Map();
+
+export function permissionOutcome(options = [], allow = false) {
+  if (!allow) return { outcome: { outcome: "cancelled" } };
+  const selected =
+    options.find((option) => option.kind === "allow_once") ??
+    options.find((option) => option.kind === "allow_always");
+  return selected
+    ? { outcome: { outcome: "selected", optionId: selected.optionId } }
+    : { outcome: { outcome: "cancelled" } };
+}
+
+export function launchAcpAgent(
+  workspace,
+  prompt,
+  config,
+  callbacks = {},
+  options = {},
+) {
+  if (!config.agent_command) {
+    throw new Error(
+      "No ACP coding agent is configured. Pair again with --agent or --agent-command and optional --agent-args JSON.",
+    );
+  }
+  const persistent = options.persistent === true;
+  const runtimeKey = persistent ? acpRuntimeKey(workspace, config) : null;
+  let runtime = runtimeKey ? runtimes.get(runtimeKey) : null;
+  if (!runtime?.isRunning()) {
+    runtime = new AcpRuntime(workspace, config, () => {
+      if (runtimeKey && runtimes.get(runtimeKey) === runtime) {
+        runtimes.delete(runtimeKey);
+      }
+    });
+    if (runtimeKey) runtimes.set(runtimeKey, runtime);
+  }
+  const sessionKey = options.sessionKey || `isolated-${crypto.randomUUID()}`;
+  const completed = runtime
+    .prompt({
+      sessionKey,
+      prompt,
+      previousSessionId: options.previousSessionId,
+      sandbox: options.sandbox,
+      profile: options.profile,
+      callbacks,
+    })
+    .finally(async () => {
+      if (!persistent) await runtime.dispose();
+    });
+  return {
+    child: runtime.child,
+    completed,
+    cancel: () => runtime.cancel(sessionKey),
+  };
+}
+
+export async function disposeAcpRuntimes() {
+  const active = [...runtimes.values()];
+  runtimes.clear();
+  await Promise.all(active.map((runtime) => runtime.dispose()));
+}
+
+export function activeAcpRuntimeCount() {
+  return runtimes.size;
+}
+
+class AcpRuntime {
+  constructor(workspace, config, onClose) {
+    this.workspace = workspace;
+    this.config = config;
+    this.onClose = onClose;
+    this.sessions = new Map();
+    this.turns = new Map();
+    this.stderr = "";
+    this.disposed = false;
+    this.idleTimer = null;
+    this.child = spawn(
+      config.agent_command,
+      Array.isArray(config.agent_args) ? config.agent_args : [],
+      {
+        cwd: workspace,
+        env: { ...process.env, ...(config.agent_env || {}) },
+        shell:
+          process.platform === "win32" &&
+          /\.(cmd|bat)$/i.test(config.agent_command),
+        stdio: ["pipe", "pipe", "pipe"],
+      },
+    );
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => {
+      this.stderr = `${this.stderr}${chunk}`.slice(-4_000);
+      for (const turn of this.turns.values()) {
+        turn.callbacks.onEvent?.({
+          type: "agent.stderr",
+          message: String(chunk).trim().slice(0, 500),
+        });
+      }
+    });
+    this.child.once("error", (error) => {
+      this.spawnError = error;
+    });
+    const stream = acp.ndJsonStream(
+      Writable.toWeb(this.child.stdin),
+      Readable.toWeb(this.child.stdout),
+    );
+    this.connection = acp
+      .client({ name: "EngineerOS" })
+      .onRequest(acp.methods.client.session.requestPermission, (ctx) =>
+        this.permissionOutcome(ctx.params),
+      )
+      .onNotification(acp.methods.client.session.update, (ctx) =>
+        this.handleUpdate(ctx.params),
+      )
+      .connect(stream);
+    this.context = this.connection.agent;
+    this.ready = this.initialize();
+    void this.ready.catch(() => {
+      void this.dispose();
+    });
+    this.child.once("exit", () => this.closed());
+    void this.connection.closed.then(
+      () => this.closed(),
+      () => this.closed(),
+    );
+  }
+
+  async initialize() {
+    try {
+      const initialized = await this.context.request(
+        acp.methods.agent.initialize,
+        {
+          protocolVersion: acp.PROTOCOL_VERSION,
+          clientCapabilities: {
+            session: { configOptions: { boolean: {} } },
+          },
+        },
+      );
+      this.capabilities = initialized.agentCapabilities ?? {};
+      return initialized;
+    } catch (error) {
+      throw this.failure("could not initialize", error);
+    }
+  }
+
+  async prompt({
+    sessionKey,
+    prompt,
+    previousSessionId,
+    sandbox = "read-only",
+    profile = {},
+    callbacks,
+  }) {
+    this.clearIdleTimer();
+    const initialized = await this.ready;
+    let session = this.sessions.get(sessionKey);
+    if (!session) {
+      session = await this.openSession(
+        sessionKey,
+        previousSessionId,
+        sandbox,
+        profile,
+      );
+      callbacks.onEvent?.({
+        type: "agent.connected",
+        message: `Agent connected with protocol ${initialized.protocolVersion}`,
+      });
+    }
+    if (this.turns.has(session.sessionId)) {
+      throw new Error(
+        "The agent is already answering another prompt in this session.",
+      );
+    }
+    const turn = { callbacks, finalMessage: "", sandbox };
+    this.turns.set(session.sessionId, turn);
+    try {
+      const response = await this.context.request(
+        acp.methods.agent.session.prompt,
+        {
+          sessionId: session.sessionId,
+          prompt: [{ type: "text", text: prompt }],
+        },
+      );
+      if (response.stopReason === "error") {
+        throw new Error("The ACP agent ended the task with an error.");
+      }
+      return {
+        finalMessage: turn.finalMessage,
+        model: profile.model || this.config.agent_name || "acp-agent",
+        sessionId: session.sessionId,
+      };
+    } catch (error) {
+      throw this.failure("failed", error);
+    } finally {
+      this.turns.delete(session.sessionId);
+      this.scheduleIdleDisposal();
+    }
+  }
+
+  async openSession(sessionKey, previousSessionId, sandbox, profile) {
+    let response;
+    let sessionId;
+    if (previousSessionId && this.capabilities?.loadSession === true) {
+      response = await this.context.request(acp.methods.agent.session.load, {
+        sessionId: previousSessionId,
+        cwd: this.workspace,
+        mcpServers: [],
+      });
+      sessionId = previousSessionId;
+    } else {
+      response = await this.context.request(acp.methods.agent.session.new, {
+        cwd: this.workspace,
+        mcpServers: [],
+      });
+      sessionId = response.sessionId;
+    }
+    await this.applyMode(sessionId, response.modes, sandbox);
+    await this.applyProfile(sessionId, response.configOptions, profile);
+    const session = { sessionId };
+    this.sessions.set(sessionKey, session);
+    return session;
+  }
+
+  async applyMode(sessionId, modes, sandbox) {
+    const modeId = this.config.agent_modes?.[sandbox];
+    if (!modeId) return;
+    if (!modes?.availableModes?.some((mode) => mode.id === modeId)) {
+      throw new Error(
+        `${this.config.agent_name || "This ACP agent"} does not advertise the required '${modeId}' mode for ${sandbox} prompts.`,
+      );
+    }
+    await this.context.request(acp.methods.agent.session.setMode, {
+      sessionId,
+      modeId,
+    });
+  }
+
+  async applyProfile(sessionId, configOptions = [], profile = {}) {
+    const requested = [
+      ["model", profile.model],
+      ["thought_level", profile.reasoning_effort],
+    ];
+    for (const [category, value] of requested) {
+      if (!value) continue;
+      const option = configOptions?.find(
+        (candidate) => candidate.category === category,
+      );
+      if (!option || option.type !== "select") {
+        throw new Error(
+          `This ACP agent does not advertise ${category.replace("_", " ")} selection.`,
+        );
+      }
+      const available = option.options.flatMap((candidate) =>
+        Array.isArray(candidate.options) ? candidate.options : [candidate],
+      );
+      const selected = available.find(
+        (candidate) =>
+          candidate.value === value ||
+          candidate.name?.toLowerCase() === String(value).toLowerCase(),
+      );
+      if (!selected) {
+        throw new Error(
+          `${option.name} does not offer '${value}'. Available values: ${available
+            .map((candidate) => candidate.value)
+            .join(", ")}.`,
+        );
+      }
+      await this.context.request(acp.methods.agent.session.setConfigOption, {
+        sessionId,
+        configId: option.id,
+        value: selected.value,
+      });
+    }
+  }
+
+  async handleUpdate(notification) {
+    const turn = this.turns.get(notification.sessionId);
+    if (!turn) return;
+    const update = notification.update;
+    if (
+      update.sessionUpdate === "agent_message_chunk" &&
+      update.content?.type === "text"
+    ) {
+      turn.finalMessage += update.content.text;
+    }
+    turn.callbacks.onEvent?.({
+      type: `acp.${update.sessionUpdate}`,
+      update,
+    });
+  }
+
+  permissionOutcome(request) {
+    const turn = this.turns.get(request.sessionId);
+    const outcome = permissionOutcome(
+      request.options,
+      turn?.sandbox === "workspace-write",
+    );
+    turn?.callbacks.onEvent?.({
+      type: "acp.permission",
+      update: {
+        title: "Agent requested workspace permission",
+        status: turn?.sandbox === "workspace-write" ? "approved" : "denied",
+      },
+    });
+    return outcome;
+  }
+
+  async cancel(sessionKey) {
+    const session = this.sessions.get(sessionKey);
+    if (!session || !this.isRunning()) return;
+    await this.context.notify(acp.methods.agent.session.cancel, {
+      sessionId: session.sessionId,
+    });
+  }
+
+  isRunning() {
+    return (
+      !this.disposed &&
+      this.child.exitCode === null &&
+      !this.connection.signal.aborted
+    );
+  }
+
+  scheduleIdleDisposal() {
+    if (this.turns.size || this.disposed) return;
+    this.clearIdleTimer();
+    this.idleTimer = setTimeout(() => void this.dispose(), RUNTIME_IDLE_MS);
+    this.idleTimer.unref?.();
+  }
+
+  clearIdleTimer() {
+    clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+
+  failure(action, error) {
+    const detail = this.stderr.trim().slice(-1_000);
+    const cause = this.spawnError || error;
+    return new Error(
+      `ACP agent ${action}: ${cause instanceof Error ? cause.message : String(cause)}${detail ? ` ${detail}` : ""}`,
+    );
+  }
+
+  closed() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.clearIdleTimer();
+    this.onClose?.();
+  }
+
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.clearIdleTimer();
+    this.onClose?.();
+    this.connection.close();
+    if (this.child.exitCode === null) {
+      this.child.kill("SIGTERM");
+      await Promise.race([
+        new Promise((resolve) => this.child.once("exit", resolve)),
+        new Promise((resolve) => setTimeout(resolve, 500)),
+      ]);
+    }
+    if (this.child.exitCode === null) this.child.kill("SIGKILL");
+    this.child.stdin.destroy();
+    this.child.stdout.destroy();
+    this.child.stderr.destroy();
+  }
+}
+
+function acpRuntimeKey(workspace, config) {
+  return JSON.stringify([
+    workspace,
+    config.agent_command,
+    config.agent_args || [],
+    config.agent_env || {},
+  ]);
+}