@engineeros/connector 0.16.0 → 0.17.0

package/package.json

@@ -1,41 +1,24 @@
-{
-  "name": "@engineeros/connector",
-  "version": "0.16.0",
-  "description": "Connect a local coding agent to EngineerOS, using ACP when supported.",
-  "private": false,
-  "type": "module",
-  "license": "UNLICENSED",
-  "files": [
-    "bin",
-    "src",
-    "README.md"
-  ],
-  "bin": {
-    "engineeros-connector": "bin/engineeros-connector.mjs"
-  },
-  "scripts": {
-    "start": "node ./bin/engineeros-connector.mjs",
-    "prepublishOnly": "node ./scripts/release.mjs check",
-    "release:patch": "node ./scripts/release.mjs patch",
-    "test": "node --test --test-concurrency=1",
-    "type-check": "node --check ./bin/engineeros-connector.mjs && node --check ./scripts/release.mjs && node --check ./src/acp-client.mjs && node --check ./src/agent-harness.mjs && node --check ./src/agent-registry.mjs && node --check ./src/assessment-spool.mjs && node --check ./src/capabilities.mjs && node --check ./src/cli-args.mjs && node --check ./src/codex-app-server.mjs && node --check ./src/config.mjs && node --check ./src/connection.mjs && node --check ./src/mcp-server.mjs && node --check ./src/runner.mjs"
-  },
-  "engines": {
-    "node": ">=22"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/vinpuli/engineerosv2.git",
-    "directory": "packages/engineeros-connector"
-  },
-  "bugs": {
-    "url": "https://github.com/vinpuli/engineerosv2/issues"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@agentclientprotocol/sdk": "1.3.0",
-    "zod": "3.25.76"
-  }
-}
+{
+  "name": "@engineeros/connector",
+  "version": "0.17.0",
+  "description": "Connect a local coding agent to EngineerOS, using ACP when supported.",
+  "type": "module",
+  "license": "UNLICENSED",
+  "files": [
+    "bin/engineeros-connector.mjs",
+    "README.md"
+  ],
+  "bin": {
+    "engineeros-connector": "bin/engineeros-connector.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.3.0",
+    "zod": "3.25.76"
+  }
+}

package/src/acp-client.mjs

@@ -1,468 +0,0 @@
-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();
-    });
-  runtime.child.engineerOsCancel = () => 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 async function inspectAcpExecutionProfiles(workspace, config) {
-  const runtime = new AcpRuntime(workspace, config, () => {});
-  try {
-    await runtime.ready;
-    const response = await runtime.context.request(acp.methods.agent.session.new, {
-      cwd: workspace,
-      mcpServers: [],
-    });
-    return executionProfilesFromConfigOptions(response.configOptions);
-  } finally {
-    await runtime.dispose();
-  }
-}
-
-export function executionProfilesFromConfigOptions(configOptions = []) {
-  const selectOption = (category) =>
-    configOptions.find((candidate) => candidate.category === category && candidate.type === "select");
-  const selectValues = (option) =>
-    (option?.options || []).flatMap((candidate) =>
-      Array.isArray(candidate.options) ? candidate.options : [candidate],
-    );
-  const modelOption = selectOption("model");
-  const effortOption = selectOption("thought_level");
-  const models = selectValues(modelOption);
-  const efforts = selectValues(effortOption);
-  return {
-    model_selection: models.length > 0,
-    model_profiles: models.map((model) => ({
-      id: model.value,
-      name: model.name || model.value,
-      description: model.description || "",
-      is_default: model.value === modelOption.currentValue,
-      default_reasoning_effort: effortOption?.currentValue || null,
-      reasoning_efforts: efforts.map((effort) => effort.value),
-    })),
-    reasoning_efforts: efforts.map((effort) => effort.value),
-  };
-}
-
-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.disposePromise = null;
-    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 || {}) },
-        windowsHide: true,
-        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.stdout.once("end", () => this.closed());
-    this.child.stdout.once("close", () => this.closed());
-    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}`,
-      });
-    }
-    await callbacks.onSession?.(session.sessionId);
-    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,
-        usage: normalizeTokenUsage(response.usage),
-      };
-    } 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.childIsRunning() &&
-      !this.connection.signal.aborted
-    );
-  }
-
-  childIsRunning() {
-    return this.child.exitCode === null && this.child.signalCode === null;
-  }
-
-  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() {
-    void this.dispose();
-  }
-
-  async dispose() {
-    if (this.disposePromise) return this.disposePromise;
-    this.disposed = true;
-    this.clearIdleTimer();
-    this.onClose?.();
-    this.disposePromise = this.releaseResources();
-    return this.disposePromise;
-  }
-
-  async releaseResources() {
-    try {
-      this.connection.close();
-    } catch {
-      // The ACP transport may already be closed.
-    }
-    if (this.childIsRunning()) {
-      this.child.kill("SIGTERM");
-      await Promise.race([
-        new Promise((resolve) => this.child.once("exit", resolve)),
-        new Promise((resolve) => setTimeout(resolve, 500)),
-      ]);
-    }
-    if (this.childIsRunning()) {
-      this.child.kill("SIGKILL");
-      await Promise.race([
-        new Promise((resolve) => this.child.once("exit", resolve)),
-        new Promise((resolve) => setTimeout(resolve, 500)),
-      ]);
-    }
-    this.child.stdin.destroy();
-    this.child.stdout.destroy();
-    this.child.stderr.destroy();
-  }
-}
-
-export function normalizeTokenUsage(value) {
-  if (!value || typeof value !== "object") return null;
-  const number = (...keys) => {
-    for (const key of keys) {
-      const candidate = value[key];
-      if (Number.isFinite(candidate) && candidate >= 0) return Math.trunc(candidate);
-    }
-    return 0;
-  };
-  const usage = {
-    input_tokens: number("inputTokens", "input_tokens"),
-    output_tokens: number("outputTokens", "output_tokens"),
-    cache_read_tokens: number("cachedReadTokens", "cachedInputTokens", "cache_read_input_tokens"),
-    cache_write_tokens: number(
-      "cachedWriteTokens",
-      "cacheWriteInputTokens",
-      "cache_creation_input_tokens",
-    ),
-    reasoning_tokens: number("reasoningTokens", "reasoningOutputTokens", "reasoning_tokens"),
-  };
-  usage.total_tokens = number("totalTokens", "total_tokens") ||
-    Object.values(usage).reduce((total, tokens) => total + tokens, 0);
-  return usage.total_tokens > 0 ? usage : null;
-}
-
-function acpRuntimeKey(workspace, config) {
-  return JSON.stringify([
-    workspace,
-    config.agent_command,
-    config.agent_args || [],
-    config.agent_env || {},
-  ]);
-}