@vicvic-im/agent-bot 0.1.1 → 0.1.3

package/dist/bin-server.cjs

@@ -0,0 +1,1422 @@
+"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/bin-server.ts
+var import_node_path4 = require("path");
+
+// 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, entry] of Object.entries(record)) {
+    if (typeof entry !== "string") {
+      throw new ConfigError(`Invalid "agent.env.${key}": expected a string`);
+    }
+    env[key] = entry;
+  }
+  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((entry) => String(entry)) : 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/core/lock.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+
+// src/core/state.ts
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path2 = require("path");
+
+// src/agents/types.ts
+var EMPTY_USAGE = { used: 0, size: 0, cost: null };
+
+// src/core/state.ts
+function vbotHome() {
+  return process.env.VBOT_HOME?.trim() || (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".vbot");
+}
+function stateDir() {
+  return (0, import_node_path2.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_path2.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_fs2.existsSync)(path)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs2.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_fs2.mkdirSync)(dir, { recursive: true });
+  const path = (0, import_node_path2.join)(dir, `${state.tokenHash}.json`);
+  const tmp = `${path}.${process.pid}.tmp`;
+  (0, import_node_fs2.writeFileSync)(tmp, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+  (0, import_node_fs2.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_path3.join)(stateDir(), `${tokenHash(token)}.lock`);
+function readPid(path) {
+  try {
+    const pid = Number.parseInt((0, import_node_fs3.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_fs3.mkdirSync)(stateDir(), { recursive: true });
+  const path = lockPath(token);
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      const fd = (0, import_node_fs3.openSync)(path, "wx");
+      (0, import_node_fs3.writeSync)(fd, String(process.pid));
+      (0, import_node_fs3.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_fs3.unlinkSync)(path);
+      } catch {
+      }
+    }
+  }
+  throw new LockError("Failed to acquire vbot lock; please retry.");
+}
+function releaseLock(token) {
+  const path = lockPath(token);
+  if (!(0, import_node_fs3.existsSync)(path)) return;
+  const pid = readPid(path);
+  if (pid !== process.pid) return;
+  try {
+    (0, import_node_fs3.unlinkSync)(path);
+  } catch {
+  }
+}
+
+// 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/version.ts
+var VBOT_VERSION = "0.1.3";
+
+// 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;
+function flattenSelectOptions(options) {
+  return options.flatMap(
+    (entry) => "group" in entry ? entry.options.map((option) => ({ value: option.value, label: option.name })) : [{ value: entry.value, label: entry.name }]
+  );
+}
+function isModelOption(option) {
+  return option.type === "select" && (option.category === "model" || option.id === "model");
+}
+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;
+  }
+  currentModel() {
+    const option = this.configOptions.find(isModelOption);
+    if (!option || option.type !== "select") return null;
+    const value = String(option.currentValue);
+    const options = flattenSelectOptions(option.options);
+    const label = options.find((entry) => entry.value === value)?.label ?? value;
+    return { value, label, options };
+  }
+  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: VBOT_VERSION }
+      });
+      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((resolve3) => setImmediate(resolve3));
+      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(isModelOption);
+    if (!option) return false;
+    const response = await this.ctx.request(acp.methods.agent.session.setConfigOption, {
+      sessionId: this.session,
+      configId: option.id,
+      value: model
+    });
+    if (response?.configOptions?.length) this.configOptions = response.configOptions;
+    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((resolve3) => {
+      child.once("exit", () => resolve3());
+    });
+    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/core/dispatcher.ts
+var import_node_os3 = require("os");
+var HELP_ROWS = [
+  ["/new", "Start a new session"],
+  ["/stop", "Abort the current request"],
+  ["/status", "Show agent, session and queue status"],
+  ["/agent [name]", "Show or switch agent backend"],
+  ["/model [name]", "Show or switch model"],
+  ["/cost", "Show context usage and cost"],
+  ["/version", "Show vbot version"],
+  ["/help", "Show this help"]
+];
+var HELP_FOOTER = "Other /commands are sent to the agent as prompts.";
+var NEW_BUSY_TEXT = "Cannot reset the session while a request is running. Use /stop first.";
+var MODEL_BUSY_TEXT = "Cannot switch model while a request is running. Use /stop first.";
+var HELP_TEXT = [
+  table(
+    ["Command", "Description"],
+    HELP_ROWS.map(([command, description]) => [command, description])
+  ),
+  "",
+  HELP_FOOTER
+].join("\n");
+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 escapeCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function table(headers, rows) {
+  const head = `| ${headers.map(escapeCell).join(" | ")} |`;
+  const separator = `| ${headers.map(() => "---").join(" | ")} |`;
+  const body = rows.map((row) => `| ${row.map(escapeCell).join(" | ")} |`);
+  return [head, separator, ...body].join("\n");
+}
+function formatNumber(value) {
+  if (!Number.isFinite(value)) return String(value);
+  const negative = value < 0;
+  const digits = Math.abs(Math.trunc(value)).toString();
+  let out = "";
+  for (let i = 0; i < digits.length; i += 1) {
+    if (i > 0 && (digits.length - i) % 3 === 0) out += ",";
+    out += digits[i];
+  }
+  return negative ? "-" + out : out;
+}
+function percentOf(used, size) {
+  if (size <= 0) return null;
+  return `${(used / size * 100).toFixed(1)}%`;
+}
+function usageText(runtime) {
+  const { used, size } = runtime.state().usage;
+  if (size <= 0) return "not reported";
+  const base = `${formatNumber(used)} / ${formatNumber(size)}`;
+  const percent = percentOf(used, size);
+  return percent ? `${base} (${percent})` : base;
+}
+function compactPath(path) {
+  const home = (0, import_node_os3.homedir)();
+  if (!home) return path;
+  if (path === home) return "~";
+  const prefix = home + "/";
+  if (path.startsWith(prefix)) return "~" + path.slice(home.length);
+  return path;
+}
+function modelText(runtime) {
+  const current = runtime.agent().currentModel();
+  if (current) return current.label;
+  const configured = runtime.config().agent.model;
+  if (configured) return `${configured} (configured, not applied yet)`;
+  return "unknown (session not started)";
+}
+function handleSlashCommand(runtime, text, send) {
+  const [rawCommand, ...args] = text.split(/\s+/);
+  switch (rawCommand.toLowerCase()) {
+    case "/new":
+      void 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":
+      void 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);
+  }
+}
+async function handleNew(runtime, send) {
+  if (runtime.queue().status().busy) {
+    send(NEW_BUSY_TEXT);
+    return;
+  }
+  await runtime.serialize(async () => {
+    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();
+  const current = runtime.config().agent.name;
+  if (!name) {
+    send(
+      table(
+        ["Agent", "Backend", ""],
+        AGENT_NAMES.map((entry) => [
+          entry,
+          AGENTS[entry].label,
+          entry === current ? "\u2190 current" : ""
+        ])
+      )
+    );
+    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)}`)
+  );
+}
+async function handleModel(runtime, args, send) {
+  const model = args.join(" ").trim();
+  if (!model) {
+    send(modelReport(runtime));
+    return;
+  }
+  if (runtime.queue().status().busy) {
+    send(MODEL_BUSY_TEXT);
+    return;
+  }
+  const config = runtime.config();
+  const hadSession = runtime.agent().sessionId() !== null;
+  const supported = await runtime.serialize(async () => {
+    const accepted = await runtime.agent().setModel(model);
+    config.agent.model = model;
+    runtime.saveConfig();
+    return accepted;
+  });
+  const applied = runtime.agent().currentModel()?.label ?? model;
+  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: ${applied}` : `Model set to: ${applied}. It will apply when the session starts.`
+  );
+}
+function modelReport(runtime) {
+  const current = runtime.agent().currentModel();
+  if (!current) {
+    const configured = runtime.config().agent.model;
+    const hint = configured ? `Configured: ${configured}
+
+The agent has not reported a model yet; it becomes visible after the first message.` : "This agent does not expose a runtime model option, or the session has not started.";
+    return `Current: unknown
+
+${hint}`;
+  }
+  const lines = [`Current: ${current.label}`];
+  if (current.options.length > 0) {
+    lines.push(
+      "",
+      table(
+        ["Model", ""],
+        current.options.map((option) => [
+          option.label,
+          option.value === current.value ? "\u2190 current" : ""
+        ])
+      )
+    );
+  }
+  lines.push("", "Switch: /model <name>");
+  return lines.join("\n");
+}
+function statusText(runtime) {
+  const config = runtime.config();
+  const agent = runtime.agent();
+  const state = runtime.state();
+  const queue = runtime.queue().status();
+  const { used, size } = state.usage;
+  const summary = [
+    `**${config.agent.name}**`,
+    queue.busy ? "busy" : "idle",
+    size > 0 ? `${formatNumber(used)} / ${formatNumber(size)}` : null
+  ].filter(Boolean).join(" \xB7 ");
+  const rows = [
+    ["Agent", `${config.agent.name} (${AGENTS[config.agent.name].label})`],
+    ["Session", agent.sessionId() ?? "none"],
+    ["Work dir", compactPath(config.agent.cwd)],
+    ["Model", modelText(runtime)],
+    ["Status", queue.busy ? "busy" : "idle"],
+    ["Queue", String(queue.queued)],
+    ["Usage", usageText(runtime)],
+    ["Capabilities", capabilitiesText(agent.capabilities())]
+  ];
+  return [summary, "", table(["Field", "Value"], rows)].join("\n");
+}
+function costText(runtime) {
+  const usage = runtime.state().usage;
+  const cost = usage.cost ? `${usage.cost.amount} ${usage.cost.currency}` : "not reported by this agent";
+  return table(
+    ["Field", "Value"],
+    [
+      ["Context", usageText(runtime)],
+      ["Cost", cost]
+    ]
+  );
+}
+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/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((resolve3, reject) => {
+      socket.send(JSON.stringify({ type: "reply", msgUid, text }), (error) => {
+        if (error) reject(error);
+        else resolve3();
+      });
+    });
+  }
+  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(configPath2) {
+  const { config } = loadConfig(configPath2);
+  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: configPath2,
+    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, configPath2)
+  };
+  holder.queue = new BotQueue((item, signal) => gate(() => processPrompt(ctx, item, signal)));
+  const runtime = createRuntime(
+    ctx,
+    (task) => gate(task),
+    (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(configPath2) {
+  const bot = await startBot(configPath2);
+  await bot.finished;
+}
+function createRuntime(ctx, gate, switchAgent2) {
+  return {
+    config: () => ctx.config,
+    agent: () => ctx.getAgent(),
+    queue: () => ctx.getQueue(),
+    state: () => ctx.state,
+    saveState: () => ctx.saveState(),
+    saveConfig: () => ctx.saveConfig(),
+    serialize: (task) => gate(task),
+    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)}`);
+}
+
+// src/bin-server.ts
+var configPath = process.argv[2];
+if (!configPath) {
+  console.error("Usage: bin-server.js <config-path>");
+  process.exit(1);
+}
+runBot((0, import_node_path4.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);
+});
+//# sourceMappingURL=bin-server.cjs.map