@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/adapters/acp.js

@@ -0,0 +1,328 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { startJsonlProcess, commandExists, describeFailure, processErrorKind, stringify, truncate } from "./process.js";
+const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const string = (value) => typeof value === "string" && value.length > 0 && value.length <= 4e3;
+class AcpError extends Error {
+  constructor(message, kind = "cli_incompatible", code) {
+    super(message);
+    this.kind = kind;
+    this.code = code;
+  }
+}
+class AcpClient {
+  constructor(connection, opts, onUpdate) {
+    this.connection = connection;
+    this.opts = opts;
+    this.onUpdate = onUpdate;
+    this.proc = startJsonlProcess({
+      command: connection.command,
+      args: connection.args,
+      cwd: opts.cwd,
+      interactive: true,
+      timeoutMs: opts.timeoutMs,
+      idleTimeoutMs: opts.idleTimeoutMs,
+      resultGraceMs: 1e3,
+      onJson: (message) => {
+        try {
+          this.receive(message);
+        } catch (error) {
+          this.fail(error);
+          this.proc.kill();
+        }
+      },
+      onText: () => {
+        this.fail(new AcpError("The CLI wrote invalid ACP data to stdout. Configure its ACP subcommand; logs must go to stderr."));
+        this.proc.kill();
+      }
+    });
+    void this.proc.outcome.then((outcome) => {
+      this.fail(new AcpError(describeFailure(connection.name, outcome), processErrorKind(outcome) ?? "other"));
+    });
+    opts.signal?.addEventListener("abort", this.cancel, { once: true });
+    if (opts.signal?.aborted) this.cancel();
+  }
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  stopped;
+  lifetime = new AbortController();
+  cancelTimer;
+  approvalCount = 0;
+  permissionIds = /* @__PURE__ */ new Set();
+  permissionTasks = /* @__PURE__ */ new Set();
+  toolDetails = /* @__PURE__ */ new Map();
+  sessionId;
+  prompting = false;
+  proc;
+  fail(error) {
+    this.stopped ??= error;
+    this.lifetime.abort();
+    for (const waiter of this.pending.values()) {
+      clearTimeout(waiter.timer);
+      waiter.reject(this.stopped);
+    }
+    this.pending.clear();
+  }
+  cancel = () => {
+    if (this.sessionId) this.proc.send({ jsonrpc: "2.0", method: "session/cancel", params: { sessionId: this.sessionId } });
+    this.fail(new AcpError("ACP turn was cancelled", "cancelled"));
+    this.cancelTimer = setTimeout(() => this.proc.kill(), 1e3);
+    this.cancelTimer.unref();
+  };
+  request(method, params, timeoutMs = 2e4) {
+    if (this.stopped) return Promise.reject(this.stopped);
+    return new Promise((resolve, reject) => {
+      const id = ++this.nextId;
+      const timer = timeoutMs ? setTimeout(() => {
+        this.pending.delete(id);
+        reject(new AcpError(`ACP ${method} did not respond in time`, "timeout"));
+      }, timeoutMs) : void 0;
+      timer?.unref();
+      this.pending.set(id, { resolve, reject, timer });
+      if (!this.proc.send({ jsonrpc: "2.0", id, method, params })) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(new AcpError("ACP process closed its input", "other"));
+      }
+    });
+  }
+  receive(message) {
+    if (!object(message) || message.jsonrpc !== "2.0") throw new AcpError("The CLI did not return ACP JSON-RPC 2.0 messages");
+    if (message.method === void 0) {
+      const waiter = this.pending.get(message.id);
+      if (!waiter) return;
+      this.pending.delete(message.id);
+      clearTimeout(waiter.timer);
+      if (object(message.error)) waiter.reject(new AcpError(truncate(String(message.error.message ?? "ACP request failed")), message.error.code === -32e3 ? "auth" : message.error.code === -32002 ? "session_not_found" : [-32601, -32602].includes(message.error.code) ? "cli_incompatible" : "other", message.error.code));
+      else if (object(message.result)) waiter.resolve(message.result);
+      else waiter.reject(new AcpError("ACP response is missing its result"));
+      return;
+    }
+    if (message.id !== void 0) {
+      if (!(typeof message.id === "number" || typeof message.id === "string")) throw new AcpError("Invalid ACP request ID");
+      if (message.method === "session/request_permission") {
+        if (this.permissionIds.has(message.id) || this.permissionIds.size >= 16) throw new AcpError("Too many or duplicate ACP permission requests");
+        this.permissionIds.add(message.id);
+        const task = this.permission(message).finally(() => {
+          this.permissionIds.delete(message.id);
+          this.permissionTasks.delete(task);
+        });
+        this.permissionTasks.add(task);
+      } else this.proc.send({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: "Client capability is not supported" } });
+    } else if (message.method === "session/update" && this.prompting && message.params?.sessionId === this.sessionId && object(message.params.update)) {
+      const update = message.params.update;
+      if (["tool_call", "tool_call_update"].includes(update.sessionUpdate) && string(update.toolCallId)) {
+        if (!this.toolDetails.has(update.toolCallId) && this.toolDetails.size >= 2e3) throw new AcpError("ACP turn exceeds the tool call limit");
+        const previous = this.toolDetails.get(update.toolCallId) ?? {};
+        this.toolDetails.set(update.toolCallId, {
+          ...previous,
+          toolCallId: update.toolCallId,
+          ...typeof update.kind === "string" ? { kind: update.kind } : {},
+          ...typeof update.title === "string" ? { title: truncate(update.title, 1e3) } : {},
+          ...Array.isArray(update.locations) ? { locations: update.locations.slice(0, 50).filter((item) => string(item?.path)).map((item) => ({ path: item.path })) } : {},
+          ...update.rawInput !== void 0 ? { rawInput: { description: truncate(stringify(update.rawInput)), ...typeof update.rawInput?.command === "string" ? { command: truncate(update.rawInput.command) } : {}, ...string(update.rawInput?.path) ? { path: update.rawInput.path } : {} } } : {}
+        });
+      }
+      this.onUpdate(update);
+    }
+  }
+  async permission(message) {
+    const params = message.params;
+    const tool = object(params?.toolCall) ? { ...this.toolDetails.get(params.toolCall.toolCallId), ...params.toolCall } : void 0;
+    let optionId;
+    const options = Array.isArray(params?.options) ? params.options : [];
+    const once = (kind) => options.find((option) => option?.kind === kind && string(option.optionId))?.optionId;
+    const eligible = this.prompting && params?.sessionId === this.sessionId && object(tool) && string(tool.toolCallId);
+    const canAsk = eligible && (this.opts.mode === "write" || ["read", "search", "think"].includes(tool.kind));
+    const controller = new AbortController();
+    let waiting = false;
+    const abort = () => controller.abort();
+    this.lifetime.signal.addEventListener("abort", abort, { once: true });
+    if (this.lifetime.signal.aborted) controller.abort();
+    const timer = setTimeout(abort, 12e4);
+    timer.unref();
+    try {
+      if (canAsk && once("allow_once") && this.opts.interactiveApprovals && this.opts.onApproval && !controller.signal.aborted) {
+        waiting = true;
+        this.approvalCount++;
+        this.proc.pauseIdle(true);
+        const paths = Array.isArray(tool.locations) ? tool.locations.slice(0, 50).map((location) => location?.path).filter(string) : [];
+        if (!paths.length && tool.kind === "edit" && string(tool.rawInput?.path)) paths.push(tool.rawInput.path);
+        const request = {
+          id: `acp:${String(message.id)}`,
+          kind: ["edit", "delete", "move"].includes(tool.kind) ? "file-change" : "command",
+          paths,
+          cwd: this.opts.cwd,
+          command: typeof tool.rawInput?.command === "string" ? truncate(tool.rawInput.command) : truncate(stringify(tool.rawInput ?? tool.title ?? tool.kind)),
+          reason: truncate(String(tool.title ?? "ACP tool request"))
+        };
+        const decision = await Promise.race([
+          this.opts.onApproval(request, controller.signal),
+          new Promise((resolve) => {
+            if (controller.signal.aborted) resolve("decline");
+            else controller.signal.addEventListener("abort", () => resolve("decline"), { once: true });
+          })
+        ]);
+        if (decision === "approve" && !controller.signal.aborted) optionId = once("allow_once");
+      }
+    } catch {
+    } finally {
+      clearTimeout(timer);
+      this.lifetime.signal.removeEventListener("abort", abort);
+      controller.abort();
+      if (waiting) {
+        this.approvalCount--;
+        if (!this.approvalCount) this.proc.pauseIdle(false);
+      }
+      optionId ??= once("reject_once");
+      this.proc.send({ jsonrpc: "2.0", id: message.id, result: { outcome: this.lifetime.signal.aborted || !optionId ? { outcome: "cancelled" } : { outcome: "selected", optionId } } });
+    }
+  }
+  async initialize() {
+    const init = await this.request("initialize", { protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: "code-flow", version: "0.1.0" } });
+    if (init.protocolVersion !== 1) throw new AcpError(`Unsupported ACP protocol version: ${String(init.protocolVersion)}; code-flow supports v1`);
+    return init;
+  }
+  async session(init) {
+    const params = { cwd: this.opts.cwd, mcpServers: [] };
+    let session;
+    if (this.opts.resumeSessionId) {
+      if (init.agentCapabilities?.loadSession !== true) throw new AcpError("This ACP agent cannot load previous sessions", "session_not_found");
+      session = await this.request("session/load", { ...params, sessionId: this.opts.resumeSessionId });
+      this.sessionId = this.opts.resumeSessionId;
+    } else {
+      session = await this.request("session/new", params);
+      if (!string(session.sessionId)) throw new AcpError("ACP session/new returned no valid session ID");
+      this.sessionId = session.sessionId;
+    }
+    return session;
+  }
+  async close() {
+    this.opts.signal?.removeEventListener("abort", this.cancel);
+    clearTimeout(this.cancelTimer);
+    this.lifetime.abort();
+    await Promise.allSettled([...this.permissionTasks]);
+    this.proc.resultSeen();
+    this.proc.endInput();
+    await this.proc.outcome;
+  }
+}
+function configOption(session, category) {
+  const options = Array.isArray(session?.configOptions) ? session.configOptions.filter((option) => option?.type === "select" && option.category === category && string(option.id)) : [];
+  return options.find((option) => option.id === category) ?? options.find((option) => category !== "model" || option.id !== "provider");
+}
+function choices(option) {
+  const flat = Array.isArray(option?.options) ? option.options.flatMap((item) => Array.isArray(item?.options) ? item.options : [item]) : [];
+  return flat.filter((item) => string(item?.value) && string(item?.name)).slice(0, 1e3).map((item) => ({ id: item.value, label: item.name }));
+}
+function acpCatalog(session) {
+  const model = configOption(session, "model"), effort = configOption(session, "thought_level");
+  const models = model ? choices(model) : Array.isArray(session?.models?.availableModels) ? session.models.availableModels.filter((item) => string(item?.modelId) && string(item?.name)).slice(0, 1e3).map((item) => ({ id: item.modelId, label: item.name })) : [];
+  const defaultModel = model?.currentValue ?? session?.models?.currentModelId;
+  return {
+    models,
+    efforts: choices(effort).map((item) => item.id),
+    allowCustom: false,
+    defaultModel: string(defaultModel) ? defaultModel : void 0,
+    defaultEffort: string(effort?.currentValue) ? effort.currentValue : void 0
+  };
+}
+async function probeAcp(connection) {
+  const cwd = await mkdtemp(join(tmpdir(), "codeflow-acp-probe-"));
+  let client;
+  try {
+    client = new AcpClient(connection, { cwd, prompt: "", mode: "read", timeoutMs: 3e4 }, () => {
+    });
+    const init = await client.initialize(), session = await client.session(init);
+    return {
+      protocolVersion: 1,
+      agent: string(init.agentInfo?.title) ? init.agentInfo.title : string(init.agentInfo?.name) ? init.agentInfo.name : connection.name,
+      version: string(init.agentInfo?.version) ? init.agentInfo.version : void 0,
+      sessionResume: init.agentCapabilities?.loadSession === true,
+      catalog: acpCatalog(session)
+    };
+  } finally {
+    await client?.close();
+    await rm(cwd, { recursive: true, force: true });
+  }
+}
+function createAcpAdapter(connection) {
+  const saved = structuredClone(connection);
+  return {
+    id: saved.id,
+    displayName: saved.name,
+    binary: saved.command,
+    available: () => commandExists(saved.command),
+    catalog: async () => (await probeAcp(saved)).catalog,
+    run: (opts, event) => runAcp(saved, opts, event)
+  };
+}
+async function runAcp(connection, opts, event) {
+  if (opts.signal?.aborted) return { ok: false, finalText: "", error: "ACP turn was cancelled", errorKind: "cancelled" };
+  if (opts.agentContainer || opts.trust !== "full") return { ok: false, finalText: "", error: "ACP connections require Full access on the current host; sandbox and container profiles are not supported", errorKind: "cli_incompatible" };
+  let finalText = "", client;
+  const calls = /* @__PURE__ */ new Map(), finished = /* @__PURE__ */ new Set();
+  try {
+    client = new AcpClient(connection, opts, (update) => {
+      if (update.sessionUpdate === "agent_message_chunk" || update.sessionUpdate === "agent_thought_chunk") {
+        if (update.content?.type !== "text" || typeof update.content.text !== "string") return;
+        if (update.sessionUpdate === "agent_message_chunk") {
+          if (finalText.length + update.content.text.length > 4 * 1024 * 1024) throw new AcpError("ACP answer exceeds the 4 MiB limit");
+          finalText += update.content.text;
+          event({ kind: "text", text: update.content.text });
+        } else event({ kind: "thinking", text: update.content.text });
+      } else if (["tool_call", "tool_call_update"].includes(update.sessionUpdate) && string(update.toolCallId)) {
+        const previous = calls.get(update.toolCallId);
+        if (!previous && calls.size >= 2e3) throw new AcpError("ACP turn exceeds the tool call limit");
+        const name = String(update.title ?? previous?.name ?? update.kind ?? "Tool");
+        const input = update.rawInput !== void 0 ? truncate(stringify(update.rawInput), 16e3) : previous?.input ?? "{}";
+        if (!previous || previous.name !== name || previous.input !== input) {
+          event({ kind: "tool_call", callId: update.toolCallId, name, input });
+        }
+        const text = Array.isArray(update.content) ? update.content.map((item) => item.type === "content" && item.content?.type === "text" ? item.content.text : item.type === "diff" ? `${item.path}
+${item.newText ?? ""}` : "").join("\n") : void 0;
+        const output = truncate(text ?? (update.rawOutput !== void 0 ? stringify(update.rawOutput) : previous?.output ?? ""), 32e3);
+        calls.set(update.toolCallId, { name, input, output });
+        if (["completed", "failed"].includes(update.status) && !finished.has(update.toolCallId)) {
+          finished.add(update.toolCallId);
+          event({ kind: "tool_result", callId: update.toolCallId, output, isError: update.status === "failed" });
+        }
+      }
+    });
+    const init = await client.initialize();
+    let session = await client.session(init);
+    event({ kind: "session", sessionId: client.sessionId });
+    for (const [category, value] of [["model", opts.model], ["thought_level", opts.effort]]) {
+      if (!value) continue;
+      const option = configOption(session, category);
+      if (option) {
+        if (!choices(option).some((item) => item.id === value)) throw new AcpError(`ACP agent does not advertise ${category} ${value}`);
+        session = { ...session, ...await client.request("session/set_config_option", { sessionId: client.sessionId, configId: option.id, value }) };
+      } else if (category === "model" && acpCatalog(session).models.some((model) => model.id === value)) {
+        await client.request("session/set_model", { sessionId: client.sessionId, modelId: value });
+      } else throw new AcpError(`This ACP agent does not support selecting ${category}`);
+    }
+    const prompt = `${opts.mode === "read" ? "This is a read-only task. Do not edit files or run commands that change the repository.\n\n" : ""}${opts.prompt}${opts.jsonSchema ? `
+
+Return your final answer as JSON matching this schema:
+${JSON.stringify(opts.jsonSchema)}` : ""}`;
+    client.prompting = true;
+    const result = await client.request("session/prompt", { sessionId: client.sessionId, prompt: [{ type: "text", text: prompt }] }, 0);
+    client.prompting = false;
+    if (opts.signal?.aborted || result.stopReason === "cancelled") throw new AcpError("ACP turn was cancelled", "cancelled");
+    if (result.stopReason !== "end_turn") throw new AcpError(`ACP turn stopped: ${String(result.stopReason ?? "missing stop reason")}`, "other");
+    return { ok: true, finalText, sessionId: client.sessionId };
+  } catch (error) {
+    const failure = error;
+    return { ok: false, finalText, sessionId: client?.sessionId, error: failure.message, errorKind: opts.signal?.aborted ? "cancelled" : error instanceof AcpError ? error.kind : "other" };
+  } finally {
+    await client?.close();
+  }
+}
+export {
+  acpCatalog,
+  createAcpAdapter,
+  probeAcp,
+  runAcp
+};

