sessix-server 0.2.9 → 0.3.1

package/dist/index.js

@@ -24,9 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_node_os7 = require("os");
-var import_node_fs3 = require("fs");
-var import_node_path6 = require("path");
+var import_node_os8 = require("os");
+var import_node_fs4 = require("fs");
+var import_node_path7 = require("path");
+var import_node_child_process9 = require("child_process");
 
 // src/i18n/locales/zh.ts
 var zh = {
@@ -51,6 +52,9 @@ var zh = {
     tokenRegenerated: "\u{1F511} Token \u5DF2\u91CD\u7F6E\uFF0C\u6240\u6709\u5BA2\u6237\u7AEF\u5DF2\u65AD\u5F00\uFF0C\u8BF7\u91CD\u65B0\u626B\u7801\u914D\u5BF9",
     tokenRegenerateFailed: "Token \u91CD\u7F6E\u5931\u8D25:",
     updateAvailable: "\u53D1\u73B0\u65B0\u7248\u672C v{{latest}}\uFF08\u5F53\u524D v{{current}}\uFF09\uFF0C\u8FD0\u884C\u4EE5\u4E0B\u547D\u4EE4\u66F4\u65B0\uFF1A",
+    autoUpdating: "\u53D1\u73B0\u65B0\u7248\u672C v{{latest}}\uFF08\u5F53\u524D v{{current}}\uFF09\uFF0C\u6B63\u5728\u81EA\u52A8\u66F4\u65B0...",
+    autoUpdateFailed: "\u81EA\u52A8\u66F4\u65B0\u5931\u8D25\uFF0C\u7EE7\u7EED\u4F7F\u7528\u5F53\u524D\u7248\u672C",
+    skipUpdateCheck: "\u8DF3\u8FC7\u7248\u672C\u68C0\u67E5\uFF08SESSIX_NO_UPDATE_CHECK=1\uFF09",
     receivedSignal: "\u6536\u5230 {{signal}}\uFF0C\u6B63\u5728\u4F18\u96C5\u5173\u95ED...",
     goodbye: "\u6240\u6709\u670D\u52A1\u5DF2\u5173\u95ED\uFF0C\u518D\u89C1\uFF01",
     shutdownError: "\u5173\u95ED\u8FC7\u7A0B\u51FA\u9519:",
@@ -161,6 +165,9 @@ var en = {
     tokenRegenerated: "\u{1F511} Token regenerated, all clients disconnected. Scan QR to re-pair",
     tokenRegenerateFailed: "Token regeneration failed:",
     updateAvailable: "New version v{{latest}} available (current v{{current}}). Update with:",
+    autoUpdating: "New version v{{latest}} available (current v{{current}}), auto-updating...",
+    autoUpdateFailed: "Auto-update failed, continuing with current version",
+    skipUpdateCheck: "Skipping update check (SESSIX_NO_UPDATE_CHECK=1)",
     receivedSignal: "Received {{signal}}, graceful shutdown...",
     goodbye: "All services closed, goodbye!",
     shutdownError: "Shutdown error:",
@@ -295,11 +302,11 @@ function t(key, params) {
 }
 
 // src/server.ts
-var import_uuid5 = require("uuid");
+var import_uuid6 = require("uuid");
 var import_promises4 = require("fs/promises");
-var import_node_os6 = require("os");
-var import_node_path5 = require("path");
-var import_node_child_process6 = require("child_process");
+var import_node_os7 = require("os");
+var import_node_path6 = require("path");
+var import_node_child_process8 = require("child_process");
 var import_node_util = require("util");
 
 // src/providers/ProcessProvider.ts
@@ -319,14 +326,14 @@ var import_node_os = require("os");
 var import_node_child_process = require("child_process");
 var isWindows = process.platform === "win32";
 function killProcessCrossPlatform(proc, timeoutMs = 3e3) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (proc.exitCode !== null || proc.signalCode !== null) {
-      resolve();
+      resolve2();
       return;
     }
     const onExit = () => {
       clearTimeout(timer);
-      resolve();
+      resolve2();
     };
     proc.once("exit", onExit);
     if (isWindows) {
@@ -342,7 +349,7 @@ function killProcessCrossPlatform(proc, timeoutMs = 3e3) {
           proc.kill("SIGKILL");
         }
       }
-      resolve();
+      resolve2();
     }, timeoutMs);
   });
 }
