@vicvic-im/agent-bot 0.0.0-stage → 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,1499 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
+var import_commander = require("commander");
+var import_picocolors2 = __toESM(require("picocolors"), 1);
+
+// src/commands/setup.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_inquirer = __toESM(require("inquirer"), 1);
+var import_picocolors = __toESM(require("picocolors"), 1);
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+
+// src/agents/registry.ts
+var AGENTS = {
+  claude: {
+    name: "claude",
+    label: "Claude Code",
+    command: {
+      command: "npx",
+      args: ["-y", "@agentclientprotocol/claude-agent-acp@0.100.0"]
+    },
+    authHint: "Run `claude login` (or configure ANTHROPIC_AUTH_TOKEN) before using vbot."
+  },
+  codex: {
+    name: "codex",
+    label: "Codex CLI",
+    command: {
+      command: "npx",
+      args: ["-y", "@agentclientprotocol/codex-acp@2.5.0"]
+    },
+    authHint: "Run `codex login` before using vbot."
+  },
+  opencode: {
+    name: "opencode",
+    label: "OpenCode",
+    command: {
+      command: "opencode",
+      args: ["acp"]
+    },
+    authHint: "OpenCode >= 1.19 is required; configure a provider/model in OpenCode first."
+  },
+  pi: {
+    name: "pi",
+    label: "Pi",
+    command: {
+      command: "npx",
+      args: ["-y", "--package=pi-acp@0.0.34", "--", "pi-acp"]
+    },
+    authHint: "Install and authenticate Pi (`pi` CLI) before using vbot."
+  }
+};
+var AGENT_NAMES = Object.keys(AGENTS);
+function isAgentName(value) {
+  return AGENT_NAMES.includes(value);
+}
+function definitionOf(name) {
+  return AGENTS[name];
+}
+
+// src/config.ts
+var CONFIG_FILENAME = "vbot.json";
+var GLOBAL_CONFIG_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".vbot");
+var GLOBAL_CONFIG_PATH = (0, import_node_path.join)(GLOBAL_CONFIG_DIR, "config.json");
+var DEFAULT_BASE_URL = "https://api.vicvic.im";
+var DEFAULT_TIMEOUT_MS = 36e5;
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function readJson(path) {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch (error) {
+    throw new ConfigError(
+      `Failed to read config ${path}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function asRecord(value, field) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new ConfigError(`Invalid "${field}" in vbot.json: expected an object`);
+  }
+  return value;
+}
+function asString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new ConfigError(`Invalid "${field}" in vbot.json: expected a non-empty string`);
+  }
+  return value.trim();
+}
+function optionalString(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") {
+    throw new ConfigError(`Invalid "${field}" in vbot.json: expected a string`);
+  }
+  return value.trim() || void 0;
+}
+function trimTrailingSlash(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") end -= 1;
+  return value.slice(0, end);
+}
+function parseEnv(value) {
+  if (value === void 0 || value === null) return void 0;
+  const record = asRecord(value, "agent.env");
+  const env = {};
+  for (const [key, entry2] of Object.entries(record)) {
+    if (typeof entry2 !== "string") {
+      throw new ConfigError(`Invalid "agent.env.${key}": expected a string`);
+    }
+    env[key] = entry2;
+  }
+  return env;
+}
+function parseProvider(root) {
+  const provider = optionalString(root.provider, "provider") ?? "vicvic";
+  if (provider !== "vicvic") {
+    throw new ConfigError(`Unsupported provider "${provider}"; only "vicvic" is supported`);
+  }
+  return "vicvic";
+}
+function parseVicvic(root, env) {
+  const vicvic = asRecord(root.vicvic, "vicvic");
+  const baseUrl = trimTrailingSlash(
+    optionalString(vicvic.baseUrl, "vicvic.baseUrl") ?? DEFAULT_BASE_URL
+  );
+  const token = env.VBOT_TOKEN?.trim() || optionalString(vicvic.token, "vicvic.token");
+  if (!token) {
+    throw new ConfigError(
+      'Missing "vicvic.token"; set it in vbot.json or the VBOT_TOKEN environment variable'
+    );
+  }
+  return { baseUrl, token };
+}
+function parseAgent(root, configDir) {
+  const agentRaw = asRecord(root.agent, "agent");
+  const agentName = asString(agentRaw.name, "agent.name");
+  if (!isAgentName(agentName)) {
+    throw new ConfigError(
+      `Invalid "agent.name" "${agentName}"; expected one of claude, codex, opencode, pi`
+    );
+  }
+  const cwdValue = asString(agentRaw.cwd, "agent.cwd");
+  const cwd = (0, import_node_path.isAbsolute)(cwdValue) ? cwdValue : (0, import_node_path.resolve)(configDir, cwdValue);
+  if (!(0, import_node_fs.existsSync)(cwd)) {
+    throw new ConfigError(`"agent.cwd" does not exist: ${cwd}`);
+  }
+  const argsRaw = agentRaw.args;
+  if (argsRaw !== void 0 && !Array.isArray(argsRaw)) {
+    throw new ConfigError('Invalid "agent.args": expected an array of strings');
+  }
+  return {
+    name: agentName,
+    command: optionalString(agentRaw.command, "agent.command"),
+    args: Array.isArray(argsRaw) ? argsRaw.map((entry2) => String(entry2)) : void 0,
+    cwd,
+    model: optionalString(agentRaw.model, "agent.model") ?? null,
+    env: parseEnv(agentRaw.env)
+  };
+}
+function parseTimeout(root) {
+  const value = typeof root.timeoutMs === "number" ? root.timeoutMs : DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(value) || value < 1e3 || value > 864e5) {
+    throw new ConfigError('Invalid "timeoutMs": expected a number between 1000 and 86400000');
+  }
+  return value;
+}
+function normalizeConfig(raw, configDir, env = process.env) {
+  const root = asRecord(raw, "root");
+  return {
+    provider: parseProvider(root),
+    vicvic: parseVicvic(root, env),
+    agent: parseAgent(root, configDir),
+    timeoutMs: parseTimeout(root),
+    logPrompt: root.logPrompt === true
+  };
+}
+function findConfigPath(explicit) {
+  if (explicit) {
+    const path = (0, import_node_path.resolve)(explicit);
+    if (!(0, import_node_fs.existsSync)(path)) throw new ConfigError(`Config file not found: ${path}`);
+    return path;
+  }
+  const local = (0, import_node_path.resolve)(process.cwd(), CONFIG_FILENAME);
+  if ((0, import_node_fs.existsSync)(local)) return local;
+  if ((0, import_node_fs.existsSync)(GLOBAL_CONFIG_PATH)) return GLOBAL_CONFIG_PATH;
+  return void 0;
+}
+function loadConfig(explicit) {
+  const path = findConfigPath(explicit);
+  if (!path) {
+    throw new ConfigError(
+      `No vbot.json found in ${process.cwd()} or ${GLOBAL_CONFIG_PATH}. Run "vbot start" to create one.`
+    );
+  }
+  const config = normalizeConfig(readJson(path), (0, import_node_path.dirname)(path));
+  return { config, path };
+}
+function saveConfig(config, path) {
+  const dir = (0, import_node_path.dirname)(path);
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  (0, import_node_fs.writeFileSync)(tmp, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  (0, import_node_fs.renameSync)(tmp, path);
+  try {
+    (0, import_node_fs.chmodSync)(path, 384);
+  } catch {
+  }
+}
+
+// src/commands/setup.ts
+async function ensureConfig(explicit) {
+  let found;
+  if (explicit) {
+    const explicitPath = (0, import_node_path2.resolve)(explicit);
+    found = (0, import_node_fs2.existsSync)(explicitPath) ? explicitPath : void 0;
+  } else {
+    found = findConfigPath();
+  }
+  if (found) return loadConfig(found);
+  const target = (0, import_node_path2.resolve)(explicit ?? "vbot.json");
+  console.log(import_picocolors.default.yellow("vbot.json not found, starting setup...\n"));
+  const answers = await import_inquirer.default.prompt([
+    {
+      type: "list",
+      name: "agent",
+      message: "Agent backend:",
+      choices: AGENT_NAMES.map((name) => ({
+        name: `${name} (${AGENTS[name].label})`,
+        value: name
+      }))
+    },
+    {
+      type: "input",
+      name: "cwd",
+      message: "Work directory:",
+      default: process.cwd(),
+      validate: (value) => value.trim() ? true : "Work directory is required"
+    },
+    {
+      type: "number",
+      name: "timeoutMs",
+      message: "Timeout in ms:",
+      default: DEFAULT_TIMEOUT_MS
+    },
+    {
+      type: "confirm",
+      name: "logPrompt",
+      message: "Log prompt content? (not recommended)",
+      default: false
+    },
+    {
+      type: "input",
+      name: "baseUrl",
+      message: "vicvic.im server URL:",
+      default: DEFAULT_BASE_URL
+    },
+    {
+      type: "password",
+      name: "token",
+      message: "Bot pairing token:",
+      validate: (value) => value.trim() ? true : "Pairing token is required"
+    }
+  ]);
+  const agentName = answers.agent;
+  if (!isAgentName(agentName)) throw new Error(`Invalid agent: ${agentName}`);
+  const config = normalizeConfig(
+    {
+      provider: "vicvic",
+      vicvic: { baseUrl: answers.baseUrl.trim() || DEFAULT_BASE_URL, token: answers.token.trim() },
+      agent: { name: agentName, cwd: answers.cwd.trim() },
+      timeoutMs: answers.timeoutMs,
+      logPrompt: answers.logPrompt
+    },
+    (0, import_node_path2.resolve)((0, import_node_path2.dirname)(target))
+  );
+  saveConfig(config, target);
+  console.log(import_picocolors.default.green(`\u2714 Config saved to ${target}
+`));
+  return { config, path: target };
+}
+
+// src/server.ts
+var import_node_path5 = require("path");
+
+// src/agents/acp.ts
+var import_node_child_process = require("child_process");
+var import_node_stream = require("stream");
+var acp = __toESM(require("@agentclientprotocol/sdk"), 1);
+
+// src/agents/types.ts
+var EMPTY_USAGE = { used: 0, size: 0, cost: null };
+
+// src/agents/acp.ts
+var AgentAbortError = class extends Error {
+  constructor() {
+    super("Aborted");
+    this.name = "AbortError";
+  }
+};
+var AgentStartError = class extends Error {
+  constructor(message, stderr) {
+    super(message);
+    this.stderr = stderr;
+    this.name = "AgentStartError";
+  }
+  stderr;
+};
+var STDERR_LIMIT = 4e3;
+var AcpAgent = class {
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+  }
+  name;
+  config;
+  child = null;
+  connection = null;
+  ctx = null;
+  startPromise = null;
+  session = null;
+  configOptions = [];
+  initCaps;
+  turn = null;
+  stderr = "";
+  sawUsageCost = false;
+  pendingModel = null;
+  capabilities() {
+    return {
+      resume: Boolean(this.initCaps?.sessionCapabilities?.resume),
+      load: Boolean(this.initCaps?.loadSession),
+      setConfigOption: this.configOptions.length > 0,
+      usageCost: this.sawUsageCost
+    };
+  }
+  sessionId() {
+    return this.session;
+  }
+  resetSession() {
+    this.session = null;
+  }
+  async start() {
+    if (this.connection) return;
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = this.doStart().finally(() => {
+      this.startPromise = null;
+    });
+    return this.startPromise;
+  }
+  async doStart() {
+    const definition = definitionOf(this.name);
+    const command = this.config.command ?? definition.command.command;
+    const args = this.config.args ?? definition.command.args;
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      cwd: this.config.cwd,
+      env: { ...process.env, ...this.config.env },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    this.stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      this.stderr = `${this.stderr}${chunk.toString()}`.slice(-STDERR_LIMIT);
+      if (this.stderr.length > 0) {
+        console.error(`[${this.name}] ${chunk.toString().trimEnd()}`);
+      }
+    });
+    child.on("exit", (code, signal) => {
+      if (this.child === child) {
+        this.connection = null;
+        this.ctx = null;
+        this.child = null;
+      }
+      if (code !== 0 && signal !== "SIGTERM") {
+        console.error(`[${this.name}] exited with code ${code ?? "?"} signal ${signal ?? "-"}`);
+      }
+    });
+    if (!child.stdout || !child.stdin) {
+      child.kill();
+      throw new AgentStartError(
+        `Failed to start ${this.name}: stdio pipes are unavailable`,
+        this.stderr
+      );
+    }
+    const input = import_node_stream.Writable.toWeb(child.stdin);
+    const output = import_node_stream.Readable.toWeb(child.stdout);
+    const stream = acp.ndJsonStream(input, output);
+    const app = acp.client({ name: "vbot" });
+    app.onRequest(acp.methods.client.session.requestPermission, ({ params }) => {
+      const options = params.options;
+      const chosen = options.find((option) => option.kind === "allow_always") ?? options.find((option) => option.kind === "allow_once");
+      if (!chosen) {
+        return { outcome: { outcome: "cancelled" } };
+      }
+      return { outcome: { outcome: "selected", optionId: chosen.optionId } };
+    });
+    app.onNotification(acp.methods.client.session.update, ({ params }) => {
+      this.handleUpdate(params);
+    });
+    const connection = app.connect(stream);
+    this.connection = connection;
+    this.ctx = connection.agent;
+    try {
+      const init = await this.ctx.request(acp.methods.agent.initialize, {
+        protocolVersion: 1,
+        clientCapabilities: {},
+        clientInfo: { name: "vbot", version: "0.1.0" }
+      });
+      this.initCaps = init.agentCapabilities;
+    } catch (error) {
+      await this.close();
+      throw new AgentStartError(
+        `Failed to initialize ${this.name}: ${error instanceof Error ? error.message : String(error)}`,
+        this.stderr
+      );
+    }
+  }
+  async ensureSession(savedSessionId) {
+    if (!this.ctx) throw new Error(`${this.name} is not started`);
+    if (this.session) return { sessionId: this.session, isNew: false };
+    if (savedSessionId) {
+      const caps = this.initCaps;
+      try {
+        if (caps?.sessionCapabilities?.resume) {
+          const resumed = await this.ctx.request(acp.methods.agent.session.resume, {
+            sessionId: savedSessionId,
+            cwd: this.config.cwd,
+            mcpServers: []
+          });
+          this.configOptions = resumed.configOptions ?? [];
+          this.session = savedSessionId;
+          return { sessionId: savedSessionId, isNew: false };
+        }
+        if (caps?.loadSession) {
+          const loaded = await this.ctx.request(acp.methods.agent.session.load, {
+            sessionId: savedSessionId,
+            cwd: this.config.cwd,
+            mcpServers: []
+          });
+          this.configOptions = loaded.configOptions ?? [];
+          this.session = savedSessionId;
+          return { sessionId: savedSessionId, isNew: false };
+        }
+      } catch (error) {
+        console.warn(
+          `[${this.name}] failed to resume session ${savedSessionId}, starting a new one: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const created = await this.ctx.request(acp.methods.agent.session.new, {
+      cwd: this.config.cwd,
+      mcpServers: []
+    });
+    this.session = created.sessionId;
+    this.configOptions = created.configOptions ?? [];
+    return { sessionId: created.sessionId, isNew: true };
+  }
+  async run(request) {
+    await this.start();
+    const opened = await this.ensureSession(request.sessionId);
+    const model = request.model ?? this.pendingModel;
+    if (model) {
+      await this.setModel(model).catch(() => false);
+    }
+    const turn = {
+      text: "",
+      usage: { ...EMPTY_USAGE },
+      sawCost: false,
+      onEvent: request.onEvent
+    };
+    this.turn = turn;
+    const aborted = new Promise((_, reject) => {
+      if (request.signal.aborted) {
+        reject(new AgentAbortError());
+        return;
+      }
+      request.signal.addEventListener("abort", () => reject(new AgentAbortError()), { once: true });
+    });
+    const onAbort = () => this.cancel().catch(() => void 0);
+    if (request.signal.aborted) onAbort();
+    else request.signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      if (!this.ctx) throw new Error(`${this.name} is not started`);
+      const pending = this.ctx.request(
+        acp.methods.agent.session.prompt,
+        {
+          sessionId: opened.sessionId,
+          prompt: [{ type: "text", text: request.prompt }]
+        },
+        { cancellationSignal: request.signal, stopWaitingOnCancel: true }
+      );
+      pending.catch(() => void 0);
+      const response = await Promise.race([pending, aborted]);
+      await new Promise((resolve5) => setImmediate(resolve5));
+      if (response.stopReason === "cancelled" || request.signal.aborted) {
+        throw new AgentAbortError();
+      }
+      return {
+        text: turn.text,
+        sessionId: opened.sessionId,
+        usage: turn.usage,
+        newSession: opened.isNew
+      };
+    } catch (error) {
+      if (request.signal.aborted || error instanceof Error && error.name === "AbortError") {
+        throw new AgentAbortError();
+      }
+      throw error;
+    } finally {
+      request.signal.removeEventListener("abort", onAbort);
+      this.turn = null;
+    }
+  }
+  async cancel() {
+    if (!this.ctx || !this.session) return;
+    try {
+      await this.ctx.notify(acp.methods.agent.session.cancel, { sessionId: this.session });
+    } catch {
+    }
+  }
+  async setModel(model) {
+    if (!this.ctx || !this.session) {
+      this.pendingModel = model;
+      return true;
+    }
+    const option = this.configOptions.find(
+      (entry2) => entry2.type === "select" && (entry2.id === "model" || entry2.category === "model")
+    );
+    if (!option) return false;
+    await this.ctx.request(acp.methods.agent.session.setConfigOption, {
+      sessionId: this.session,
+      configId: option.id,
+      value: model
+    });
+    this.pendingModel = null;
+    return true;
+  }
+  async close() {
+    const child = this.child;
+    const connection = this.connection;
+    this.child = null;
+    this.connection = null;
+    this.ctx = null;
+    this.session = null;
+    this.configOptions = [];
+    this.pendingModel = null;
+    this.turn = null;
+    try {
+      connection?.close();
+    } catch {
+    }
+    if (!child || child.exitCode !== null) return;
+    const exited = new Promise((resolve5) => {
+      child.once("exit", () => resolve5());
+    });
+    child.kill("SIGTERM");
+    const timer = setTimeout(() => child.kill("SIGKILL"), 3e3);
+    await exited;
+    clearTimeout(timer);
+  }
+  handleUpdate(notification) {
+    if (notification.sessionId !== this.session) return;
+    const turn = this.turn;
+    if (!turn) return;
+    this.dispatchUpdate(notification.update, turn);
+  }
+  dispatchUpdate(update, turn) {
+    switch (update.sessionUpdate) {
+      case "agent_message_chunk":
+        this.applyContentChunk(update, turn, "text");
+        break;
+      case "agent_thought_chunk":
+        this.applyContentChunk(update, turn, "thought");
+        break;
+      case "tool_call":
+        turn.onEvent?.({ type: "tool", name: update.title, status: update.status ?? "pending" });
+        break;
+      case "tool_call_update":
+        this.applyToolUpdate(update, turn);
+        break;
+      case "usage_update":
+        this.applyUsage(update, turn);
+        break;
+      case "config_option_update":
+        this.configOptions = update.configOptions;
+        break;
+      default:
+        break;
+    }
+  }
+  applyContentChunk(chunk, turn, kind) {
+    if (chunk.content.type !== "text") return;
+    if (kind === "text") turn.text += chunk.content.text;
+    turn.onEvent?.({ type: kind, text: chunk.content.text });
+  }
+  applyToolUpdate(tool, turn) {
+    turn.onEvent?.({
+      type: "tool",
+      name: tool.title ?? tool.toolCallId,
+      status: tool.status ?? "pending"
+    });
+  }
+  applyUsage(update, turn) {
+    turn.usage = { used: update.used, size: update.size, cost: update.cost ?? null };
+    if (update.cost) {
+      turn.sawCost = true;
+      this.sawUsageCost = true;
+    }
+    turn.onEvent?.({ type: "usage", usage: turn.usage });
+  }
+};
+
+// src/core/queue.ts
+var BotQueue = class {
+  constructor(processor) {
+    this.processor = processor;
+  }
+  processor;
+  items = [];
+  running = false;
+  controller = null;
+  currentText = null;
+  async enqueue(item) {
+    if (this.running) {
+      const ahead = this.items.length + 1;
+      this.items.push(item);
+      await item.reply(`Queued \u2014 ${ahead} message(s) ahead of you`);
+      return;
+    }
+    this.running = true;
+    this.items.push(item);
+    try {
+      await this.drain();
+    } finally {
+      this.running = false;
+      this.controller = null;
+      this.currentText = null;
+    }
+  }
+  /** 中止当前任务并清空队列；返回是否有任务被中止。 */
+  stop() {
+    const wasBusy = this.running;
+    this.controller?.abort();
+    this.controller = null;
+    this.items.length = 0;
+    return wasBusy;
+  }
+  status() {
+    return { busy: this.running, queued: this.items.length, current: this.currentText };
+  }
+  async drain() {
+    while (this.items.length > 0) {
+      const item = this.items.shift();
+      if (!item) break;
+      this.controller = new AbortController();
+      this.currentText = item.text;
+      try {
+        await this.processor(item, this.controller.signal);
+      } catch (error) {
+        console.error("[queue] processor error:", error);
+        await item.reply(`Error: ${error instanceof Error ? error.message : String(error)}`).catch(() => void 0);
+      } finally {
+        this.controller = null;
+        this.currentText = null;
+      }
+    }
+  }
+};
+
+// src/version.ts
+var VBOT_VERSION = "0.1.0";
+
+// src/core/dispatcher.ts
+var HELP_TEXT = `Available commands:
+/new \u2014 Start a new session
+/stop \u2014 Abort the current request
+/status \u2014 Show agent, session and queue status
+/agent [name] \u2014 Show or switch agent backend
+/model [name] \u2014 Show or switch model
+/cost \u2014 Show context usage and cost
+/version \u2014 Show vbot version
+/help \u2014 Show this help
+
+Other /commands are sent to the agent as prompts.`;
+function createDispatcher(runtime) {
+  return (text, reply) => {
+    const send = (message) => {
+      reply(message).catch((error) => console.error("[dispatch] reply failed:", error));
+    };
+    const prompt = text.startsWith("/") ? handleSlashCommand(runtime, text, send) : text;
+    if (prompt === null) return;
+    runtime.queue().enqueue({ text: prompt, reply }).catch((error) => {
+      console.error("[dispatch] enqueue failed:", error);
+      send("System error, please try again later.");
+    });
+  };
+}
+function handleSlashCommand(runtime, text, send) {
+  const [rawCommand, ...args] = text.split(/\s+/);
+  switch (rawCommand.toLowerCase()) {
+    case "/new":
+      handleNew(runtime, send);
+      return null;
+    case "/stop":
+      handleStop(runtime, send);
+      return null;
+    case "/status":
+      send(statusText(runtime));
+      return null;
+    case "/agent":
+      handleAgent(runtime, args, send);
+      return null;
+    case "/model":
+      handleModel(runtime, args, send);
+      return null;
+    case "/cost":
+      send(costText(runtime));
+      return null;
+    case "/help":
+      send(HELP_TEXT);
+      return null;
+    case "/version":
+      send(`vbot v${VBOT_VERSION}`);
+      return null;
+    default:
+      return text.slice(1);
+  }
+}
+function handleNew(runtime, send) {
+  runtime.agent().resetSession();
+  const state = runtime.state();
+  state.acpSessionId = null;
+  state.usage = { used: 0, size: 0, cost: null };
+  runtime.saveState();
+  send("Session reset. Starting a new conversation.");
+}
+function handleStop(runtime, send) {
+  const queue = runtime.queue();
+  const queued = queue.status().queued;
+  if (!queue.stop()) {
+    send("No running request to stop.");
+    return;
+  }
+  send(
+    queued > 0 ? `Current request aborted. ${queued} queued message(s) discarded.` : "Current request aborted."
+  );
+}
+function handleAgent(runtime, args, send) {
+  const name = args.join(" ").trim();
+  if (!name) {
+    const current = runtime.config().agent.name;
+    const list = AGENT_NAMES.map((entry2) => `${entry2 === current ? "*" : " "} ${entry2}`).join("\n");
+    send(`Current agent: ${current}
+Available agents:
+${list}`);
+    return;
+  }
+  if (!isAgentName(name)) {
+    send(`Unknown agent "${name}". Available: ${AGENT_NAMES.join(", ")}`);
+    return;
+  }
+  if (runtime.queue().status().busy) {
+    send("Cannot switch agent while a request is running. Use /stop first.");
+    return;
+  }
+  send(`Switching to ${name}...`);
+  runtime.switchAgent(name).then((message) => send(message)).catch(
+    (error) => send(`Error: ${error instanceof Error ? error.message : String(error)}`)
+  );
+}
+function handleModel(runtime, args, send) {
+  const model = args.join(" ").trim();
+  if (!model) {
+    send(`Current model: ${runtime.config().agent.model ?? "default"}`);
+    return;
+  }
+  const config = runtime.config();
+  const hadSession = runtime.agent().sessionId() !== null;
+  config.agent.model = model;
+  runtime.saveConfig();
+  runtime.agent().setModel(model).then((supported) => {
+    if (!supported) {
+      send(
+        `Model saved: ${model}. This agent does not expose a runtime model option; it will be used on the next session if supported.`
+      );
+      return;
+    }
+    send(
+      hadSession ? `Model switched to: ${model}` : `Model set to: ${model}. It will apply when the session starts.`
+    );
+  }).catch(
+    (error) => send(`Error: ${error instanceof Error ? error.message : String(error)}`)
+  );
+}
+function statusText(runtime) {
+  const config = runtime.config();
+  const agent = runtime.agent();
+  const state = runtime.state();
+  const queue = runtime.queue().status();
+  const lines = [
+    `Agent: ${config.agent.name} (${AGENTS[config.agent.name].label})`,
+    `Session: ${agent.sessionId() ?? "none"}`,
+    `Work dir: ${config.agent.cwd}`,
+    `Model: ${config.agent.model ?? "default"}`,
+    `Status: ${queue.busy ? "busy" : "idle"}`,
+    `Queue: ${queue.queued}`,
+    `Usage: ${state.usage.used}/${state.usage.size} tokens`,
+    `Capabilities: ${capabilitiesText(agent.capabilities())}`
+  ];
+  return lines.join("\n");
+}
+function costText(runtime) {
+  const usage = runtime.state().usage;
+  const context = `Context: ${usage.used}/${usage.size} tokens`;
+  if (!usage.cost) {
+    return `${context}
+Cost: this agent does not report cost.`;
+  }
+  return `${context}
+Cost: ${usage.cost.amount} ${usage.cost.currency}`;
+}
+function capabilitiesText(caps) {
+  const enabled = [
+    caps.resume ? "resume" : null,
+    caps.load ? "load" : null,
+    caps.setConfigOption ? "model" : null,
+    caps.usageCost ? "cost" : null
+  ].filter(Boolean);
+  return enabled.length > 0 ? enabled.join(", ") : "basic";
+}
+
+// src/core/gate.ts
+function createGate() {
+  let tail = Promise.resolve();
+  return function run(task) {
+    const result = tail.then(task, task);
+    tail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
+}
+
+// src/core/switch.ts
+async function switchAgent(ctx, name) {
+  const previous = ctx.getAgent();
+  const nextConfig = {
+    ...ctx.config.agent,
+    name,
+    command: void 0,
+    args: void 0,
+    model: null
+  };
+  const next = ctx.createAgent ? ctx.createAgent(name, nextConfig) : new AcpAgent(name, nextConfig);
+  await next.start();
+  ctx.setAgent(next);
+  ctx.config.agent = nextConfig;
+  ctx.state.agent = name;
+  ctx.state.acpSessionId = null;
+  ctx.state.usage = { ...EMPTY_USAGE };
+  ctx.saveConfig();
+  ctx.saveState();
+  await previous.close().catch(() => void 0);
+  return `Switched to ${name} (${AGENTS[name].label}). A new session will start.`;
+}
+
+// src/core/lock.ts
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
+
+// src/core/state.ts
+var import_node_crypto = require("crypto");
+var import_node_fs3 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
+function vbotHome() {
+  return process.env.VBOT_HOME?.trim() || (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".vbot");
+}
+function stateDir() {
+  return (0, import_node_path3.join)(vbotHome(), "state");
+}
+function tokenHash(token) {
+  return (0, import_node_crypto.createHash)("sha256").update(token).digest("hex").slice(0, 16);
+}
+function statePath(token) {
+  return (0, import_node_path3.join)(stateDir(), `${tokenHash(token)}.json`);
+}
+function emptyState(token, agent, cwd) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    tokenHash: tokenHash(token),
+    agent,
+    acpSessionId: null,
+    cwd,
+    createdAt: now,
+    lastUsedAt: now,
+    usage: { ...EMPTY_USAGE }
+  };
+}
+function loadState(token) {
+  const path = statePath(token);
+  if (!(0, import_node_fs3.existsSync)(path)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs3.readFileSync)(path, "utf8"));
+    if (typeof parsed.acpSessionId !== "string" && parsed.acpSessionId !== null) return null;
+    if (typeof parsed.agent !== "string") return null;
+    return {
+      tokenHash: tokenHash(token),
+      agent: parsed.agent,
+      acpSessionId: parsed.acpSessionId ?? null,
+      cwd: typeof parsed.cwd === "string" ? parsed.cwd : process.cwd(),
+      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+      lastUsedAt: typeof parsed.lastUsedAt === "string" ? parsed.lastUsedAt : (/* @__PURE__ */ new Date()).toISOString(),
+      usage: parsed.usage && typeof parsed.usage === "object" ? { ...EMPTY_USAGE, ...parsed.usage } : { ...EMPTY_USAGE }
+    };
+  } catch {
+    return null;
+  }
+}
+function saveState(state) {
+  const dir = stateDir();
+  (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+  const path = (0, import_node_path3.join)(dir, `${state.tokenHash}.json`);
+  const tmp = `${path}.${process.pid}.tmp`;
+  (0, import_node_fs3.writeFileSync)(tmp, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+  (0, import_node_fs3.renameSync)(tmp, path);
+}
+
+// src/core/lock.ts
+var LockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LockError";
+  }
+};
+var lockPath = (token) => (0, import_node_path4.join)(stateDir(), `${tokenHash(token)}.lock`);
+function readPid(path) {
+  try {
+    const pid = Number.parseInt((0, import_node_fs4.readFileSync)(path, "utf8").trim(), 10);
+    return Number.isFinite(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireLock(token) {
+  (0, import_node_fs4.mkdirSync)(stateDir(), { recursive: true });
+  const path = lockPath(token);
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const fd = (0, import_node_fs4.openSync)(path, "wx");
+      (0, import_node_fs4.writeSync)(fd, String(process.pid));
+      (0, import_node_fs4.closeSync)(fd);
+      return () => releaseLock(token);
+    } catch (error) {
+      if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
+        throw error;
+      }
+      const pid = readPid(path);
+      if (pid && isAlive(pid)) {
+        throw new LockError(`This bot is already running in another vbot process (pid ${pid}).`);
+      }
+      try {
+        (0, import_node_fs4.unlinkSync)(path);
+      } catch {
+      }
+    }
+  }
+  throw new LockError("Failed to acquire vbot lock; please retry.");
+}
+function releaseLock(token) {
+  const path = lockPath(token);
+  if (!(0, import_node_fs4.existsSync)(path)) return;
+  const pid = readPid(path);
+  if (pid !== process.pid) return;
+  try {
+    (0, import_node_fs4.unlinkSync)(path);
+  } catch {
+  }
+}
+
+// src/core/wire.ts
+var import_ws = __toESM(require("ws"), 1);
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var HEARTBEAT_MS = 3e4;
+var INVALID_TOKEN_CODE = 4001;
+function trimTrailingSlash2(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") end -= 1;
+  return value.slice(0, end);
+}
+function botUrl(baseUrl, token) {
+  const wsBase = trimTrailingSlash2(baseUrl.replace(/^http/, "ws"));
+  return `${wsBase}/bot/connect?token=${encodeURIComponent(token)}`;
+}
+var VicvicWire = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  socket = null;
+  stopped = false;
+  attempt = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  start() {
+    this.stopped = false;
+    this.connect();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.clearHeartbeat();
+    this.socket?.close();
+    this.socket = null;
+  }
+  /** 发送回复；socket 不可用时 reject，由调用方决定是否记录日志。 */
+  async reply(msgUid, text) {
+    const socket = this.socket;
+    if (!socket || socket.readyState !== import_ws.default.OPEN) {
+      throw new Error("Bot connection is not open");
+    }
+    await new Promise((resolve5, reject) => {
+      socket.send(JSON.stringify({ type: "reply", msgUid, text }), (error) => {
+        if (error) reject(error);
+        else resolve5();
+      });
+    });
+  }
+  connect() {
+    if (this.stopped) return;
+    const url = botUrl(this.options.baseUrl, this.options.token);
+    const socket = new import_ws.default(url);
+    this.socket = socket;
+    socket.on("open", () => {
+      this.attempt = 0;
+      this.startHeartbeat();
+      console.log("[vicvic] connected");
+    });
+    socket.on("message", (raw) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (frame.type === "ready") {
+        console.log("[vicvic] ready");
+        this.options.handlers.onReady?.();
+        return;
+      }
+      if (frame.type === "prompt" && typeof frame.text === "string" && frame.text.length > 0) {
+        this.options.handlers.onPrompt(
+          frame.text,
+          frame.msgUid,
+          (text) => this.reply(frame.msgUid, text)
+        );
+      }
+    });
+    socket.on("close", (code, reason) => {
+      this.clearHeartbeat();
+      if (this.socket === socket) this.socket = null;
+      if (code === INVALID_TOKEN_CODE) {
+        this.stopped = true;
+        this.options.handlers.onFatal?.(
+          new Error(`Invalid bot token (${reason.toString() || "4001"}).`)
+        );
+        return;
+      }
+      console.log("[vicvic] disconnected");
+      this.options.handlers.onDisconnected?.();
+      this.scheduleReconnect();
+    });
+    socket.on("error", (error) => {
+      console.error("[vicvic] ws error:", error.message);
+    });
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.reconnectTimer) return;
+    const delay = Math.min(RECONNECT_BASE_MS * 2 ** this.attempt, RECONNECT_MAX_MS);
+    this.attempt += 1;
+    console.log(`[vicvic] reconnecting in ${Math.round(delay / 1e3)}s`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+  startHeartbeat() {
+    this.clearHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      try {
+        this.socket?.ping();
+      } catch {
+      }
+    }, HEARTBEAT_MS);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+};
+
+// src/core/chunk.ts
+var MAX_MESSAGE_CHARS = 4e3;
+function isLowSurrogate(code) {
+  return code >= 56320 && code <= 57343;
+}
+function fenceCount(text) {
+  return (text.match(/```/g) ?? []).length;
+}
+function avoidSurrogateSplit(text, cut, start) {
+  return cut > start && isLowSurrogate(text.charCodeAt(cut)) ? cut - 1 : cut;
+}
+function preferNewline(text, start, cut, max) {
+  const newline = text.lastIndexOf("\n", cut);
+  return newline >= start + Math.floor(max / 2) ? newline + 1 : cut;
+}
+function avoidFenceSplit(text, start, cut, max) {
+  if (fenceCount(text.slice(start, cut)) % 2 === 0) return cut;
+  const fenceStart = text.lastIndexOf("```", cut);
+  return fenceStart >= start + Math.floor(max / 4) ? fenceStart : cut;
+}
+function findCut(text, start, max) {
+  const hardCut = Math.min(start + max, text.length);
+  let cut = avoidSurrogateSplit(text, hardCut, start);
+  cut = preferNewline(text, start, cut, max);
+  cut = avoidFenceSplit(text, start, cut, max);
+  return cut > start ? cut : hardCut;
+}
+function splitMessage(text, max = MAX_MESSAGE_CHARS) {
+  if (!text) return [];
+  if (max < 2) throw new Error("max must be >= 2");
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    if (text.length - start <= max) {
+      chunks.push(text.slice(start));
+      break;
+    }
+    const cut = findCut(text, start, max);
+    const chunk = text.slice(start, cut);
+    if (chunk.trim().length > 0) chunks.push(chunk);
+    start = cut;
+  }
+  return chunks;
+}
+
+// src/server.ts
+function replySafe(reply, text) {
+  reply(text).catch((error) => console.error("[server] reply failed:", error));
+}
+function logAgentEvent(event) {
+  if (event.type === "tool") {
+    console.log(`[agent] tool ${event.name} (${event.status})`);
+  } else if (event.type === "usage") {
+    const cost = event.usage.cost ? ` ${event.usage.cost.amount} ${event.usage.cost.currency}` : "";
+    console.log(`[agent] usage ${event.usage.used}/${event.usage.size}${cost}`);
+  } else if (event.type === "thought") {
+    console.log(`[agent] thought: ${event.text.slice(0, 80)}`);
+  }
+}
+async function startBot(configPath) {
+  const { config } = loadConfig(configPath);
+  const token = config.vicvic.token;
+  const release = acquireLock(token);
+  const state = loadState(token) ?? emptyState(token, config.agent.name, config.agent.cwd);
+  state.agent = config.agent.name;
+  state.cwd = config.agent.cwd;
+  let agent = new AcpAgent(config.agent.name, config.agent);
+  const gate = createGate();
+  let switching = false;
+  const holder = { queue: null };
+  const ctx = {
+    config,
+    configPath,
+    state,
+    getAgent: () => agent,
+    setAgent: (next) => {
+      agent = next;
+    },
+    getQueue: () => {
+      if (!holder.queue) throw new Error("queue is not initialized");
+      return holder.queue;
+    },
+    saveState: () => {
+      state.lastUsedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveState(state);
+    },
+    saveConfig: () => saveConfig(config, configPath)
+  };
+  holder.queue = new BotQueue((item, signal) => gate(() => processPrompt(ctx, item, signal)));
+  const runtime = createRuntime(ctx, (name) => {
+    if (switching) return Promise.reject(new Error("Agent switch already in progress."));
+    switching = true;
+    return gate(() => switchAgent(ctx, name)).finally(() => {
+      switching = false;
+    });
+  });
+  const dispatch = createDispatcher(runtime);
+  let notifySignal = () => void 0;
+  const wire = new VicvicWire({
+    baseUrl: config.vicvic.baseUrl,
+    token,
+    handlers: {
+      onPrompt: (text, _msgUid, reply) => {
+        if (config.logPrompt) console.log(`[vicvic] prompt: ${text.slice(0, 100)}...`);
+        else console.log("[vicvic] prompt");
+        dispatch(text, reply);
+      },
+      onFatal: (error) => {
+        console.error(`[vicvic] fatal: ${error.message}`);
+        process.exitCode = 2;
+        notifySignal();
+      }
+    }
+  });
+  const lifecycle = setupLifecycle(wire, () => agent, release);
+  notifySignal = lifecycle.onSignal;
+  announce(config);
+  wire.start();
+  return { finished: lifecycle.finished, stop: lifecycle.stop };
+}
+function setupLifecycle(getWire, getAgent, release) {
+  let finish = () => void 0;
+  const finished = new Promise((resolveFinished) => {
+    finish = resolveFinished;
+  });
+  let stopped = false;
+  const onSignal = () => {
+    console.log("[vbot] shutting down");
+    stop().catch((error) => console.error("[server] shutdown failed:", error));
+  };
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    getWire.stop();
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    await getAgent().close().catch(() => void 0);
+    release();
+    finish();
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  return { finished, onSignal, stop };
+}
+function announce(config) {
+  console.warn(
+    `vbot runs ${config.agent.name} with your local user permissions and auto-approves permission requests.
+Only use it in a directory you trust. Authentication must be completed in the agent CLI beforehand.`
+  );
+  console.log(AGENTS[config.agent.name].authHint);
+  console.log(`vbot starting. agent=${config.agent.name} cwd=${config.agent.cwd}`);
+}
+async function runBot(configPath) {
+  const bot = await startBot(configPath);
+  await bot.finished;
+}
+function createRuntime(ctx, switchAgent2) {
+  return {
+    config: () => ctx.config,
+    agent: () => ctx.getAgent(),
+    queue: () => ctx.getQueue(),
+    state: () => ctx.state,
+    saveState: () => ctx.saveState(),
+    saveConfig: () => ctx.saveConfig(),
+    switchAgent: switchAgent2
+  };
+}
+async function processPrompt(ctx, item, signal) {
+  replySafe(item.reply, "Processing...");
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => controller.abort();
+  signal.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, ctx.config.timeoutMs);
+  try {
+    const result = await ctx.getAgent().run({
+      prompt: item.text,
+      sessionId: ctx.state.acpSessionId ?? void 0,
+      cwd: ctx.config.agent.cwd,
+      model: ctx.config.agent.model,
+      signal: controller.signal,
+      onEvent: ctx.config.logPrompt ? logAgentEvent : void 0
+    });
+    ctx.state.acpSessionId = result.sessionId;
+    ctx.state.usage = result.usage;
+    ctx.saveState();
+    for (const chunk of splitMessage(result.text || "(no output)")) {
+      await item.reply(chunk);
+    }
+  } catch (error) {
+    if (error instanceof AgentAbortError) {
+      if (timedOut)
+        replySafe(item.reply, "Execution timeout, please retry or simplify your request.");
+      else if (!signal.aborted) replySafe(item.reply, "Request aborted.");
+      return;
+    }
+    replyError(item.reply, error);
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+function replyError(reply, error) {
+  if (error instanceof AgentStartError) {
+    console.error(`[server] agent start failed: ${error.message}
+${error.stderr}`);
+    replySafe(reply, `Error: ${error.message}`);
+    return;
+  }
+  console.error("[server] agent run failed:", error);
+  replySafe(reply, `Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+var entry = process.argv[1] ?? "";
+if (/(^|[\\/])server\.(js|cjs|ts)$/.test(entry)) {
+  const configPath = process.argv[2];
+  if (!configPath) {
+    console.error("Usage: server.js <config-path>");
+    process.exit(1);
+  }
+  runBot((0, import_node_path5.resolve)(configPath)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    const expected = error instanceof ConfigError || error instanceof LockError;
+    process.exit(expected ? 2 : 1);
+  });
+}
+
+// src/cli.ts
+function processName(cwd) {
+  return `vbot-${(0, import_node_path6.basename)((0, import_node_path6.resolve)(cwd)).replace(/[^a-zA-Z0-9._-]+/g, "-")}`;
+}
+var ENV_BIN = "/usr/bin/env";
+function hasPm2() {
+  try {
+    (0, import_node_child_process2.execFileSync)(ENV_BIN, ["pm2", "--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pm2(args, capture = false) {
+  return (0, import_node_child_process2.execFileSync)(ENV_BIN, ["pm2", ...args], {
+    stdio: capture ? "pipe" : "inherit",
+    encoding: "utf8"
+  });
+}
+function resolveName(configPath) {
+  const path = findConfigPath(configPath);
+  if (!path) return "vbot";
+  try {
+    const { config } = loadConfig(path);
+    return processName(config.agent.cwd);
+  } catch {
+    return "vbot";
+  }
+}
+function serverEntry() {
+  const cliPath = process.argv[1];
+  if (!cliPath) throw new Error("Cannot resolve vbot entry; run the installed binary.");
+  const candidate = (0, import_node_path6.join)((0, import_node_path6.dirname)(cliPath), "server.js");
+  if (!(0, import_node_fs5.existsSync)(candidate)) {
+    throw new Error(`Server bundle not found at ${candidate}. Run "pnpm build" first.`);
+  }
+  return candidate;
+}
+var program = new import_commander.Command();
+program.name("vbot").description("Connect local coding agents to vicvic.im").version(readVersion());
+function readVersion() {
+  try {
+    const raw = (0, import_node_fs5.readFileSync)((0, import_node_path6.join)((0, import_node_path6.dirname)(process.argv[1] ?? ""), "..", "package.json"), "utf8");
+    return JSON.parse(raw).version ?? "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+program.command("start").description("Start vbot (prompts for config on first run)").option("--foreground", "run in the foreground instead of pm2").option("-c, --config <path>", "config file path").action(async (options) => {
+  const { path } = await ensureConfig(options.config);
+  if (options.foreground || !hasPm2()) {
+    if (!options.foreground) {
+      console.log(
+        import_picocolors2.default.yellow("pm2 not found; running in the foreground. Install pm2 for background mode.")
+      );
+    }
+    await runBot(path);
+    return;
+  }
+  const name = resolveName(path);
+  try {
+    pm2(["describe", name], true);
+    pm2(["restart", name, "--update-env"]);
+  } catch {
+    pm2([
+      "start",
+      serverEntry(),
+      "--name",
+      name,
+      "--stop-exit-codes",
+      "2",
+      "--log-date-format",
+      "YYYY-MM-DD HH:mm:ss",
+      "--",
+      path
+    ]);
+  }
+  pm2(["save"], true);
+  console.log(import_picocolors2.default.green(`\u2714 ${name} started. Use "vbot logs" to view output.`));
+});
+program.command("stop").option("-c, --config <path>", "config file path").action((options) => {
+  try {
+    pm2(["stop", resolveName(options.config)]);
+  } catch {
+    console.error(import_picocolors2.default.red("Failed to stop vbot. Is it running?"));
+  }
+});
+program.command("restart").option("-c, --config <path>", "config file path").action((options) => {
+  try {
+    pm2(["restart", resolveName(options.config), "--update-env"]);
+  } catch {
+    console.error(import_picocolors2.default.red('Failed to restart vbot. Try "vbot start".'));
+  }
+});
+program.command("status").option("-c, --config <path>", "config file path").action((options) => {
+  try {
+    pm2(["describe", resolveName(options.config)]);
+  } catch {
+    console.log(import_picocolors2.default.yellow("vbot is not running."));
+  }
+});
+program.command("logs").option("-c, --config <path>", "config file path").action((options) => {
+  try {
+    pm2(["logs", resolveName(options.config), "--lines", "50"]);
+  } catch {
+    console.error("Failed to show logs. Is pm2 installed?");
+  }
+});
+program.command("delete").option("-c, --config <path>", "config file path").action((options) => {
+  try {
+    pm2(["delete", resolveName(options.config)]);
+  } catch {
+    console.error("Failed to delete vbot process.");
+  }
+});
+program.parseAsync(process.argv).catch((error) => {
+  console.error(import_picocolors2.default.red(error instanceof Error ? error.message : String(error)));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.cjs.map