package/src/adapters/agent-tools.js

@@ -0,0 +1,28 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { AGENT_TOOLS } from "../agent-tools.js";
+function agentMcpConfig(connection) {
+  if (!/^http:\/\/127\.0\.0\.1:\d+\/v1\/agent-tools$/.test(connection.endpoint) || !/^[\w-]{43}$/.test(connection.token) || !Number.isFinite(connection.expiresAt) || connection.expiresAt <= Date.now()) throw new Error("Invalid task tool connection");
+  return { serverUrl: connection.endpoint.replace(/agent-tools$/, "agent-mcp"), headers: { Authorization: `Bearer ${connection.token}` }, tools: Object.fromEntries(AGENT_TOOLS.map((tool) => [tool.name, { eager: true }])) };
+}
+async function prepareAgentTools(connection) {
+  const dir = await mkdtemp(join(tmpdir(), "codeflow-agent-tools-"));
+  try {
+    const path = join(dir, "connection.json"), config = join(dir, "mcp.json");
+    await writeFile(path, JSON.stringify(connection), { mode: 384 });
+    const args = [fileURLToPath(new URL("../agent-tool-client.mjs", import.meta.url)), "--connection", path];
+    const value = { command: process.execPath, args, enabled_tools: AGENT_TOOLS.map((tool) => tool.name), startup_timeout_sec: 10, tool_timeout_sec: 660, tools: Object.fromEntries(AGENT_TOOLS.map((tool) => [tool.name, { approval_mode: "approve" }])) };
+    await writeFile(config, JSON.stringify({ mcpServers: { codeflow_agent: { type: "stdio", command: process.execPath, args } } }), { mode: 384 });
+    const toml = `mcp_servers.codeflow_agent={command=${JSON.stringify(process.execPath)},args=${JSON.stringify(args)},enabled_tools=${JSON.stringify(value.enabled_tools)},startup_timeout_sec=10,tool_timeout_sec=660,tools={${AGENT_TOOLS.map((tool) => `${tool.name}={approval_mode="approve"}`).join(",")}}}`;
+    return { claudeConfig: config, codexConfig: ["-c", toml], codexThreadConfig: { "mcp_servers.codeflow_agent": value }, cleanup: () => rm(dir, { recursive: true, force: true }) };
+  } catch (error) {
+    await rm(dir, { recursive: true, force: true });
+    throw error;
+  }
+}
+export {
+  agentMcpConfig,
+  prepareAgentTools
+};