@@ -644,7 +651,9 @@ var ProcessProvider = class {
         const event = result.value;
         if (event.type === "assistant") {
           for (const block of event.message.content) {
-            if (block.type === "tool_use" && block.name === "AskUserQuestion") {
+            if (block.type === "tool_use") {
+              const isQuestion = block.name === "AskUserQuestion" || block.name === "AskFollowupQuestion";
+              if (!isQuestion) continue;
               const input = block.input;
               const question = input.question ?? "";
               if (!question) continue;
@@ -656,6 +665,7 @@ var ProcessProvider = class {
               }
               if (sessionSet.has(prevKey)) continue;
               sessionSet.add(prevKey);
+              console.log(`[ProcessProvider] Session ${sessionId}: detected ${block.name} (toolUseId=${block.id})`);
               this.emitter.emit(this.getQuestionEventName(sessionId), {
                 toolUseId: block.id,
                 question,
@@ -771,7 +781,7 @@ var ProcessProvider = class {
     const prompt = `You are an AI coding assistant. Based on the following Claude Code conversation context, suggest the most valuable next instruction for the user (give the instruction directly, no explanation, no quotes):
 
 ${context}`;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const env = { ...process.env };
       delete env.CLAUDECODE;
       const proc = (0, import_child_process.spawn)(CLAUDE_PATH, ["-p", prompt, "--output-format", "text"], {
@@ -786,7 +796,7 @@ ${context}`;
       });
       proc.once("exit", (code) => {
         if (code === 0) {
-          resolve(output.trim());
+          resolve2(output.trim());
         } else {
           reject(new Error(`generateSuggestion process exit code: ${code}`));
         }
@@ -813,10 +823,10 @@ ${context}`;
       tool_use_id: toolUseId,
       content: answer
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       entry.process.stdin.write(toolResult + "\n", (err) => {
         if (err) reject(err);
-        else resolve();
+        else resolve2();
       });
     });
     console.log(`[ProcessProvider] Session ${sessionId}: AskUserQuestion answered (toolUseId=${toolUseId})`);
@@ -847,11 +857,643 @@ ${context}`;
   }
 };
 
-// src/session/SessionManager.ts
+// src/providers/CodexProvider.ts
+var import_child_process2 = require("child_process");
+var import_readline2 = require("readline");
+var import_events2 = require("events");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
 var import_uuid2 = require("uuid");
+
+// src/utils/codexPath.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_node_os3 = require("os");
+function findCodexPath() {
+  try {
+    const cmd = isWindows ? "where codex" : "which codex";
+    return (0, import_node_child_process3.execSync)(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
+  } catch {
+  }
+  const candidates = isWindows ? [
+    (0, import_node_path2.join)(process.env.LOCALAPPDATA ?? "", "Programs", "codex", "codex.exe"),
+    (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".codex", "local", "codex.exe")
+  ] : [
+    "/opt/homebrew/bin/codex",
+    "/usr/local/bin/codex",
+    (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".local", "bin", "codex")
+  ];
+  for (const candidate of candidates) {
+    try {
+      (0, import_node_fs2.accessSync)(candidate, import_node_fs2.constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return "codex";
+}
+function resolveCodexJsEntry(codexPath) {
+  try {
+    let realPath;
+    try {
+      realPath = (0, import_node_fs2.readlinkSync)(codexPath);
+      if (!realPath.startsWith("/")) {
+        realPath = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(codexPath), realPath);
+      }
+    } catch {
+      realPath = codexPath;
+    }
+    const head = (0, import_node_fs2.readFileSync)(realPath, { encoding: "utf-8", flag: "r" }).slice(0, 100);
+    if (head.startsWith("#!/usr/bin/env node") || head.startsWith("#!/usr/bin/node")) {
+      return realPath;
+    }
+  } catch {
+  }
+  return void 0;
+}
+var CODEX_PATH = findCodexPath();
+var CODEX_JS_ENTRY = resolveCodexJsEntry(CODEX_PATH);
+async function getCodexVersion() {
+  try {
+    const cmd = CODEX_JS_ENTRY ? `"${process.execPath}" "${CODEX_JS_ENTRY}" --version` : `"${CODEX_PATH}" --version`;
+    const output = (0, import_node_child_process3.execSync)(cmd, {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    return output.replace(/^codex-cli\s+/, "");
+  } catch {
+    return void 0;
+  }
+}
+function isCodexAvailable() {
+  if (CODEX_JS_ENTRY) {
+    try {
+      (0, import_node_fs2.accessSync)(CODEX_JS_ENTRY, import_node_fs2.constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    (0, import_node_fs2.accessSync)(CODEX_PATH, import_node_fs2.constants.X_OK);
+    return true;
+  } catch {
+    try {
+      (0, import_node_child_process3.execSync)(`"${CODEX_PATH}" --version`, { timeout: 5e3 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/providers/CodexProvider.ts
+var SESSIX_DIR = (0, import_path.join)((0, import_os.homedir)(), ".sessix");
+var CODEX_SESSIONS_FILE = (0, import_path.join)(SESSIX_DIR, "codex-sessions.json");
+var CodexProvider = class {
+  activeSessions = /* @__PURE__ */ new Map();
+  emitter = new import_events2.EventEmitter();
+  /** 持久化的会话元数据（sessionId → metadata） */
+  persistedSessions = /* @__PURE__ */ new Map();
+  /** 自增 ID 计数器，用于生成 ClaudeStreamEvent 中的 message/block ID */
+  idCounter = 0;
+  constructor() {
+    this.loadPersistedSessions();
+  }
+  async startSession(opts) {
+    const { projectPath, message, sessionId: existingSessionId } = opts;
+    const sessionId = existingSessionId ?? (0, import_uuid2.v4)();
+    if (this.activeSessions.has(sessionId)) {
+      await this.killSession(sessionId);
+    }
+    const projectId = projectPath.split("/").filter(Boolean).pop() ?? "unknown";
+    const session = {
+      id: sessionId,
+      projectId,
+      projectPath,
+      status: "running",
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      summary: message.slice(0, 80),
+      agentType: "codex"
+    };
+    const resume = opts.resume ?? !!existingSessionId;
+    let resumeThreadId;
+    if (resume && existingSessionId) {
+      const persisted = this.persistedSessions.get(existingSessionId);
+      if (persisted?.threadId) {
+        resumeThreadId = persisted.threadId;
+        console.log(`[CodexProvider] Resuming session ${sessionId} with threadId: ${resumeThreadId}`);
+      } else {
+        console.warn(`[CodexProvider] Session ${sessionId} resume requested but no persisted threadId found, creating new session`);
+      }
+    }
+    const proc = this.spawnCodexProcess(projectPath, message, resumeThreadId, opts.model);
+    session.pid = proc.pid;
+    this.activeSessions.set(sessionId, {
+      session,
+      process: proc,
+      threadId: resumeThreadId,
+      turnStartTime: Date.now()
+    });
+    const initEvent = {
+      type: "system",
+      subtype: "init",
+      session_id: sessionId
+    };
+    this.emitter.emit(this.getEventName(sessionId), initEvent);
+    proc.on("error", (err) => {
+      console.error(`[CodexProvider] Session ${sessionId} process error:`, err.message);
+      this.activeSessions.delete(sessionId);
+      this.emitError(sessionId, `Process spawn failed: ${err.message}`);
+    });
+    this.attachStdoutListener(sessionId, proc);
+    this.attachStderrListener(sessionId, proc);
+    this.attachExitListener(sessionId, proc);
+    return session;
+  }
+  async killSession(sessionId) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) return;
+    if (entry.process.exitCode === null && entry.process.signalCode === null) {
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      await killProcessCrossPlatform(entry.process);
+    }
+    this.activeSessions.delete(sessionId);
+  }
+  async sendMessage(sessionId, message) {
+    let entry = this.activeSessions.get(sessionId);
+    if (!entry) {
+      const persisted = this.persistedSessions.get(sessionId);
+      if (!persisted?.threadId) {
+        throw new Error(`Session ${sessionId} not found or already ended`);
+      }
+      const projectId = persisted.projectPath.split("/").filter(Boolean).pop() ?? "unknown";
+      const session = {
+        id: sessionId,
+        projectId,
+        projectPath: persisted.projectPath,
+        status: "running",
+        createdAt: persisted.createdAt,
+        lastActiveAt: Date.now(),
+        summary: persisted.summary,
+        agentType: "codex"
+      };
+      const placeholderProc = (0, import_child_process2.spawn)("true", [], { stdio: "ignore" });
+      entry = {
+        session,
+        process: placeholderProc,
+        threadId: persisted.threadId,
+        turnStartTime: Date.now()
+      };
+      this.activeSessions.set(sessionId, entry);
+    }
+    const procAlive = entry.process.exitCode === null && entry.process.signalCode === null;
+    if (procAlive) {
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      await killProcessCrossPlatform(entry.process);
+    }
+    const threadId = entry.threadId ?? this.persistedSessions.get(sessionId)?.threadId;
+    if (!threadId) {
+      console.warn(`[CodexProvider] Session ${sessionId} has no thread ID, falling back to new thread`);
+    }
+    const proc = this.spawnCodexProcess(entry.session.projectPath, message, threadId ?? void 0);
+    entry.session.status = "running";
+    entry.session.lastActiveAt = Date.now();
+    entry.session.pid = proc.pid;
+    entry.process = proc;
+    entry.turnStartTime = Date.now();
+    proc.on("error", (err) => {
+      console.error(`[CodexProvider] Session ${sessionId} sendMessage process error:`, err.message);
+      this.activeSessions.delete(sessionId);
+      this.emitError(sessionId, `Failed to send message: ${err.message}`);
+    });
+    this.attachStdoutListener(sessionId, proc);
+    this.attachStderrListener(sessionId, proc);
+    this.attachExitListener(sessionId, proc);
+  }
+  onEvent(sessionId, callback) {
+    const eventName = this.getEventName(sessionId);
+    this.emitter.on(eventName, callback);
+    return () => {
+      this.emitter.off(eventName, callback);
+    };
+  }
+  getActiveSessions() {
+    return Array.from(this.activeSessions.values()).map((e) => e.session);
+  }
+  async generateSuggestion(_context) {
+    return "";
+  }
+  async answerQuestion(_sessionId, _toolUseId, _answer) {
+  }
+  onQuestion(_sessionId, _callback) {
+    return () => {
+    };
+  }
+  // ============================================
+  // 私有方法
+  // ============================================
+  nextId() {
+    return `codex_${++this.idCounter}`;
+  }
+  /**
+   * 启动 codex CLI 进程
+   *
+   * @param projectPath 工作目录
+   * @param message 用户消息
+   * @param resumeThreadId 如果提供，则使用 `codex exec resume` 恢复会话
+   */
+  spawnCodexProcess(projectPath, message, resumeThreadId, model) {
+    const args = ["exec", "--json", "--full-auto"];
+    if (model) {
+      args.push("-m", model);
+    }
+    args.push("-C", projectPath);
+    if (resumeThreadId) {
+      args.push("resume", resumeThreadId);
+    }
+    args.push(message);
+    const env = { ...process.env };
+    let cmd;
+    let spawnArgs;
+    if (CODEX_JS_ENTRY) {
+      cmd = process.execPath;
+      spawnArgs = [CODEX_JS_ENTRY, ...args];
+      console.log(`[CodexProvider] Spawning via node: ${cmd} ${CODEX_JS_ENTRY} ${args.join(" ")}`);
+    } else {
+      cmd = CODEX_PATH;
+      spawnArgs = args;
+      console.log(`[CodexProvider] Spawning: ${CODEX_PATH} ${args.join(" ")}`);
+    }
+    const proc = (0, import_child_process2.spawn)(cmd, spawnArgs, {
+      cwd: projectPath,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    try {
+      proc.stdin?.end();
+    } catch {
+    }
+    return proc;
+  }
+  /**
+   * 挂载 stdout 监听器，逐行解析 Codex NDJSON 并转换为 ClaudeStreamEvent
+   */
+  attachStdoutListener(sessionId, proc) {
+    if (!proc.stdout) return;
+    const rl = (0, import_readline2.createInterface)({ input: proc.stdout, crlfDelay: Infinity });
+    const entry = this.activeSessions.get(sessionId);
+    if (entry) entry.rl = rl;
+    rl.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      console.log(`[CodexProvider] Session ${sessionId} stdout: ${trimmed.substring(0, 200)}`);
+      let event;
+      try {
+        event = JSON.parse(trimmed);
+      } catch {
+        console.warn(`[CodexProvider] Session ${sessionId}: failed to parse: ${trimmed.substring(0, 100)}`);
+        return;
+      }
+      this.handleCodexEvent(sessionId, event);
+    });
+  }
+  /**
+   * 处理单个 Codex NDJSON 事件，转换并发射 ClaudeStreamEvent
+   */
+  handleCodexEvent(sessionId, event) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) return;
+    entry.session.lastActiveAt = Date.now();
+    switch (event.type) {
+      case "thread.started": {
+        if (event.thread_id) {
+          entry.threadId = event.thread_id;
+          this.persistSession(sessionId, {
+            threadId: event.thread_id,
+            projectPath: entry.session.projectPath,
+            summary: entry.session.summary,
+            createdAt: entry.session.createdAt,
+            lastActiveAt: Date.now()
+          });
+          console.log(`[CodexProvider] Session ${sessionId} threadId persisted: ${event.thread_id}`);
+        }
+        break;
+      }
+      case "turn.started": {
+        entry.session.status = "running";
+        entry.turnStartTime = Date.now();
+        break;
+      }
+      case "item.completed": {
+        if (!event.item) break;
+        this.handleItemCompleted(sessionId, event.item);
+        break;
+      }
+      case "turn.completed": {
+        entry.session.status = "idle";
+        const duration = entry.turnStartTime ? Date.now() - entry.turnStartTime : 0;
+        const resultEvent = {
+          type: "result",
+          subtype: "success",
+          session_id: sessionId,
+          is_error: false,
+          result: "",
+          duration_ms: duration,
+          num_turns: 1,
+          usage: event.usage
+        };
+        this.emitter.emit(this.getEventName(sessionId), resultEvent);
+        break;
+      }
+      case "turn.failed": {
+        entry.session.status = "error";
+        const failEvent = {
+          type: "result",
+          subtype: "error",
+          session_id: sessionId,
+          is_error: true,
+          result: event.error ?? "Turn failed",
+          duration_ms: entry.turnStartTime ? Date.now() - entry.turnStartTime : 0,
+          num_turns: 1
+        };
+        this.emitter.emit(this.getEventName(sessionId), failEvent);
+        break;
+      }
+    }
+  }
+  /**
+   * 处理 item.completed 事件，按 item.type 转换为对应的 ClaudeStreamEvent
+   */
+  handleItemCompleted(sessionId, item) {
+    switch (item.type) {
+      case "agent_message": {
+        const msgEvent = {
+          type: "assistant",
+          session_id: sessionId,
+          message: {
+            id: item.id || this.nextId(),
+            model: "codex",
+            role: "assistant",
+            content: [{ type: "text", text: item.text ?? "" }]
+          }
+        };
+        this.emitter.emit(this.getEventName(sessionId), msgEvent);
+        break;
+      }
+      case "command_execution": {
+        const toolUseId = item.id || this.nextId();
+        const toolEvent = {
+          type: "assistant",
+          session_id: sessionId,
+          message: {
+            id: this.nextId(),
+            model: "codex",
+            role: "assistant",
+            content: [{
+              type: "tool_use",
+              id: toolUseId,
+              name: "Bash",
+              input: { command: item.command ?? "" }
+            }]
+          }
+        };
+        this.emitter.emit(this.getEventName(sessionId), toolEvent);
+        const resultContent = item.aggregated_output ?? "";
+        const isError = item.exit_code != null && item.exit_code !== 0;
+        const toolResultEvent = {
+          type: "user",
+          session_id: sessionId,
+          message: {
+            role: "user",
+            content: [{
+              type: "tool_result",
+              tool_use_id: toolUseId,
+              content: resultContent,
+              is_error: isError
+            }]
+          }
+        };
+        this.emitter.emit(this.getEventName(sessionId), toolResultEvent);
+        break;
+      }
+      case "file_change": {
+        const editToolUseId = item.id || this.nextId();
+        const toolEvent = {
+          type: "assistant",
+          session_id: sessionId,
+          message: {
+            id: this.nextId(),
+            model: "codex",
+            role: "assistant",
+            content: [{
+              type: "tool_use",
+              id: editToolUseId,
+              name: "Edit",
+              input: { file_path: item.file_path ?? "", diff: item.diff ?? "" }
+            }]
+          }
+        };
+        this.emitter.emit(this.getEventName(sessionId), toolEvent);
+        const toolResultEvent = {
+          type: "user",
+          session_id: sessionId,
+          message: {
+            role: "user",
+            content: [{
+              type: "tool_result",
+              tool_use_id: editToolUseId,
+              content: `File edited: ${item.file_path ?? "unknown"}`
+            }]
+          }
+        };
+        this.emitter.emit(this.getEventName(sessionId), toolResultEvent);
+        break;
+      }
+      case "reasoning": {
+        const thinkEvent = {
+          type: "assistant",
+          session_id: sessionId,
+          message: {
+            id: item.id || this.nextId(),
+            model: "codex",
+            role: "assistant",
+            content: [{ type: "thinking", thinking: item.text ?? "" }]
+          }
+        };
+        this.emitter.emit(this.getEventName(sessionId), thinkEvent);
+        break;
+      }
+    }
+  }
+  attachStderrListener(sessionId, proc) {
+    if (!proc.stderr) return;
+    proc.stderr.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        console.error(`[CodexProvider] Session ${sessionId} stderr: ${text}`);
+      }
+    });
+  }
+  attachExitListener(sessionId, proc) {
+    proc.once("exit", (code, signal) => {
+      const entry = this.activeSessions.get(sessionId);
+      if (!entry) return;
+      if (entry.process !== proc) return;
+      console.log(`[CodexProvider] Session ${sessionId} process exited: code=${code} signal=${signal} threadId=${entry.threadId ?? "NONE"}`);
+      if (entry.rl) {
+        entry.rl.close();
+        entry.rl = void 0;
+      }
+      entry.session.pid = void 0;
+      entry.session.lastActiveAt = Date.now();
+      const alreadyHasResult = entry.session.status === "idle" || entry.session.status === "error";
+      if (alreadyHasResult) return;
+      const isNormal = isNormalExit(code, signal);
+      entry.session.status = isNormal ? "idle" : "error";
+      if (!isNormal) {
+        console.error(`[CodexProvider] Session ${sessionId}: process exited abnormally code=${code} signal=${signal}`);
+      }
+      const syntheticResult = {
+        type: "result",
+        subtype: isNormal ? "success" : "error",
+        session_id: sessionId,
+        is_error: !isNormal,
+        result: isNormal ? "" : `Process exited code=${code} signal=${signal}`,
+        duration_ms: 0,
+        num_turns: 0
+      };
+      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    });
+  }
+  emitError(sessionId, message) {
+    const event = {
+      type: "result",
+      subtype: "error",
+      result: message,
+      session_id: sessionId,
+      duration_ms: 0,
+      is_error: true,
+      num_turns: 0
+    };
+    this.emitter.emit(this.getEventName(sessionId), event);
+  }
+  getEventName(sessionId) {
+    return `claude:${sessionId}`;
+  }
+  // ============================================
+  // 持久化方法
+  // ============================================
+  /**
+   * 从磁盘加载持久化的 Codex 会话元数据
+   */
+  loadPersistedSessions() {
+    try {
+      if (!(0, import_fs.existsSync)(CODEX_SESSIONS_FILE)) return;
+      const data = JSON.parse((0, import_fs.readFileSync)(CODEX_SESSIONS_FILE, "utf-8"));
+      for (const [sessionId, meta] of Object.entries(data)) {
+        this.persistedSessions.set(sessionId, meta);
+      }
+      console.log(`[CodexProvider] Loaded ${this.persistedSessions.size} persisted sessions`);
+    } catch (err) {
+      console.warn("[CodexProvider] Failed to load persisted sessions:", err);
+    }
+  }
+  /**
+   * 持久化单个会话的元数据到磁盘
+   */
+  persistSession(sessionId, meta) {
+    this.persistedSessions.set(sessionId, meta);
+    this.flushPersistedSessions();
+  }
+  /**
+   * 将所有持久化数据写入磁盘
+   */
+  flushPersistedSessions() {
+    try {
+      if (!(0, import_fs.existsSync)(SESSIX_DIR)) {
+        (0, import_fs.mkdirSync)(SESSIX_DIR, { recursive: true });
+      }
+      const data = {};
+      for (const [sessionId, meta] of this.persistedSessions) {
+        data[sessionId] = meta;
+      }
+      (0, import_fs.writeFileSync)(CODEX_SESSIONS_FILE, JSON.stringify(data, null, 2), "utf-8");
+    } catch (err) {
+      console.error("[CodexProvider] Failed to persist sessions:", err);
+    }
+  }
+  /**
+   * 检查某个 sessionId 是否为已知的 Codex 会话（供 SessionManager 查询 agentType）
+   */
+  isKnownSession(sessionId) {
+    return this.activeSessions.has(sessionId) || this.persistedSessions.has(sessionId);
+  }
+};
+
+// src/providers/ProviderFactory.ts
+var import_node_child_process4 = require("child_process");
+var ProviderFactory = class {
+  providers = /* @__PURE__ */ new Map();
+  getProvider(agentType) {
+    const existing = this.providers.get(agentType);
+    if (existing) return existing;
+    let provider;
+    switch (agentType) {
+      case "codex":
+        provider = new CodexProvider();
+        break;
+      case "claude-code":
+      default:
+        provider = new ProcessProvider();
+        break;
+    }
+    this.providers.set(agentType, provider);
+    return provider;
+  }
+  async detectAgents() {
+    const agents = [];
+    try {
+      const claudePath = findClaudePath();
+      const claudeVersion = (0, import_node_child_process4.execSync)(`"${claudePath}" --version`, {
+        encoding: "utf-8",
+        timeout: 5e3
+      }).trim();
+      agents.push({
+        type: "claude-code",
+        name: "Claude Code",
+        available: true,
+        version: claudeVersion
+      });
+    } catch {
+      agents.push({ type: "claude-code", name: "Claude Code", available: false });
+    }
+    if (isCodexAvailable()) {
+      const version = await getCodexVersion();
+      agents.push({ type: "codex", name: "Codex", available: true, version });
+    } else {
+      agents.push({ type: "codex", name: "Codex", available: false });
+    }
+    return agents;
+  }
+};
+
+// src/session/SessionManager.ts
+var import_uuid3 = require("uuid");
 var BUFFER_MAX = 5e3;
 var SessionManager = class {
   provider;
+  providerFactory;
+  sessionAgentType = /* @__PURE__ */ new Map();
   /** 事件回调列表（事件会被转发到 WsBridge） */
   eventCallbacks = [];
   /** 每个会话的事件流取消订阅函数 */
@@ -877,8 +1519,26 @@ var SessionManager = class {
   bufferTruncated = /* @__PURE__ */ new Set();
   /** sessionId → projectPath 映射，用于截断时从 JSONL 补全历史 */
   sessionProjectPaths = /* @__PURE__ */ new Map();
-  constructor(provider) {
-    this.provider = provider;
+  constructor(providerOrFactory) {
+    if (providerOrFactory instanceof ProviderFactory) {
+      this.providerFactory = providerOrFactory;
+      this.provider = providerOrFactory.getProvider("claude-code");
+    } else {
+      this.provider = providerOrFactory;
+      this.providerFactory = null;
+    }
+  }
+  getProviderForSession(sessionId) {
+    if (!this.providerFactory) return this.provider;
+    let agentType = this.sessionAgentType.get(sessionId);
+    if (!agentType) {
+      const codexProvider = this.providerFactory.getProvider("codex");
+      if (codexProvider instanceof CodexProvider && codexProvider.isKnownSession(sessionId)) {
+        agentType = "codex";
+        this.sessionAgentType.set(sessionId, agentType);
+      }
+    }
+    return this.providerFactory.getProvider(agentType ?? "claude-code");
   }
   // ============================================
   // 公开 API
@@ -889,8 +1549,9 @@ var SessionManager = class {
    * 调用 provider.startSession()，订阅事件流，
    * 将 ClaudeStreamEvent 包装为 ServerEvent 转发。
    */
-  async createSession(projectPath, message, resumeSessionId, newSessionId, model, permissionMode, effort, images) {
-    const session = await this.provider.startSession({
+  async createSession(projectPath, message, resumeSessionId, newSessionId, model, permissionMode, effort, images, agentType = "claude-code") {
+    const provider = this.providerFactory ? this.providerFactory.getProvider(agentType) : this.provider;
+    const session = await provider.startSession({
       projectPath,
       message,
       sessionId: resumeSessionId ?? newSessionId,
@@ -900,6 +1561,7 @@ var SessionManager = class {
       effort,
       images
     });
+    this.sessionAgentType.set(session.id, agentType);
     this.lastBroadcastStatus.set(session.id, session.status);
     this.sessionProjectPaths.set(session.id, projectPath);
     this.unsubscribeSession(session.id);
@@ -911,7 +1573,8 @@ var SessionManager = class {
    * 发送消息到已有会话
    */
   async sendMessage(sessionId, message, permissionMode, images) {
-    await this.provider.sendMessage(sessionId, message, permissionMode, images);
+    const provider = this.getProviderForSession(sessionId);
+    await provider.sendMessage(sessionId, message, permissionMode, images);
     this.updateSessionStatus(sessionId, "running");
     console.log(`[SessionManager] Message sent to session: ${sessionId}`);
   }
@@ -931,7 +1594,9 @@ var SessionManager = class {
       clearTimeout(pending.timer);
       this.pendingAssistantEvents.delete(sessionId);
     }
-    await this.provider.killSession(sessionId);
+    const provider = this.getProviderForSession(sessionId);
+    await provider.killSession(sessionId);
+    this.sessionAgentType.delete(sessionId);
     console.log(`[SessionManager] Session killed: ${sessionId}`);
   }
   /**
@@ -1010,7 +1675,11 @@ var SessionManager = class {
    * 获取所有活跃会话（含服务器端统计）
    */
   getActiveSessions() {
-    return this.provider.getActiveSessions().map((session) => {
+    const rawSessions = this.providerFactory ? [
+      ...this.providerFactory.getProvider("claude-code").getActiveSessions(),
+      ...this.providerFactory.getProvider("codex").getActiveSessions()
+    ] : this.provider.getActiveSessions();
+    return rawSessions.map((session) => {
       const stats = this.getSessionStats(session.id);
       return stats ? { ...session, stats } : session;
     });
@@ -1040,6 +1709,7 @@ var SessionManager = class {
     this.sessionEventBuffers.clear();
     this.bufferTruncated.clear();
     this.sessionProjectPaths.clear();
+    this.sessionAgentType.clear();
     this.sessionStats.clear();
     for (const [, pending] of this.pendingAssistantEvents) {
       clearTimeout(pending.timer);
@@ -1057,10 +1727,11 @@ var SessionManager = class {
    * 订阅指定会话的事件流（包括 AskUserQuestion 问题事件）
    */
   subscribeToSession(sessionId) {
-    const unsubscribeEvent = this.provider.onEvent(sessionId, (event) => {
+    const provider = this.getProviderForSession(sessionId);
+    const unsubscribeEvent = provider.onEvent(sessionId, (event) => {
       this.handleClaudeEvent(sessionId, event);
     });
-    const unsubscribeQuestion = this.provider.onQuestion(
+    const unsubscribeQuestion = provider.onQuestion(
       sessionId,
       ({ toolUseId, question, options }) => {
         this.handleAskUserQuestion(sessionId, toolUseId, question, options);
@@ -1235,7 +1906,7 @@ var SessionManager = class {
       console.log(`[SessionManager] Session ${sessionId}: AskUserQuestion updated (requestId=${existingRequestId})`);
       return;
     }
-    const requestId = (0, import_uuid2.v4)();
+    const requestId = (0, import_uuid3.v4)();
     const request = {
       id: requestId,
       sessionId,
@@ -1246,12 +1917,13 @@ var SessionManager = class {
     };
     this.updateSessionStatus(sessionId, "waiting_question");
     this.emit({ type: "question_request", request });
-    const answerPromise = new Promise((resolve) => {
-      this.pendingQuestions.set(requestId, { sessionId, toolUseId, question, options, createdAt: request.createdAt, resolve });
+    const answerPromise = new Promise((resolve2) => {
+      this.pendingQuestions.set(requestId, { sessionId, toolUseId, question, options, createdAt: request.createdAt, resolve: resolve2 });
     });
     answerPromise.then(async (answer) => {
       try {
-        await this.provider.answerQuestion(sessionId, toolUseId, answer);
+        const provider = this.getProviderForSession(sessionId);
+        await provider.answerQuestion(sessionId, toolUseId, answer);
       } catch (err) {
         console.error(`[SessionManager] answerQuestion failed (${sessionId}):`, err);
       }
@@ -1488,11 +2160,11 @@ var WsBridge = class _WsBridge {
    * 使用此方法代替 new WsBridge()，确保 EADDRINUSE 等错误能被调用方的 try-catch 捕获。
    */
   static async create(options) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const bridge = new _WsBridge(options);
       bridge.wss.once("listening", () => {
         bridge.wss.on("error", (err) => console.error(`[WsBridge] ${t("ws.serverError")}:`, err));
-        resolve(bridge);
+        resolve2(bridge);
       });
       bridge.wss.once("error", reject);
     });
@@ -1555,7 +2227,7 @@ var WsBridge = class _WsBridge {
   }
   /** 优雅关闭 WebSocket 服务 */
   close() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (this.heartbeatTimer) {
         clearInterval(this.heartbeatTimer);
         this.heartbeatTimer = null;
@@ -1568,7 +2240,7 @@ var WsBridge = class _WsBridge {
           reject(err);
         } else {
           console.log("[WsBridge] WebSocket server closed");
-          resolve();
+          resolve2();
         }
       });
     });
@@ -1674,15 +2346,15 @@ var WsBridge = class _WsBridge {
 
 // src/approval/ApprovalProxy.ts
 var import_node_http = __toESM(require("http"));
-var import_node_fs2 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
-var import_node_os3 = __toESM(require("os"));
-var import_uuid3 = require("uuid");
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+var import_node_os4 = __toESM(require("os"));
+var import_uuid4 = require("uuid");
 var ApprovalProxy = class _ApprovalProxy {
   server;
   token;
   port;
-  settingsPath = import_node_path2.default.join(import_node_os3.default.homedir(), ".claude", "settings.json");
+  settingsPath = import_node_path3.default.join(import_node_os4.default.homedir(), ".claude", "settings.json");
   /** 待处理的审批请求：requestId -> { resolve, timer, request } */
   pendingApprovals = /* @__PURE__ */ new Map();
   /** 审批请求回调（通知外部推送到手机） */
@@ -1708,11 +2380,11 @@ var ApprovalProxy = class _ApprovalProxy {
    * 异步工厂方法：等待端口监听成功后 resolve，端口占用等错误时 reject。
    */
   static async create(options) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const proxy = new _ApprovalProxy(options);
       proxy.server.once("listening", () => {
         proxy.server.on("error", (err) => console.error(`[ApprovalProxy] ${t("approval.serverError")}:`, err));
-        resolve(proxy);
+        resolve2(proxy);
       });
       proxy.server.once("error", reject);
     });
@@ -1787,7 +2459,7 @@ var ApprovalProxy = class _ApprovalProxy {
   isToolInClaudeSettings(toolName, projectPath) {
     const checkPath = (filepath) => {
       try {
-        const raw = import_node_fs2.default.readFileSync(filepath, "utf-8");
+        const raw = import_node_fs3.default.readFileSync(filepath, "utf-8");
         const settings = JSON.parse(raw);
         const allow = settings?.permissions?.allow ?? [];
         return allow.some((entry) => {
@@ -1801,24 +2473,24 @@ var ApprovalProxy = class _ApprovalProxy {
       }
     };
     if (projectPath) {
-      const projectSettingsPath = import_node_path2.default.join(projectPath, ".claude", "settings.json");
+      const projectSettingsPath = import_node_path3.default.join(projectPath, ".claude", "settings.json");
       if (checkPath(projectSettingsPath)) return true;
     }
     return checkPath(this.settingsPath);
   }
   /** 将工具写入 settings.json permissions.allow（项目级或全局） */
   addToClaudeSettings(projectPath, toolName) {
-    const targetPath = projectPath ? import_node_path2.default.join(projectPath, ".claude", "settings.json") : this.settingsPath;
+    const targetPath = projectPath ? import_node_path3.default.join(projectPath, ".claude", "settings.json") : this.settingsPath;
     try {
       if (projectPath) {
-        const dir = import_node_path2.default.dirname(targetPath);
-        if (!import_node_fs2.default.existsSync(dir)) {
-          import_node_fs2.default.mkdirSync(dir, { recursive: true });
+        const dir = import_node_path3.default.dirname(targetPath);
+        if (!import_node_fs3.default.existsSync(dir)) {
+          import_node_fs3.default.mkdirSync(dir, { recursive: true });
         }
       }
       let settings = {};
       try {
-        settings = JSON.parse(import_node_fs2.default.readFileSync(targetPath, "utf-8"));
+        settings = JSON.parse(import_node_fs3.default.readFileSync(targetPath, "utf-8"));
       } catch {
       }
       if (!settings.permissions) {
@@ -1832,7 +2504,7 @@ var ApprovalProxy = class _ApprovalProxy {
       const entry = `${toolName}(*)`;
       if (!allow.includes(entry)) {
         allow.push(entry);
-        import_node_fs2.default.writeFileSync(targetPath, JSON.stringify(settings, null, 2), "utf-8");
+        import_node_fs3.default.writeFileSync(targetPath, JSON.stringify(settings, null, 2), "utf-8");
         const label = projectPath ? `${projectPath}/.claude/settings.json` : "~/.claude/settings.json";
         console.log(`[ApprovalProxy] ${t("approval.alwaysAllowWritten", { entry, label })}`);
       }
@@ -1869,7 +2541,7 @@ var ApprovalProxy = class _ApprovalProxy {
   }
   /** 优雅关闭 HTTP 服务 */
   close() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const pendingEntries = Array.from(this.pendingApprovals.entries());
       for (const [, pending] of pendingEntries) {
         clearTimeout(pending.timer);
@@ -1881,7 +2553,7 @@ var ApprovalProxy = class _ApprovalProxy {
           reject(err);
         } else {
           console.log(`[ApprovalProxy] ${t("approval.httpClosed")}`);
-          resolve();
+          resolve2();
         }
       });
     });
@@ -1927,7 +2599,7 @@ var ApprovalProxy = class _ApprovalProxy {
     try {
       const body = await this.parseJsonBody(req);
       const payload = body.payload ?? body;
-      const requestId = (0, import_uuid3.v4)();
+      const requestId = (0, import_uuid4.v4)();
       const projectPath = String(body.projectPath ?? "unknown");
       const toolName = String(payload.tool_name ?? body.tool_name ?? "unknown");
       const toolInput = payload.tool_input ?? body.tool_input ?? {};
@@ -1952,13 +2624,13 @@ var ApprovalProxy = class _ApprovalProxy {
         return;
       }
       this.notifyApprovalRequest(approvalRequest);
-      const decision = await new Promise((resolve) => {
+      const decision = await new Promise((resolve2) => {
         const timer = setTimeout(() => {
           console.log(`[ApprovalProxy] ${t("approval.timeout", { id: requestId })}`);
           this.pendingApprovals.delete(requestId);
-          resolve({ decision: "allow" });
+          resolve2({ decision: "allow" });
         }, 325e3);
-        this.pendingApprovals.set(requestId, { resolve, timer, request: approvalRequest });
+        this.pendingApprovals.set(requestId, { resolve: resolve2, timer, request: approvalRequest });
       });
       this.sendJson(res, 200, decision);
     } catch (err) {
@@ -2019,7 +2691,7 @@ var ApprovalProxy = class _ApprovalProxy {
   /** 手动解析请求的 JSON body（限制最大 1MB 防止滥用） */
   parseJsonBody(req) {
     const MAX_BODY_SIZE = 1024 * 1024;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const chunks = [];
       let totalSize = 0;
       let destroyed = false;
@@ -2037,7 +2709,7 @@ var ApprovalProxy = class _ApprovalProxy {
         try {
           const raw = Buffer.concat(chunks).toString("utf-8");
           const parsed = JSON.parse(raw);
-          resolve(parsed);
+          resolve2(parsed);
         } catch {
           reject(new Error(t("approval.invalidJson")));
         }
@@ -2059,8 +2731,8 @@ var ApprovalProxy = class _ApprovalProxy {
 };
 
 // src/mdns/MdnsService.ts
-var import_node_child_process3 = require("child_process");
-var import_node_os4 = require("os");
+var import_node_child_process5 = require("child_process");
+var import_node_os5 = require("os");
 function buildTxtArgs(txt) {
   return Object.entries(txt).map(([k, v]) => `${k}=${v}`);
 }
@@ -2078,7 +2750,7 @@ var MdnsService = class {
     this.httpPort = options.httpPort;
     this.version = options.version ?? "0.1.0";
     this.pairing = options.pairing ?? "closed";
-    this.useDnsSd = (0, import_node_os4.platform)() === "darwin";
+    this.useDnsSd = (0, import_node_os5.platform)() === "darwin";
   }
   getTxt() {
     return {
@@ -2111,7 +2783,7 @@ var MdnsService = class {
       String(this.wsPort),
       ...buildTxtArgs(this.getTxt())
     ];
-    this.proc = (0, import_node_child_process3.spawn)("dns-sd", args, { stdio: "ignore" });
+    this.proc = (0, import_node_child_process5.spawn)("dns-sd", args, { stdio: "ignore" });
     this.proc.on("error", (err) => {
       console.warn(`[MdnsService] dns-sd failed, falling back to bonjour-service: ${err.message}`);
       this.proc = null;
@@ -2132,7 +2804,7 @@ var MdnsService = class {
       return;
     }
     try {
-      const { default: Bonjour } = await import("bonjour-service");
+      const { Bonjour } = await import("bonjour-service");
       const { networkInterfaces: networkInterfaces2 } = await import("os");
       const lanAddrs = getLanAddresses(networkInterfaces2);
       const opts = lanAddrs.length > 0 ? { interface: lanAddrs[0] } : {};
@@ -2223,12 +2895,12 @@ function getLanAddresses(networkInterfacesFn) {
 
 // src/hooks/HookInstaller.ts
 var import_promises2 = require("fs/promises");
-var import_node_path3 = require("path");
-var import_node_os5 = require("os");
-var SESSIX_HOOKS_DIR = (0, import_node_path3.join)((0, import_node_os5.homedir)(), ".sessix", "hooks");
-var HOOK_SCRIPT_PATH = (0, import_node_path3.join)(SESSIX_HOOKS_DIR, "approval-hook.js");
-var PERMISSION_ACCEPT_PATH = (0, import_node_path3.join)(SESSIX_HOOKS_DIR, "permission-accept.js");
-var CLAUDE_SETTINGS_PATH = (0, import_node_path3.join)((0, import_node_os5.homedir)(), ".claude", "settings.json");
+var import_node_path4 = require("path");
+var import_node_os6 = require("os");
+var SESSIX_HOOKS_DIR = (0, import_node_path4.join)((0, import_node_os6.homedir)(), ".sessix", "hooks");
+var HOOK_SCRIPT_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "approval-hook.js");
+var PERMISSION_ACCEPT_PATH = (0, import_node_path4.join)(SESSIX_HOOKS_DIR, "permission-accept.js");
+var CLAUDE_SETTINGS_PATH = (0, import_node_path4.join)((0, import_node_os6.homedir)(), ".claude", "settings.json");
 var HOOK_COMMAND = "node ~/.sessix/hooks/approval-hook.js";
 var PERMISSION_ACCEPT_COMMAND = "node ~/.sessix/hooks/permission-accept.js";
 var LEGACY_HOOK_COMMANDS = [
@@ -2402,7 +3074,7 @@ var HookInstaller = class {
    * 写入 Claude Code settings.json
    */
   async writeClaudeSettings(settings) {
-    await (0, import_promises2.mkdir)((0, import_node_path3.join)((0, import_node_os5.homedir)(), ".claude"), { recursive: true });
+    await (0, import_promises2.mkdir)((0, import_node_path4.join)((0, import_node_os6.homedir)(), ".claude"), { recursive: true });
     await (0, import_promises2.writeFile)(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
   }
   /**
@@ -2429,7 +3101,7 @@ var HookInstaller = class {
 };
 
 // src/notification/NotificationService.ts
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 var NotificationService = class {
   constructor(sessionManager, expoChannel = null) {
     this.sessionManager = sessionManager;
@@ -2525,7 +3197,7 @@ var NotificationService = class {
     const dangerLevel = this.getDangerLevel(request.toolName);
     const isDangerous = dangerLevel === "danger" || dangerLevel === "write";
     const categoryId = isDangerous ? "APPROVAL_DANGEROUS" : "APPROVAL_NORMAL";
-    const projectName = (0, import_node_path4.basename)(
+    const projectName = (0, import_node_path5.basename)(
       this.sessionManager.getActiveSessions().find((s) => s.id === request.sessionId)?.projectPath ?? ""
     );
     const pushTitle = isDangerous ? `\u26A0\uFE0F ${title}` : title;
@@ -2581,7 +3253,7 @@ var NotificationService = class {
   /** 从审批请求中提取操作目标的简短描述 */
   extractTarget(request) {
     const input = request.toolInput;
-    if (input.file_path) return (0, import_node_path4.basename)(String(input.file_path));
+    if (input.file_path) return (0, import_node_path5.basename)(String(input.file_path));
     if (input.command) return String(input.command).slice(0, 40);
     return request.description.slice(0, 40);
   }
@@ -2684,7 +3356,7 @@ var NotificationService = class {
   getSessionTitle(sessionId) {
     const session = this.sessionManager.getActiveSessions().find((s) => s.id === sessionId);
     if (!session) return "Unknown";
-    return session.summary ?? (0, import_node_path4.basename)(session.projectPath);
+    return session.summary ?? (0, import_node_path5.basename)(session.projectPath);
   }
   /** 获取会话的 YOLO 模式状态 */
   getYoloMode(sessionId) {
@@ -2693,7 +3365,7 @@ var NotificationService = class {
 };
 
 // src/notification/DesktopNotificationChannel.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process6 = require("child_process");
 var DesktopNotificationChannel = class {
   isAvailable() {
     return process.platform === "darwin";
@@ -2704,12 +3376,12 @@ var DesktopNotificationChannel = class {
     const body = payload.body.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
     const sound = payload.sound ?? "Ping";
     const script = `display notification "${body}" with title "${title}" sound name "${sound}"`;
-    return new Promise((resolve) => {
-      (0, import_node_child_process4.execFile)("osascript", ["-e", script], (err) => {
+    return new Promise((resolve2) => {
+      (0, import_node_child_process6.execFile)("osascript", ["-e", script], (err) => {
         if (err) {
           console.warn("[DesktopNotificationChannel] Send notification failed:", err.message);
         }
-        resolve();
+        resolve2();
       });
     });
   }
@@ -2909,7 +3581,7 @@ var ActivityPushChannel = class {
     const topic = "com.kachun.sessix.push-type.liveactivity";
     const jwt = this.getJWT();
     const payloadStr = JSON.stringify(payload);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let client;
       try {
         client = this.getHttp2Client();
@@ -2937,7 +3609,7 @@ var ActivityPushChannel = class {
       });
       req.on("end", () => {
         if (statusCode === 200) {
-          resolve();
+          resolve2();
         } else {
           if (statusCode === 0) {
             this.http2Client?.destroy();
@@ -2979,12 +3651,12 @@ var ActivityPushChannel = class {
 
 // src/session/ProjectReader.ts
 var import_promises3 = require("fs/promises");
-var import_readline2 = require("readline");
-var import_path = require("path");
-var import_os = require("os");
-var CLAUDE_PROJECTS_DIR = (0, import_path.join)((0, import_os.homedir)(), ".claude", "projects");
+var import_readline3 = require("readline");
+var import_path2 = require("path");
+var import_os2 = require("os");
+var CLAUDE_PROJECTS_DIR = (0, import_path2.join)((0, import_os2.homedir)(), ".claude", "projects");
 function getSessionFilePath(projectPath, sessionId) {
-  return (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodeDirName(projectPath), `${sessionId}.jsonl`);
+  return (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodeDirName(projectPath), `${sessionId}.jsonl`);
 }
 async function getProjects() {
   try {
@@ -3001,7 +3673,7 @@ async function getProjects() {
       const encodedPath = entry.name;
       const decodedPath = decodeDirName(encodedPath);
       const name = decodedPath.split("/").filter(Boolean).pop() ?? encodedPath;
-      const projectDir = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath);
+      const projectDir = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodedPath);
       const { count: sessionCount, latestMtime } = await countJsonlFilesWithMtime(projectDir);
       projects.push({
         id: encodedPath,
@@ -3023,7 +3695,7 @@ async function getProjects() {
 async function getHistoricalSessions(projectPath) {
   try {
     const encodedPath = encodeDirName(projectPath);
-    const projectDir = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath);
+    const projectDir = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodedPath);
     const dirExists = await directoryExists(projectDir);
     if (!dirExists) {
       return { ok: true, value: [] };
@@ -3034,7 +3706,7 @@ async function getHistoricalSessions(projectPath) {
     await Promise.all(
       jsonlFiles.map(async (entry) => {
         const sessionId = entry.name.slice(0, -6);
-        const filePath = (0, import_path.join)(projectDir, entry.name);
+        const filePath = (0, import_path2.join)(projectDir, entry.name);
         try {
           const contentTs = await extractLastTimestamp(filePath);
           if (contentTs) {
@@ -3053,13 +3725,13 @@ async function getHistoricalSessions(projectPath) {
     );
     for (const entry of uuidDirs) {
       try {
-        const fileStat = await (0, import_promises3.stat)((0, import_path.join)(projectDir, entry.name));
+        const fileStat = await (0, import_promises3.stat)((0, import_path2.join)(projectDir, entry.name));
         mtimeMap.set(entry.name, fileStat.mtimeMs);
       } catch {
         mtimeMap.set(entry.name, 0);
       }
     }
-    const indexPath = (0, import_path.join)(projectDir, "sessions-index.json");
+    const indexPath = (0, import_path2.join)(projectDir, "sessions-index.json");
     const sessionMap = /* @__PURE__ */ new Map();
     try {
       const indexContent = await (0, import_promises3.readFile)(indexPath, "utf-8");
@@ -3077,7 +3749,7 @@ async function getHistoricalSessions(projectPath) {
         }
         await Promise.all(
           Array.from(sessionMap.values()).filter((s) => (s.messageCount ?? 0) > 0 && !s.summary && !s.firstPrompt).map(async (s) => {
-            const filePath = (0, import_path.join)(projectDir, `${s.sessionId}.jsonl`);
+            const filePath = (0, import_path2.join)(projectDir, `${s.sessionId}.jsonl`);
             const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
             if (firstPrompt) s.firstPrompt = firstPrompt;
           })
@@ -3091,7 +3763,7 @@ async function getHistoricalSessions(projectPath) {
         if (uuidDirSet.has(sessionId)) {
           sessionMap.set(sessionId, { sessionId, lastModified: mtime, messageCount: -1 });
         } else {
-          const filePath = (0, import_path.join)(projectDir, `${sessionId}.jsonl`);
+          const filePath = (0, import_path2.join)(projectDir, `${sessionId}.jsonl`);
           const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
           sessionMap.set(sessionId, { sessionId, lastModified: mtime, firstPrompt });
         }
@@ -3115,7 +3787,7 @@ async function getHistoricalSessions(projectPath) {
 async function getSessionHistory(projectPath, sessionId) {
   try {
     const encodedPath = encodeDirName(projectPath);
-    const filePath = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath, `${sessionId}.jsonl`);
+    const filePath = (0, import_path2.join)(CLAUDE_PROJECTS_DIR, encodedPath, `${sessionId}.jsonl`);
     const raw = await (0, import_promises3.readFile)(filePath, "utf-8").catch((err) => {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -3228,7 +3900,7 @@ async function extractFirstPrompt(filePath) {
   let fileHandle;
   try {
     fileHandle = await (0, import_promises3.open)(filePath, "r");
-    const rl = (0, import_readline2.createInterface)({
+    const rl = (0, import_readline3.createInterface)({
       input: fileHandle.createReadStream({ encoding: "utf-8" }),
       crlfDelay: Infinity
     });
@@ -3296,15 +3968,15 @@ async function countJsonlFilesWithMtime(dirPath) {
     await Promise.all([
       ...jsonlEntries.map(async (entry) => {
         try {
-          const contentTs = await extractLastTimestamp((0, import_path.join)(dirPath, entry.name));
-          const ts = contentTs ?? (await (0, import_promises3.stat)((0, import_path.join)(dirPath, entry.name))).mtimeMs;
+          const contentTs = await extractLastTimestamp((0, import_path2.join)(dirPath, entry.name));
+          const ts = contentTs ?? (await (0, import_promises3.stat)((0, import_path2.join)(dirPath, entry.name))).mtimeMs;
           if (ts > latestMtime) latestMtime = ts;
         } catch {
         }
       }),
       ...uuidDirs.map(async (entry) => {
         try {
-          const fileStat = await (0, import_promises3.stat)((0, import_path.join)(dirPath, entry.name));
+          const fileStat = await (0, import_promises3.stat)((0, import_path2.join)(dirPath, entry.name));
           if (fileStat.mtimeMs > latestMtime) latestMtime = fileStat.mtimeMs;
         } catch {
         }
@@ -3376,14 +4048,14 @@ var PairingManager = class {
 };
 
 // src/auth/AuthManager.ts
-var import_child_process2 = require("child_process");
 var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_util = require("util");
-var import_events2 = require("events");
-var execFileAsync = (0, import_util.promisify)(import_child_process3.execFile);
+var import_events3 = require("events");
+var execFileAsync = (0, import_util.promisify)(import_child_process4.execFile);
 var CLAUDE_PATH2 = findClaudePath();
 var LOGIN_TIMEOUT_MS = 5 * 60 * 1e3;
-var AuthManager = class extends import_events2.EventEmitter {
+var AuthManager = class extends import_events3.EventEmitter {
   loginProcess = null;
   loginTimeout = null;
   urlSent = false;
@@ -3411,7 +4083,7 @@ var AuthManager = class extends import_events2.EventEmitter {
     }
     this.clearLoginTimeout();
     this.urlSent = false;
-    const proc = (0, import_child_process2.spawn)(CLAUDE_PATH2, ["auth", "login"], {
+    const proc = (0, import_child_process3.spawn)(CLAUDE_PATH2, ["auth", "login"], {
       env: { ...process.env, BROWSER: "echo" },
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -3497,8 +4169,8 @@ var AuthManager = class extends import_events2.EventEmitter {
 var import_promises5 = require("fs/promises");
 
 // src/terminal/TerminalExecutor.ts
-var import_node_child_process5 = require("child_process");
-var import_uuid4 = require("uuid");
+var import_node_child_process7 = require("child_process");
+var import_uuid5 = require("uuid");
 var EXEC_TIMEOUT_MS = 5 * 60 * 1e3;
 var TerminalExecutor = class {
   processes = /* @__PURE__ */ new Map();
@@ -3520,10 +4192,10 @@ var TerminalExecutor = class {
     }
   }
   exec(sessionId, command, cwd) {
-    const execId = (0, import_uuid4.v4)();
+    const execId = (0, import_uuid5.v4)();
     const shell = isWindows ? "powershell" : "bash";
     const args = isWindows ? ["-Command", command] : ["-c", command];
-    const proc = (0, import_node_child_process5.spawn)(shell, args, {
+    const proc = (0, import_node_child_process7.spawn)(shell, args, {
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
       env: { ...process.env }
@@ -3586,7 +4258,7 @@ var TerminalExecutor = class {
 // src/server.ts
 var WS_PORT = 3745;
 var HTTP_PORT = 3746;
-var execAsync = (0, import_node_util.promisify)(import_node_child_process6.exec);
+var execAsync = (0, import_node_util.promisify)(import_node_child_process8.exec);
 async function killPortProcess(port) {
   try {
     if (isWindows) {
@@ -3610,7 +4282,7 @@ async function killPortProcess(port) {
         await execAsync(`kill -9 ${pids.join(" ")}`);
       }
     }
-    await new Promise((resolve) => setTimeout(resolve, 600));
+    await new Promise((resolve2) => setTimeout(resolve2, 600));
   } catch {
   }
 }
@@ -3628,8 +4300,8 @@ async function createWithRetry(label, port, factory) {
   }
 }
 async function start(opts = {}) {
-  const configDir = (0, import_node_path5.join)((0, import_node_os6.homedir)(), ".sessix");
-  const tokenFile = (0, import_node_path5.join)(configDir, "token");
+  const configDir = (0, import_node_path6.join)((0, import_node_os7.homedir)(), ".sessix");
+  const tokenFile = (0, import_node_path6.join)(configDir, "token");
   let token;
   if (opts.token !== void 0) {
     token = opts.token;
@@ -3641,14 +4313,14 @@ async function start(opts = {}) {
       try {
         token = (await (0, import_promises4.readFile)(tokenFile, "utf8")).trim();
       } catch {
-        token = (0, import_uuid5.v4)();
+        token = (0, import_uuid6.v4)();
         await (0, import_promises4.mkdir)(configDir, { recursive: true });
         await (0, import_promises4.writeFile)(tokenFile, token, "utf8");
       }
     }
   }
-  const provider = new ProcessProvider();
-  const sessionManager = new SessionManager(provider);
+  const providerFactory = new ProviderFactory();
+  const sessionManager = new SessionManager(providerFactory);
   const terminalExecutor = new TerminalExecutor();
   const wsBridge = await createWithRetry(
     "WsBridge",
@@ -3688,7 +4360,7 @@ async function start(opts = {}) {
   let mdnsService = null;
   const pairingManager = new PairingManager({
     token,
-    serverName: (0, import_node_os6.hostname)(),
+    serverName: (0, import_node_os7.hostname)(),
     version: "0.2.0",
     onStateChange: (state) => mdnsService?.updatePairingState(state)
   });
@@ -3745,7 +4417,8 @@ async function start(opts = {}) {
             event.model,
             event.permissionMode,
             event.effort,
-            event.images
+            event.images,
+            event.agentType
           );
           wsBridge.broadcast({
             type: "session_list",
@@ -3921,7 +4594,7 @@ async function start(opts = {}) {
               return null;
             }).filter(Boolean).join("\n");
           }
-          const suggestion = await provider.generateSuggestion(context);
+          const suggestion = await providerFactory.getProvider("claude-code").generateSuggestion(context);
           wsBridge.send(ws, {
             type: "prompt_suggestion",
             sessionId: event.sessionId,
@@ -3999,6 +4672,11 @@ async function start(opts = {}) {
           }
           break;
         }
+        case "list_agents": {
+          const agents = await providerFactory.detectAgents();
+          wsBridge.send(ws, { type: "agent_list", agents });
+          break;
+        }
         default: {
           wsBridge.send(ws, {
             type: "error",
@@ -4162,7 +4840,7 @@ async function start(opts = {}) {
     openPairing: (duration) => pairingManager.open(duration),
     closePairing: () => pairingManager.close(),
     regenerateToken: async () => {
-      const newToken = (0, import_uuid5.v4)();
+      const newToken = (0, import_uuid6.v4)();
       await (0, import_promises4.mkdir)(configDir, { recursive: true });
       await (0, import_promises4.writeFile)(tokenFile, newToken, "utf8");
       instance.token = newToken;
@@ -4181,7 +4859,7 @@ async function start(opts = {}) {
 var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 function getPackageVersion() {
   try {
-    const pkg = JSON.parse((0, import_node_fs3.readFileSync)((0, import_node_path6.join)(__dirname, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path7.join)(__dirname, "..", "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -4203,11 +4881,38 @@ async function fetchLatestVersion() {
     return null;
   }
 }
+function isNewer(latest, current) {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+}
+async function autoUpdateIfNeeded() {
+  if (process.env.SESSIX_NO_UPDATE_CHECK === "1" || process.env.__SESSIX_UPDATED === "1") return;
+  const latest = await fetchLatestVersion();
+  if (!latest || !isNewer(latest, PKG_VERSION)) return;
+  console.log(`  \u{1F4E6} ${t("startup.autoUpdating", { current: PKG_VERSION, latest })}`);
+  console.log();
+  try {
+    (0, import_node_child_process9.execFileSync)("npx", [`sessix-server@${latest}`], {
+      stdio: "inherit",
+      env: { ...process.env, __SESSIX_UPDATED: "1" }
+    });
+    process.exit(0);
+  } catch {
+    console.log(`  \u26A0\uFE0F  ${t("startup.autoUpdateFailed")}`);
+    console.log();
+  }
+}
 async function main() {
   console.log("=".repeat(50));
   console.log(`${t("startup.banner")}  v${PKG_VERSION}`);
   console.log("=".repeat(50));
   console.log();
+  await autoUpdateIfNeeded();
   const enableAutoConnect = process.env.SESSIX_AUTO_CONNECT !== "false";
   const server = await start({ enableAutoConnect });
   const localIp = getLocalIp();
@@ -4248,13 +4953,6 @@ async function main() {
   console.log(t("startup.pairingOpen"));
   console.log(t("startup.pressT"));
   console.log();
-  fetchLatestVersion().then((latest) => {
-    if (!latest || latest === PKG_VERSION) return;
-    console.log();
-    console.log(`  \u{1F4E6} ${t("startup.updateAvailable", { current: PKG_VERSION, latest })}`);
-    console.log(`     npx sessix-server@latest`);
-    console.log();
-  });
   const shutdown = async (signal) => {
     console.log(`
 [Main] ${t("startup.receivedSignal", { signal })}`);
@@ -4305,7 +5003,7 @@ ${t("startup.pairingReopened")}`);
   }
 }
 function getLocalIp() {
-  const interfaces = (0, import_node_os7.networkInterfaces)();
+  const interfaces = (0, import_node_os8.networkInterfaces)();
   for (const iface of Object.values(interfaces)) {
     for (const addr of iface ?? []) {
       if (addr.family === "IPv4" && !addr.internal) {