acpx 0.1.0

package/dist/cli.js

@@ -0,0 +1,1452 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command, CommanderError, InvalidArgumentError } from "commander";
+
+// src/output.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function asStatus(status) {
+  return status ?? "unknown";
+}
+var TextOutputFormatter = class {
+  stdout;
+  constructor(stdout) {
+    this.stdout = stdout;
+  }
+  onSessionUpdate(notification) {
+    const update = notification.update;
+    switch (update.sessionUpdate) {
+      case "agent_message_chunk": {
+        if (update.content.type === "text") {
+          this.stdout.write(update.content.text);
+        }
+        return;
+      }
+      case "agent_thought_chunk": {
+        if (update.content.type === "text") {
+          this.stdout.write(`
+[thought] ${update.content.text}
+`);
+        }
+        return;
+      }
+      case "tool_call": {
+        this.stdout.write(`
+[tool] ${update.title} (${asStatus(update.status)})
+`);
+        return;
+      }
+      case "tool_call_update": {
+        const title = update.title ?? update.toolCallId;
+        this.stdout.write(`
+[tool] ${title} (${asStatus(update.status)})
+`);
+        return;
+      }
+      case "plan": {
+        this.stdout.write("\n[plan]\n");
+        for (const entry of update.entries) {
+          this.stdout.write(`- (${entry.status}) ${entry.content}
+`);
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  onDone(stopReason) {
+    this.stdout.write(`
+[done] ${stopReason}
+`);
+  }
+  flush() {
+  }
+};
+var JsonOutputFormatter = class {
+  stdout;
+  constructor(stdout) {
+    this.stdout = stdout;
+  }
+  onSessionUpdate(notification) {
+    const update = notification.update;
+    const timestamp = nowIso();
+    switch (update.sessionUpdate) {
+      case "agent_message_chunk": {
+        if (update.content.type === "text") {
+          this.emit({
+            type: "text",
+            content: update.content.text,
+            timestamp
+          });
+        }
+        return;
+      }
+      case "agent_thought_chunk": {
+        if (update.content.type === "text") {
+          this.emit({
+            type: "thought",
+            content: update.content.text,
+            timestamp
+          });
+        }
+        return;
+      }
+      case "tool_call": {
+        this.emit({
+          type: "tool_call",
+          title: update.title,
+          toolCallId: update.toolCallId,
+          status: update.status,
+          timestamp
+        });
+        return;
+      }
+      case "tool_call_update": {
+        this.emit({
+          type: "tool_call",
+          title: update.title ?? void 0,
+          toolCallId: update.toolCallId,
+          status: update.status ?? void 0,
+          timestamp
+        });
+        return;
+      }
+      case "plan": {
+        this.emit({
+          type: "plan",
+          entries: update.entries.map((entry) => ({
+            content: entry.content,
+            status: entry.status,
+            priority: entry.priority
+          })),
+          timestamp
+        });
+        return;
+      }
+      default: {
+        this.emit({
+          type: "update",
+          update: update.sessionUpdate,
+          timestamp
+        });
+      }
+    }
+  }
+  onDone(stopReason) {
+    this.emit({
+      type: "done",
+      stopReason,
+      timestamp: nowIso()
+    });
+  }
+  flush() {
+  }
+  emit(event) {
+    this.stdout.write(`${JSON.stringify(event)}
+`);
+  }
+};
+var QuietOutputFormatter = class {
+  stdout;
+  chunks = [];
+  constructor(stdout) {
+    this.stdout = stdout;
+  }
+  onSessionUpdate(notification) {
+    const update = notification.update;
+    if (update.sessionUpdate !== "agent_message_chunk") {
+      return;
+    }
+    if (update.content.type !== "text") {
+      return;
+    }
+    this.chunks.push(update.content.text);
+  }
+  onDone(_stopReason) {
+    const text = this.chunks.join("");
+    this.stdout.write(text.endsWith("\n") ? text : `${text}
+`);
+  }
+  flush() {
+  }
+};
+function createOutputFormatter(format, options = {}) {
+  const stdout = options.stdout ?? process.stdout;
+  switch (format) {
+    case "text":
+      return new TextOutputFormatter(stdout);
+    case "json":
+      return new JsonOutputFormatter(stdout);
+    case "quiet":
+      return new QuietOutputFormatter(stdout);
+    default: {
+      const exhaustive = format;
+      throw new Error(`Unsupported output format: ${exhaustive}`);
+    }
+  }
+}
+
+// src/session.ts
+import fs2 from "fs/promises";
+import os from "os";
+import path2 from "path";
+
+// src/client.ts
+import {
+  ClientSideConnection,
+  PROTOCOL_VERSION,
+  ndJsonStream
+} from "@agentclientprotocol/sdk";
+import {
+  spawn
+} from "child_process";
+import { randomUUID } from "crypto";
+import fs from "fs/promises";
+import path from "path";
+import { Readable, Writable } from "stream";
+
+// src/permissions.ts
+import readline from "readline/promises";
+function selected(optionId) {
+  return { outcome: { outcome: "selected", optionId } };
+}
+function cancelled() {
+  return { outcome: { outcome: "cancelled" } };
+}
+function pickOption(options, kinds) {
+  for (const kind of kinds) {
+    const match = options.find((option) => option.kind === kind);
+    if (match) {
+      return match;
+    }
+  }
+  return void 0;
+}
+function inferToolKind(params) {
+  if (params.toolCall.kind) {
+    return params.toolCall.kind;
+  }
+  const title = params.toolCall.title?.trim().toLowerCase();
+  if (!title) {
+    return void 0;
+  }
+  const head = title.split(":", 1)[0]?.trim();
+  if (!head) {
+    return void 0;
+  }
+  if (head.includes("read") || head.includes("cat")) {
+    return "read";
+  }
+  if (head.includes("search") || head.includes("find") || head.includes("grep")) {
+    return "search";
+  }
+  if (head.includes("write") || head.includes("edit") || head.includes("patch")) {
+    return "edit";
+  }
+  if (head.includes("delete") || head.includes("remove")) {
+    return "delete";
+  }
+  if (head.includes("move") || head.includes("rename")) {
+    return "move";
+  }
+  if (head.includes("run") || head.includes("execute") || head.includes("bash")) {
+    return "execute";
+  }
+  if (head.includes("fetch") || head.includes("http") || head.includes("url")) {
+    return "fetch";
+  }
+  if (head.includes("think")) {
+    return "think";
+  }
+  return "other";
+}
+function isAutoApprovedReadKind(kind) {
+  return kind === "read" || kind === "search";
+}
+async function promptForPermission(params) {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    return false;
+  }
+  const toolName = params.toolCall.title ?? "tool";
+  const toolKind = inferToolKind(params) ?? "other";
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  try {
+    const answer = await rl.question(
+      `
+[permission] Allow ${toolName} [${toolKind}]? (y/N) `
+    );
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function resolvePermissionRequest(params, mode) {
+  const options = params.options ?? [];
+  if (options.length === 0) {
+    return cancelled();
+  }
+  const allowOption = pickOption(options, ["allow_once", "allow_always"]);
+  const rejectOption = pickOption(options, ["reject_once", "reject_always"]);
+  if (mode === "approve-all") {
+    if (allowOption) {
+      return selected(allowOption.optionId);
+    }
+    return selected(options[0].optionId);
+  }
+  if (mode === "deny-all") {
+    if (rejectOption) {
+      return selected(rejectOption.optionId);
+    }
+    return cancelled();
+  }
+  const kind = inferToolKind(params);
+  if (isAutoApprovedReadKind(kind) && allowOption) {
+    return selected(allowOption.optionId);
+  }
+  const approved = await promptForPermission(params);
+  if (approved && allowOption) {
+    return selected(allowOption.optionId);
+  }
+  if (!approved && rejectOption) {
+    return selected(rejectOption.optionId);
+  }
+  return cancelled();
+}
+function classifyPermissionDecision(params, response) {
+  if (response.outcome.outcome !== "selected") {
+    return "cancelled";
+  }
+  const selectedOptionId = response.outcome.optionId;
+  const selectedOption = params.options.find(
+    (option) => option.optionId === selectedOptionId
+  );
+  if (!selectedOption) {
+    return "cancelled";
+  }
+  if (selectedOption.kind === "allow_once" || selectedOption.kind === "allow_always") {
+    return "approved";
+  }
+  return "denied";
+}
+
+// src/client.ts
+var DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES = 64 * 1024;
+var REPLAY_IDLE_MS = 80;
+var REPLAY_DRAIN_TIMEOUT_MS = 5e3;
+var DRAIN_POLL_INTERVAL_MS = 20;
+function waitForSpawn(child) {
+  return new Promise((resolve, reject) => {
+    const onSpawn = () => {
+      child.off("error", onError);
+      resolve();
+    };
+    const onError = (error) => {
+      child.off("spawn", onSpawn);
+      reject(error);
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+  });
+}
+function splitCommandLine(value) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const ch of value) {
+    if (escaping) {
+      current += ch;
+      escaping = false;
+      continue;
+    }
+    if (ch === "\\" && quote !== "'") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current.length > 0) {
+        parts.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (escaping) {
+    current += "\\";
+  }
+  if (quote) {
+    throw new Error("Invalid --agent command: unterminated quote");
+  }
+  if (current.length > 0) {
+    parts.push(current);
+  }
+  if (parts.length === 0) {
+    throw new Error("Invalid --agent command: empty command");
+  }
+  return {
+    command: parts[0],
+    args: parts.slice(1)
+  };
+}
+function asAbsoluteCwd(cwd) {
+  return path.resolve(cwd);
+}
+function toEnvObject(env) {
+  if (!env || env.length === 0) {
+    return void 0;
+  }
+  const merged = { ...process.env };
+  for (const entry of env) {
+    merged[entry.name] = entry.value;
+  }
+  return merged;
+}
+var AcpClient = class {
+  options;
+  connection;
+  agent;
+  initResult;
+  permissionStats = {
+    requested: 0,
+    approved: 0,
+    denied: 0,
+    cancelled: 0
+  };
+  terminals = /* @__PURE__ */ new Map();
+  sessionUpdateChain = Promise.resolve();
+  observedSessionUpdates = 0;
+  processedSessionUpdates = 0;
+  suppressSessionUpdates = false;
+  constructor(options) {
+    this.options = {
+      ...options,
+      cwd: asAbsoluteCwd(options.cwd)
+    };
+  }
+  get initializeResult() {
+    return this.initResult;
+  }
+  getAgentPid() {
+    return this.agent?.pid ?? void 0;
+  }
+  getPermissionStats() {
+    return { ...this.permissionStats };
+  }
+  supportsLoadSession() {
+    return Boolean(this.initResult?.agentCapabilities?.loadSession);
+  }
+  async start() {
+    if (this.connection && this.agent) {
+      return;
+    }
+    const { command, args } = splitCommandLine(this.options.agentCommand);
+    this.log(`spawning agent: ${command} ${args.join(" ")}`);
+    const child = spawn(command, args, {
+      cwd: this.options.cwd,
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    await waitForSpawn(child);
+    const input = Writable.toWeb(child.stdin);
+    const output = Readable.toWeb(child.stdout);
+    const stream = ndJsonStream(input, output);
+    const connection = new ClientSideConnection(
+      () => ({
+        sessionUpdate: async (params) => {
+          await this.handleSessionUpdate(params);
+        },
+        requestPermission: async (params) => {
+          return this.handlePermissionRequest(params);
+        },
+        readTextFile: async (params) => {
+          return this.handleReadTextFile(params);
+        },
+        writeTextFile: async (params) => {
+          return this.handleWriteTextFile(params);
+        },
+        createTerminal: async (params) => {
+          return this.handleCreateTerminal(params);
+        },
+        terminalOutput: async (params) => {
+          return this.handleTerminalOutput(params);
+        },
+        waitForTerminalExit: async (params) => {
+          return this.handleWaitForTerminalExit(params);
+        },
+        killTerminal: async (params) => {
+          return this.handleKillTerminal(params);
+        },
+        releaseTerminal: async (params) => {
+          return this.handleReleaseTerminal(params);
+        }
+      }),
+      stream
+    );
+    try {
+      const initResult = await connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientCapabilities: {
+          fs: {
+            readTextFile: true,
+            writeTextFile: true
+          },
+          terminal: true
+        },
+        clientInfo: {
+          name: "acpx",
+          version: "0.1.0"
+        }
+      });
+      this.connection = connection;
+      this.agent = child;
+      this.initResult = initResult;
+      this.log(`initialized protocol version ${initResult.protocolVersion}`);
+    } catch (error) {
+      child.kill();
+      throw error;
+    }
+  }
+  async createSession(cwd = this.options.cwd) {
+    const connection = this.getConnection();
+    const result = await connection.newSession({
+      cwd: asAbsoluteCwd(cwd),
+      mcpServers: []
+    });
+    return result.sessionId;
+  }
+  async loadSession(sessionId, cwd = this.options.cwd) {
+    this.getConnection();
+    await this.loadSessionWithOptions(sessionId, cwd, {});
+  }
+  async loadSessionWithOptions(sessionId, cwd = this.options.cwd, options = {}) {
+    const connection = this.getConnection();
+    const previousSuppression = this.suppressSessionUpdates;
+    this.suppressSessionUpdates = previousSuppression || Boolean(options.suppressReplayUpdates);
+    try {
+      await connection.loadSession({
+        sessionId,
+        cwd: asAbsoluteCwd(cwd),
+        mcpServers: []
+      });
+      await this.waitForSessionUpdateDrain(
+        options.replayIdleMs ?? REPLAY_IDLE_MS,
+        options.replayDrainTimeoutMs ?? REPLAY_DRAIN_TIMEOUT_MS
+      );
+    } finally {
+      this.suppressSessionUpdates = previousSuppression;
+    }
+  }
+  async prompt(sessionId, text) {
+    const connection = this.getConnection();
+    return connection.prompt({
+      sessionId,
+      prompt: [
+        {
+          type: "text",
+          text
+        }
+      ]
+    });
+  }
+  async close() {
+    for (const terminalId of [...this.terminals.keys()]) {
+      await this.releaseTerminalById(terminalId);
+    }
+    if (this.agent && !this.agent.killed) {
+      this.agent.kill();
+    }
+    this.sessionUpdateChain = Promise.resolve();
+    this.observedSessionUpdates = 0;
+    this.processedSessionUpdates = 0;
+    this.suppressSessionUpdates = false;
+    this.connection = void 0;
+    this.agent = void 0;
+  }
+  getConnection() {
+    if (!this.connection) {
+      throw new Error("ACP client not started");
+    }
+    return this.connection;
+  }
+  log(message) {
+    if (!this.options.verbose) {
+      return;
+    }
+    process.stderr.write(`[acpx] ${message}
+`);
+  }
+  async handlePermissionRequest(params) {
+    const response = await resolvePermissionRequest(
+      params,
+      this.options.permissionMode
+    );
+    const decision = classifyPermissionDecision(params, response);
+    this.permissionStats.requested += 1;
+    if (decision === "approved") {
+      this.permissionStats.approved += 1;
+    } else if (decision === "denied") {
+      this.permissionStats.denied += 1;
+    } else {
+      this.permissionStats.cancelled += 1;
+    }
+    return response;
+  }
+  async handleReadTextFile(params) {
+    const content = await fs.readFile(params.path, "utf8");
+    if (params.line == null && params.limit == null) {
+      return { content };
+    }
+    const lines = content.split("\n");
+    const start = Math.max(0, (params.line ?? 1) - 1);
+    const end = params.limit == null ? lines.length : start + Math.max(params.limit, 0);
+    return {
+      content: lines.slice(start, end).join("\n")
+    };
+  }
+  async handleWriteTextFile(params) {
+    await fs.mkdir(path.dirname(params.path), { recursive: true });
+    await fs.writeFile(params.path, params.content, "utf8");
+    return {};
+  }
+  async handleCreateTerminal(params) {
+    const outputByteLimit = Math.max(
+      1,
+      params.outputByteLimit ?? DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES
+    );
+    const proc = spawn(params.command, params.args ?? [], {
+      cwd: params.cwd ?? this.options.cwd,
+      env: toEnvObject(params.env),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    await waitForSpawn(proc);
+    const terminalId = randomUUID();
+    const terminal = {
+      process: proc,
+      output: Buffer.alloc(0),
+      truncated: false,
+      outputByteLimit,
+      exitCode: void 0,
+      signal: void 0,
+      waiters: []
+    };
+    const appendOutput = (chunk) => {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      terminal.output = Buffer.concat([terminal.output, buf]);
+      if (terminal.output.length > terminal.outputByteLimit) {
+        terminal.output = terminal.output.subarray(
+          terminal.output.length - terminal.outputByteLimit
+        );
+        terminal.truncated = true;
+      }
+    };
+    proc.stdout.on("data", appendOutput);
+    proc.stderr.on("data", appendOutput);
+    proc.once("exit", (exitCode, signal) => {
+      terminal.exitCode = exitCode;
+      terminal.signal = signal;
+      const response = {
+        exitCode: exitCode ?? null,
+        signal: signal ?? null
+      };
+      for (const waiter of terminal.waiters.splice(0)) {
+        waiter(response);
+      }
+    });
+    this.terminals.set(terminalId, terminal);
+    return { terminalId };
+  }
+  async handleTerminalOutput(params) {
+    const terminal = this.getTerminal(params.terminalId);
+    if (!terminal) {
+      throw new Error(`Unknown terminal: ${params.terminalId}`);
+    }
+    const hasExitStatus = terminal.exitCode !== void 0 || terminal.signal !== void 0;
+    return {
+      output: terminal.output.toString("utf8"),
+      truncated: terminal.truncated,
+      exitStatus: hasExitStatus ? {
+        exitCode: terminal.exitCode ?? null,
+        signal: terminal.signal ?? null
+      } : void 0
+    };
+  }
+  async handleWaitForTerminalExit(params) {
+    const terminal = this.getTerminal(params.terminalId);
+    if (!terminal) {
+      throw new Error(`Unknown terminal: ${params.terminalId}`);
+    }
+    if (terminal.exitCode !== void 0 || terminal.signal !== void 0) {
+      return {
+        exitCode: terminal.exitCode ?? null,
+        signal: terminal.signal ?? null
+      };
+    }
+    return new Promise((resolve) => {
+      terminal.waiters.push(resolve);
+    });
+  }
+  async handleKillTerminal(params) {
+    const terminal = this.getTerminal(params.terminalId);
+    if (!terminal) {
+      throw new Error(`Unknown terminal: ${params.terminalId}`);
+    }
+    if (!terminal.process.killed) {
+      terminal.process.kill();
+    }
+    return {};
+  }
+  async handleReleaseTerminal(params) {
+    await this.releaseTerminalById(params.terminalId);
+    return {};
+  }
+  async releaseTerminalById(terminalId) {
+    const terminal = this.getTerminal(terminalId);
+    if (!terminal) {
+      return;
+    }
+    if (!terminal.process.killed) {
+      terminal.process.kill();
+    }
+    this.terminals.delete(terminalId);
+  }
+  getTerminal(terminalId) {
+    return this.terminals.get(terminalId);
+  }
+  async handleSessionUpdate(notification) {
+    const sequence = ++this.observedSessionUpdates;
+    this.sessionUpdateChain = this.sessionUpdateChain.then(async () => {
+      try {
+        if (!this.suppressSessionUpdates) {
+          this.options.onSessionUpdate?.(notification);
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.log(`session update handler failed: ${message}`);
+      } finally {
+        this.processedSessionUpdates = sequence;
+      }
+    });
+    await this.sessionUpdateChain;
+  }
+  async waitForSessionUpdateDrain(idleMs, timeoutMs) {
+    const normalizedIdleMs = Math.max(0, idleMs);
+    const normalizedTimeoutMs = Math.max(normalizedIdleMs, timeoutMs);
+    const deadline = Date.now() + normalizedTimeoutMs;
+    let lastObserved = this.observedSessionUpdates;
+    let idleSince = Date.now();
+    while (Date.now() <= deadline) {
+      const observed = this.observedSessionUpdates;
+      if (observed !== lastObserved) {
+        lastObserved = observed;
+        idleSince = Date.now();
+      }
+      if (this.processedSessionUpdates === this.observedSessionUpdates && Date.now() - idleSince >= normalizedIdleMs) {
+        await this.sessionUpdateChain;
+        if (this.processedSessionUpdates === this.observedSessionUpdates) {
+          return;
+        }
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, DRAIN_POLL_INTERVAL_MS);
+      });
+    }
+    throw new Error(
+      `Timed out waiting for session replay drain after ${normalizedTimeoutMs}ms`
+    );
+  }
+};
+
+// src/session.ts
+var SESSION_BASE_DIR = path2.join(os.homedir(), ".acpx", "sessions");
+var PROCESS_EXIT_GRACE_MS = 1500;
+var PROCESS_POLL_MS = 50;
+var TimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Timed out after ${timeoutMs}ms`);
+    this.name = "TimeoutError";
+  }
+};
+var InterruptedError = class extends Error {
+  constructor() {
+    super("Interrupted");
+    this.name = "InterruptedError";
+  }
+};
+function sessionFilePath(id) {
+  const safeId = encodeURIComponent(id);
+  return path2.join(SESSION_BASE_DIR, `${safeId}.json`);
+}
+async function ensureSessionDir() {
+  await fs2.mkdir(SESSION_BASE_DIR, { recursive: true });
+}
+async function withTimeout(promise, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return promise;
+  }
+  let timer;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new TimeoutError(timeoutMs));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+async function withInterrupt(run, onInterrupt) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (cb) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      process.off("SIGINT", onSigint);
+      process.off("SIGTERM", onSigterm);
+      cb();
+    };
+    const onSigint = () => {
+      void onInterrupt().finally(() => {
+        finish(() => reject(new InterruptedError()));
+      });
+    };
+    const onSigterm = () => {
+      void onInterrupt().finally(() => {
+        finish(() => reject(new InterruptedError()));
+      });
+    };
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onSigterm);
+    void run().then(
+      (result) => finish(() => resolve(result)),
+      (error) => finish(() => reject(error))
+    );
+  });
+}
+function parseSessionRecord(raw) {
+  if (!raw || typeof raw !== "object") {
+    return null;
+  }
+  const record = raw;
+  const pid = record.pid == null ? void 0 : Number.isInteger(record.pid) && record.pid > 0 ? record.pid : null;
+  if (typeof record.id !== "string" || typeof record.sessionId !== "string" || typeof record.agentCommand !== "string" || typeof record.cwd !== "string" || typeof record.createdAt !== "string" || typeof record.lastUsedAt !== "string" || pid === null) {
+    return null;
+  }
+  return {
+    ...record,
+    id: record.id,
+    sessionId: record.sessionId,
+    agentCommand: record.agentCommand,
+    cwd: record.cwd,
+    createdAt: record.createdAt,
+    lastUsedAt: record.lastUsedAt,
+    pid
+  };
+}
+async function writeSessionRecord(record) {
+  await ensureSessionDir();
+  const file = sessionFilePath(record.id);
+  const tempFile = `${file}.${process.pid}.${Date.now()}.tmp`;
+  const payload = JSON.stringify(record, null, 2);
+  await fs2.writeFile(tempFile, `${payload}
+`, "utf8");
+  await fs2.rename(tempFile, file);
+}
+async function resolveSessionRecord(sessionId) {
+  await ensureSessionDir();
+  const directPath = sessionFilePath(sessionId);
+  try {
+    const directPayload = await fs2.readFile(directPath, "utf8");
+    const directRecord = parseSessionRecord(JSON.parse(directPayload));
+    if (directRecord) {
+      return directRecord;
+    }
+  } catch {
+  }
+  const sessions = await listSessions();
+  const exact = sessions.filter(
+    (session) => session.id === sessionId || session.sessionId === sessionId
+  );
+  if (exact.length === 1) {
+    return exact[0];
+  }
+  if (exact.length > 1) {
+    throw new Error(`Multiple sessions match id: ${sessionId}`);
+  }
+  const suffixMatches = sessions.filter(
+    (session) => session.id.endsWith(sessionId) || session.sessionId.endsWith(sessionId)
+  );
+  if (suffixMatches.length === 1) {
+    return suffixMatches[0];
+  }
+  if (suffixMatches.length > 1) {
+    throw new Error(`Session id is ambiguous: ${sessionId}`);
+  }
+  throw new Error(`Session not found: ${sessionId}`);
+}
+function toPromptResult(stopReason, sessionId, client) {
+  return {
+    stopReason,
+    sessionId,
+    permissionStats: client.getPermissionStats()
+  };
+}
+function absolutePath(value) {
+  return path2.resolve(value);
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object") {
+    const maybeMessage = error.message;
+    if (typeof maybeMessage === "string" && maybeMessage.length > 0) {
+      return maybeMessage;
+    }
+    try {
+      return JSON.stringify(error);
+    } catch {
+    }
+  }
+  return String(error);
+}
+function shouldFallbackToNewSession(error) {
+  if (error instanceof TimeoutError || error instanceof InterruptedError) {
+    return false;
+  }
+  const message = formatError(error).toLowerCase();
+  if (message.includes("resource_not_found") || message.includes("resource not found") || message.includes("session not found") || message.includes("unknown session") || message.includes("invalid session")) {
+    return true;
+  }
+  const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+  return code === -32001 || code === -32002;
+}
+function isProcessAlive(pid) {
+  if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function waitForProcessExit(pid, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() <= deadline) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, PROCESS_POLL_MS);
+    });
+  }
+  return !isProcessAlive(pid);
+}
+async function terminateProcess(pid) {
+  if (!isProcessAlive(pid)) {
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  if (await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS)) {
+    return true;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return false;
+  }
+  await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS);
+  return true;
+}
+function firstAgentCommandToken(command) {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  const token = trimmed.split(/\s+/, 1)[0];
+  return token.length > 0 ? token : void 0;
+}
+async function isLikelyMatchingProcess(pid, agentCommand) {
+  const expectedToken = firstAgentCommandToken(agentCommand);
+  if (!expectedToken) {
+    return false;
+  }
+  const procCmdline = `/proc/${pid}/cmdline`;
+  try {
+    const payload = await fs2.readFile(procCmdline, "utf8");
+    const argv = payload.split("\0").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    if (argv.length === 0) {
+      return false;
+    }
+    const executableBase = path2.basename(argv[0]);
+    const expectedBase = path2.basename(expectedToken);
+    return executableBase === expectedBase || argv.some((entry) => path2.basename(entry) === expectedBase);
+  } catch {
+    return true;
+  }
+}
+async function runOnce(options) {
+  const output = options.outputFormatter;
+  const client = new AcpClient({
+    agentCommand: options.agentCommand,
+    cwd: absolutePath(options.cwd),
+    permissionMode: options.permissionMode,
+    verbose: options.verbose,
+    onSessionUpdate: (notification) => output.onSessionUpdate(notification)
+  });
+  try {
+    return await withInterrupt(
+      async () => {
+        await withTimeout(client.start(), options.timeoutMs);
+        const sessionId = await withTimeout(
+          client.createSession(absolutePath(options.cwd)),
+          options.timeoutMs
+        );
+        const response = await withTimeout(
+          client.prompt(sessionId, options.message),
+          options.timeoutMs
+        );
+        output.onDone(response.stopReason);
+        output.flush();
+        return toPromptResult(response.stopReason, sessionId, client);
+      },
+      async () => {
+        await client.close();
+      }
+    );
+  } finally {
+    await client.close();
+  }
+}
+async function createSession(options) {
+  const client = new AcpClient({
+    agentCommand: options.agentCommand,
+    cwd: absolutePath(options.cwd),
+    permissionMode: options.permissionMode,
+    verbose: options.verbose
+  });
+  try {
+    return await withInterrupt(
+      async () => {
+        await withTimeout(client.start(), options.timeoutMs);
+        const sessionId = await withTimeout(
+          client.createSession(absolutePath(options.cwd)),
+          options.timeoutMs
+        );
+        const now = isoNow();
+        const record = {
+          id: sessionId,
+          sessionId,
+          agentCommand: options.agentCommand,
+          cwd: absolutePath(options.cwd),
+          createdAt: now,
+          lastUsedAt: now,
+          pid: client.getAgentPid(),
+          protocolVersion: client.initializeResult?.protocolVersion,
+          agentCapabilities: client.initializeResult?.agentCapabilities
+        };
+        await writeSessionRecord(record);
+        return record;
+      },
+      async () => {
+        await client.close();
+      }
+    );
+  } finally {
+    await client.close();
+  }
+}
+async function sendSession(options) {
+  const output = options.outputFormatter;
+  const record = await resolveSessionRecord(options.sessionId);
+  const storedProcessAlive = isProcessAlive(record.pid);
+  if (storedProcessAlive && options.verbose) {
+    process.stderr.write(
+      `[acpx] saved session pid ${record.pid} is running; reconnecting with loadSession
+`
+    );
+  }
+  const client = new AcpClient({
+    agentCommand: record.agentCommand,
+    cwd: absolutePath(record.cwd),
+    permissionMode: options.permissionMode,
+    verbose: options.verbose,
+    onSessionUpdate: (notification) => output.onSessionUpdate(notification)
+  });
+  try {
+    return await withInterrupt(
+      async () => {
+        await withTimeout(client.start(), options.timeoutMs);
+        record.pid = client.getAgentPid();
+        let resumed = false;
+        let loadError;
+        let activeSessionId = record.sessionId;
+        if (client.supportsLoadSession()) {
+          try {
+            await withTimeout(
+              client.loadSessionWithOptions(record.sessionId, record.cwd, {
+                suppressReplayUpdates: true
+              }),
+              options.timeoutMs
+            );
+            resumed = true;
+          } catch (error) {
+            loadError = formatError(error);
+            if (!shouldFallbackToNewSession(error)) {
+              throw error;
+            }
+            activeSessionId = await withTimeout(
+              client.createSession(record.cwd),
+              options.timeoutMs
+            );
+            record.sessionId = activeSessionId;
+          }
+        } else {
+          activeSessionId = await withTimeout(
+            client.createSession(record.cwd),
+            options.timeoutMs
+          );
+          record.sessionId = activeSessionId;
+        }
+        const response = await withTimeout(
+          client.prompt(activeSessionId, options.message),
+          options.timeoutMs
+        );
+        output.onDone(response.stopReason);
+        output.flush();
+        record.lastUsedAt = isoNow();
+        record.protocolVersion = client.initializeResult?.protocolVersion;
+        record.agentCapabilities = client.initializeResult?.agentCapabilities;
+        await writeSessionRecord(record);
+        return {
+          ...toPromptResult(response.stopReason, record.id, client),
+          record,
+          resumed,
+          loadError
+        };
+      },
+      async () => {
+        await client.close();
+      }
+    );
+  } finally {
+    await client.close();
+  }
+}
+async function listSessions() {
+  await ensureSessionDir();
+  const entries = await fs2.readdir(SESSION_BASE_DIR, { withFileTypes: true });
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const fullPath = path2.join(SESSION_BASE_DIR, entry.name);
+    try {
+      const payload = await fs2.readFile(fullPath, "utf8");
+      const parsed = parseSessionRecord(JSON.parse(payload));
+      if (parsed) {
+        records.push(parsed);
+      }
+    } catch {
+    }
+  }
+  records.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+  return records;
+}
+async function closeSession(sessionId) {
+  const record = await resolveSessionRecord(sessionId);
+  if (record.pid != null && isProcessAlive(record.pid) && await isLikelyMatchingProcess(record.pid, record.agentCommand)) {
+    await terminateProcess(record.pid);
+  }
+  const file = sessionFilePath(record.id);
+  await fs2.unlink(file);
+  return record;
+}
+
+// src/types.ts
+var EXIT_CODES = {
+  SUCCESS: 0,
+  ERROR: 1,
+  USAGE: 2,
+  TIMEOUT: 3,
+  PERMISSION_DENIED: 4,
+  INTERRUPTED: 130
+};
+var OUTPUT_FORMATS = ["text", "json", "quiet"];
+
+// src/cli.ts
+function parseOutputFormat(value) {
+  if (!OUTPUT_FORMATS.includes(value)) {
+    throw new InvalidArgumentError(
+      `Invalid format "${value}". Expected one of: ${OUTPUT_FORMATS.join(", ")}`
+    );
+  }
+  return value;
+}
+function parseTimeoutSeconds(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError("Timeout must be a positive number of seconds");
+  }
+  return Math.round(parsed * 1e3);
+}
+function resolvePermissionMode(flags) {
+  const selected2 = [flags.approveAll, flags.approveReads, flags.denyAll].filter(
+    Boolean
+  ).length;
+  if (selected2 > 1) {
+    throw new InvalidArgumentError(
+      "Use only one permission mode: --approve-all, --approve-reads, or --deny-all"
+    );
+  }
+  if (flags.approveAll) {
+    return "approve-all";
+  }
+  if (flags.denyAll) {
+    return "deny-all";
+  }
+  return "approve-reads";
+}
+function addPermissionFlags(command) {
+  return command.option("--approve-all", "Auto-approve all permission requests").option(
+    "--approve-reads",
+    "Auto-approve read/search requests and prompt for writes"
+  ).option("--deny-all", "Deny all permission requests");
+}
+function addFormatFlag(command) {
+  return command.option(
+    "--format <fmt>",
+    "Output format: text, json, quiet",
+    parseOutputFormat,
+    "text"
+  );
+}
+async function readPrompt(promptParts) {
+  const joined = promptParts.join(" ").trim();
+  if (joined.length > 0) {
+    return joined;
+  }
+  if (process.stdin.isTTY) {
+    throw new InvalidArgumentError(
+      "Prompt is required (pass as argument or pipe via stdin)"
+    );
+  }
+  let data = "";
+  for await (const chunk of process.stdin) {
+    data += String(chunk);
+  }
+  const prompt = data.trim();
+  if (!prompt) {
+    throw new InvalidArgumentError("Prompt from stdin is empty");
+  }
+  return prompt;
+}
+function applyPermissionExitCode(result) {
+  const stats = result.permissionStats;
+  const deniedOrCancelled = stats.denied + stats.cancelled;
+  if (stats.requested > 0 && stats.approved === 0 && deniedOrCancelled > 0) {
+    process.exitCode = EXIT_CODES.PERMISSION_DENIED;
+  }
+}
+function printSessionRecordByFormat(record, format) {
+  if (format === "json") {
+    process.stdout.write(
+      `${JSON.stringify({
+        type: "session",
+        ...record
+      })}
+`
+    );
+    return;
+  }
+  process.stdout.write(`${record.id}
+`);
+}
+function printSessionsByFormat(sessions, format) {
+  if (format === "json") {
+    process.stdout.write(`${JSON.stringify(sessions)}
+`);
+    return;
+  }
+  if (format === "quiet") {
+    for (const session of sessions) {
+      process.stdout.write(`${session.id}
+`);
+    }
+    return;
+  }
+  if (sessions.length === 0) {
+    process.stdout.write("No sessions\n");
+    return;
+  }
+  for (const session of sessions) {
+    process.stdout.write(
+      `${session.id}	${session.cwd}	${session.lastUsedAt}
+`
+    );
+  }
+}
+async function main() {
+  const program = new Command();
+  program.name("acpx").description("Headless CLI client for the Agent Client Protocol").showHelpAfterError();
+  program.command("run").description("Run a one-shot prompt").argument("[prompt...]", "Prompt text").requiredOption("--agent <command>", "ACP adapter command").option("--cwd <dir>", "Working directory", process.cwd()).option(
+    "--timeout <seconds>",
+    "Maximum time to wait for agent response",
+    parseTimeoutSeconds
+  ).option("--verbose", "Enable verbose debug logs").allowUnknownOption(false);
+  const runCommand = program.commands.find((cmd) => cmd.name() === "run");
+  if (!runCommand) {
+    throw new Error("Failed to build run command");
+  }
+  addPermissionFlags(runCommand);
+  addFormatFlag(runCommand);
+  runCommand.action(async (promptParts, flags) => {
+    const prompt = await readPrompt(promptParts);
+    const permissionMode = resolvePermissionMode(flags);
+    const formatter = createOutputFormatter(flags.format);
+    const result = await runOnce({
+      agentCommand: flags.agent,
+      cwd: flags.cwd,
+      message: prompt,
+      permissionMode,
+      outputFormatter: formatter,
+      timeoutMs: flags.timeout,
+      verbose: flags.verbose
+    });
+    applyPermissionExitCode(result);
+  });
+  const session = program.command("session").description("Session management");
+  const sessionCreate = session.command("create").description("Create a persistent session").requiredOption("--agent <command>", "ACP adapter command").option("--cwd <dir>", "Working directory", process.cwd()).option(
+    "--timeout <seconds>",
+    "Maximum time to wait for agent response",
+    parseTimeoutSeconds
+  ).option("--verbose", "Enable verbose debug logs");
+  addPermissionFlags(sessionCreate);
+  addFormatFlag(sessionCreate);
+  sessionCreate.action(async (flags) => {
+    const permissionMode = resolvePermissionMode(flags);
+    const record = await createSession({
+      agentCommand: flags.agent,
+      cwd: flags.cwd,
+      permissionMode,
+      timeoutMs: flags.timeout,
+      verbose: flags.verbose
+    });
+    printSessionRecordByFormat(record, flags.format);
+  });
+  const sessionSend = session.command("send").description("Send a prompt to an existing session").argument("<sessionId>", "Session ID").argument("[prompt...]", "Prompt text").option(
+    "--timeout <seconds>",
+    "Maximum time to wait for agent response",
+    parseTimeoutSeconds
+  ).option("--verbose", "Enable verbose debug logs");
+  addPermissionFlags(sessionSend);
+  addFormatFlag(sessionSend);
+  sessionSend.action(
+    async (sessionId, promptParts, flags) => {
+      const prompt = await readPrompt(promptParts);
+      const permissionMode = resolvePermissionMode(flags);
+      const formatter = createOutputFormatter(flags.format);
+      const result = await sendSession({
+        sessionId,
+        message: prompt,
+        permissionMode,
+        outputFormatter: formatter,
+        timeoutMs: flags.timeout,
+        verbose: flags.verbose
+      });
+      applyPermissionExitCode(result);
+      if (flags.verbose && result.loadError) {
+        process.stderr.write(
+          `[acpx] loadSession failed, started fresh session: ${result.loadError}
+`
+        );
+      }
+    }
+  );
+  const sessionList = session.command("list").description("List saved sessions");
+  addFormatFlag(sessionList);
+  sessionList.action(async (flags) => {
+    const sessions = await listSessions();
+    printSessionsByFormat(sessions, flags.format);
+  });
+  const sessionClose = session.command("close").description("Close and remove a saved session").argument("<sessionId>", "Session ID");
+  addFormatFlag(sessionClose);
+  sessionClose.action(async (sessionId, flags) => {
+    const record = await closeSession(sessionId);
+    if (flags.format === "json") {
+      process.stdout.write(
+        `${JSON.stringify({
+          type: "session_closed",
+          id: record.id,
+          sessionId: record.sessionId
+        })}
+`
+      );
+      return;
+    }
+    if (flags.format === "quiet") {
+      return;
+    }
+    process.stdout.write(`${record.id}
+`);
+  });
+  program.exitOverride((error) => {
+    throw error;
+  });
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
+        process.exit(EXIT_CODES.SUCCESS);
+      }
+      process.exit(EXIT_CODES.USAGE);
+    }
+    if (error instanceof InterruptedError) {
+      process.exit(EXIT_CODES.INTERRUPTED);
+    }
+    if (error instanceof TimeoutError) {
+      process.stderr.write(`${error.message}
+`);
+      process.exit(EXIT_CODES.TIMEOUT);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}
+`);
+    process.exit(EXIT_CODES.ERROR);
+  }
+}
+void main();