package/src/adapters/agy-auth.js

@@ -0,0 +1,67 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+function agyCredentialFailure(text) {
+  return /(?:token refresh failed|failed to refresh loaded token|failed to (?:save|persist|marshal) (?:refreshed (?:OAuth )?token|credentials)|failed to (?:save|persist) token to keyring|failed to load (?:stored )?token from keyring, falling back to file|stored credentials are invalid or expired)/i.test(text);
+}
+const AGY_AUTH_LOG_LIMIT = 4 * 1024 * 1024;
+function observeAgyAuthLine(observation, line) {
+  const message = line.match(/\b(?:auth|auth_provider|server_oauth|credentials|keyring)\.go:\d+\]\s+(.*)$/)?.[1];
+  if (!message) return;
+  if (/token refreshed, new expiry=|Auto-saving refreshed token from token source callback/.test(message)) observation.refreshObserved = true;
+  if (agyCredentialFailure(message)) observation.credentialFailure = true;
+  if (/OAuth: starting OAuth flow/.test(message)) observation.interactiveAuthObserved = true;
+  const expired = message.match(/keyringAuth: loaded token, [^\r\n]*\bexpired=(true|false)\b/)?.[1];
+  if (expired) observation.loadedTokenExpired = observation.loadedTokenExpired === true || expired === "true";
+}
+async function inspectAgyAuthLog(path) {
+  const result = { log: "unreadable", refreshObserved: false, credentialFailure: false, interactiveAuthObserved: false, loadedTokenExpired: null };
+  let file;
+  try {
+    file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const stat = await file.stat();
+    if (!stat.isFile() || stat.nlink !== 1) return result;
+    if (stat.size > AGY_AUTH_LOG_LIMIT) {
+      result.log = "too-large";
+      return result;
+    }
+    const buffer = Buffer.alloc(16 * 1024);
+    let consumed = 0, pending = "", dropped = false;
+    while (consumed <= AGY_AUTH_LOG_LIMIT) {
+      const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, AGY_AUTH_LOG_LIMIT + 1 - consumed), consumed);
+      if (!bytesRead) break;
+      consumed += bytesRead;
+      if (consumed > AGY_AUTH_LOG_LIMIT) {
+        result.log = "too-large";
+        return result;
+      }
+      for (const part of buffer.subarray(0, bytesRead).toString("latin1").split(/(?<=\n)/)) {
+        if (!dropped) {
+          pending += part;
+          if (pending.length > 8192) {
+            pending = "";
+            dropped = true;
+          }
+        }
+        if (part.endsWith("\n")) {
+          if (!dropped) observeAgyAuthLine(result, pending.trimEnd());
+          pending = "";
+          dropped = false;
+        }
+      }
+    }
+    if (pending && !dropped) observeAgyAuthLine(result, pending);
+    result.log = "read";
+    return result;
+  } catch (error) {
+    result.log = error.code === "ENOENT" ? "missing" : "unreadable";
+    return result;
+  } finally {
+    await file?.close();
+  }
+}
+export {
+  AGY_AUTH_LOG_LIMIT,
+  agyCredentialFailure,
+  inspectAgyAuthLog,
+  observeAgyAuthLine
+};