@mobvibe/cli 0.0.0-dev

package/dist/index.js

@@ -0,0 +1,2708 @@
+// src/index.ts
+import { Command } from "commander";
+
+// src/auth/login.ts
+import * as readline from "readline/promises";
+
+// src/lib/logger.ts
+import pino from "pino";
+var LOG_LEVEL = process.env.LOG_LEVEL ?? "info";
+var isPretty = process.env.NODE_ENV !== "production";
+var redact = {
+  paths: [
+    "req.headers.authorization",
+    "req.headers.cookie",
+    "req.headers['x-api-key']",
+    "headers.authorization",
+    "headers.cookie",
+    "headers['x-api-key']",
+    "apiKey",
+    "token"
+  ],
+  censor: "[redacted]"
+};
+var transport = isPretty ? {
+  target: "pino-pretty",
+  options: {
+    colorize: true,
+    translateTime: "SYS:standard",
+    ignore: "pid,hostname"
+  }
+} : void 0;
+var logger = pino(
+  {
+    level: LOG_LEVEL,
+    redact,
+    base: { service: "mobvibe-cli" },
+    serializers: {
+      err: pino.stdSerializers.err,
+      error: pino.stdSerializers.err
+    }
+  },
+  transport ? pino.transport(transport) : void 0
+);
+
+// src/auth/credentials.ts
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
+var MOBVIBE_DIR = process.env.MOBVIBE_HOME ?? path.join(os.homedir(), ".mobvibe");
+var CREDENTIALS_FILE = path.join(MOBVIBE_DIR, "credentials.json");
+async function ensureMobvibeDir() {
+  await fs.mkdir(MOBVIBE_DIR, { recursive: true });
+}
+async function loadCredentials() {
+  try {
+    const data = await fs.readFile(CREDENTIALS_FILE, "utf8");
+    const credentials = JSON.parse(data);
+    if (!credentials.apiKey) {
+      return null;
+    }
+    return credentials;
+  } catch {
+    return null;
+  }
+}
+async function saveCredentials(credentials) {
+  await ensureMobvibeDir();
+  await fs.writeFile(
+    CREDENTIALS_FILE,
+    JSON.stringify(credentials, null, 2),
+    { mode: 384 }
+    // Read/write only for owner
+  );
+}
+async function deleteCredentials() {
+  try {
+    await fs.unlink(CREDENTIALS_FILE);
+  } catch {
+  }
+}
+async function getApiKey() {
+  if (process.env.MOBVIBE_API_KEY) {
+    return process.env.MOBVIBE_API_KEY;
+  }
+  const credentials = await loadCredentials();
+  return credentials?.apiKey;
+}
+var DEFAULT_GATEWAY_URL = "https://mobvibe.zeabur.app";
+async function getGatewayUrl() {
+  if (process.env.MOBVIBE_GATEWAY_URL) {
+    return process.env.MOBVIBE_GATEWAY_URL;
+  }
+  const credentials = await loadCredentials();
+  if (credentials?.gatewayUrl) {
+    return credentials.gatewayUrl;
+  }
+  return DEFAULT_GATEWAY_URL;
+}
+
+// src/auth/login.ts
+async function login() {
+  logger.info("login_prompt_start");
+  console.log("To get an API key:");
+  console.log("  1. Open the Mobvibe WebUI in your browser");
+  console.log("  2. Go to Settings (gear icon) -> API Keys");
+  console.log("  3. Click 'Create API Key' and copy it");
+  console.log("  4. Paste the API key below\n");
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const apiKey = await rl.question("Paste your API key: ");
+    if (!apiKey.trim()) {
+      logger.warn("login_missing_api_key");
+      return { success: false, error: "No API key provided" };
+    }
+    if (!apiKey.trim().startsWith("mbk_")) {
+      logger.warn("login_invalid_api_key_format");
+      return {
+        success: false,
+        error: "Invalid API key format (should start with mbk_)"
+      };
+    }
+    const credentials = {
+      apiKey: apiKey.trim(),
+      createdAt: Date.now()
+    };
+    await saveCredentials(credentials);
+    logger.info("login_credentials_saved");
+    console.log("\nAPI key saved!");
+    console.log("Run 'mobvibe start' to connect to the gateway.");
+    return { success: true };
+  } finally {
+    rl.close();
+  }
+}
+async function logout() {
+  await deleteCredentials();
+  logger.info("logout_complete");
+  console.log("Logged out successfully. Credentials deleted.");
+}
+async function loginStatus() {
+  const credentials = await loadCredentials();
+  if (credentials) {
+    logger.info("login_status_logged_in");
+    console.log("Status: Logged in");
+    console.log(`API key: ${credentials.apiKey.slice(0, 12)}...`);
+    console.log(`Saved: ${new Date(credentials.createdAt).toLocaleString()}`);
+  } else {
+    logger.info("login_status_logged_out");
+    console.log("Status: Not logged in");
+    console.log("Run 'mobvibe login' to authenticate.");
+  }
+}
+
+// src/config.ts
+import os2 from "os";
+import path3 from "path";
+
+// src/config-loader.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var CONFIG_FILENAME = ".config.json";
+var validateAgentConfig = (agent, index) => {
+  const errors = [];
+  const prefix = `agents[${index}]`;
+  if (typeof agent !== "object" || agent === null) {
+    errors.push(`${prefix}: must be an object`);
+    return { valid: null, errors };
+  }
+  const record = agent;
+  if (typeof record.id !== "string" || record.id.trim().length === 0) {
+    errors.push(`${prefix}.id: must be a non-empty string`);
+    return { valid: null, errors };
+  }
+  if (typeof record.command !== "string" || record.command.trim().length === 0) {
+    errors.push(`${prefix}.command: must be a non-empty string`);
+    return { valid: null, errors };
+  }
+  const validated = {
+    id: record.id.trim(),
+    command: record.command.trim()
+  };
+  if (record.label !== void 0) {
+    if (typeof record.label !== "string") {
+      errors.push(`${prefix}.label: must be a string`);
+    } else if (record.label.trim().length > 0) {
+      validated.label = record.label.trim();
+    }
+  }
+  if (record.args !== void 0) {
+    if (!Array.isArray(record.args)) {
+      errors.push(`${prefix}.args: must be an array of strings`);
+    } else {
+      const validArgs = record.args.filter((arg) => {
+        if (typeof arg !== "string") {
+          errors.push(`${prefix}.args: all elements must be strings`);
+          return false;
+        }
+        return true;
+      });
+      if (validArgs.length > 0) {
+        validated.args = validArgs;
+      }
+    }
+  }
+  if (record.env !== void 0) {
+    if (typeof record.env !== "object" || record.env === null) {
+      errors.push(`${prefix}.env: must be an object`);
+    } else {
+      const envRecord = record.env;
+      const validEnv = {};
+      let hasEnv = false;
+      for (const [key, value] of Object.entries(envRecord)) {
+        if (typeof value !== "string") {
+          errors.push(`${prefix}.env.${key}: must be a string`);
+        } else {
+          validEnv[key] = value;
+          hasEnv = true;
+        }
+      }
+      if (hasEnv) {
+        validated.env = validEnv;
+      }
+    }
+  }
+  if (errors.length > 0) {
+    return { valid: null, errors };
+  }
+  return { valid: validated, errors: [] };
+};
+var validateUserConfig = (data) => {
+  const errors = [];
+  if (typeof data !== "object" || data === null) {
+    errors.push("config: must be an object");
+    return { config: null, errors };
+  }
+  const record = data;
+  const config = {};
+  if (record.agents !== void 0) {
+    if (!Array.isArray(record.agents)) {
+      errors.push("agents: must be an array");
+    } else {
+      const validAgents = [];
+      const seenIds = /* @__PURE__ */ new Set();
+      for (let i = 0; i < record.agents.length; i++) {
+        const result = validateAgentConfig(record.agents[i], i);
+        errors.push(...result.errors);
+        if (result.valid) {
+          if (seenIds.has(result.valid.id)) {
+            errors.push(`agents[${i}].id: duplicate id "${result.valid.id}"`);
+          } else {
+            seenIds.add(result.valid.id);
+            validAgents.push(result.valid);
+          }
+        }
+      }
+      if (validAgents.length > 0) {
+        config.agents = validAgents;
+      }
+    }
+  }
+  if (record.defaultAgentId !== void 0) {
+    if (typeof record.defaultAgentId !== "string") {
+      errors.push("defaultAgentId: must be a string");
+    } else if (record.defaultAgentId.trim().length > 0) {
+      config.defaultAgentId = record.defaultAgentId.trim();
+    }
+  }
+  if (errors.length > 0) {
+    return { config: null, errors };
+  }
+  return { config, errors: [] };
+};
+var loadUserConfig = async (homePath) => {
+  const configPath = path2.join(homePath, CONFIG_FILENAME);
+  console.log(`[config] Loading config from: ${configPath}`);
+  try {
+    const content = await fs2.readFile(configPath, "utf-8");
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      console.log(`[config] Invalid JSON in config file: ${configPath}`);
+      return {
+        config: null,
+        errors: ["Invalid JSON in config file"],
+        path: configPath
+      };
+    }
+    const { config, errors } = validateUserConfig(parsed);
+    if (errors.length > 0) {
+      console.log("[config] Validation errors:", errors);
+    }
+    if (config) {
+      console.log("[config] Loaded config:", JSON.stringify(config, null, 2));
+    }
+    return { config, errors, path: configPath };
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      console.log(`[config] No config file found at: ${configPath}`);
+      return { config: null, errors: [], path: configPath };
+    }
+    const message = error instanceof Error ? error.message : "Unknown error reading config";
+    console.log(`[config] Error reading config: ${message}`);
+    return { config: null, errors: [message], path: configPath };
+  }
+};
+
+// src/config.ts
+var DEFAULT_OPENCODE_BACKEND = {
+  id: "opencode",
+  label: "opencode",
+  command: "opencode",
+  args: ["acp"]
+};
+var generateMachineId = () => {
+  const hostname = os2.hostname();
+  const platform = os2.platform();
+  const arch = os2.arch();
+  const username = os2.userInfo().username;
+  return `${hostname}-${platform}-${arch}-${username}`;
+};
+var userAgentToBackendConfig = (agent) => ({
+  id: agent.id,
+  label: agent.label ?? agent.id,
+  command: agent.command,
+  args: agent.args ?? [],
+  envOverrides: agent.env
+});
+var mergeBackends = (defaultBackend, userAgents) => {
+  if (!userAgents || userAgents.length === 0) {
+    return { backends: [defaultBackend], defaultId: defaultBackend.id };
+  }
+  const userOpencode = userAgents.find((a) => a.id === "opencode");
+  if (userOpencode) {
+    return {
+      backends: userAgents.map(userAgentToBackendConfig),
+      defaultId: userAgents[0].id
+    };
+  }
+  return {
+    backends: [defaultBackend, ...userAgents.map(userAgentToBackendConfig)],
+    defaultId: defaultBackend.id
+  };
+};
+var getCliConfig = async () => {
+  const env = process.env;
+  const homePath = env.MOBVIBE_HOME ?? path3.join(os2.homedir(), ".mobvibe");
+  const userConfigResult = await loadUserConfig(homePath);
+  if (userConfigResult.errors.length > 0) {
+    for (const error of userConfigResult.errors) {
+      logger.warn({ configPath: userConfigResult.path, error }, "config_error");
+    }
+  }
+  const { backends, defaultId } = mergeBackends(
+    DEFAULT_OPENCODE_BACKEND,
+    userConfigResult.config?.agents
+  );
+  const resolvedDefaultId = userConfigResult.config?.defaultAgentId && backends.some((b) => b.id === userConfigResult.config?.defaultAgentId) ? userConfigResult.config.defaultAgentId : defaultId;
+  const gatewayUrl = await getGatewayUrl();
+  return {
+    gatewayUrl,
+    acpBackends: backends,
+    defaultAcpBackendId: resolvedDefaultId,
+    clientName: env.MOBVIBE_ACP_CLIENT_NAME ?? "mobvibe-cli",
+    clientVersion: env.MOBVIBE_ACP_CLIENT_VERSION ?? "0.0.0",
+    homePath,
+    logPath: path3.join(homePath, "logs"),
+    pidFile: path3.join(homePath, "daemon.pid"),
+    machineId: env.MOBVIBE_MACHINE_ID ?? generateMachineId(),
+    hostname: os2.hostname(),
+    platform: os2.platform(),
+    userConfigPath: userConfigResult.path,
+    userConfigErrors: userConfigResult.errors.length > 0 ? userConfigResult.errors : void 0
+  };
+};
+
+// src/daemon/daemon.ts
+import { spawn as spawn2 } from "child_process";
+import fs4 from "fs/promises";
+import path5 from "path";
+
+// src/acp/session-manager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { EventEmitter as EventEmitter2 } from "events";
+
+// ../../packages/shared/dist/types/errors.js
+var createErrorDetail = (input) => ({
+  ...input
+});
+var isProtocolMismatch = (error) => {
+  if (error instanceof Error) {
+    return /protocol/i.test(error.message);
+  }
+  return false;
+};
+var AppError = class extends Error {
+  detail;
+  status;
+  constructor(detail, status = 500) {
+    super(detail.message);
+    this.detail = detail;
+    this.status = status;
+  }
+};
+
+// src/acp/acp-connection.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
+import { Readable, Writable } from "stream";
+import {
+  ClientSideConnection,
+  ndJsonStream,
+  PROTOCOL_VERSION
+} from "@agentclientprotocol/sdk";
+var getErrorMessage = (error) => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+var buildClient = (handlers) => ({
+  async requestPermission(params) {
+    if (handlers.onRequestPermission) {
+      return handlers.onRequestPermission(params);
+    }
+    return { outcome: { outcome: "cancelled" } };
+  },
+  async sessionUpdate(params) {
+    handlers.onSessionUpdate(params);
+  },
+  async createTerminal(params) {
+    if (!handlers.onCreateTerminal) {
+      throw new Error("Terminal create handler not configured");
+    }
+    return handlers.onCreateTerminal(params);
+  },
+  async terminalOutput(params) {
+    if (!handlers.onTerminalOutput) {
+      return { output: "", truncated: false };
+    }
+    return handlers.onTerminalOutput(params);
+  },
+  async waitForTerminalExit(params) {
+    if (!handlers.onWaitForTerminalExit) {
+      return { exitCode: null, signal: null };
+    }
+    return handlers.onWaitForTerminalExit(params);
+  },
+  async killTerminal(params) {
+    if (!handlers.onKillTerminal) {
+      return {};
+    }
+    return handlers.onKillTerminal(params);
+  },
+  async releaseTerminal(params) {
+    if (!handlers.onReleaseTerminal) {
+      return {};
+    }
+    return handlers.onReleaseTerminal(params);
+  }
+});
+var formatExitMessage = (code, signal) => {
+  if (signal) {
+    return `ACP process received signal ${signal}`;
+  }
+  if (code !== null) {
+    return `ACP process exited with code ${code}`;
+  }
+  return "ACP process exited";
+};
+var buildConnectError = (error) => {
+  const detail = getErrorMessage(error);
+  if (isProtocolMismatch(error)) {
+    return createErrorDetail({
+      code: "ACP_PROTOCOL_MISMATCH",
+      message: "ACP protocol version mismatch",
+      retryable: false,
+      scope: "service",
+      detail
+    });
+  }
+  return createErrorDetail({
+    code: "ACP_CONNECT_FAILED",
+    message: "Failed to connect to ACP backend process",
+    retryable: true,
+    scope: "service",
+    detail
+  });
+};
+var buildProcessExitError = (detail) => createErrorDetail({
+  code: "ACP_PROCESS_EXITED",
+  message: "ACP backend process exited unexpectedly",
+  retryable: true,
+  scope: "service",
+  detail
+});
+var buildConnectionClosedError = (detail) => createErrorDetail({
+  code: "ACP_CONNECTION_CLOSED",
+  message: "ACP connection closed",
+  retryable: true,
+  scope: "service",
+  detail
+});
+var normalizeOutputText = (value) => value.normalize("NFC");
+var isOutputOverLimit = (value, limit) => Buffer.byteLength(value, "utf8") > limit;
+var sliceOutputToLimit = (value, limit) => {
+  const buffer = Buffer.from(value, "utf8");
+  if (buffer.byteLength <= limit) {
+    return value;
+  }
+  const sliced = buffer.subarray(buffer.byteLength - limit);
+  let start = 0;
+  while (start < sliced.length && (sliced[start] & 192) === 128) {
+    start += 1;
+  }
+  return sliced.subarray(start).toString("utf8");
+};
+var AcpConnection = class {
+  constructor(options) {
+    this.options = options;
+  }
+  connection;
+  process;
+  closedPromise;
+  state = "idle";
+  connectedAt;
+  error;
+  sessionId;
+  agentInfo;
+  agentCapabilities;
+  sessionUpdateEmitter = new EventEmitter();
+  statusEmitter = new EventEmitter();
+  terminalOutputEmitter = new EventEmitter();
+  permissionHandler;
+  terminals = /* @__PURE__ */ new Map();
+  getStatus() {
+    return {
+      backendId: this.options.backend.id,
+      backendLabel: this.options.backend.label,
+      state: this.state,
+      command: this.options.backend.command,
+      args: [...this.options.backend.args],
+      connectedAt: this.connectedAt?.toISOString(),
+      error: this.error,
+      sessionId: this.sessionId,
+      pid: this.process?.pid
+    };
+  }
+  getAgentInfo() {
+    return this.agentInfo;
+  }
+  /**
+   * Get the agent's session capabilities.
+   */
+  getSessionCapabilities() {
+    return {
+      list: this.agentCapabilities?.sessionCapabilities?.list != null,
+      load: this.agentCapabilities?.loadSession === true,
+      resume: this.agentCapabilities?.sessionCapabilities?.resume != null
+    };
+  }
+  /**
+   * Check if the agent supports session/list.
+   */
+  supportsSessionList() {
+    return this.agentCapabilities?.sessionCapabilities?.list != null;
+  }
+  /**
+   * Check if the agent supports session/load.
+   */
+  supportsSessionLoad() {
+    return this.agentCapabilities?.loadSession === true;
+  }
+  /**
+   * Check if the agent supports session/resume.
+   */
+  supportsSessionResume() {
+    return this.agentCapabilities?.sessionCapabilities?.resume != null;
+  }
+  /**
+   * List sessions from the agent (session/list).
+   * @param params Optional filter parameters
+   * @returns List of session info from the agent
+   */
+  async listSessions(params) {
+    if (!this.supportsSessionList()) {
+      return [];
+    }
+    const connection = await this.ensureReady();
+    const response = await connection.unstable_listSessions({
+      cursor: params?.cursor ?? void 0,
+      cwd: params?.cwd ?? void 0
+    });
+    return response.sessions;
+  }
+  /**
+   * Load a historical session with message history replay (session/load).
+   * @param sessionId The session ID to load
+   * @param cwd The working directory
+   * @returns Load session response with modes/models state
+   */
+  async loadSession(sessionId, cwd) {
+    if (!this.supportsSessionLoad()) {
+      throw new Error("Agent does not support session/load capability");
+    }
+    const connection = await this.ensureReady();
+    const response = await connection.loadSession({
+      sessionId,
+      cwd,
+      mcpServers: []
+    });
+    this.sessionId = sessionId;
+    return response;
+  }
+  /**
+   * Resume an active session without message history replay (session/resume).
+   * @param sessionId The session ID to resume
+   * @param cwd The working directory
+   * @returns Resume session response
+   */
+  async resumeSession(sessionId, cwd) {
+    if (!this.supportsSessionResume()) {
+      throw new Error("Agent does not support session/resume capability");
+    }
+    const connection = await this.ensureReady();
+    const response = await connection.unstable_resumeSession({
+      sessionId,
+      cwd,
+      mcpServers: []
+    });
+    this.sessionId = sessionId;
+    return response;
+  }
+  setPermissionHandler(handler) {
+    this.permissionHandler = handler;
+  }
+  onTerminalOutput(listener) {
+    this.terminalOutputEmitter.on("output", listener);
+    return () => {
+      this.terminalOutputEmitter.off("output", listener);
+    };
+  }
+  onSessionUpdate(listener) {
+    this.sessionUpdateEmitter.on("update", listener);
+    return () => {
+      this.sessionUpdateEmitter.off("update", listener);
+    };
+  }
+  onStatusChange(listener) {
+    this.statusEmitter.on("status", listener);
+    return () => {
+      this.statusEmitter.off("status", listener);
+    };
+  }
+  updateStatus(state, error) {
+    this.state = state;
+    this.error = error;
+    this.statusEmitter.emit("status", this.getStatus());
+  }
+  async connect() {
+    if (this.state === "connecting" || this.state === "ready") {
+      return;
+    }
+    this.updateStatus("connecting");
+    this.agentInfo = void 0;
+    try {
+      const env = this.options.backend.envOverrides ? { ...process.env, ...this.options.backend.envOverrides } : process.env;
+      const child = spawn(
+        this.options.backend.command,
+        this.options.backend.args,
+        {
+          stdio: ["pipe", "pipe", "pipe"],
+          env
+        }
+      );
+      this.process = child;
+      this.sessionId = void 0;
+      child.stderr.pipe(process.stderr);
+      const input = Writable.toWeb(child.stdin);
+      const output = Readable.toWeb(child.stdout);
+      const stream = ndJsonStream(input, output);
+      const connection = new ClientSideConnection(
+        () => buildClient({
+          onSessionUpdate: (notification) => this.emitSessionUpdate(notification),
+          onRequestPermission: (params) => this.handlePermissionRequest(params),
+          onCreateTerminal: (params) => this.createTerminal(params),
+          onTerminalOutput: (params) => this.getTerminalOutput(params),
+          onWaitForTerminalExit: (params) => this.waitForTerminalExit(params),
+          onKillTerminal: (params) => this.killTerminal(params),
+          onReleaseTerminal: (params) => this.releaseTerminal(params)
+        }),
+        stream
+      );
+      this.connection = connection;
+      child.once("error", (error) => {
+        if (this.state === "stopped") {
+          return;
+        }
+        this.updateStatus("error", buildConnectError(error));
+      });
+      child.once("exit", (code, signal) => {
+        if (this.state === "stopped") {
+          return;
+        }
+        this.updateStatus(
+          "error",
+          buildProcessExitError(formatExitMessage(code, signal))
+        );
+      });
+      this.closedPromise = connection.closed.catch((error) => {
+        this.updateStatus(
+          "error",
+          buildConnectionClosedError(getErrorMessage(error))
+        );
+      });
+      const initializeResponse = await connection.initialize({
+        protocolVersion: PROTOCOL_VERSION,
+        clientInfo: {
+          name: this.options.client.name,
+          version: this.options.client.version
+        },
+        clientCapabilities: { terminal: true }
+      });
+      this.agentInfo = initializeResponse.agentInfo ?? void 0;
+      this.agentCapabilities = initializeResponse.agentCapabilities ?? void 0;
+      this.connectedAt = /* @__PURE__ */ new Date();
+      this.updateStatus("ready");
+    } catch (error) {
+      this.updateStatus("error", buildConnectError(error));
+      await this.stopProcess();
+      throw error;
+    }
+  }
+  async createSession(options) {
+    const connection = await this.ensureReady();
+    const response = await this.createSessionInternal(
+      connection,
+      options?.cwd ?? process.cwd()
+    );
+    this.sessionId = response.sessionId;
+    return response;
+  }
+  async prompt(sessionId, prompt) {
+    const connection = await this.ensureReady();
+    return connection.prompt({ sessionId, prompt });
+  }
+  async cancel(sessionId) {
+    const connection = await this.ensureReady();
+    await connection.cancel({ sessionId });
+  }
+  async setSessionMode(sessionId, modeId) {
+    const connection = await this.ensureReady();
+    await connection.setSessionMode({ sessionId, modeId });
+  }
+  async setSessionModel(sessionId, modelId) {
+    const connection = await this.ensureReady();
+    await connection.unstable_setSessionModel({ sessionId, modelId });
+  }
+  async createTerminal(params) {
+    const outputLimit = typeof params.outputByteLimit === "number" && params.outputByteLimit > 0 ? Math.floor(params.outputByteLimit) : 1024 * 1024;
+    const resolvedEnv = params.env ? Object.fromEntries(
+      params.env.map((envVar) => [envVar.name, envVar.value])
+    ) : void 0;
+    const terminalId = randomUUID();
+    const record = {
+      sessionId: params.sessionId,
+      command: params.command,
+      args: params.args ?? [],
+      outputByteLimit: outputLimit,
+      output: {
+        output: "",
+        truncated: false,
+        exitStatus: null
+      }
+    };
+    this.terminals.set(terminalId, record);
+    const child = spawn(params.command, params.args ?? [], {
+      cwd: params.cwd ?? void 0,
+      env: resolvedEnv ? { ...process.env, ...resolvedEnv } : process.env
+    });
+    child.once("error", (error) => {
+      record.output.exitStatus = {
+        exitCode: null,
+        signal: null
+      };
+      record.resolveExit?.({ exitCode: null, signal: null });
+      this.terminalOutputEmitter.emit("output", {
+        sessionId: record.sessionId,
+        terminalId,
+        delta: `
+[terminal error] ${String(error)}`,
+        truncated: record.output.truncated,
+        output: record.output.output,
+        exitStatus: record.output.exitStatus
+      });
+    });
+    record.process = child;
+    let resolveExit = () => {
+    };
+    record.onExit = new Promise((resolve) => {
+      resolveExit = resolve;
+    });
+    record.resolveExit = resolveExit;
+    const handleChunk = (chunk) => {
+      const delta = normalizeOutputText(chunk.toString("utf8"));
+      if (!delta) {
+        return;
+      }
+      const combinedOutput = record.output.output + delta;
+      record.output.truncated = isOutputOverLimit(
+        combinedOutput,
+        record.outputByteLimit
+      );
+      record.output.output = sliceOutputToLimit(
+        combinedOutput,
+        record.outputByteLimit
+      );
+      this.terminalOutputEmitter.emit("output", {
+        sessionId: record.sessionId,
+        terminalId,
+        delta,
+        truncated: record.output.truncated,
+        output: record.output.truncated ? record.output.output : void 0,
+        exitStatus: record.output.exitStatus
+      });
+    };
+    child.stdout?.on("data", handleChunk);
+    child.stderr?.on("data", handleChunk);
+    child.on("exit", (code, signal) => {
+      record.output.exitStatus = {
+        exitCode: code ?? null,
+        signal: signal ?? null
+      };
+      record.resolveExit?.({
+        exitCode: code ?? null,
+        signal: signal ?? null
+      });
+      this.terminalOutputEmitter.emit("output", {
+        sessionId: record.sessionId,
+        terminalId,
+        delta: "",
+        truncated: record.output.truncated,
+        output: record.output.output,
+        exitStatus: record.output.exitStatus
+      });
+    });
+    return { terminalId };
+  }
+  async getTerminalOutput(params) {
+    const record = this.terminals.get(params.terminalId);
+    if (!record || record.sessionId !== params.sessionId) {
+      return { output: "", truncated: false };
+    }
+    return record.output;
+  }
+  async waitForTerminalExit(params) {
+    const record = this.terminals.get(params.terminalId);
+    if (!record || record.sessionId !== params.sessionId) {
+      return Promise.resolve({ exitCode: null, signal: null });
+    }
+    return record.onExit ?? Promise.resolve({ exitCode: null, signal: null });
+  }
+  async killTerminal(params) {
+    const record = this.terminals.get(params.terminalId);
+    if (!record || record.sessionId !== params.sessionId) {
+      return {};
+    }
+    record.process?.kill("SIGTERM");
+    return {};
+  }
+  async releaseTerminal(params) {
+    const record = this.terminals.get(params.terminalId);
+    if (record?.process && record.process.exitCode === null) {
+      record.process.kill("SIGTERM");
+    }
+    this.terminals.delete(params.terminalId);
+    return {};
+  }
+  async disconnect() {
+    if (this.state === "stopped") {
+      return;
+    }
+    this.updateStatus("stopped");
+    this.sessionId = void 0;
+    this.agentInfo = void 0;
+    await this.stopProcess();
+    await this.closedPromise;
+    this.connection = void 0;
+  }
+  async ensureReady() {
+    if (this.state !== "ready" || !this.connection) {
+      await this.connect();
+    }
+    if (!this.connection || this.state !== "ready") {
+      throw new Error("ACP connection not available");
+    }
+    return this.connection;
+  }
+  async createSessionInternal(connection, cwd) {
+    const session = await connection.newSession({
+      cwd,
+      mcpServers: []
+    });
+    return session;
+  }
+  emitSessionUpdate(notification) {
+    this.sessionUpdateEmitter.emit("update", notification);
+  }
+  async handlePermissionRequest(params) {
+    if (this.permissionHandler) {
+      return this.permissionHandler(params);
+    }
+    return { outcome: { outcome: "cancelled" } };
+  }
+  async stopProcess() {
+    const child = this.process;
+    if (!child) {
+      return;
+    }
+    this.process = void 0;
+    if (child.exitCode === null && !child.killed) {
+      child.kill("SIGTERM");
+    }
+  }
+};
+
+// src/acp/session-manager.ts
+var buildPermissionKey = (sessionId, requestId) => `${sessionId}:${requestId}`;
+var resolveModelState = (models) => {
+  if (!models) {
+    return {
+      modelId: void 0,
+      modelName: void 0,
+      availableModels: void 0
+    };
+  }
+  const availableModels = models.availableModels?.map((model) => ({
+    id: model.modelId,
+    name: model.name,
+    description: model.description ?? void 0
+  }));
+  const modelId = models.currentModelId ?? void 0;
+  const modelName = availableModels?.find(
+    (model) => model.id === modelId
+  )?.name;
+  return { modelId, modelName, availableModels };
+};
+var resolveModeState = (modes) => {
+  if (!modes) {
+    return {
+      modeId: void 0,
+      modeName: void 0,
+      availableModes: void 0
+    };
+  }
+  const modeId = modes.currentModeId ?? void 0;
+  const modeName = modes.availableModes?.find(
+    (mode) => mode.id === modeId
+  )?.name;
+  return {
+    modeId,
+    modeName,
+    availableModes: modes.availableModes?.map((mode) => ({
+      id: mode.id,
+      name: mode.name
+    }))
+  };
+};
+var createCapabilityNotSupportedError = (message) => new AppError(
+  createErrorDetail({
+    code: "CAPABILITY_NOT_SUPPORTED",
+    message,
+    retryable: false,
+    scope: "session"
+  }),
+  409
+);
+var SessionManager = class {
+  constructor(config) {
+    this.config = config;
+    this.backendById = new Map(
+      config.acpBackends.map((backend) => [backend.id, backend])
+    );
+    this.defaultBackendId = config.defaultAcpBackendId;
+  }
+  sessions = /* @__PURE__ */ new Map();
+  backendById;
+  defaultBackendId;
+  permissionRequests = /* @__PURE__ */ new Map();
+  sessionUpdateEmitter = new EventEmitter2();
+  sessionErrorEmitter = new EventEmitter2();
+  permissionRequestEmitter = new EventEmitter2();
+  permissionResultEmitter = new EventEmitter2();
+  terminalOutputEmitter = new EventEmitter2();
+  sessionsChangedEmitter = new EventEmitter2();
+  listSessions() {
+    return Array.from(this.sessions.values()).map(
+      (record) => this.buildSummary(record)
+    );
+  }
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  onSessionUpdate(listener) {
+    this.sessionUpdateEmitter.on("update", listener);
+    return () => {
+      this.sessionUpdateEmitter.off("update", listener);
+    };
+  }
+  onSessionError(listener) {
+    this.sessionErrorEmitter.on("error", listener);
+    return () => {
+      this.sessionErrorEmitter.off("error", listener);
+    };
+  }
+  onPermissionRequest(listener) {
+    this.permissionRequestEmitter.on("request", listener);
+    return () => {
+      this.permissionRequestEmitter.off("request", listener);
+    };
+  }
+  onPermissionResult(listener) {
+    this.permissionResultEmitter.on("result", listener);
+    return () => {
+      this.permissionResultEmitter.off("result", listener);
+    };
+  }
+  onTerminalOutput(listener) {
+    this.terminalOutputEmitter.on("output", listener);
+    return () => {
+      this.terminalOutputEmitter.off("output", listener);
+    };
+  }
+  onSessionsChanged(listener) {
+    this.sessionsChangedEmitter.on("changed", listener);
+    return () => {
+      this.sessionsChangedEmitter.off("changed", listener);
+    };
+  }
+  emitSessionsChanged(payload) {
+    this.sessionsChangedEmitter.emit("changed", payload);
+  }
+  listPendingPermissions(sessionId) {
+    return Array.from(this.permissionRequests.values()).filter((record) => record.sessionId === sessionId).map((record) => this.buildPermissionRequestPayload(record));
+  }
+  resolvePermissionRequest(sessionId, requestId, outcome) {
+    const key = buildPermissionKey(sessionId, requestId);
+    const record = this.permissionRequests.get(key);
+    if (!record) {
+      throw new AppError(
+        createErrorDetail({
+          code: "REQUEST_VALIDATION_FAILED",
+          message: "Permission request not found",
+          retryable: false,
+          scope: "request"
+        }),
+        404
+      );
+    }
+    const response = { outcome };
+    record.resolve(response);
+    this.permissionRequests.delete(key);
+    const payload = {
+      sessionId,
+      requestId,
+      outcome
+    };
+    this.permissionResultEmitter.emit("result", payload);
+    return payload;
+  }
+  resolveBackend(backendId) {
+    const normalized = backendId?.trim();
+    const resolvedId = normalized && normalized.length > 0 ? normalized : this.defaultBackendId;
+    const backend = this.backendById.get(resolvedId);
+    if (!backend) {
+      throw new AppError(
+        createErrorDetail({
+          code: "REQUEST_VALIDATION_FAILED",
+          message: "Invalid backend ID",
+          retryable: false,
+          scope: "request"
+        }),
+        400
+      );
+    }
+    return backend;
+  }
+  async createSession(options) {
+    const backend = this.resolveBackend(options?.backendId);
+    const connection = new AcpConnection({
+      backend,
+      client: {
+        name: this.config.clientName,
+        version: this.config.clientVersion
+      }
+    });
+    try {
+      await connection.connect();
+      const session = await connection.createSession({ cwd: options?.cwd });
+      connection.setPermissionHandler(
+        (params) => this.handlePermissionRequest(session.sessionId, params)
+      );
+      const now = /* @__PURE__ */ new Date();
+      const agentInfo = connection.getAgentInfo();
+      const { modelId, modelName, availableModels } = resolveModelState(
+        session.models
+      );
+      const { modeId, modeName, availableModes } = resolveModeState(
+        session.modes
+      );
+      const record = {
+        sessionId: session.sessionId,
+        title: options?.title ?? `Session ${this.sessions.size + 1}`,
+        backendId: backend.id,
+        backendLabel: backend.label,
+        connection,
+        createdAt: now,
+        updatedAt: now,
+        cwd: options?.cwd,
+        agentName: agentInfo?.title ?? agentInfo?.name,
+        modelId,
+        modelName,
+        modeId,
+        modeName,
+        availableModes,
+        availableModels,
+        availableCommands: void 0
+      };
+      record.unsubscribe = connection.onSessionUpdate(
+        (notification) => {
+          this.touchSession(session.sessionId);
+          this.sessionUpdateEmitter.emit("update", notification);
+          const update = notification.update;
+          if (update.sessionUpdate === "current_mode_update") {
+            record.modeId = update.currentModeId;
+            record.modeName = record.availableModes?.find(
+              (mode) => mode.id === update.currentModeId
+            )?.name ?? record.modeName;
+            return;
+          }
+          if (update.sessionUpdate === "session_info_update") {
+            if (typeof update.title === "string") {
+              record.title = update.title;
+            }
+            if (typeof update.updatedAt === "string") {
+              record.updatedAt = new Date(update.updatedAt);
+            }
+          }
+          if (update.sessionUpdate === "available_commands_update") {
+            if (update.availableCommands) {
+              record.availableCommands = update.availableCommands;
+            }
+          }
+        }
+      );
+      record.unsubscribeTerminal = connection.onTerminalOutput((event) => {
+        this.terminalOutputEmitter.emit("output", event);
+      });
+      connection.onStatusChange((status) => {
+        if (status.error) {
+          this.sessionErrorEmitter.emit("error", {
+            sessionId: session.sessionId,
+            error: status.error
+          });
+        }
+      });
+      this.sessions.set(session.sessionId, record);
+      const summary = this.buildSummary(record);
+      this.emitSessionsChanged({
+        added: [summary],
+        updated: [],
+        removed: []
+      });
+      return summary;
+    } catch (error) {
+      const status = connection.getStatus();
+      await connection.disconnect();
+      if (status.error) {
+        throw new AppError(status.error, 500);
+      }
+      throw error;
+    }
+  }
+  buildPermissionRequestPayload(record) {
+    const toolCall = record.params.toolCall;
+    return {
+      sessionId: record.sessionId,
+      requestId: record.requestId,
+      options: record.params.options.map((option) => ({
+        optionId: option.optionId,
+        // SDK uses 'name', our shared type uses 'label'
+        label: option.name,
+        description: option._meta?.description ?? null
+      })),
+      toolCall: {
+        toolCallId: toolCall.toolCallId,
+        name: toolCall._meta?.name ?? null,
+        title: toolCall.title,
+        command: toolCall._meta?.command ?? null,
+        args: toolCall._meta?.args ?? null
+      }
+    };
+  }
+  handlePermissionRequest(sessionId, params) {
+    const requestId = params.toolCall?.toolCallId ?? randomUUID2();
+    const key = buildPermissionKey(sessionId, requestId);
+    const existing = this.permissionRequests.get(key);
+    if (existing) {
+      return existing.promise;
+    }
+    let resolver = () => {
+    };
+    const promise = new Promise((resolve) => {
+      resolver = resolve;
+    });
+    const record = {
+      sessionId,
+      requestId,
+      params,
+      promise,
+      resolve: resolver
+    };
+    this.permissionRequests.set(key, record);
+    this.permissionRequestEmitter.emit(
+      "request",
+      this.buildPermissionRequestPayload(record)
+    );
+    return promise;
+  }
+  cancelPermissionRequests(sessionId) {
+    const cancelledOutcome = {
+      outcome: "cancelled"
+    };
+    for (const [key, record] of this.permissionRequests.entries()) {
+      if (record.sessionId !== sessionId) {
+        continue;
+      }
+      record.resolve({ outcome: cancelledOutcome });
+      this.permissionRequests.delete(key);
+      this.permissionResultEmitter.emit("result", {
+        sessionId,
+        requestId: record.requestId,
+        outcome: cancelledOutcome
+      });
+    }
+  }
+  updateTitle(sessionId, title) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      throw new AppError(
+        createErrorDetail({
+          code: "SESSION_NOT_FOUND",
+          message: "Session not found",
+          retryable: false,
+          scope: "session"
+        }),
+        404
+      );
+    }
+    record.title = title;
+    record.updatedAt = /* @__PURE__ */ new Date();
+    const summary = this.buildSummary(record);
+    this.emitSessionsChanged({
+      added: [],
+      updated: [summary],
+      removed: []
+    });
+    return summary;
+  }
+  touchSession(sessionId) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return;
+    }
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async setSessionMode(sessionId, modeId) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      throw new AppError(
+        createErrorDetail({
+          code: "SESSION_NOT_FOUND",
+          message: "Session not found",
+          retryable: false,
+          scope: "session"
+        }),
+        404
+      );
+    }
+    if (!record.availableModes || record.availableModes.length === 0) {
+      throw createCapabilityNotSupportedError(
+        "Current agent does not support mode switching"
+      );
+    }
+    const selected = record.availableModes.find((mode) => mode.id === modeId);
+    if (!selected) {
+      throw new AppError(
+        createErrorDetail({
+          code: "REQUEST_VALIDATION_FAILED",
+          message: "Invalid mode ID",
+          retryable: false,
+          scope: "request"
+        }),
+        400
+      );
+    }
+    await record.connection.setSessionMode(sessionId, modeId);
+    record.modeId = selected.id;
+    record.modeName = selected.name;
+    record.updatedAt = /* @__PURE__ */ new Date();
+    const summary = this.buildSummary(record);
+    this.emitSessionsChanged({
+      added: [],
+      updated: [summary],
+      removed: []
+    });
+    return summary;
+  }
+  async setSessionModel(sessionId, modelId) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      throw new AppError(
+        createErrorDetail({
+          code: "SESSION_NOT_FOUND",
+          message: "Session not found",
+          retryable: false,
+          scope: "session"
+        }),
+        404
+      );
+    }
+    if (!record.availableModels || record.availableModels.length === 0) {
+      throw createCapabilityNotSupportedError(
+        "Current agent does not support model switching"
+      );
+    }
+    const selected = record.availableModels.find(
+      (model) => model.id === modelId
+    );
+    if (!selected) {
+      throw new AppError(
+        createErrorDetail({
+          code: "REQUEST_VALIDATION_FAILED",
+          message: "Invalid model ID",
+          retryable: false,
+          scope: "request"
+        }),
+        400
+      );
+    }
+    await record.connection.setSessionModel(sessionId, modelId);
+    record.modelId = selected.id;
+    record.modelName = selected.name;
+    record.updatedAt = /* @__PURE__ */ new Date();
+    const summary = this.buildSummary(record);
+    this.emitSessionsChanged({
+      added: [],
+      updated: [summary],
+      removed: []
+    });
+    return summary;
+  }
+  async cancelSession(sessionId) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return false;
+    }
+    this.cancelPermissionRequests(sessionId);
+    await record.connection.cancel(sessionId);
+    this.touchSession(sessionId);
+    return true;
+  }
+  async closeSession(sessionId) {
+    const record = this.sessions.get(sessionId);
+    if (!record) {
+      return false;
+    }
+    try {
+      record.unsubscribe?.();
+      record.unsubscribeTerminal?.();
+    } catch (error) {
+      logger.error({ err: error, sessionId }, "session_unsubscribe_failed");
+    }
+    this.cancelPermissionRequests(sessionId);
+    try {
+      await record.connection.disconnect();
+    } catch (error) {
+      logger.error({ err: error, sessionId }, "session_disconnect_failed");
+    }
+    this.sessions.delete(sessionId);
+    this.emitSessionsChanged({
+      added: [],
+      updated: [],
+      removed: [sessionId]
+    });
+    return true;
+  }
+  async closeAll() {
+    const sessionIds = Array.from(this.sessions.keys());
+    await Promise.all(
+      sessionIds.map((sessionId) => this.closeSession(sessionId))
+    );
+  }
+  /**
+   * Discover sessions persisted by the ACP agent.
+   * Creates a temporary connection to query sessions.
+   * @param options Optional parameters for discovery
+   * @returns List of discovered sessions and agent capabilities
+   */
+  async discoverSessions(options) {
+    const backend = this.resolveBackend(options?.backendId);
+    const connection = new AcpConnection({
+      backend,
+      client: {
+        name: this.config.clientName,
+        version: this.config.clientVersion
+      }
+    });
+    try {
+      await connection.connect();
+      const capabilities = connection.getSessionCapabilities();
+      const sessions = [];
+      if (capabilities.list) {
+        const agentSessions = await connection.listSessions({
+          cwd: options?.cwd
+        });
+        for (const session of agentSessions) {
+          sessions.push({
+            sessionId: session.sessionId,
+            cwd: session.cwd,
+            title: session.title ?? void 0,
+            updatedAt: session.updatedAt ?? void 0
+          });
+        }
+      }
+      logger.info(
+        {
+          backendId: backend.id,
+          sessionCount: sessions.length,
+          capabilities
+        },
+        "sessions_discovered"
+      );
+      return { sessions, capabilities };
+    } finally {
+      await connection.disconnect();
+    }
+  }
+  /**
+   * Load a historical session from the ACP agent.
+   * This will replay the session's message history.
+   * @param sessionId The session ID to load
+   * @param cwd The working directory
+   * @param backendId Optional backend ID
+   * @returns The loaded session summary
+   */
+  async loadSession(sessionId, cwd, backendId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      return this.buildSummary(existing);
+    }
+    const backend = this.resolveBackend(backendId);
+    const connection = new AcpConnection({
+      backend,
+      client: {
+        name: this.config.clientName,
+        version: this.config.clientVersion
+      }
+    });
+    try {
+      await connection.connect();
+      if (!connection.supportsSessionLoad()) {
+        throw createCapabilityNotSupportedError(
+          "Agent does not support session loading"
+        );
+      }
+      const response = await connection.loadSession(sessionId, cwd);
+      connection.setPermissionHandler(
+        (params) => this.handlePermissionRequest(sessionId, params)
+      );
+      const now = /* @__PURE__ */ new Date();
+      const agentInfo = connection.getAgentInfo();
+      const { modelId, modelName, availableModels } = resolveModelState(
+        response.models
+      );
+      const { modeId, modeName, availableModes } = resolveModeState(
+        response.modes
+      );
+      const record = {
+        sessionId,
+        title: `Loaded Session`,
+        backendId: backend.id,
+        backendLabel: backend.label,
+        connection,
+        createdAt: now,
+        updatedAt: now,
+        cwd,
+        agentName: agentInfo?.title ?? agentInfo?.name,
+        modelId,
+        modelName,
+        modeId,
+        modeName,
+        availableModes,
+        availableModels,
+        availableCommands: void 0
+      };
+      this.setupSessionSubscriptions(record);
+      this.sessions.set(sessionId, record);
+      const summary = this.buildSummary(record);
+      this.emitSessionsChanged({
+        added: [summary],
+        updated: [],
+        removed: []
+      });
+      logger.info({ sessionId, backendId: backend.id }, "session_loaded");
+      return summary;
+    } catch (error) {
+      await connection.disconnect();
+      throw error;
+    }
+  }
+  /**
+   * Resume an active session from the ACP agent.
+   * This does not replay message history.
+   * @param sessionId The session ID to resume
+   * @param cwd The working directory
+   * @param backendId Optional backend ID
+   * @returns The resumed session summary
+   */
+  async resumeSession(sessionId, cwd, backendId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) {
+      return this.buildSummary(existing);
+    }
+    const backend = this.resolveBackend(backendId);
+    const connection = new AcpConnection({
+      backend,
+      client: {
+        name: this.config.clientName,
+        version: this.config.clientVersion
+      }
+    });
+    try {
+      await connection.connect();
+      if (!connection.supportsSessionResume()) {
+        throw createCapabilityNotSupportedError(
+          "Agent does not support session resuming"
+        );
+      }
+      const response = await connection.resumeSession(sessionId, cwd);
+      connection.setPermissionHandler(
+        (params) => this.handlePermissionRequest(sessionId, params)
+      );
+      const now = /* @__PURE__ */ new Date();
+      const agentInfo = connection.getAgentInfo();
+      const { modelId, modelName, availableModels } = resolveModelState(
+        response.models
+      );
+      const { modeId, modeName, availableModes } = resolveModeState(
+        response.modes
+      );
+      const record = {
+        sessionId,
+        title: `Resumed Session`,
+        backendId: backend.id,
+        backendLabel: backend.label,
+        connection,
+        createdAt: now,
+        updatedAt: now,
+        cwd,
+        agentName: agentInfo?.title ?? agentInfo?.name,
+        modelId,
+        modelName,
+        modeId,
+        modeName,
+        availableModes,
+        availableModels,
+        availableCommands: void 0
+      };
+      this.setupSessionSubscriptions(record);
+      this.sessions.set(sessionId, record);
+      const summary = this.buildSummary(record);
+      this.emitSessionsChanged({
+        added: [summary],
+        updated: [],
+        removed: []
+      });
+      logger.info({ sessionId, backendId: backend.id }, "session_resumed");
+      return summary;
+    } catch (error) {
+      await connection.disconnect();
+      throw error;
+    }
+  }
+  /**
+   * Set up event subscriptions for a session record.
+   */
+  setupSessionSubscriptions(record) {
+    const { sessionId, connection } = record;
+    record.unsubscribe = connection.onSessionUpdate(
+      (notification) => {
+        this.touchSession(sessionId);
+        this.sessionUpdateEmitter.emit("update", notification);
+        const update = notification.update;
+        if (update.sessionUpdate === "current_mode_update") {
+          record.modeId = update.currentModeId;
+          record.modeName = record.availableModes?.find(
+            (mode) => mode.id === update.currentModeId
+          )?.name ?? record.modeName;
+          return;
+        }
+        if (update.sessionUpdate === "session_info_update") {
+          if (typeof update.title === "string") {
+            record.title = update.title;
+          }
+          if (typeof update.updatedAt === "string") {
+            record.updatedAt = new Date(update.updatedAt);
+          }
+        }
+        if (update.sessionUpdate === "available_commands_update") {
+          if (update.availableCommands) {
+            record.availableCommands = update.availableCommands;
+          }
+        }
+      }
+    );
+    record.unsubscribeTerminal = connection.onTerminalOutput((event) => {
+      this.terminalOutputEmitter.emit("output", event);
+    });
+    connection.onStatusChange((status) => {
+      if (status.error) {
+        this.sessionErrorEmitter.emit("error", {
+          sessionId,
+          error: status.error
+        });
+      }
+    });
+  }
+  buildSummary(record) {
+    const status = record.connection.getStatus();
+    return {
+      sessionId: record.sessionId,
+      title: record.title,
+      backendId: record.backendId,
+      backendLabel: record.backendLabel,
+      state: status.state,
+      error: status.error,
+      pid: status.pid,
+      createdAt: record.createdAt.toISOString(),
+      updatedAt: record.updatedAt.toISOString(),
+      cwd: record.cwd,
+      agentName: record.agentName,
+      modelId: record.modelId,
+      modelName: record.modelName,
+      modeId: record.modeId,
+      modeName: record.modeName,
+      availableModes: record.availableModes,
+      availableModels: record.availableModels,
+      availableCommands: record.availableCommands
+    };
+  }
+};
+
+// src/daemon/socket-client.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import fs3 from "fs/promises";
+import { homedir } from "os";
+import path4 from "path";
+import ignore from "ignore";
+import { io } from "socket.io-client";
+var SESSION_ROOT_NAME = "Working Directory";
+var MAX_RESOURCE_FILES = 2e3;
+var DEFAULT_IGNORES = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".cache",
+  "__pycache__",
+  ".venv",
+  "venv",
+  "target"
+];
+var loadGitignore = async (rootPath) => {
+  const ig = ignore().add(DEFAULT_IGNORES);
+  try {
+    const gitignorePath = path4.join(rootPath, ".gitignore");
+    const content = await fs3.readFile(gitignorePath, "utf8");
+    ig.add(content);
+  } catch {
+  }
+  return ig;
+};
+var resolveImageMimeType = (filePath) => {
+  const extension = path4.extname(filePath).toLowerCase();
+  switch (extension) {
+    case ".apng":
+      return "image/apng";
+    case ".avif":
+      return "image/avif";
+    case ".gif":
+      return "image/gif";
+    case ".jpeg":
+      return "image/jpeg";
+    case ".jpg":
+      return "image/jpeg";
+    case ".png":
+      return "image/png";
+    case ".svg":
+      return "image/svg+xml";
+    case ".webp":
+      return "image/webp";
+    default:
+      return void 0;
+  }
+};
+var readDirectoryEntries = async (dirPath) => {
+  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
+  const resolvedEntries = await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = path4.join(dirPath, entry.name);
+      let isDirectory = entry.isDirectory();
+      if (!isDirectory && entry.isSymbolicLink()) {
+        try {
+          const stats = await fs3.stat(entryPath);
+          isDirectory = stats.isDirectory();
+        } catch {
+        }
+      }
+      const entryType = isDirectory ? "directory" : "file";
+      return {
+        name: entry.name,
+        path: entryPath,
+        type: entryType,
+        hidden: entry.name.startsWith(".")
+      };
+    })
+  );
+  return resolvedEntries.sort((left, right) => {
+    if (left.type !== right.type) {
+      return left.type === "directory" ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name);
+  });
+};
+var filterVisibleEntries = (entries) => entries.filter((entry) => !entry.hidden);
+var buildHostFsRoots = async () => {
+  const homePath = homedir();
+  return {
+    homePath,
+    roots: [{ name: "Home", path: homePath }]
+  };
+};
+var SocketClient = class extends EventEmitter3 {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.socket = io(`${options.config.gatewayUrl}/cli`, {
+      path: "/socket.io",
+      reconnection: true,
+      reconnectionAttempts: Number.POSITIVE_INFINITY,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 3e4,
+      transports: ["websocket"],
+      autoConnect: false,
+      extraHeaders: {
+        "x-api-key": options.apiKey
+      }
+    });
+    this.setupEventHandlers();
+    this.setupRpcHandlers();
+    this.setupSessionManagerListeners();
+  }
+  socket;
+  connected = false;
+  reconnectAttempts = 0;
+  heartbeatInterval;
+  setupEventHandlers() {
+    this.socket.on("connect", () => {
+      logger.info(
+        { gatewayUrl: this.options.config.gatewayUrl },
+        "gateway_connected"
+      );
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      logger.info("gateway_register_start");
+      this.register();
+      this.startHeartbeat();
+      this.emit("connected");
+    });
+    this.socket.on("disconnect", (reason) => {
+      logger.warn({ reason }, "gateway_disconnected");
+      this.connected = false;
+      this.stopHeartbeat();
+      this.emit("disconnected", reason);
+    });
+    this.socket.on("connect_error", (error) => {
+      this.reconnectAttempts++;
+      if (this.reconnectAttempts <= 3 || this.reconnectAttempts % 10 === 0) {
+        logger.error(
+          { attempt: this.reconnectAttempts, err: error },
+          "gateway_connect_error"
+        );
+      }
+    });
+    this.socket.on("cli:registered", async (info) => {
+      logger.info({ machineId: info.machineId }, "gateway_registered");
+      try {
+        const { sessions, capabilities } = await this.options.sessionManager.discoverSessions();
+        if (sessions.length > 0) {
+          this.socket.emit("sessions:discovered", { sessions, capabilities });
+          logger.info(
+            { count: sessions.length, capabilities },
+            "historical_sessions_discovered"
+          );
+        }
+      } catch (error) {
+        logger.warn({ err: error }, "session_discovery_failed");
+      }
+    });
+    this.socket.on("cli:error", (error) => {
+      logger.error({ err: error }, "gateway_auth_error");
+      this.emit("auth_error", error);
+    });
+  }
+  setupRpcHandlers() {
+    const { sessionManager } = this.options;
+    this.socket.on("rpc:session:create", async (request) => {
+      try {
+        logger.info({ requestId: request.requestId }, "rpc_session_create");
+        const session = await sessionManager.createSession(request.params);
+        this.sendRpcResponse(request.requestId, session);
+      } catch (error) {
+        logger.error(
+          { err: error, requestId: request.requestId },
+          "rpc_session_create_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:session:close", async (request) => {
+      try {
+        logger.info(
+          { requestId: request.requestId, sessionId: request.params.sessionId },
+          "rpc_session_close"
+        );
+        await sessionManager.closeSession(request.params.sessionId);
+        this.sendRpcResponse(request.requestId, { ok: true });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_session_close_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:session:cancel", async (request) => {
+      try {
+        logger.info(
+          { requestId: request.requestId, sessionId: request.params.sessionId },
+          "rpc_session_cancel"
+        );
+        await sessionManager.cancelSession(request.params.sessionId);
+        this.sendRpcResponse(request.requestId, { ok: true });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_session_cancel_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:session:mode", async (request) => {
+      try {
+        logger.info(
+          {
+            requestId: request.requestId,
+            sessionId: request.params.sessionId,
+            modeId: request.params.modeId
+          },
+          "rpc_session_mode"
+        );
+        const session = await sessionManager.setSessionMode(
+          request.params.sessionId,
+          request.params.modeId
+        );
+        this.sendRpcResponse(request.requestId, session);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId,
+            modeId: request.params.modeId
+          },
+          "rpc_session_mode_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:session:model", async (request) => {
+      try {
+        logger.info(
+          {
+            requestId: request.requestId,
+            sessionId: request.params.sessionId,
+            modelId: request.params.modelId
+          },
+          "rpc_session_model"
+        );
+        const session = await sessionManager.setSessionModel(
+          request.params.sessionId,
+          request.params.modelId
+        );
+        this.sendRpcResponse(request.requestId, session);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId,
+            modelId: request.params.modelId
+          },
+          "rpc_session_model_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:message:send", async (request) => {
+      const requestStart = process.hrtime.bigint();
+      try {
+        const { sessionId, prompt } = request.params;
+        logger.info(
+          {
+            requestId: request.requestId,
+            sessionId,
+            promptBlocks: prompt.length
+          },
+          "rpc_message_send"
+        );
+        logger.debug(
+          {
+            requestId: request.requestId,
+            sessionId,
+            promptBlocks: prompt.length
+          },
+          "rpc_message_send_start"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record) {
+          throw new Error("Session not found");
+        }
+        sessionManager.touchSession(sessionId);
+        const result = await record.connection.prompt(
+          sessionId,
+          prompt
+        );
+        sessionManager.touchSession(sessionId);
+        this.sendRpcResponse(request.requestId, {
+          stopReason: result.stopReason
+        });
+        const durationMs = Number(process.hrtime.bigint() - requestStart) / 1e6;
+        logger.info(
+          {
+            requestId: request.requestId,
+            sessionId,
+            stopReason: result.stopReason,
+            durationMs
+          },
+          "rpc_message_send_complete"
+        );
+        logger.debug(
+          {
+            requestId: request.requestId,
+            sessionId,
+            durationMs
+          },
+          "rpc_message_send_finish"
+        );
+      } catch (error) {
+        const durationMs = Number(process.hrtime.bigint() - requestStart) / 1e6;
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId,
+            promptBlocks: request.params.prompt.length,
+            durationMs
+          },
+          "rpc_message_send_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:permission:decision", async (request) => {
+      try {
+        const { sessionId, requestId, outcome } = request.params;
+        logger.info(
+          { requestId: request.requestId, sessionId, outcome },
+          "rpc_permission_decision"
+        );
+        sessionManager.resolvePermissionRequest(sessionId, requestId, outcome);
+        this.sendRpcResponse(request.requestId, { ok: true });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId,
+            permissionRequestId: request.params.requestId,
+            outcome: request.params.outcome
+          },
+          "rpc_permission_decision_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:fs:roots", async (request) => {
+      try {
+        logger.debug(
+          { requestId: request.requestId, sessionId: request.params.sessionId },
+          "rpc_fs_roots"
+        );
+        const record = sessionManager.getSession(request.params.sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const root = {
+          name: SESSION_ROOT_NAME,
+          path: record.cwd
+        };
+        this.sendRpcResponse(request.requestId, { root });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_fs_roots_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:hostfs:roots", async (request) => {
+      try {
+        logger.debug(
+          {
+            requestId: request.requestId,
+            machineId: request.params.machineId
+          },
+          "rpc_hostfs_roots"
+        );
+        const result = await buildHostFsRoots();
+        this.sendRpcResponse(request.requestId, result);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            machineId: request.params.machineId
+          },
+          "rpc_hostfs_roots_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:hostfs:entries", async (request) => {
+      try {
+        const { path: requestPath, machineId } = request.params;
+        logger.debug(
+          { requestId: request.requestId, machineId, path: requestPath },
+          "rpc_hostfs_entries"
+        );
+        const entries = await readDirectoryEntries(requestPath);
+        this.sendRpcResponse(request.requestId, {
+          path: requestPath,
+          entries: filterVisibleEntries(entries)
+        });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            machineId: request.params.machineId
+          },
+          "rpc_hostfs_entries_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:fs:entries", async (request) => {
+      try {
+        const { sessionId, path: requestPath } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId, path: requestPath },
+          "rpc_fs_entries"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const resolved = requestPath ? path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath) : record.cwd;
+        const entries = await readDirectoryEntries(resolved);
+        this.sendRpcResponse(request.requestId, { path: resolved, entries });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_fs_entries_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:fs:file", async (request) => {
+      try {
+        const { sessionId, path: requestPath } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId, path: requestPath },
+          "rpc_fs_file"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const resolved = path4.isAbsolute(requestPath) ? requestPath : path4.join(record.cwd, requestPath);
+        const mimeType = resolveImageMimeType(resolved);
+        if (mimeType) {
+          const buffer = await fs3.readFile(resolved);
+          const preview2 = {
+            path: resolved,
+            previewType: "image",
+            content: `data:${mimeType};base64,${buffer.toString("base64")}`,
+            mimeType
+          };
+          this.sendRpcResponse(request.requestId, preview2);
+          return;
+        }
+        const content = await fs3.readFile(resolved, "utf8");
+        const preview = {
+          path: resolved,
+          previewType: "code",
+          content
+        };
+        this.sendRpcResponse(request.requestId, preview);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_fs_file_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:fs:resources", async (request) => {
+      try {
+        const { sessionId } = request.params;
+        logger.debug(
+          { requestId: request.requestId, sessionId },
+          "rpc_fs_resources"
+        );
+        const record = sessionManager.getSession(sessionId);
+        if (!record || !record.cwd) {
+          throw new Error("Session not found or no working directory");
+        }
+        const entries = await this.listSessionResources(record.cwd);
+        this.sendRpcResponse(request.requestId, {
+          rootPath: record.cwd,
+          entries
+        });
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_fs_resources_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:sessions:discover", async (request) => {
+      try {
+        const { cwd, backendId } = request.params;
+        logger.info(
+          { requestId: request.requestId, cwd, backendId },
+          "rpc_sessions_discover"
+        );
+        const result = await sessionManager.discoverSessions({
+          cwd,
+          backendId
+        });
+        this.sendRpcResponse(request.requestId, result);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId
+          },
+          "rpc_sessions_discover_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:session:load", async (request) => {
+      try {
+        const { sessionId, cwd } = request.params;
+        logger.info(
+          { requestId: request.requestId, sessionId, cwd },
+          "rpc_session_load"
+        );
+        const session = await sessionManager.loadSession(sessionId, cwd);
+        this.sendRpcResponse(request.requestId, session);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_session_load_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+    this.socket.on("rpc:session:resume", async (request) => {
+      try {
+        const { sessionId, cwd } = request.params;
+        logger.info(
+          { requestId: request.requestId, sessionId, cwd },
+          "rpc_session_resume"
+        );
+        const session = await sessionManager.resumeSession(sessionId, cwd);
+        this.sendRpcResponse(request.requestId, session);
+      } catch (error) {
+        logger.error(
+          {
+            err: error,
+            requestId: request.requestId,
+            sessionId: request.params.sessionId
+          },
+          "rpc_session_resume_error"
+        );
+        this.sendRpcError(request.requestId, error);
+      }
+    });
+  }
+  setupSessionManagerListeners() {
+    const { sessionManager } = this.options;
+    sessionManager.onSessionUpdate((notification) => {
+      if (this.connected) {
+        this.socket.emit(
+          "session:update",
+          notification
+        );
+      }
+    });
+    sessionManager.onSessionError((payload) => {
+      if (this.connected) {
+        this.socket.emit("session:error", payload);
+      }
+    });
+    sessionManager.onPermissionRequest((payload) => {
+      if (this.connected) {
+        this.socket.emit("permission:request", payload);
+      }
+    });
+    sessionManager.onPermissionResult((payload) => {
+      if (this.connected) {
+        this.socket.emit("permission:result", payload);
+      }
+    });
+    sessionManager.onTerminalOutput((event) => {
+      if (this.connected) {
+        this.socket.emit("terminal:output", event);
+      }
+    });
+    sessionManager.onSessionsChanged((payload) => {
+      if (this.connected) {
+        logger.info(
+          {
+            added: payload.added.length,
+            updated: payload.updated.length,
+            removed: payload.removed.length
+          },
+          "sessions_changed_emit"
+        );
+        this.socket.emit("sessions:changed", payload);
+      }
+    });
+  }
+  async listSessionResources(rootPath) {
+    const ig = await loadGitignore(rootPath);
+    const allFiles = await this.listAllFiles(rootPath, ig, rootPath, []);
+    return allFiles.map((filePath) => ({
+      name: path4.basename(filePath),
+      relativePath: path4.relative(rootPath, filePath),
+      path: filePath
+    }));
+  }
+  async listAllFiles(rootPath, ig, baseDir, collected = []) {
+    if (collected.length >= MAX_RESOURCE_FILES) {
+      return collected;
+    }
+    const entries = await fs3.readdir(rootPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (collected.length >= MAX_RESOURCE_FILES) {
+        break;
+      }
+      const entryPath = path4.join(rootPath, entry.name);
+      const relativePath = path4.relative(baseDir, entryPath);
+      const checkPath = entry.isDirectory() ? `${relativePath}/` : relativePath;
+      if (ig.ignores(checkPath)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await this.listAllFiles(entryPath, ig, baseDir, collected);
+      } else if (entry.isFile()) {
+        collected.push(entryPath);
+      }
+    }
+    return collected;
+  }
+  sendRpcResponse(requestId, result) {
+    const response = { requestId, result };
+    this.socket.emit("rpc:response", response);
+    logger.debug({ requestId }, "rpc_response_sent");
+  }
+  sendRpcError(requestId, error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    const detail = error instanceof Error ? error.stack : void 0;
+    logger.error(
+      {
+        requestId,
+        err: error,
+        message,
+        detail
+      },
+      "rpc_response_error_sent"
+    );
+    const response = {
+      requestId,
+      error: {
+        code: "INTERNAL_ERROR",
+        message,
+        retryable: true,
+        scope: "request",
+        detail
+      }
+    };
+    this.socket.emit("rpc:response", response);
+  }
+  register() {
+    const { config, sessionManager } = this.options;
+    logger.info({ machineId: config.machineId }, "cli_register_emit");
+    this.socket.emit("cli:register", {
+      machineId: config.machineId,
+      hostname: config.hostname,
+      version: config.clientVersion,
+      backends: config.acpBackends.map((backend) => ({
+        backendId: backend.id,
+        backendLabel: backend.label
+      })),
+      defaultBackendId: config.defaultAcpBackendId
+    });
+    logger.info({ machineId: config.machineId }, "cli_register_sessions_list");
+    this.socket.emit("sessions:list", sessionManager.listSessions());
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.connected) {
+        this.socket.emit("cli:heartbeat");
+        this.socket.emit(
+          "sessions:list",
+          this.options.sessionManager.listSessions()
+        );
+      }
+    }, 3e4);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = void 0;
+    }
+  }
+  connect() {
+    this.socket.connect();
+  }
+  disconnect() {
+    this.stopHeartbeat();
+    this.socket.disconnect();
+  }
+  isConnected() {
+    return this.connected;
+  }
+};
+
+// src/daemon/daemon.ts
+var DaemonManager = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async ensureHomeDirectory() {
+    await fs4.mkdir(this.config.homePath, { recursive: true });
+    await fs4.mkdir(this.config.logPath, { recursive: true });
+  }
+  async getPid() {
+    try {
+      const content = await fs4.readFile(this.config.pidFile, "utf8");
+      const pid = Number.parseInt(content.trim(), 10);
+      if (Number.isNaN(pid)) {
+        return null;
+      }
+      try {
+        process.kill(pid, 0);
+        return pid;
+      } catch {
+        await this.removePidFile();
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+  async writePidFile(pid) {
+    await fs4.writeFile(this.config.pidFile, String(pid), "utf8");
+  }
+  async removePidFile() {
+    try {
+      await fs4.unlink(this.config.pidFile);
+    } catch {
+    }
+  }
+  async status() {
+    const pid = await this.getPid();
+    if (!pid) {
+      return { running: false };
+    }
+    return { running: true, pid };
+  }
+  async start(options) {
+    const existingPid = await this.getPid();
+    if (existingPid) {
+      logger.info({ pid: existingPid }, "daemon_already_running");
+      return;
+    }
+    await this.ensureHomeDirectory();
+    if (options?.foreground) {
+      await this.runForeground();
+    } else {
+      await this.spawnBackground();
+    }
+  }
+  async stop() {
+    const pid = await this.getPid();
+    if (!pid) {
+      logger.info("daemon_not_running");
+      return;
+    }
+    try {
+      process.kill(pid, 0);
+    } catch {
+      logger.warn("daemon_pid_missing_cleanup");
+      await this.removePidFile();
+      return;
+    }
+    try {
+      logger.info({ pid }, "daemon_stop_sigterm");
+      process.kill(pid, "SIGTERM");
+      const startTime = Date.now();
+      const timeout = 5e3;
+      while (Date.now() - startTime < timeout) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        try {
+          process.kill(pid, 0);
+        } catch {
+          logger.info({ pid }, "daemon_stopped_gracefully");
+          await this.removePidFile();
+          return;
+        }
+      }
+      logger.warn({ pid }, "daemon_force_kill_start");
+      try {
+        process.kill(pid, "SIGKILL");
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        logger.warn({ pid }, "daemon_force_kill_complete");
+      } catch {
+        logger.info({ pid }, "daemon_already_stopped");
+      }
+      await this.removePidFile();
+    } catch (error) {
+      logger.error({ err: error }, "daemon_stop_error");
+      await this.removePidFile();
+    }
+  }
+  async spawnBackground() {
+    const logFile = path5.join(
+      this.config.logPath,
+      `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-daemon.log`
+    );
+    const args = process.argv.slice(1).filter((arg) => arg !== "--foreground" && arg !== "-f");
+    args.push("--foreground");
+    const child = spawn2(process.argv[0], args, {
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        MOBVIBE_GATEWAY_URL: this.config.gatewayUrl
+      }
+    });
+    if (!child.pid) {
+      logger.error("daemon_spawn_failed");
+      throw new Error("Failed to spawn daemon process");
+    }
+    const logStream = await fs4.open(logFile, "a");
+    const fileHandle = logStream;
+    child.stdout?.on("data", (data) => {
+      fileHandle.write(`[stdout] ${data.toString()}`).catch(() => {
+      });
+    });
+    child.stderr?.on("data", (data) => {
+      fileHandle.write(`[stderr] ${data.toString()}`).catch(() => {
+      });
+    });
+    child.on("exit", (code, signal) => {
+      fileHandle.write(`[exit] Process exited with code ${code}, signal ${signal}
+`).catch(() => {
+      });
+      fileHandle.close().catch(() => {
+      });
+    });
+    child.unref();
+    logger.info({ pid: child.pid }, "daemon_started");
+    console.log(`Logs: ${logFile}`);
+    logger.info({ logFile }, "daemon_log_path");
+  }
+  async runForeground() {
+    const pid = process.pid;
+    await this.writePidFile(pid);
+    logger.info({ pid }, "daemon_starting");
+    logger.info({ gatewayUrl: this.config.gatewayUrl }, "daemon_gateway_url");
+    logger.info({ machineId: this.config.machineId }, "daemon_machine_id");
+    const apiKey = await getApiKey();
+    if (!apiKey) {
+      logger.error("daemon_api_key_missing");
+      console.error(
+        `[mobvibe-cli] No API key found. Run 'mobvibe login' to authenticate.`
+      );
+      logger.warn("daemon_exit_missing_api_key");
+      process.exit(1);
+    }
+    logger.info("daemon_api_key_loaded");
+    const sessionManager = new SessionManager(this.config);
+    const socketClient = new SocketClient({
+      config: this.config,
+      sessionManager,
+      apiKey
+    });
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+      if (shuttingDown) {
+        logger.warn({ signal }, "daemon_shutdown_already_running");
+        return;
+      }
+      shuttingDown = true;
+      logger.info({ signal }, "daemon_shutdown_start");
+      try {
+        socketClient.disconnect();
+        await sessionManager.closeAll();
+        await this.removePidFile();
+        logger.info({ signal }, "daemon_shutdown_complete");
+      } catch (error) {
+        logger.error({ err: error, signal }, "daemon_shutdown_error");
+      }
+    };
+    process.on("SIGINT", () => {
+      shutdown("SIGINT").catch((error) => {
+        logger.error({ err: error }, "daemon_shutdown_sigint_error");
+      });
+    });
+    process.on("SIGTERM", () => {
+      shutdown("SIGTERM").catch((error) => {
+        logger.error({ err: error }, "daemon_shutdown_sigterm_error");
+      });
+    });
+    socketClient.connect();
+    await new Promise(() => {
+    });
+  }
+  async logs(options) {
+    const files = await fs4.readdir(this.config.logPath);
+    const logFiles = files.filter((f) => f.endsWith("-daemon.log")).sort().reverse();
+    if (logFiles.length === 0) {
+      logger.warn("daemon_logs_empty");
+      console.log("No log files found");
+      return;
+    }
+    const latestLog = path5.join(this.config.logPath, logFiles[0]);
+    logger.info({ logFile: latestLog }, "daemon_logs_latest");
+    console.log(`Log file: ${latestLog}
+`);
+    if (options?.follow) {
+      const tail = spawn2("tail", ["-f", latestLog], {
+        stdio: "inherit"
+      });
+      await new Promise((resolve) => {
+        tail.on("close", () => resolve());
+      });
+    } else {
+      const content = await fs4.readFile(latestLog, "utf8");
+      const lines = content.split("\n");
+      const count = options?.lines ?? 50;
+      console.log(lines.slice(-count).join("\n"));
+    }
+  }
+};
+
+// src/index.ts
+var program = new Command();
+program.name("mobvibe").description("Mobvibe CLI - Connect local ACP backends to the gateway").version("0.0.0");
+program.command("start").description("Start the mobvibe daemon").option("--gateway <url>", "Gateway URL", process.env.MOBVIBE_GATEWAY_URL).option("--foreground", "Run in foreground instead of detaching").action(async (options) => {
+  if (options.gateway) {
+    process.env.MOBVIBE_GATEWAY_URL = options.gateway;
+  }
+  const config = await getCliConfig();
+  const daemon = new DaemonManager(config);
+  await daemon.start({ foreground: options.foreground });
+});
+program.command("stop").description("Stop the mobvibe daemon").action(async () => {
+  const config = await getCliConfig();
+  const daemon = new DaemonManager(config);
+  await daemon.stop();
+});
+program.command("status").description("Show daemon status").action(async () => {
+  const config = await getCliConfig();
+  const daemon = new DaemonManager(config);
+  const status = await daemon.status();
+  if (status.running) {
+    logger.info({ pid: status.pid }, "daemon_status_running");
+    console.log(`Daemon is running (PID ${status.pid})`);
+    if (status.connected !== void 0) {
+      console.log(`Connected to gateway: ${status.connected ? "yes" : "no"}`);
+    }
+    if (status.sessionCount !== void 0) {
+      console.log(`Active sessions: ${status.sessionCount}`);
+    }
+  } else {
+    logger.info("daemon_status_not_running");
+    console.log("Daemon is not running");
+  }
+});
+program.command("logs").description("Show daemon logs").option("-f, --follow", "Follow log output").option("-n, --lines <number>", "Number of lines to show", "50").action(async (options) => {
+  const config = await getCliConfig();
+  const daemon = new DaemonManager(config);
+  await daemon.logs({
+    follow: options.follow,
+    lines: Number.parseInt(options.lines, 10)
+  });
+});
+program.command("login").description("Authenticate with an API key from the WebUI").action(async () => {
+  const result = await login();
+  if (!result.success) {
+    logger.error({ err: result.error }, "login_failed");
+    console.error(`Login failed: ${result.error}`);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Remove stored credentials").action(async () => {
+  await logout();
+});
+program.command("auth-status").description("Show authentication status").action(async () => {
+  await loginStatus();
+});
+async function run() {
+  await program.parseAsync(process.argv);
+}
+run().catch((error) => {
+  logger.error({ err: error }, "cli_run_error");
+  console.error("Error:", error.message);
+  process.exit(1);
+});
+export {
+  run
+};
+//# sourceMappingURL=index.js.map