sessix-server 0.1.0

package/dist/server.js

@@ -0,0 +1,3054 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  start: () => start
+});
+module.exports = __toCommonJS(server_exports);
+var import_uuid4 = require("uuid");
+var import_promises4 = require("fs/promises");
+var import_node_os4 = require("os");
+var import_node_path4 = require("path");
+var import_node_child_process2 = require("child_process");
+var import_node_util = require("util");
+
+// src/providers/ProcessProvider.ts
+var import_child_process = require("child_process");
+var import_readline = require("readline");
+var import_events = require("events");
+var import_node_os = require("os");
+var import_uuid = require("uuid");
+function findClaudePath() {
+  try {
+    return (0, import_child_process.execSync)("which claude", { encoding: "utf-8" }).trim();
+  } catch {
+    const candidates = [
+      `${process.env.HOME}/.local/bin/claude`,
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude"
+    ];
+    for (const candidate of candidates) {
+      try {
+        (0, import_child_process.execSync)(`test -x "${candidate}"`);
+        return candidate;
+      } catch {
+      }
+    }
+    return "claude";
+  }
+}
+var CLAUDE_PATH = findClaudePath();
+var ProcessProvider = class {
+  /** 活跃会话映射表：sessionId -> { session, process } */
+  activeSessions = /* @__PURE__ */ new Map();
+  /** 事件发射器，用于分发 Claude 事件流 */
+  emitter = new import_events.EventEmitter();
+  /** 已发射的 AskUserQuestion toolUseId 集合（避免 partial message 重复触发） */
+  emittedQuestionToolUseIds = /* @__PURE__ */ new Set();
+  /**
+   * 启动新会话或恢复已有会话
+   *
+   * 会 spawn 一个 `claude` CLI 进程，设置工作目录和环境变量，
+   * 并开始监听 stdout 的 NDJSON 输出。
+   */
+  async startSession(opts) {
+    const { projectPath, message, sessionId: existingSessionId, model, permissionMode, effort, images } = opts;
+    const sessionId = existingSessionId ?? (0, import_uuid.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)
+    };
+    const resume = opts.resume ?? !!existingSessionId;
+    const proc = this.spawnClaudeProcess(sessionId, projectPath, resume, model, permissionMode, effort);
+    this.writeUserMessage(proc, message, sessionId, images);
+    session.pid = proc.pid;
+    this.activeSessions.set(sessionId, { session, process: proc, model, permissionMode, effort });
+    proc.on("error", (err) => {
+      console.error(`[ProcessProvider] \u4F1A\u8BDD ${sessionId} \u8FDB\u7A0B\u9519\u8BEF:`, err.message);
+      this.activeSessions.delete(sessionId);
+      const syntheticResult = {
+        type: "result",
+        subtype: "error",
+        result: `\u8FDB\u7A0B\u542F\u52A8\u5931\u8D25: ${err.message}`,
+        session_id: sessionId,
+        duration_ms: 0,
+        is_error: true,
+        num_turns: 0
+      };
+      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    });
+    this.attachStdoutListener(sessionId, proc);
+    this.attachStderrListener(sessionId, proc);
+    this.attachExitListener(sessionId, proc);
+    return session;
+  }
+  /**
+   * 终止指定会话
+   *
+   * kill 进程并从活跃映射中移除。
+   */
+  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 {
+      }
+      entry.process.kill("SIGTERM");
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          if (entry.process.exitCode === null && entry.process.signalCode === null) {
+            entry.process.kill("SIGKILL");
+          }
+          resolve();
+        }, 3e3);
+        entry.process.once("exit", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+    }
+    this.activeSessions.delete(sessionId);
+  }
+  /**
+   * 向已有会话发送新消息
+   *
+   * 快速路径：进程存活时直接写 stdin（毫秒级响应）。
+   * 慢速路径：进程已退出时 respawn 并 --resume。
+   */
+  async sendMessage(sessionId, message, permissionMode, images) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) {
+      throw new Error(`\u4F1A\u8BDD ${sessionId} \u4E0D\u5B58\u5728\u6216\u5DF2\u7ED3\u675F`);
+    }
+    const modeChanged = permissionMode != null && permissionMode !== (entry.permissionMode ?? "default");
+    if (!modeChanged && entry.process.exitCode === null && entry.process.signalCode === null && !entry.process.stdin?.destroyed) {
+      this.writeUserMessage(entry.process, message, sessionId, images);
+      return;
+    }
+    if (modeChanged) {
+      console.log(`[ProcessProvider] \u4F1A\u8BDD ${sessionId}: \u6743\u9650\u6A21\u5F0F\u5207\u6362 ${entry.permissionMode ?? "default"} \u2192 ${permissionMode}\uFF0Crespawn`);
+      if (entry.process.exitCode === null && entry.process.signalCode === null) {
+        try {
+          entry.process.stdin?.end();
+        } catch {
+        }
+        entry.process.kill("SIGTERM");
+      }
+    } else {
+      console.log(`[ProcessProvider] \u4F1A\u8BDD ${sessionId}: \u8FDB\u7A0B\u5DF2\u9000\u51FA\uFF0Crespawn \u91CD\u65B0\u542F\u52A8`);
+    }
+    const savedPendingQuestion = entry.pendingQuestion;
+    const newMode = permissionMode ?? entry.permissionMode;
+    const proc = this.spawnClaudeProcess(sessionId, entry.session.projectPath, true, entry.model, newMode, entry.effort);
+    this.writeUserMessage(proc, message, sessionId, images);
+    entry.session.status = "running";
+    entry.session.lastActiveAt = Date.now();
+    entry.session.pid = proc.pid;
+    entry.process = proc;
+    entry.permissionMode = newMode;
+    entry.pendingQuestion = savedPendingQuestion;
+    proc.on("error", (err) => {
+      console.error(`[ProcessProvider] \u4F1A\u8BDD ${sessionId} sendMessage \u8FDB\u7A0B\u9519\u8BEF:`, err.message);
+      this.activeSessions.delete(sessionId);
+      const syntheticResult = {
+        type: "result",
+        subtype: "error",
+        result: `\u6D88\u606F\u53D1\u9001\u5931\u8D25: ${err.message}`,
+        session_id: sessionId,
+        duration_ms: 0,
+        is_error: true,
+        num_turns: 0
+      };
+      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    });
+    this.attachStdoutListener(sessionId, proc);
+    this.attachStderrListener(sessionId, proc);
+    this.attachExitListener(sessionId, proc);
+  }
+  /**
+   * 订阅指定会话的 Claude 事件流
+   *
+   * @returns 取消订阅函数
+   */
+  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((entry) => entry.session);
+  }
+  // ============================================
+  // 私有方法
+  // ============================================
+  /**
+   * 启动 claude CLI 进程（持久模式，stdin 保持开放接收多条消息）
+   */
+  spawnClaudeProcess(sessionId, projectPath, resume = false, model, permissionMode, effort) {
+    const args = [
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages"
+    ];
+    if (resume) {
+      args.push("--resume", sessionId);
+    } else {
+      args.push("--session-id", sessionId);
+    }
+    if (model) {
+      args.push("--model", model);
+    }
+    if (permissionMode && permissionMode !== "default") {
+      args.push("--permission-mode", permissionMode);
+    }
+    if (effort) {
+      args.push("--effort", effort);
+    }
+    const env = { ...process.env, SESSIX_SESSION_ID: sessionId };
+    delete env.CLAUDECODE;
+    const proc = (0, import_child_process.spawn)(CLAUDE_PATH, args, {
+      cwd: projectPath,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return proc;
+  }
+  /**
+   * 向持久进程的 stdin 写入一条用户消息（NDJSON 格式）
+   *
+   * 写入失败时合成 error result 事件，确保 SessionManager 能感知到失败。
+   */
+  writeUserMessage(proc, message, sessionId, images) {
+    const content = [];
+    if (images?.length) {
+      for (const img of images) {
+        content.push({
+          type: "image",
+          source: { type: "base64", media_type: img.media_type, data: img.data }
+        });
+      }
+    }
+    content.push({ type: "text", text: message });
+    const payload = JSON.stringify({
+      type: "user",
+      session_id: "",
+      message: { role: "user", content },
+      parent_tool_use_id: null
+    });
+    if (!proc.stdin || proc.stdin.destroyed) {
+      console.error(`[ProcessProvider] stdin \u4E0D\u53EF\u7528\uFF0C\u6D88\u606F\u4E22\u5931`);
+      if (sessionId) {
+        this.emitWriteError(sessionId, "\u8FDB\u7A0B stdin \u5DF2\u5173\u95ED\uFF0C\u6D88\u606F\u672A\u9001\u8FBE");
+      }
+      return;
+    }
+    proc.stdin.write(payload + "\n", (err) => {
+      if (err && sessionId) {
+        console.error(`[ProcessProvider] \u4F1A\u8BDD ${sessionId} stdin \u5199\u5165\u5931\u8D25:`, err.message);
+        this.emitWriteError(sessionId, `\u6D88\u606F\u53D1\u9001\u5931\u8D25: ${err.message}`);
+      }
+    });
+  }
+  /**
+   * 发出写入失败的合成错误事件
+   */
+  emitWriteError(sessionId, message) {
+    const syntheticResult = {
+      type: "result",
+      subtype: "error",
+      result: message,
+      session_id: sessionId,
+      duration_ms: 0,
+      is_error: true,
+      num_turns: 0
+    };
+    this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+  }
+  /**
+   * 挂载 stdout 监听器，逐行解析 NDJSON
+   */
+  attachStdoutListener(sessionId, proc) {
+    if (!proc.stdout) {
+      console.warn(`[ProcessProvider] \u4F1A\u8BDD ${sessionId}: stdout \u4E0D\u53EF\u7528`);
+      return;
+    }
+    const rl = (0, import_readline.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;
+      const result = this.parseLine(trimmed);
+      if (result.ok) {
+        const event = result.value;
+        if (event.type === "assistant") {
+          for (const block of event.message.content) {
+            if (block.type === "tool_use" && block.name === "AskUserQuestion") {
+              const input = block.input;
+              const question = input.question ?? "";
+              if (!question) continue;
+              const prevKey = `${block.id}:${question}:${JSON.stringify(input.options ?? [])}`;
+              if (this.emittedQuestionToolUseIds.has(prevKey)) continue;
+              this.emittedQuestionToolUseIds.add(prevKey);
+              this.emitter.emit(this.getQuestionEventName(sessionId), {
+                toolUseId: block.id,
+                question,
+                options: input.options
+              });
+            }
+          }
+        }
+        this.updateSessionStatus(sessionId, event);
+        this.emitter.emit(this.getEventName(sessionId), event);
+      } else {
+        console.warn(
+          `[ProcessProvider] \u4F1A\u8BDD ${sessionId}: \u65E0\u6CD5\u89E3\u6790\u884C: ${trimmed.substring(0, 100)}`
+        );
+      }
+    });
+  }
+  /**
+   * 挂载 stderr 监听器，记录日志
+   */
+  attachStderrListener(sessionId, proc) {
+    if (!proc.stderr) return;
+    proc.stderr.on("data", (data) => {
+      const text = data.toString().trim();
+      if (text) {
+        console.error(`[ProcessProvider] \u4F1A\u8BDD ${sessionId} stderr: ${text}`);
+      }
+    });
+  }
+  /**
+   * 挂载进程退出监听器
+   *
+   * 当进程退出时发出合成的 result 事件，确保 SessionManager 能感知到退出。
+   * 正常退出时 Claude 会先通过 stdout 发送真实 result 事件，
+   * updateSessionStatus 会将 session.status 更新为 idle/error。
+   * 此时合成事件会重复触发，导致手机端出现两张总结卡。
+   * 修复：已收到真实 result（status 已为 idle/error）时跳过合成事件。
+   * 异常退出时（crash/OOM/killed）没有真实 result 事件，合成事件确保状态正确广播。
+   */
+  attachExitListener(sessionId, proc) {
+    proc.once("exit", (code, signal) => {
+      const entry = this.activeSessions.get(sessionId);
+      if (!entry) return;
+      if (entry.process !== proc) return;
+      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 = code === 0 || code === 143 || signal === "SIGTERM";
+      entry.session.status = isNormal ? "idle" : "error";
+      if (!isNormal) {
+        console.error(
+          `[ProcessProvider] \u4F1A\u8BDD ${sessionId}: \u8FDB\u7A0B\u5F02\u5E38\u9000\u51FA code=${code} signal=${signal}`
+        );
+      }
+      const syntheticResult = {
+        type: "result",
+        subtype: isNormal ? "success" : "error",
+        session_id: sessionId,
+        is_error: !isNormal,
+        result: isNormal ? "" : `\u8FDB\u7A0B\u9000\u51FA code=${code} signal=${signal}`,
+        duration_ms: 0,
+        num_turns: 0
+      };
+      this.emitter.emit(this.getEventName(sessionId), syntheticResult);
+    });
+  }
+  /**
+   * 解析一行 NDJSON 文本为 ClaudeStreamEvent
+   */
+  parseLine(line) {
+    try {
+      const parsed = JSON.parse(line);
+      return { ok: true, value: parsed };
+    } catch (err) {
+      return {
+        ok: false,
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+  /**
+   * 根据 Claude 事件更新会话状态
+   */
+  updateSessionStatus(sessionId, event) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) return;
+    entry.session.lastActiveAt = Date.now();
+    switch (event.type) {
+      case "system":
+        if (event.subtype === "init") {
+          entry.session.status = "running";
+        }
+        break;
+      case "assistant":
+        entry.session.status = "running";
+        break;
+      case "result":
+        entry.session.status = event.is_error ? "error" : "idle";
+        break;
+    }
+  }
+  /**
+   * 根据对话上下文生成下一步建议指令
+   *
+   * 使用 --output-format text 做一次性调用，返回纯文本结果。
+   */
+  async generateSuggestion(context) {
+    const prompt = `\u4F60\u662F\u4E00\u4E2A AI \u7F16\u7A0B\u52A9\u624B\u3002\u6839\u636E\u4EE5\u4E0B Claude Code \u5BF9\u8BDD\u4E0A\u4E0B\u6587\uFF0C\u5EFA\u8BAE\u7528\u6237\u4E0B\u4E00\u6B65\u6700\u6709\u4EF7\u503C\u7684\u4E00\u6761\u6307\u4EE4\uFF08\u76F4\u63A5\u7ED9\u51FA\u6307\u4EE4\u5185\u5BB9\uFF0C\u4E0D\u8981\u89E3\u91CA\uFF0C\u4E0D\u8981\u52A0\u5F15\u53F7\uFF09\uFF1A
+
+${context}`;
+    return new Promise((resolve, reject) => {
+      const env = { ...process.env };
+      delete env.CLAUDECODE;
+      const proc = (0, import_child_process.spawn)(CLAUDE_PATH, ["-p", prompt, "--output-format", "text"], {
+        cwd: (0, import_node_os.homedir)(),
+        env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      proc.stdin.end();
+      let output = "";
+      proc.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      proc.once("exit", (code) => {
+        if (code === 0) {
+          resolve(output.trim());
+        } else {
+          reject(new Error(`generateSuggestion \u8FDB\u7A0B\u9000\u51FA\u7801: ${code}`));
+        }
+      });
+      proc.once("error", reject);
+    });
+  }
+  /**
+   * 向正在等待中的 AskUserQuestion 提供答案
+   *
+   * 将答案写入 Claude 进程的 stdin（作为 tool_result），
+   * Claude 收到后继续执行。
+   */
+  async answerQuestion(sessionId, toolUseId, answer) {
+    const entry = this.activeSessions.get(sessionId);
+    if (!entry) {
+      throw new Error(`\u4F1A\u8BDD ${sessionId} \u4E0D\u5B58\u5728`);
+    }
+    if (!entry.process.stdin || entry.process.stdin.destroyed) {
+      throw new Error(`\u4F1A\u8BDD ${sessionId} stdin \u4E0D\u53EF\u7528`);
+    }
+    const toolResult = JSON.stringify({
+      type: "tool_result",
+      tool_use_id: toolUseId,
+      content: answer
+    });
+    await new Promise((resolve, reject) => {
+      entry.process.stdin.write(toolResult + "\n", (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    console.log(`[ProcessProvider] \u4F1A\u8BDD ${sessionId}: AskUserQuestion \u5DF2\u56DE\u7B54 (toolUseId=${toolUseId})`);
+  }
+  /**
+   * 订阅指定会话的 AskUserQuestion 事件
+   *
+   * @returns 取消订阅函数
+   */
+  onQuestion(sessionId, callback) {
+    const eventName = this.getQuestionEventName(sessionId);
+    this.emitter.on(eventName, callback);
+    return () => {
+      this.emitter.off(eventName, callback);
+    };
+  }
+  /**
+   * 生成事件名称
+   */
+  getEventName(sessionId) {
+    return `claude:${sessionId}`;
+  }
+  /**
+   * 生成 AskUserQuestion 内部事件名称
+   */
+  getQuestionEventName(sessionId) {
+    return `question:${sessionId}`;
+  }
+};
+
+// src/session/SessionManager.ts
+var import_uuid2 = require("uuid");
+var BUFFER_MAX = 5e3;
+var SessionManager = class {
+  provider;
+  /** 事件回调列表（事件会被转发到 WsBridge） */
+  eventCallbacks = [];
+  /** 每个会话的事件流取消订阅函数 */
+  unsubscribeMap = /* @__PURE__ */ new Map();
+  /** 每个会话的事件缓冲区（用于新订阅者重放）*/
+  sessionEventBuffers = /* @__PURE__ */ new Map();
+  /** AskUserQuestion 问题映射：requestId → resolve 回调 */
+  pendingQuestions = /* @__PURE__ */ new Map();
+  /**
+   * 会话状态缓存（用于追踪 status 变化，检测 oldStatus !== newStatus 时广播）
+   *
+   * 这是 status 变化的唯一检测源。ProcessProvider 的 session.status 是实际值，
+   * 这里只缓存上次广播的值，用于去重。
+   */
+  lastBroadcastStatus = /* @__PURE__ */ new Map();
+  /** 每个会话的服务器端累计统计 */
+  sessionStats = /* @__PURE__ */ new Map();
+  /** 每个会话进入 running 状态的 wall-clock 起始时间 */
+  runningStartedAt = /* @__PURE__ */ new Map();
+  /** assistant 事件合并缓冲区（30ms 窗口内的 assistant 事件合并为一次发送） */
+  pendingAssistantEvents = /* @__PURE__ */ new Map();
+  constructor(provider) {
+    this.provider = provider;
+  }
+  // ============================================
+  // 公开 API
+  // ============================================
+  /**
+   * 创建新会话
+   *
+   * 调用 provider.startSession()，订阅事件流，
+   * 将 ClaudeStreamEvent 包装为 ServerEvent 转发。
+   */
+  async createSession(projectPath, message, resumeSessionId, newSessionId, model, permissionMode, effort, images) {
+    const session = await this.provider.startSession({
+      projectPath,
+      message,
+      sessionId: resumeSessionId ?? newSessionId,
+      resume: !!resumeSessionId,
+      model,
+      permissionMode,
+      effort,
+      images
+    });
+    this.lastBroadcastStatus.set(session.id, session.status);
+    this.unsubscribeSession(session.id);
+    this.subscribeToSession(session.id);
+    console.log(`[SessionManager] \u4F1A\u8BDD\u5DF2\u521B\u5EFA: ${session.id} (\u9879\u76EE: ${projectPath})`);
+    return session;
+  }
+  /**
+   * 发送消息到已有会话
+   */
+  async sendMessage(sessionId, message, permissionMode, images) {
+    await this.provider.sendMessage(sessionId, message, permissionMode, images);
+    this.updateSessionStatus(sessionId, "running");
+    console.log(`[SessionManager] \u6D88\u606F\u5DF2\u53D1\u9001\u5230\u4F1A\u8BDD: ${sessionId}`);
+  }
+  /**
+   * 终止会话
+   */
+  async killSession(sessionId) {
+    this.unsubscribeSession(sessionId);
+    this.clearPendingQuestions(sessionId);
+    this.lastBroadcastStatus.delete(sessionId);
+    this.sessionEventBuffers.delete(sessionId);
+    this.sessionStats.delete(sessionId);
+    const pending = this.pendingAssistantEvents.get(sessionId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this.pendingAssistantEvents.delete(sessionId);
+    }
+    await this.provider.killSession(sessionId);
+    console.log(`[SessionManager] \u4F1A\u8BDD\u5DF2\u7EC8\u6B62: ${sessionId}`);
+  }
+  /**
+   * 获取会话的缓冲事件（用于新订阅者重放）
+   */
+  getSessionEvents(sessionId) {
+    return this.sessionEventBuffers.get(sessionId) ?? [];
+  }
+  /**
+   * 处理 AskUserQuestion 回答（从手机端传来）
+   */
+  handleQuestionResponse(requestId, answer) {
+    const pending = this.pendingQuestions.get(requestId);
+    if (!pending) {
+      console.warn(`[SessionManager] \u672A\u627E\u5230\u95EE\u9898\u8BF7\u6C42: ${requestId}`);
+      return;
+    }
+    this.pendingQuestions.delete(requestId);
+    this.updateSessionStatus(pending.sessionId, "running");
+    pending.resolve(answer);
+    console.log(`[SessionManager] \u95EE\u9898\u5DF2\u56DE\u7B54: ${requestId}`);
+  }
+  /**
+   * 获取所有活跃会话（含服务器端统计）
+   */
+  getActiveSessions() {
+    return this.provider.getActiveSessions().map((session) => {
+      const stats = this.getSessionStats(session.id);
+      return stats ? { ...session, stats } : session;
+    });
+  }
+  /**
+   * 注册事件回调（事件会被转发到 WsBridge）
+   *
+   * @returns 取消注册的函数
+   */
+  onEvent(callback) {
+    this.eventCallbacks.push(callback);
+    return () => {
+      const index = this.eventCallbacks.indexOf(callback);
+      if (index !== -1) {
+        this.eventCallbacks.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * 清理所有资源
+   */
+  destroy() {
+    for (const [, unsub] of this.unsubscribeMap) {
+      unsub();
+    }
+    this.unsubscribeMap.clear();
+    this.sessionEventBuffers.clear();
+    this.sessionStats.clear();
+    for (const [, pending] of this.pendingAssistantEvents) {
+      clearTimeout(pending.timer);
+    }
+    this.pendingAssistantEvents.clear();
+    this.pendingQuestions.clear();
+    this.lastBroadcastStatus.clear();
+    this.eventCallbacks.length = 0;
+    console.log("[SessionManager] \u5DF2\u9500\u6BC1");
+  }
+  // ============================================
+  // 内部方法
+  // ============================================
+  /**
+   * 订阅指定会话的事件流（包括 AskUserQuestion 问题事件）
+   */
+  subscribeToSession(sessionId) {
+    const unsubscribeEvent = this.provider.onEvent(sessionId, (event) => {
+      this.handleClaudeEvent(sessionId, event);
+    });
+    const unsubscribeQuestion = this.provider.onQuestion(
+      sessionId,
+      ({ toolUseId, question, options }) => {
+        this.handleAskUserQuestion(sessionId, toolUseId, question, options);
+      }
+    );
+    this.unsubscribeMap.set(sessionId, () => {
+      unsubscribeEvent();
+      unsubscribeQuestion();
+    });
+  }
+  /**
+   * 取消指定会话的事件订阅
+   */
+  unsubscribeSession(sessionId) {
+    const unsub = this.unsubscribeMap.get(sessionId);
+    if (unsub) {
+      unsub();
+      this.unsubscribeMap.delete(sessionId);
+    }
+  }
+  /**
+   * 处理来自 provider 的 Claude 事件
+   *
+   * - 包装为 ServerEvent 转发
+   * - assistant 事件在 30ms 窗口内合并后批量发送（减少 WebSocket 帧数）
+   * - 检测 status 变化
+   */
+  handleClaudeEvent(sessionId, event) {
+    const buffer = this.sessionEventBuffers.get(sessionId) ?? [];
+    buffer.push(event);
+    if (buffer.length > BUFFER_MAX) {
+      buffer.splice(0, buffer.length - BUFFER_MAX);
+    }
+    this.sessionEventBuffers.set(sessionId, buffer);
+    if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+      const thinkingBlocks = event.message.content.filter((b) => b.type === "thinking");
+      if (thinkingBlocks.length > 0) {
+        console.log(`[SessionManager] \u{1F9E0} thinking block detected in ${sessionId}: msgId=${event.message.id}, blocks=${thinkingBlocks.length}, len=${thinkingBlocks.map((b) => (b.thinking || "").length).join(",")}`);
+      }
+    }
+    switch (event.type) {
+      case "assistant":
+        this.bufferAssistantEvent(sessionId, event);
+        break;
+      case "system":
+        this.flushPendingAssistant(sessionId);
+        this.emit({ type: "claude_event", sessionId, event });
+        if (event.subtype === "init") {
+          this.updateSessionStatus(sessionId, "running");
+        }
+        break;
+      case "user":
+        this.flushPendingAssistant(sessionId);
+        this.emit({ type: "claude_event", sessionId, event });
+        break;
+      case "result": {
+        this.flushPendingAssistant(sessionId);
+        this.emit({ type: "claude_event", sessionId, event });
+        const stats = this.sessionStats.get(sessionId) ?? {
+          totalInputTokens: 0,
+          totalOutputTokens: 0,
+          totalDurationMs: 0
+        };
+        if (event.usage) {
+          stats.totalInputTokens += event.usage.input_tokens ?? 0;
+          stats.totalOutputTokens += event.usage.output_tokens ?? 0;
+        }
+        if (event.total_cost_usd != null) {
+          stats.totalCostUsd = (stats.totalCostUsd ?? 0) + event.total_cost_usd;
+        }
+        this.sessionStats.set(sessionId, stats);
+        if (event.is_error) {
+          this.updateSessionStatus(sessionId, "error");
+        } else {
+          this.updateSessionStatus(sessionId, "idle");
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * 缓冲 assistant 事件到 30ms 窗口
+   */
+  bufferAssistantEvent(sessionId, event) {
+    let pending = this.pendingAssistantEvents.get(sessionId);
+    if (!pending) {
+      pending = {
+        events: [],
+        timer: setTimeout(() => this.flushPendingAssistant(sessionId), 30)
+      };
+      this.pendingAssistantEvents.set(sessionId, pending);
+    }
+    pending.events.push(event);
+  }
+  /**
+   * 刷新缓冲的 assistant 事件，批量发送
+   */
+  flushPendingAssistant(sessionId) {
+    const pending = this.pendingAssistantEvents.get(sessionId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingAssistantEvents.delete(sessionId);
+    if (pending.events.length === 1) {
+      this.emit({ type: "claude_event", sessionId, event: pending.events[0] });
+    } else if (pending.events.length > 1) {
+      this.emit({ type: "claude_events", sessionId, events: pending.events });
+    }
+  }
+  /**
+   * 更新会话状态，如果状态发生变化则广播通知
+   *
+   * 使用 lastBroadcastStatus 去重，只在状态实际变化时广播。
+   */
+  updateSessionStatus(sessionId, newStatus) {
+    const lastStatus = this.lastBroadcastStatus.get(sessionId);
+    if (lastStatus !== newStatus) {
+      if (lastStatus === "running") {
+        const startedAt = this.runningStartedAt.get(sessionId);
+        if (startedAt) {
+          const stats2 = this.sessionStats.get(sessionId) ?? {
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalDurationMs: 0
+          };
+          stats2.totalDurationMs += Date.now() - startedAt;
+          this.sessionStats.set(sessionId, stats2);
+          this.runningStartedAt.delete(sessionId);
+        }
+      }
+      if (newStatus === "running") {
+        this.runningStartedAt.set(sessionId, Date.now());
+      }
+      this.lastBroadcastStatus.set(sessionId, newStatus);
+      const stats = this.getSessionStats(sessionId);
+      this.emit({
+        type: "status_change",
+        sessionId,
+        status: newStatus,
+        stats
+      });
+      console.log(`[SessionManager] \u4F1A\u8BDD ${sessionId} \u72B6\u6001\u53D8\u5316: ${lastStatus ?? "(\u65E0)"} \u2192 ${newStatus}`);
+    }
+  }
+  /** 获取会话统计（含 runningStartedAt） */
+  getSessionStats(sessionId) {
+    const runningStartedAt = this.runningStartedAt.get(sessionId);
+    const stats = this.sessionStats.get(sessionId);
+    if (!stats && !runningStartedAt) return void 0;
+    const base = stats ?? { totalInputTokens: 0, totalOutputTokens: 0, totalDurationMs: 0 };
+    return runningStartedAt ? { ...base, runningStartedAt } : base;
+  }
+  /**
+   * 处理 AskUserQuestion 事件：广播问题请求到手机，等待用户回答
+   */
+  handleAskUserQuestion(sessionId, toolUseId, question, options) {
+    const existingEntry = Array.from(this.pendingQuestions.entries()).find(
+      ([, v]) => v.toolUseId === toolUseId
+    );
+    if (existingEntry) {
+      const [existingRequestId] = existingEntry;
+      const updatedRequest = {
+        id: existingRequestId,
+        sessionId,
+        toolUseId,
+        question,
+        options,
+        createdAt: Date.now()
+      };
+      this.emit({ type: "question_request", request: updatedRequest });
+      console.log(`[SessionManager] \u4F1A\u8BDD ${sessionId}: AskUserQuestion \u5DF2\u66F4\u65B0 (requestId=${existingRequestId})`);
+      return;
+    }
+    const requestId = (0, import_uuid2.v4)();
+    const request = {
+      id: requestId,
+      sessionId,
+      toolUseId,
+      question,
+      options,
+      createdAt: Date.now()
+    };
+    this.updateSessionStatus(sessionId, "waiting_question");
+    this.emit({ type: "question_request", request });
+    const answerPromise = new Promise((resolve) => {
+      this.pendingQuestions.set(requestId, { sessionId, toolUseId, resolve });
+    });
+    answerPromise.then(async (answer) => {
+      try {
+        await this.provider.answerQuestion(sessionId, toolUseId, answer);
+      } catch (err) {
+        console.error(`[SessionManager] answerQuestion \u5931\u8D25 (${sessionId}):`, err);
+      }
+    }).catch((err) => console.error("[SessionManager] answerPromise rejected:", err));
+    console.log(`[SessionManager] \u4F1A\u8BDD ${sessionId}: AskUserQuestion \u5DF2\u63A8\u9001 (requestId=${requestId})`);
+  }
+  /**
+   * 清除指定会话的所有待回答问题
+   */
+  clearPendingQuestions(sessionId) {
+    const toRemove = [];
+    for (const [requestId, pending] of this.pendingQuestions) {
+      if (pending.sessionId === sessionId) {
+        toRemove.push(requestId);
+      }
+    }
+    for (const requestId of toRemove) {
+      this.pendingQuestions.delete(requestId);
+    }
+  }
+  /**
+   * 发出 ServerEvent 到所有已注册的回调
+   */
+  emit(event) {
+    for (const callback of this.eventCallbacks) {
+      try {
+        callback(event);
+      } catch (err) {
+        console.error("[SessionManager] \u4E8B\u4EF6\u56DE\u8C03\u6267\u884C\u5F02\u5E38:", err);
+      }
+    }
+  }
+};
+
+// src/session/SessionFileWatcher.ts
+var import_chokidar = __toESM(require("chokidar"));
+var import_promises = require("fs/promises");
+var import_node_readline = require("readline");
+var SessionFileWatcher = class {
+  watchers = /* @__PURE__ */ new Map();
+  onEvent;
+  /** 文件无变化后自动停止监听的超时时间（10 分钟） */
+  IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+  }
+  /**
+   * 开始监听指定会话的 JSONL 文件新增内容
+   *
+   * @param sessionId    会话 ID
+   * @param filePath     JSONL 文件绝对路径
+   * @param byteOffset   已读到的字节位置（跳过历史内容，只推送新行）
+   */
+  watch(sessionId, filePath, byteOffset) {
+    if (this.watchers.has(sessionId)) return;
+    const watcher = import_chokidar.default.watch(filePath, {
+      persistent: false,
+      // 不阻止进程退出
+      usePolling: false,
+      // 使用原生 FS 事件，不轮询
+      awaitWriteFinish: {
+        stabilityThreshold: 300,
+        // 写入停止 300ms 后才触发
+        pollInterval: 100
+      }
+    });
+    const entry = {
+      filePath,
+      byteOffset,
+      idleTimer: null,
+      watcher
+    };
+    watcher.on("change", () => {
+      this.readNewLines(sessionId).catch((err) => {
+        console.error(`[SessionFileWatcher] \u8BFB\u53D6\u5F02\u5E38 ${sessionId}:`, err);
+      });
+      this.resetIdleTimer(sessionId);
+    });
+    this.watchers.set(sessionId, entry);
+    this.resetIdleTimer(sessionId);
+    console.log(`[SessionFileWatcher] \u5F00\u59CB\u76D1\u542C: ${sessionId} (offset=${byteOffset})`);
+  }
+  /** 停止监听指定会话 */
+  unwatch(sessionId) {
+    const entry = this.watchers.get(sessionId);
+    if (!entry) return;
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
+    void entry.watcher.close();
+    this.watchers.delete(sessionId);
+    console.log(`[SessionFileWatcher] \u505C\u6B62\u76D1\u542C: ${sessionId}`);
+  }
+  /** 停止所有监听（服务关闭时调用） */
+  destroy() {
+    for (const sessionId of [...this.watchers.keys()]) {
+      this.unwatch(sessionId);
+    }
+  }
+  // ============================================
+  // 内部方法
+  // ============================================
+  resetIdleTimer(sessionId) {
+    const entry = this.watchers.get(sessionId);
+    if (!entry) return;
+    if (entry.idleTimer) clearTimeout(entry.idleTimer);
+    entry.idleTimer = setTimeout(() => {
+      console.log(`[SessionFileWatcher] \u7A7A\u95F2\u8D85\u65F6\uFF0C\u505C\u6B62\u76D1\u542C: ${sessionId}`);
+      this.unwatch(sessionId);
+    }, this.IDLE_TIMEOUT_MS);
+  }
+  async readNewLines(sessionId) {
+    const entry = this.watchers.get(sessionId);
+    if (!entry) return;
+    let fileHandle;
+    let rl;
+    try {
+      fileHandle = await (0, import_promises.open)(entry.filePath, "r");
+      const fileStat = await fileHandle.stat();
+      const newSize = fileStat.size;
+      if (newSize <= entry.byteOffset) return;
+      rl = (0, import_node_readline.createInterface)({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        input: fileHandle.createReadStream({ start: entry.byteOffset, encoding: "utf-8" }),
+        crlfDelay: Infinity
+      });
+      const newEvents = [];
+      let isCompleted = false;
+      let isError = false;
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        const parsed = parseJSONLLine(line, sessionId);
+        if (parsed.type === "event" && parsed.event) {
+          newEvents.push(parsed.event);
+        } else if (parsed.type === "completed") {
+          isCompleted = true;
+          isError = parsed.isError;
+        }
+      }
+      entry.byteOffset = newSize;
+      for (const event of newEvents) {
+        this.onEvent({ type: "claude_event", sessionId, event });
+      }
+      if (isCompleted) {
+        this.onEvent({ type: "status_change", sessionId, status: isError ? "error" : "idle" });
+        this.unwatch(sessionId);
+      }
+    } finally {
+      rl?.close();
+      await fileHandle?.close();
+    }
+  }
+};
+function parseJSONLLine(line, sessionId) {
+  try {
+    const obj = JSON.parse(line);
+    if (obj.type === "user" && obj.message) {
+      const msgContent = obj.message.content;
+      if (typeof msgContent === "string") {
+        if (msgContent.includes("<local-command") || msgContent.includes("<command-name>")) {
+          return { type: "skip" };
+        }
+      }
+      const normalizedContent = typeof msgContent === "string" ? [{ type: "text", text: msgContent }] : Array.isArray(msgContent) ? msgContent.filter((b) => b.type === "text" && typeof b.text === "string") : [];
+      if (normalizedContent.length === 0) return { type: "skip" };
+      return {
+        type: "event",
+        event: {
+          type: "user",
+          message: { ...obj.message, content: normalizedContent },
+          session_id: sessionId
+        }
+      };
+    }
+    if (obj.type === "assistant" && obj.message) {
+      const content = (obj.message.content ?? []).filter((b) => b.type === "text" || b.type === "tool_use");
+      if (content.length === 0) return { type: "skip" };
+      return {
+        type: "event",
+        event: {
+          type: "assistant",
+          message: {
+            id: obj.message.id ?? obj.uuid ?? "unknown",
+            model: obj.message.model ?? "unknown",
+            role: "assistant",
+            content,
+            stop_reason: obj.message.stop_reason
+          },
+          session_id: sessionId
+        }
+      };
+    }
+    if (obj.type === "result") {
+      return { type: "completed", isError: !!obj.is_error };
+    }
+    return { type: "skip" };
+  } catch {
+    return { type: "skip" };
+  }
+}
+
+// src/ws/WsBridge.ts
+var import_ws = require("ws");
+var WsBridge = class _WsBridge {
+  wss;
+  token;
+  heartbeatTimer = null;
+  clientEventCallbacks = [];
+  connectionCallbacks = [];
+  disconnectCallbacks = [];
+  /** 每个连接的最后一次 pong 时间 */
+  lastPongMap = /* @__PURE__ */ new Map();
+  /** 每个连接当前正在查看的会话 ID */
+  viewingSessions = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.token = options.token;
+    this.wss = new import_ws.WebSocketServer({
+      port: options.port,
+      verifyClient: (info, callback) => {
+        const authorized = this.verifyToken(info.req);
+        if (!authorized) {
+          callback(false, 401, "Unauthorized");
+        } else {
+          callback(true);
+        }
+      }
+    });
+    this.wss.on("connection", (ws) => this.handleConnection(ws));
+    this.startHeartbeat();
+    console.log(`[WsBridge] WebSocket \u670D\u52A1\u5DF2\u542F\u52A8\uFF0C\u7AEF\u53E3 ${options.port}`);
+  }
+  /**
+   * 异步工厂方法：等待端口监听成功后 resolve，端口占用等错误时 reject。
+   * 使用此方法代替 new WsBridge()，确保 EADDRINUSE 等错误能被调用方的 try-catch 捕获。
+   */
+  static async create(options) {
+    return new Promise((resolve, reject) => {
+      const bridge = new _WsBridge(options);
+      bridge.wss.once("listening", () => {
+        bridge.wss.on("error", (err) => console.error("[WsBridge] \u670D\u52A1\u8FD0\u884C\u9519\u8BEF:", err));
+        resolve(bridge);
+      });
+      bridge.wss.once("error", reject);
+    });
+  }
+  // ============================================
+  // 公开 API
+  // ============================================
+  /** 注册客户端事件回调 */
+  onClientEvent(callback) {
+    this.clientEventCallbacks.push(callback);
+  }
+  /** 注册新连接回调（用于自动推送初始数据） */
+  onConnection(callback) {
+    this.connectionCallbacks.push(callback);
+  }
+  /** 注册断开连接回调（任意客户端断开时触发，可通过 getConnectionCount() 判断是否全部断开） */
+  onDisconnect(callback) {
+    this.disconnectCallbacks.push(callback);
+  }
+  /** 广播事件到所有已连接的客户端 */
+  broadcast(event) {
+    const data = JSON.stringify(event);
+    for (const ws of this.wss.clients) {
+      if (ws.readyState === import_ws.WebSocket.OPEN) {
+        ws.send(data);
+      }
+    }
+  }
+  /** 发送事件到指定客户端 */
+  send(ws, event) {
+    if (ws.readyState === import_ws.WebSocket.OPEN) {
+      ws.send(JSON.stringify(event));
+    }
+  }
+  /** 设置指定连接当前正在查看的会话 */
+  setViewingSession(ws, sessionId) {
+    this.viewingSessions.set(ws, sessionId);
+  }
+  /** 清除指定连接的查看状态 */
+  clearViewingSession(ws) {
+    this.viewingSessions.delete(ws);
+  }
+  /** 检查是否有任意连接正在查看指定会话 */
+  isViewingSession(sessionId) {
+    for (const sid of this.viewingSessions.values()) {
+      if (sid === sessionId) return true;
+    }
+    return false;
+  }
+  /** 获取当前活跃连接数 */
+  getConnectionCount() {
+    return this.wss.clients.size;
+  }
+  /** 优雅关闭 WebSocket 服务 */
+  close() {
+    return new Promise((resolve, reject) => {
+      if (this.heartbeatTimer) {
+        clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+      }
+      for (const ws of this.wss.clients) {
+        ws.terminate();
+      }
+      this.wss.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          console.log("[WsBridge] WebSocket \u670D\u52A1\u5DF2\u5173\u95ED");
+          resolve();
+        }
+      });
+    });
+  }
+  // ============================================
+  // 内部方法
+  // ============================================
+  /** 验证连接 token（token 为空字符串时跳过验证） */
+  verifyToken(req) {
+    if (this.token === "") return true;
+    try {
+      const url = new URL(req.url ?? "", `http://${req.headers.host}`);
+      const clientToken = url.searchParams.get("token");
+      return clientToken === this.token;
+    } catch {
+      return false;
+    }
+  }
+  /** 处理新的 WebSocket 连接 */
+  handleConnection(ws) {
+    this.lastPongMap.set(ws, Date.now());
+    console.log(`[WsBridge] \u65B0\u5BA2\u6237\u7AEF\u8FDE\u63A5\uFF0C\u5F53\u524D\u8FDE\u63A5\u6570: ${this.getConnectionCount()}`);
+    for (const callback of this.connectionCallbacks) {
+      try {
+        callback(ws);
+      } catch (err) {
+        console.error("[WsBridge] \u8FDE\u63A5\u56DE\u8C03\u6267\u884C\u5F02\u5E38:", err);
+      }
+    }
+    ws.on("pong", () => {
+      this.lastPongMap.set(ws, Date.now());
+    });
+    ws.on("message", (raw) => {
+      try {
+        const event = JSON.parse(raw.toString());
+        this.dispatchClientEvent(event, ws);
+      } catch (err) {
+        console.error("[WsBridge] \u6D88\u606F\u89E3\u6790\u5931\u8D25:", err);
+        this.send(ws, {
+          type: "error",
+          message: "\u6D88\u606F\u683C\u5F0F\u65E0\u6548",
+          code: "INVALID_MESSAGE"
+        });
+      }
+    });
+    ws.on("close", () => {
+      this.lastPongMap.delete(ws);
+      this.viewingSessions.delete(ws);
+      setTimeout(() => {
+        console.log(`[WsBridge] \u5BA2\u6237\u7AEF\u65AD\u5F00\uFF0C\u5F53\u524D\u8FDE\u63A5\u6570: ${this.getConnectionCount()}`);
+        for (const cb of this.disconnectCallbacks) {
+          try {
+            cb();
+          } catch (err) {
+            console.error("[WsBridge] \u65AD\u5F00\u56DE\u8C03\u6267\u884C\u5F02\u5E38:", err);
+          }
+        }
+      }, 0);
+    });
+    ws.on("error", (err) => {
+      console.error("[WsBridge] \u8FDE\u63A5\u9519\u8BEF:", err.message);
+    });
+  }
+  /** 分发客户端事件到所有注册的回调 */
+  dispatchClientEvent(event, ws) {
+    for (const callback of this.clientEventCallbacks) {
+      try {
+        callback(event, ws);
+      } catch (err) {
+        console.error("[WsBridge] \u4E8B\u4EF6\u56DE\u8C03\u6267\u884C\u5F02\u5E38:", err);
+      }
+    }
+  }
+  /** 启动心跳机制 */
+  startHeartbeat() {
+    this.heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      this.broadcast({ type: "heartbeat", timestamp: now });
+      for (const ws of this.wss.clients) {
+        const lastPong = this.lastPongMap.get(ws) ?? 0;
+        if (now - lastPong > 45e3) {
+          console.log("[WsBridge] \u68C0\u6D4B\u5230\u6B7B\u8FDE\u63A5\uFF0C\u4E3B\u52A8\u65AD\u5F00");
+          ws.terminate();
+          continue;
+        }
+        if (ws.readyState === import_ws.WebSocket.OPEN) {
+          ws.ping();
+        }
+      }
+    }, 15e3);
+  }
+};
+
+// src/approval/ApprovalProxy.ts
+var import_node_http = __toESM(require("http"));
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_node_os2 = __toESM(require("os"));
+var import_uuid3 = require("uuid");
+var ApprovalProxy = class _ApprovalProxy {
+  server;
+  token;
+  port;
+  settingsPath = import_node_path.default.join(import_node_os2.default.homedir(), ".claude", "settings.json");
+  /** 待处理的审批请求：requestId -> { resolve, timer, request } */
+  pendingApprovals = /* @__PURE__ */ new Map();
+  /** 审批请求回调（通知外部推送到手机） */
+  approvalRequestCallbacks = [];
+  /** YOLO 模式状态：sessionId -> enabled */
+  yoloSessions = /* @__PURE__ */ new Map();
+  /** 内存缓存：已被"始终允许"的工具名（避免每次读 settings.json） */
+  alwaysAllowedTools = /* @__PURE__ */ new Set();
+  /** 获取状态信息的回调（由外部注入） */
+  statusInfoProvider = null;
+  constructor(options) {
+    this.token = options.token;
+    this.port = options.port;
+    this.server = import_node_http.default.createServer((req, res) => {
+      this.handleRequest(req, res);
+    });
+    this.server.listen(options.port, () => {
+      console.log(`[ApprovalProxy] HTTP \u5BA1\u6279\u670D\u52A1\u5DF2\u542F\u52A8\uFF0C\u7AEF\u53E3 ${options.port}`);
+    });
+  }
+  /**
+   * 异步工厂方法：等待端口监听成功后 resolve，端口占用等错误时 reject。
+   */
+  static async create(options) {
+    return new Promise((resolve, reject) => {
+      const proxy = new _ApprovalProxy(options);
+      proxy.server.once("listening", () => {
+        proxy.server.on("error", (err) => console.error("[ApprovalProxy] \u670D\u52A1\u8FD0\u884C\u9519\u8BEF:", err));
+        resolve(proxy);
+      });
+      proxy.server.once("error", reject);
+    });
+  }
+  // ============================================
+  // 公开 API
+  // ============================================
+  /** 注册审批请求回调（当有新的审批请求时触发） */
+  onApprovalRequest(callback) {
+    this.approvalRequestCallbacks.push(callback);
+  }
+  /** 设置状态信息提供者（用于 /health 端点） */
+  setStatusInfoProvider(provider) {
+    this.statusInfoProvider = provider;
+  }
+  /** 设置会话的 YOLO 模式（服务端拦截，即使手机断连也生效） */
+  setYoloMode(sessionId, enabled) {
+    this.yoloSessions.set(sessionId, enabled);
+    console.log(`[ApprovalProxy] YOLO \u6A21\u5F0F ${enabled ? "\u5DF2\u542F\u7528" : "\u5DF2\u5173\u95ED"}: ${sessionId}`);
+  }
+  /** 检查会话是否处于 YOLO 模式 */
+  isYoloMode(sessionId) {
+    return this.yoloSessions.get(sessionId) ?? false;
+  }
+  /**
+   * 注入审批结果
+   *
+   * 从 pendingApprovals 中取出对应请求，resolve promise，
+   * 让长轮询的 HTTP 响应返回审批结果给 Claude Code hook。
+   */
+  resolveApproval(requestId, decision) {
+    const pending = this.pendingApprovals.get(requestId);
+    if (!pending) {
+      console.warn(`[ApprovalProxy] \u5BA1\u6279\u8BF7\u6C42 ${requestId} \u4E0D\u5B58\u5728\u6216\u5DF2\u8D85\u65F6`);
+      return false;
+    }
+    clearTimeout(pending.timer);
+    pending.resolve(decision);
+    this.pendingApprovals.delete(requestId);
+    console.log(`[ApprovalProxy] \u5BA1\u6279\u8BF7\u6C42 ${requestId} \u5DF2\u5904\u7406: ${decision.decision}`);
+    return true;
+  }
+  /** 获取当前待处理的审批数量 */
+  getPendingCount() {
+    return this.pendingApprovals.size;
+  }
+  /** 检查指定审批请求是否仍在等待用户决策 */
+  isPending(requestId) {
+    return this.pendingApprovals.has(requestId);
+  }
+  /** 检查工具是否已被"始终允许"（内存缓存 + settings.json 双重检查） */
+  isToolAlwaysAllowed(toolName, projectPath) {
+    if (this.alwaysAllowedTools.has(toolName)) return true;
+    return this.isToolInClaudeSettings(toolName, projectPath);
+  }
+  /** 检查工具是否已在 settings.json permissions.allow 中（检查项目级和全局） */
+  isToolInClaudeSettings(toolName, projectPath) {
+    const checkPath = (filepath) => {
+      try {
+        const raw = import_node_fs.default.readFileSync(filepath, "utf-8");
+        const settings = JSON.parse(raw);
+        const allow = settings?.permissions?.allow ?? [];
+        return allow.some((entry) => {
+          if (entry === toolName) return true;
+          if (entry === `${toolName}(*)`) return true;
+          if (toolName.startsWith(`${entry}__`)) return true;
+          return false;
+        });
+      } catch {
+        return false;
+      }
+    };
+    if (projectPath) {
+      const projectSettingsPath = import_node_path.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_path.default.join(projectPath, ".claude", "settings.json") : this.settingsPath;
+    try {
+      if (projectPath) {
+        const dir = import_node_path.default.dirname(targetPath);
+        if (!import_node_fs.default.existsSync(dir)) {
+          import_node_fs.default.mkdirSync(dir, { recursive: true });
+        }
+      }
+      let settings = {};
+      try {
+        settings = JSON.parse(import_node_fs.default.readFileSync(targetPath, "utf-8"));
+      } catch {
+      }
+      if (!settings.permissions) {
+        settings.permissions = {};
+      }
+      const perms = settings.permissions;
+      if (!Array.isArray(perms.allow)) {
+        perms.allow = [];
+      }
+      const allow = perms.allow;
+      const entry = `${toolName}(*)`;
+      if (!allow.includes(entry)) {
+        allow.push(entry);
+        import_node_fs.default.writeFileSync(targetPath, JSON.stringify(settings, null, 2), "utf-8");
+        const label = projectPath ? `${projectPath}/.claude/settings.json` : "~/.claude/settings.json";
+        console.log(`[ApprovalProxy] \u5DF2\u5C06 ${entry} \u5199\u5165 ${label}`);
+      }
+      this.alwaysAllowedTools.add(toolName);
+    } catch (err) {
+      console.error("[ApprovalProxy] \u5199\u5165 settings.json \u5931\u8D25:", err);
+    }
+  }
+  /** 获取指定会话的所有 pending approval requests（用于 subscribe 重发） */
+  getPendingRequestsForSession(sessionId) {
+    const result = [];
+    for (const { request } of this.pendingApprovals.values()) {
+      if (request.sessionId === sessionId) {
+        result.push(request);
+      }
+    }
+    return result;
+  }
+  /**
+   * 批量允许所有待处理的审批请求（手机端断线时调用）
+   */
+  approveAll(reason) {
+    const entries = Array.from(this.pendingApprovals.entries());
+    for (const [requestId, pending] of entries) {
+      clearTimeout(pending.timer);
+      pending.resolve({ decision: "allow" });
+      this.pendingApprovals.delete(requestId);
+      console.log(`[ApprovalProxy] \u5BA1\u6279\u8BF7\u6C42 ${requestId} \u5DF2\u81EA\u52A8\u5141\u8BB8${reason ? `\uFF08${reason}\uFF09` : ""}`);
+    }
+  }
+  /** 优雅关闭 HTTP 服务 */
+  close() {
+    return new Promise((resolve, reject) => {
+      const pendingEntries = Array.from(this.pendingApprovals.entries());
+      for (const [, pending] of pendingEntries) {
+        clearTimeout(pending.timer);
+        pending.resolve({ decision: "deny", reason: "\u670D\u52A1\u5668\u5DF2\u5173\u95ED" });
+      }
+      this.pendingApprovals.clear();
+      this.server.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          console.log("[ApprovalProxy] HTTP \u5BA1\u6279\u670D\u52A1\u5DF2\u5173\u95ED");
+          resolve();
+        }
+      });
+    });
+  }
+  // ============================================
+  // 内部方法
+  // ============================================
+  /** 路由请求 */
+  handleRequest(req, res) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    if (req.method === "POST" && pathname === "/hook/approval") {
+      this.handleApprovalHook(req, res);
+    } else if (req.method === "GET" && pathname === "/health") {
+      this.handleHealth(req, res);
+    } else if (req.method === "GET" && pathname === "/token") {
+      this.handleToken(req, res);
+    } else {
+      this.sendJson(res, 404, { error: "Not Found" });
+    }
+  }
+  /**
+   * 核心端点：处理 Claude Code hook 的审批请求
+   *
+   * 长轮询实现：
+   * 1. 解析请求 body
+   * 2. 创建 ApprovalRequest 对象
+   * 3. 通知外部（推到手机）
+   * 4. 创建 Promise 并 hold 住 response
+   * 5. 等待 resolveApproval() 被调用或超时
+   */
+  async handleApprovalHook(req, res) {
+    try {
+      const body = await this.parseJsonBody(req);
+      const payload = body.payload ?? body;
+      const requestId = (0, import_uuid3.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 ?? {};
+      const approvalRequest = {
+        id: requestId,
+        sessionId: String(body.sessionId ?? "unknown"),
+        projectPath,
+        toolName,
+        toolInput,
+        description: String(payload.description ?? body.description ?? `${toolName} \u5DE5\u5177\u8C03\u7528\u8BF7\u6C42`),
+        createdAt: Date.now()
+      };
+      console.log(`[ApprovalProxy] \u6536\u5230\u5BA1\u6279\u8BF7\u6C42: ${requestId} (${approvalRequest.toolName})`);
+      if (this.isToolAlwaysAllowed(approvalRequest.toolName, projectPath !== "unknown" ? projectPath : void 0)) {
+        console.log(`[ApprovalProxy] ${approvalRequest.toolName} \u5DF2\u88AB\u59CB\u7EC8\u5141\u8BB8\uFF0C\u76F4\u63A5\u653E\u884C\uFF08\u4E0D\u901A\u77E5\uFF09`);
+        this.sendJson(res, 200, { decision: "allow" });
+        return;
+      }
+      if (this.yoloSessions.get(approvalRequest.sessionId)) {
+        console.log(`[ApprovalProxy] YOLO \u6A21\u5F0F\uFF0C\u81EA\u52A8\u653E\u884C: ${approvalRequest.toolName}`);
+        this.sendJson(res, 200, { decision: "allow" });
+        return;
+      }
+      this.notifyApprovalRequest(approvalRequest);
+      const decision = await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          console.log(`[ApprovalProxy] \u5BA1\u6279\u8BF7\u6C42 ${requestId} \u5DF2\u8D85\u65F6\uFF0C\u9ED8\u8BA4\u5141\u8BB8`);
+          this.pendingApprovals.delete(requestId);
+          resolve({ decision: "allow" });
+        }, 325e3);
+        this.pendingApprovals.set(requestId, { resolve, timer, request: approvalRequest });
+      });
+      this.sendJson(res, 200, decision);
+    } catch (err) {
+      console.error("[ApprovalProxy] \u5904\u7406\u5BA1\u6279\u8BF7\u6C42\u5931\u8D25:", err);
+      this.sendJson(res, 200, { decision: "deny", reason: "\u670D\u52A1\u5668\u5904\u7406\u8BF7\u6C42\u5931\u8D25" });
+    }
+  }
+  /** 健康检查端点 */
+  handleHealth(_req, res) {
+    const info = this.statusInfoProvider?.() ?? { connections: 0, activeSessions: 0 };
+    this.sendJson(res, 200, {
+      status: "ok",
+      connections: info.connections,
+      activeSessions: info.activeSessions
+    });
+  }
+  /** 返回连接 token（仅本机访问） */
+  handleToken(req, res) {
+    const remoteAddress = req.socket.remoteAddress;
+    const isLocal = remoteAddress === "127.0.0.1" || remoteAddress === "::1" || remoteAddress === "::ffff:127.0.0.1";
+    if (!isLocal) {
+      this.sendJson(res, 403, { error: "Forbidden: \u4EC5\u5141\u8BB8\u672C\u673A\u8BBF\u95EE" });
+      return;
+    }
+    this.sendJson(res, 200, { token: this.token });
+  }
+  /** 通知所有注册的审批请求回调 */
+  notifyApprovalRequest(request) {
+    for (const callback of this.approvalRequestCallbacks) {
+      try {
+        callback(request);
+      } catch (err) {
+        console.error("[ApprovalProxy] \u5BA1\u6279\u8BF7\u6C42\u56DE\u8C03\u6267\u884C\u5F02\u5E38:", err);
+      }
+    }
+  }
+  /** 手动解析请求的 JSON body（限制最大 1MB 防止滥用） */
+  parseJsonBody(req) {
+    const MAX_BODY_SIZE = 1024 * 1024;
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let totalSize = 0;
+      let destroyed = false;
+      req.on("data", (chunk) => {
+        if (destroyed) return;
+        totalSize += chunk.length;
+        if (totalSize > MAX_BODY_SIZE) {
+          destroyed = true;
+          req.destroy();
+          return reject(new Error("\u8BF7\u6C42 body \u8FC7\u5927\uFF08\u8D85\u8FC7 1MB\uFF09"));
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => {
+        try {
+          const raw = Buffer.concat(chunks).toString("utf-8");
+          const parsed = JSON.parse(raw);
+          resolve(parsed);
+        } catch {
+          reject(new Error("\u65E0\u6548\u7684 JSON body"));
+        }
+      });
+      req.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  /** 发送 JSON 响应的辅助方法 */
+  sendJson(res, statusCode, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(statusCode, {
+      "Content-Type": "application/json; charset=utf-8",
+      "Content-Length": Buffer.byteLength(body)
+    });
+    res.end(body);
+  }
+};
+
+// src/mdns/MdnsService.ts
+var import_bonjour_service = __toESM(require("bonjour-service"));
+var MdnsService = class {
+  bonjour = null;
+  service = null;
+  wsPort;
+  httpPort;
+  version;
+  constructor(options) {
+    this.wsPort = options.wsPort;
+    this.httpPort = options.httpPort;
+    this.version = options.version ?? "0.1.0";
+  }
+  /**
+   * 启动 mDNS 广播
+   */
+  start() {
+    if (this.bonjour) {
+      console.warn("[MdnsService] \u670D\u52A1\u5DF2\u5728\u8FD0\u884C\u4E2D");
+      return;
+    }
+    this.bonjour = new import_bonjour_service.default();
+    this.service = this.bonjour.publish({
+      name: "Sessix",
+      type: "sessix",
+      port: this.wsPort,
+      txt: {
+        version: this.version,
+        httpPort: String(this.httpPort)
+      }
+    });
+    console.log(`[MdnsService] mDNS \u5E7F\u64AD\u5DF2\u542F\u52A8: _sessix._tcp \u7AEF\u53E3 ${this.wsPort}`);
+  }
+  /**
+   * 停止 mDNS 广播
+   */
+  stop() {
+    if (this.service) {
+      this.service.stop?.(() => {
+        console.log("[MdnsService] \u670D\u52A1\u5E7F\u64AD\u5DF2\u505C\u6B62");
+      });
+      this.service = null;
+    }
+    if (this.bonjour) {
+      this.bonjour.destroy();
+      this.bonjour = null;
+    }
+    console.log("[MdnsService] mDNS \u670D\u52A1\u5DF2\u5173\u95ED");
+  }
+};
+
+// src/hooks/HookInstaller.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+var import_node_os3 = require("os");
+var SESSIX_HOOKS_DIR = (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".sessix", "hooks");
+var HOOK_SCRIPT_PATH = (0, import_node_path2.join)(SESSIX_HOOKS_DIR, "approval-hook.sh");
+var PERMISSION_ACCEPT_PATH = (0, import_node_path2.join)(SESSIX_HOOKS_DIR, "permission-accept.sh");
+var CLAUDE_SETTINGS_PATH = (0, import_node_path2.join)((0, import_node_os3.homedir)(), ".claude", "settings.json");
+var HOOK_COMMAND = "~/.sessix/hooks/approval-hook.sh";
+var PERMISSION_ACCEPT_COMMAND = "~/.sessix/hooks/permission-accept.sh";
+var HOOK_SCRIPT_TEMPLATE = `#!/bin/bash
+# Sessix Approval Hook
+# \u4EC5\u5728 Sessix \u7BA1\u7406\u7684\u4F1A\u8BDD\u4E2D\u6FC0\u6D3B
+
+if [ -z "$SESSIX_SESSION_ID" ]; then
+  exit 0
+fi
+
+# \u4ECE stdin \u8BFB\u53D6 hook payload
+PAYLOAD=$(cat)
+
+# \u83B7\u53D6\u9879\u76EE\u8DEF\u5F84\uFF08\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09
+PROJECT_PATH="$PWD"
+
+# \u53D1\u9001\u5BA1\u6279\u8BF7\u6C42\u5230 Sessix \u670D\u52A1\u5668\uFF08\u957F\u8F6E\u8BE2\uFF0C\u8D85\u65F6\u65F6\u95F4 > 300s\uFF09
+RESPONSE=$(curl -s -X POST "http://localhost:3746/hook/approval" \\
+  -H "Content-Type: application/json" \\
+  -d "{\\"sessionId\\": \\"$SESSIX_SESSION_ID\\", \\"projectPath\\": \\"$PROJECT_PATH\\", \\"payload\\": $PAYLOAD}" \\
+  --max-time 330 \\
+  2>/dev/null)
+
+if [ $? -ne 0 ] || [ -z "$RESPONSE" ]; then
+  # \u5982\u679C Sessix \u670D\u52A1\u5668\u4E0D\u53EF\u7528\uFF0C\u9ED8\u8BA4\u653E\u884C\uFF08exit 0 = \u6279\u51C6\uFF09
+  exit 0
+fi
+
+# \u89E3\u6790\u670D\u52A1\u5668\u54CD\u5E94
+DECISION=$(echo "$RESPONSE" | grep -o '\\"decision\\":\\"[^"]*\\"' | cut -d'"' -f4)
+
+if [ "$DECISION" = "allow" ]; then
+  # \u7528\u6237\u6279\u51C6\u6216\u670D\u52A1\u5668\u8D85\u65F6\u81EA\u52A8\u6279\u51C6
+  exit 0
+elif [ "$DECISION" = "deny" ]; then
+  # \u7528\u6237\u660E\u786E\u62D2\u7EDD
+  exit 1
+else
+  # \u672A\u77E5\u54CD\u5E94\uFF0C\u9ED8\u8BA4\u653E\u884C
+  exit 0
+fi
+`;
+var PERMISSION_ACCEPT_TEMPLATE = `#!/bin/bash
+# Sessix PermissionRequest \u515C\u5E95
+# \u81EA\u52A8\u63A5\u53D7\u6743\u9650\u8BF7\u6C42\uFF0C\u907F\u514D Sessix \u4F1A\u8BDD\u963B\u585E
+
+if [ -z "$SESSIX_SESSION_ID" ]; then
+  exit 0
+fi
+
+# \u8F93\u51FA JSON \u51B3\u7B56\uFF0C\u81EA\u52A8\u63A5\u53D7\u6743\u9650\u8BF7\u6C42
+echo '{"decision":"allow"}'
+exit 0
+`;
+var HookInstaller = class {
+  /**
+   * 安装 hook
+   *
+   * 1. 创建 ~/.sessix/hooks/ 目录
+   * 2. 写入 approval-hook.sh 脚本
+   * 3. 赋予执行权限
+   * 4. 更新 Claude Code settings.json 添加 hook 配置
+   */
+  async install() {
+    await (0, import_promises2.mkdir)(SESSIX_HOOKS_DIR, { recursive: true });
+    await (0, import_promises2.writeFile)(HOOK_SCRIPT_PATH, HOOK_SCRIPT_TEMPLATE, "utf-8");
+    await (0, import_promises2.writeFile)(PERMISSION_ACCEPT_PATH, PERMISSION_ACCEPT_TEMPLATE, "utf-8");
+    await (0, import_promises2.chmod)(HOOK_SCRIPT_PATH, 493);
+    await (0, import_promises2.chmod)(PERMISSION_ACCEPT_PATH, 493);
+    await this.addHookToSettings();
+    console.log("[HookInstaller] Hook \u5B89\u88C5\u5B8C\u6210");
+  }
+  /**
+   * 卸载 hook
+   *
+   * 从 Claude Code settings.json 中移除 Sessix hook 配置。
+   * 注意：不删除 hook 脚本文件（保持幂等性，避免误删）。
+   */
+  async uninstall() {
+    await this.removeHookFromSettings();
+    console.log("[HookInstaller] Hook \u5DF2\u5378\u8F7D");
+  }
+  /**
+   * 检查 hook 是否已安装
+   * 脚本文件和 settings.json 配置必须同时存在才算已安装
+   */
+  async isInstalled() {
+    let approvalScriptExists = false;
+    let permissionScriptExists = false;
+    try {
+      await (0, import_promises2.access)(HOOK_SCRIPT_PATH);
+      approvalScriptExists = true;
+    } catch {
+    }
+    try {
+      await (0, import_promises2.access)(PERMISSION_ACCEPT_PATH);
+      permissionScriptExists = true;
+    } catch {
+    }
+    const settings = await this.readClaudeSettings();
+    const configExists = this.hasHookConfig(settings);
+    return approvalScriptExists && permissionScriptExists && configExists;
+  }
+  // ============================================
+  // 内部方法
+  // ============================================
+  /**
+   * 向 Claude Code settings.json 添加 Sessix hook 配置
+   */
+  async addHookToSettings() {
+    let settings = await this.readClaudeSettings();
+    let changed = false;
+    if (!settings.hooks) {
+      settings.hooks = {};
+    }
+    if (!this.hasPreToolUseConfig(settings)) {
+      if (!settings.hooks.PreToolUse) {
+        settings.hooks.PreToolUse = [];
+      }
+      settings.hooks.PreToolUse.push({
+        matcher: "",
+        hooks: [{ type: "command", command: HOOK_COMMAND }]
+      });
+      changed = true;
+    }
+    if (!this.hasPermissionRequestConfig(settings)) {
+      if (!settings.hooks.PermissionRequest) {
+        settings.hooks.PermissionRequest = [];
+      }
+      settings.hooks.PermissionRequest.push({
+        matcher: "",
+        hooks: [{ type: "command", command: PERMISSION_ACCEPT_COMMAND }]
+      });
+      changed = true;
+    }
+    if (changed) {
+      await this.writeClaudeSettings(settings);
+    } else {
+      console.log("[HookInstaller] Hook \u914D\u7F6E\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7");
+    }
+  }
+  /**
+   * 从 Claude Code settings.json 移除 Sessix hook 配置
+   */
+  async removeHookFromSettings() {
+    let settings = await this.readClaudeSettings();
+    if (!settings.hooks) return;
+    this.removeHookCommand(settings, "PreToolUse", HOOK_COMMAND);
+    this.removeHookCommand(settings, "PermissionRequest", PERMISSION_ACCEPT_COMMAND);
+    if (Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks;
+    }
+    await this.writeClaudeSettings(settings);
+  }
+  /** 从指定 hook 事件数组中移除包含指定命令的条目 */
+  removeHookCommand(settings, event, command) {
+    if (!Array.isArray(settings.hooks?.[event])) return;
+    settings.hooks[event] = settings.hooks[event].filter(
+      (entry) => !entry?.hooks?.some?.((h) => h.type === "command" && h.command === command)
+    );
+    if (settings.hooks[event].length === 0) {
+      delete settings.hooks[event];
+    }
+  }
+  /**
+   * 读取 Claude Code settings.json
+   */
+  async readClaudeSettings() {
+    try {
+      const content = await (0, import_promises2.readFile)(CLAUDE_SETTINGS_PATH, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * 写入 Claude Code settings.json
+   */
+  async writeClaudeSettings(settings) {
+    await (0, import_promises2.mkdir)((0, import_node_path2.join)((0, import_node_os3.homedir)(), ".claude"), { recursive: true });
+    await (0, import_promises2.writeFile)(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+  }
+  /**
+   * 检查 settings 中是否已包含所有 Sessix hook 配置
+   */
+  hasHookConfig(settings) {
+    return this.hasPreToolUseConfig(settings) && this.hasPermissionRequestConfig(settings);
+  }
+  /** 检查 PreToolUse 中是否有 approval-hook.sh */
+  hasPreToolUseConfig(settings) {
+    return this.hasHookEntry(settings?.hooks?.PreToolUse, HOOK_COMMAND);
+  }
+  /** 检查 PermissionRequest 中是否有 permission-accept.sh */
+  hasPermissionRequestConfig(settings) {
+    return this.hasHookEntry(settings?.hooks?.PermissionRequest, PERMISSION_ACCEPT_COMMAND);
+  }
+  /** 检查 hook 数组中是否包含指定命令 */
+  hasHookEntry(hookArray, command) {
+    if (!Array.isArray(hookArray)) return false;
+    return hookArray.some(
+      (entry) => entry?.hooks?.some?.((hook) => hook.type === "command" && hook.command === command)
+    );
+  }
+};
+
+// src/notification/NotificationService.ts
+var import_node_path3 = require("path");
+var NotificationService = class {
+  constructor(sessionManager, expoChannel = null) {
+    this.sessionManager = sessionManager;
+    this.expoChannel = expoChannel;
+    this.unsubscribe = sessionManager.onEvent((event) => this.handleEvent(event));
+    if (expoChannel) {
+      this.channelMap.set("expo", { channel: expoChannel, enabled: true });
+    }
+  }
+  channelMap = /* @__PURE__ */ new Map();
+  unsubscribe = null;
+  activityPushChannel = null;
+  /** YOLO 模式状态映射：sessionId -> isYoloMode */
+  yoloModeState = /* @__PURE__ */ new Map();
+  /** 每个会话的最新 assistant 文本消息（用于通知正文预览） */
+  latestAssistantText = /* @__PURE__ */ new Map();
+  /** 添加通知渠道（id 唯一，可用于后续动态开关） */
+  addChannel(id, channel, enabled = true) {
+    this.channelMap.set(id, { channel, enabled });
+  }
+  /** 运行时切换指定渠道的启用状态 */
+  setChannelEnabled(id, enabled) {
+    const entry = this.channelMap.get(id);
+    if (entry) entry.enabled = enabled;
+  }
+  /** 注册手机 push token（连接建立时由 WsBridge 调用） */
+  addPushToken(token) {
+    this.expoChannel?.addToken(token);
+  }
+  /** 移除手机 push token（断线时或手机主动注销时调用） */
+  removePushToken(token) {
+    this.expoChannel?.removeToken(token);
+  }
+  /** 更新通知音效偏好 */
+  setSoundPreferences(prefs) {
+    this.expoChannel?.setSoundPreferences(prefs);
+  }
+  /** 设置 ActivityKit Push 渠道（可选，需要 APNs 认证配置） */
+  setActivityPushChannel(channel) {
+    this.activityPushChannel = channel;
+  }
+  /** 注册 ActivityKit push token（由手机端启动 Live Activity 后上报） */
+  addActivityPushToken(sessionId, token) {
+    this.activityPushChannel?.addToken(sessionId, token);
+  }
+  /** 移除 ActivityKit push token */
+  removeActivityPushToken(sessionId) {
+    this.activityPushChannel?.removeToken(sessionId);
+  }
+  /** 更新会话的 YOLO 模式状态 */
+  setYoloMode(sessionId, enabled) {
+    this.yoloModeState.set(sessionId, enabled);
+  }
+  /** 直接触发审批通知（由 ApprovalProxy 回调调用） */
+  notifyApproval(request, pendingCount) {
+    if (this.yoloModeState.get(request.sessionId)) return;
+    const sessionTitle = this.getSessionTitle(request.sessionId);
+    const title = pendingCount > 1 ? `${sessionTitle} \u2014 ${pendingCount} \u9879\u5F85\u5BA1\u6279` : sessionTitle;
+    const body = pendingCount > 1 ? `\u{1F527} \u6700\u65B0: ${request.toolName}: ${request.description}` : `\u{1F527} ${request.toolName}: ${request.description}`;
+    if (this.activityPushChannel?.hasToken(request.sessionId)) {
+      const dangerLevel = this.getDangerLevel(request.toolName);
+      const isYoloMode = this.getYoloMode(request.sessionId);
+      this.activityPushChannel.updateActivityWithAlert(
+        request.sessionId,
+        {
+          status: "waitingApproval",
+          sessionTitle,
+          latestMessage: `${request.toolName}: ${request.description}`,
+          approvalInfo: {
+            requestId: request.id,
+            toolName: request.toolName,
+            description: request.description.slice(0, 80),
+            dangerLevel,
+            pendingCount
+          },
+          isYoloMode,
+          updatedAt: Date.now()
+        },
+        { title, body }
+      );
+      return;
+    }
+    this.notify({
+      title,
+      body,
+      sound: "Funk",
+      badge: pendingCount,
+      data: {
+        type: "approval_request",
+        sessionId: request.sessionId,
+        requestId: request.id
+      }
+    });
+  }
+  /** 简单的工具危险等级判断 */
+  getDangerLevel(toolName) {
+    if (toolName === "Bash") return "danger";
+    if (["Write", "Edit", "NotebookEdit"].includes(toolName)) return "write";
+    return "safe";
+  }
+  /** 清理资源 */
+  destroy() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.yoloModeState.clear();
+    this.latestAssistantText.clear();
+  }
+  // ============================================
+  // 内部方法
+  // ============================================
+  handleEvent(event) {
+    switch (event.type) {
+      case "claude_event": {
+        this.trackAssistantText(event.sessionId, event.event);
+        break;
+      }
+      case "claude_events": {
+        for (const e of event.events) {
+          this.trackAssistantText(event.sessionId, e);
+        }
+        break;
+      }
+      case "status_change": {
+        if (event.status === "idle") {
+          const sessionTitle = this.getSessionTitle(event.sessionId);
+          const latestMsg = this.latestAssistantText.get(event.sessionId);
+          const body = latestMsg ? `\u2705 ${latestMsg.slice(0, 80)}` : "\u5DF2\u5B8C\u6210\uFF0C\u7B49\u5F85\u4E0B\u4E00\u6B65\u6307\u4EE4";
+          const isYoloMode = this.getYoloMode(event.sessionId);
+          if (this.activityPushChannel?.hasToken(event.sessionId)) {
+            this.activityPushChannel.endActivity(event.sessionId, {
+              status: "idle",
+              sessionTitle,
+              latestMessage: body,
+              isYoloMode,
+              updatedAt: Date.now()
+            });
+          } else {
+            this.notify({
+              title: sessionTitle,
+              body,
+              sound: "Glass",
+              data: { type: "task_complete", sessionId: event.sessionId }
+            });
+          }
+        } else if (event.status === "error") {
+          const sessionTitle = this.getSessionTitle(event.sessionId);
+          const latestMsg = this.latestAssistantText.get(event.sessionId);
+          const body = latestMsg ? `\u274C ${latestMsg.slice(0, 80)}` : "\u6267\u884C\u51FA\u9519\uFF0C\u8BF7\u67E5\u770B\u8BE6\u60C5";
+          const isYoloMode = this.getYoloMode(event.sessionId);
+          if (this.activityPushChannel?.hasToken(event.sessionId)) {
+            this.activityPushChannel.endActivity(event.sessionId, {
+              status: "error",
+              sessionTitle,
+              latestMessage: body,
+              isYoloMode,
+              updatedAt: Date.now()
+            });
+          } else {
+            this.notify({
+              title: sessionTitle,
+              body,
+              sound: "Basso",
+              data: { type: "task_error", sessionId: event.sessionId }
+            });
+          }
+        }
+        break;
+      }
+    }
+  }
+  notify(payload) {
+    for (const { channel, enabled } of this.channelMap.values()) {
+      if (!enabled) continue;
+      channel.send(payload).catch((err) => {
+        console.error("[NotificationService] \u901A\u77E5\u53D1\u9001\u5931\u8D25:", err);
+      });
+    }
+  }
+  /** 从 assistant 事件中提取最新文本消息 */
+  trackAssistantText(sessionId, event) {
+    if (event.type !== "assistant") return;
+    const textBlocks = event.message.content.filter((b) => b.type === "text");
+    const lastText = textBlocks[textBlocks.length - 1];
+    if (lastText && lastText.type === "text" && lastText.text.trim()) {
+      this.latestAssistantText.set(sessionId, lastText.text.trim());
+    }
+  }
+  /** 获取会话标题：优先 summary，fallback 到项目名 */
+  getSessionTitle(sessionId) {
+    const session = this.sessionManager.getActiveSessions().find((s) => s.id === sessionId);
+    if (!session) return "Unknown";
+    return session.summary ?? (0, import_node_path3.basename)(session.projectPath);
+  }
+  /** 获取会话的 YOLO 模式状态 */
+  getYoloMode(sessionId) {
+    return this.yoloModeState.get(sessionId) ?? false;
+  }
+};
+
+// src/notification/MacNotificationChannel.ts
+var import_node_child_process = require("child_process");
+var MacNotificationChannel = class {
+  isAvailable() {
+    return process.platform === "darwin";
+  }
+  send(payload) {
+    if (!this.isAvailable()) return Promise.resolve();
+    const title = payload.title.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    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_process.execFile)("osascript", ["-e", script], (err) => {
+        if (err) {
+          console.warn("[MacNotificationChannel] \u53D1\u9001\u901A\u77E5\u5931\u8D25:", err.message);
+        }
+        resolve();
+      });
+    });
+  }
+};
+
+// src/notification/ExpoNotificationChannel.ts
+var EXPO_PUSH_API = "https://exp.host/--/api/v2/push/send";
+var ExpoNotificationChannel = class {
+  tokens = /* @__PURE__ */ new Set();
+  /** per-token 通知音效偏好 */
+  soundPreferences = /* @__PURE__ */ new Map();
+  isAvailable() {
+    return this.tokens.size > 0;
+  }
+  addToken(token) {
+    this.tokens.add(token);
+    console.log(`[ExpoNotificationChannel] \u5DF2\u6CE8\u518C push token\uFF0C\u5F53\u524D\u8BBE\u5907\u6570: ${this.tokens.size}`);
+  }
+  removeToken(token) {
+    this.tokens.delete(token);
+    this.soundPreferences.delete(token);
+    console.log(`[ExpoNotificationChannel] \u5DF2\u79FB\u9664 push token\uFF0C\u5F53\u524D\u8BBE\u5907\u6570: ${this.tokens.size}`);
+  }
+  /** 更新某个 token 的音效偏好 */
+  setSoundPreferences(prefs) {
+    for (const token of this.tokens) {
+      this.soundPreferences.set(token, prefs);
+    }
+    console.log("[ExpoNotificationChannel] \u5DF2\u66F4\u65B0\u97F3\u6548\u504F\u597D");
+  }
+  async send(payload) {
+    if (this.tokens.size === 0) return;
+    const messages = Array.from(this.tokens).map((to) => {
+      let sound = payload.sound ?? "default";
+      const prefs = this.soundPreferences.get(to);
+      if (prefs) {
+        const notifType = payload.data?.type ?? "";
+        if (notifType === "approval_request" && prefs.approval) sound = prefs.approval;
+        else if (notifType === "task_complete" && prefs.taskComplete) sound = prefs.taskComplete;
+        else if (notifType === "task_error" && prefs.taskError) sound = prefs.taskError;
+      }
+      return {
+        to,
+        title: payload.title,
+        body: payload.body,
+        badge: payload.badge,
+        sound: sound === "none" ? null : sound,
+        data: payload.data ?? {}
+      };
+    });
+    try {
+      console.log("[ExpoNotificationChannel] \u53D1\u9001\u63A8\u9001\uFF0Ctokens:", Array.from(this.tokens));
+      const res = await fetch(EXPO_PUSH_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Accept: "application/json" },
+        body: JSON.stringify(messages)
+      });
+      const body = await res.json();
+      if (!res.ok) {
+        console.warn("[ExpoNotificationChannel] Expo Push API \u8FD4\u56DE\u9519\u8BEF:", res.status, JSON.stringify(body));
+      } else {
+        if (!Array.isArray(body?.data)) {
+          console.warn("[ExpoNotificationChannel] Expo Push API \u54CD\u5E94\u683C\u5F0F\u5F02\u5E38\uFF0C\u7F3A\u5C11 data \u6570\u7EC4:", JSON.stringify(body));
+          return;
+        }
+        for (const ticket of body.data) {
+          if (ticket.status === "error") {
+            console.error(`[ExpoNotificationChannel] \u63A8\u9001\u5931\u8D25: ${ticket.message} (${ticket.details?.error ?? "unknown"})`);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn("[ExpoNotificationChannel] \u53D1\u9001\u63A8\u9001\u5931\u8D25:", err);
+    }
+  }
+};
+
+// src/notification/ActivityPushChannel.ts
+var http2 = __toESM(require("http2"));
+var fs2 = __toESM(require("fs"));
+var crypto = __toESM(require("crypto"));
+var ActivityPushChannel = class {
+  /** sessionId -> activityPushToken */
+  tokens = /* @__PURE__ */ new Map();
+  teamId;
+  keyId;
+  authKey;
+  apnsHost;
+  /** 缓存的 JWT token + 过期时间 */
+  cachedJwt = null;
+  /** 复用的 HTTP/2 长连接 */
+  http2Client = null;
+  constructor(config) {
+    this.teamId = config.teamId;
+    this.keyId = config.keyId;
+    this.authKey = fs2.readFileSync(config.authKeyPath, "utf-8");
+    this.apnsHost = config.sandbox ? "api.sandbox.push.apple.com" : "api.push.apple.com";
+    console.log(`[ActivityPushChannel] \u5DF2\u521D\u59CB\u5316 (${config.sandbox ? "\u6C99\u7BB1" : "\u751F\u4EA7"}\u6A21\u5F0F)`);
+  }
+  /** 获取或新建 HTTP/2 长连接 */
+  getHttp2Client() {
+    if (this.http2Client && !this.http2Client.destroyed && !this.http2Client.closed) {
+      return this.http2Client;
+    }
+    this.http2Client = http2.connect(`https://${this.apnsHost}`);
+    this.http2Client.on("error", (err) => {
+      console.warn("[ActivityPushChannel] HTTP/2 \u8FDE\u63A5\u9519\u8BEF\uFF0C\u5C06\u5728\u4E0B\u6B21\u8BF7\u6C42\u65F6\u91CD\u5EFA:", err.message);
+      this.http2Client?.destroy();
+      this.http2Client = null;
+    });
+    this.http2Client.on("close", () => {
+      this.http2Client = null;
+    });
+    return this.http2Client;
+  }
+  /** 注册 Activity push token */
+  addToken(sessionId, token) {
+    this.tokens.set(sessionId, token);
+    console.log(`[ActivityPushChannel] \u5DF2\u6CE8\u518C token: session=${sessionId}`);
+  }
+  /** 移除 Activity push token */
+  removeToken(sessionId) {
+    this.tokens.delete(sessionId);
+  }
+  /** 发送 content-state 更新到指定会话的 Live Activity */
+  async updateActivity(sessionId, contentState) {
+    const token = this.tokens.get(sessionId);
+    if (!token) return;
+    const payload = {
+      aps: {
+        timestamp: Math.floor(Date.now() / 1e3),
+        event: "update",
+        "content-state": contentState
+      }
+    };
+    try {
+      await this.sendToAPNs(token, payload);
+    } catch (err) {
+      console.warn(`[ActivityPushChannel] \u66F4\u65B0\u5931\u8D25 session=${sessionId}:`, err);
+    }
+  }
+  /** 发送带通知的 content-state 更新（审批请求时使用） */
+  async updateActivityWithAlert(sessionId, contentState, alert) {
+    const token = this.tokens.get(sessionId);
+    if (!token) return;
+    const payload = {
+      aps: {
+        timestamp: Math.floor(Date.now() / 1e3),
+        event: "update",
+        "content-state": contentState,
+        alert,
+        sound: "default"
+      }
+    };
+    try {
+      await this.sendToAPNs(token, payload);
+    } catch (err) {
+      console.warn(`[ActivityPushChannel] \u5E26\u63D0\u9192\u66F4\u65B0\u5931\u8D25 session=${sessionId}:`, err);
+    }
+  }
+  /** 结束指定会话的 Live Activity */
+  async endActivity(sessionId, contentState) {
+    const token = this.tokens.get(sessionId);
+    if (!token) return;
+    const payload = {
+      aps: {
+        timestamp: Math.floor(Date.now() / 1e3),
+        event: "end",
+        "content-state": contentState
+      }
+    };
+    try {
+      await this.sendToAPNs(token, payload);
+    } catch (err) {
+      console.warn(`[ActivityPushChannel] \u7ED3\u675F\u5931\u8D25 session=${sessionId}:`, err);
+    }
+    this.tokens.delete(sessionId);
+  }
+  /** 检查是否有指定会话的 token */
+  hasToken(sessionId) {
+    return this.tokens.has(sessionId);
+  }
+  /** 发送 APNs HTTP/2 请求 */
+  async sendToAPNs(deviceToken, payload) {
+    const topic = "com.kachun.sessix.push-type.liveactivity";
+    const jwt = this.getJWT();
+    const payloadStr = JSON.stringify(payload);
+    return new Promise((resolve, reject) => {
+      let client;
+      try {
+        client = this.getHttp2Client();
+      } catch (err) {
+        return reject(err);
+      }
+      const req = client.request({
+        ":method": "POST",
+        ":path": `/3/device/${deviceToken}`,
+        "authorization": `bearer ${jwt}`,
+        "apns-topic": topic,
+        "apns-push-type": "liveactivity",
+        "apns-priority": "10",
+        "apns-expiration": String(Math.floor(Date.now() / 1e3) + 30),
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(payloadStr)
+      });
+      let statusCode = 0;
+      let responseData = "";
+      req.on("response", (headers) => {
+        statusCode = Number(headers[":status"] ?? 0);
+      });
+      req.on("data", (chunk) => {
+        responseData += chunk;
+      });
+      req.on("end", () => {
+        if (statusCode === 200) {
+          resolve();
+        } else {
+          if (statusCode === 0) {
+            this.http2Client?.destroy();
+            this.http2Client = null;
+          }
+          reject(new Error(`APNs \u8FD4\u56DE ${statusCode}: ${responseData}`));
+        }
+      });
+      req.on("error", (err) => {
+        reject(err);
+      });
+      req.write(payloadStr);
+      req.end();
+    });
+  }
+  /** 生成或获取缓存的 APNs JWT token */
+  getJWT() {
+    const now = Math.floor(Date.now() / 1e3);
+    if (this.cachedJwt && this.cachedJwt.expiresAt > now) {
+      return this.cachedJwt.token;
+    }
+    const header = Buffer.from(JSON.stringify({
+      alg: "ES256",
+      kid: this.keyId
+    })).toString("base64url");
+    const claims = Buffer.from(JSON.stringify({
+      iss: this.teamId,
+      iat: now
+    })).toString("base64url");
+    const signingInput = `${header}.${claims}`;
+    const sign = crypto.createSign("SHA256");
+    sign.update(signingInput);
+    const signature = sign.sign(this.authKey, "base64url");
+    const token = `${signingInput}.${signature}`;
+    this.cachedJwt = { token, expiresAt: now + 3e3 };
+    return token;
+  }
+};
+
+// 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");
+function getSessionFilePath(projectPath, sessionId) {
+  return (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodeDirName(projectPath), `${sessionId}.jsonl`);
+}
+async function getProjects() {
+  try {
+    const dirExists = await directoryExists(CLAUDE_PROJECTS_DIR);
+    if (!dirExists) {
+      return { ok: true, value: [] };
+    }
+    const entries = await (0, import_promises3.readdir)(CLAUDE_PROJECTS_DIR, { withFileTypes: true });
+    const projects = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) {
+        continue;
+      }
+      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 { count: sessionCount, latestMtime } = await countJsonlFilesWithMtime(projectDir);
+      projects.push({
+        id: encodedPath,
+        path: decodedPath,
+        name,
+        sessionCount,
+        lastActiveAt: latestMtime
+      });
+    }
+    projects.sort((a, b) => a.name.localeCompare(b.name));
+    return { ok: true, value: projects };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+async function getHistoricalSessions(projectPath) {
+  try {
+    const encodedPath = encodeDirName(projectPath);
+    const projectDir = (0, import_path.join)(CLAUDE_PROJECTS_DIR, encodedPath);
+    const dirExists = await directoryExists(projectDir);
+    if (!dirExists) {
+      return { ok: true, value: [] };
+    }
+    const entries = await (0, import_promises3.readdir)(projectDir, { withFileTypes: true });
+    const jsonlFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
+    const mtimeMap = /* @__PURE__ */ new Map();
+    for (const entry of jsonlFiles) {
+      const sessionId = entry.name.slice(0, -6);
+      const filePath = (0, import_path.join)(projectDir, entry.name);
+      try {
+        const fileStat = await (0, import_promises3.stat)(filePath);
+        mtimeMap.set(sessionId, fileStat.mtimeMs);
+      } catch {
+        mtimeMap.set(sessionId, 0);
+      }
+    }
+    const uuidDirs = entries.filter(
+      (e) => e.isDirectory() && UUID_RE.test(e.name) && !mtimeMap.has(e.name)
+    );
+    for (const entry of uuidDirs) {
+      try {
+        const fileStat = await (0, import_promises3.stat)((0, import_path.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 sessionMap = /* @__PURE__ */ new Map();
+    try {
+      const indexContent = await (0, import_promises3.readFile)(indexPath, "utf-8");
+      const indexData = JSON.parse(indexContent);
+      if (indexData.version === 1 && Array.isArray(indexData.entries)) {
+        for (const entry of indexData.entries) {
+          const mtime = mtimeMap.get(entry.sessionId) ?? entry.fileMtime ?? (entry.modified ? new Date(entry.modified).getTime() : 0);
+          sessionMap.set(entry.sessionId, {
+            sessionId: entry.sessionId,
+            lastModified: mtime,
+            summary: entry.summary,
+            firstPrompt: entry.firstPrompt,
+            messageCount: entry.messageCount
+          });
+        }
+        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 firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
+            if (firstPrompt) s.firstPrompt = firstPrompt;
+          })
+        );
+      }
+    } catch {
+    }
+    const uuidDirSet = new Set(uuidDirs.map((e) => e.name));
+    for (const [sessionId, mtime] of mtimeMap) {
+      if (!sessionMap.has(sessionId)) {
+        if (uuidDirSet.has(sessionId)) {
+          sessionMap.set(sessionId, { sessionId, lastModified: mtime, messageCount: -1 });
+        } else {
+          const filePath = (0, import_path.join)(projectDir, `${sessionId}.jsonl`);
+          const firstPrompt = await extractFirstPrompt(filePath).catch(() => void 0);
+          sessionMap.set(sessionId, { sessionId, lastModified: mtime, firstPrompt });
+        }
+      }
+    }
+    const sessions = Array.from(sessionMap.values()).filter((s) => {
+      if (s.messageCount === 0) return false;
+      if (s.messageCount === -1) return true;
+      if (s.firstPrompt === void 0 && s.messageCount === void 0) return false;
+      return true;
+    });
+    sessions.sort((a, b) => b.lastModified - a.lastModified);
+    return { ok: true, value: sessions };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+async function getSessionHistory(projectPath, sessionId) {
+  try {
+    const encodedPath = encodeDirName(projectPath);
+    const filePath = (0, import_path.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;
+    });
+    if (raw === null) return { ok: false, error: new Error("ENOENT") };
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const events = [];
+    for (const line of lines) {
+      try {
+        const obj = JSON.parse(line);
+        const type = obj.type;
+        if (type === "user" && obj.message) {
+          const msgContent = obj.message.content;
+          if (typeof msgContent === "string") {
+            if (msgContent.includes("<local-command") || msgContent.includes("<command-name>")) continue;
+          } else if (Array.isArray(msgContent)) {
+            const hasText = msgContent.some(
+              (b) => b.type === "text" && !b.text?.includes("<local-command") && !b.text?.includes("<command-name>")
+            );
+            if (!hasText) continue;
+          }
+          const normalizedContent = typeof msgContent === "string" ? [{ type: "text", text: msgContent }] : Array.isArray(msgContent) ? msgContent.filter((b) => b.type === "text" && typeof b.text === "string") : [];
+          if (normalizedContent.length === 0) continue;
+          events.push({
+            type: "user",
+            message: {
+              ...obj.message,
+              content: normalizedContent
+            },
+            session_id: sessionId
+          });
+        } else if (type === "assistant" && obj.message) {
+          const content = (obj.message.content ?? []).filter(
+            (b) => b.type === "text" || b.type === "tool_use" || b.type === "thinking"
+          );
+          if (content.length === 0) continue;
+          events.push({
+            type: "assistant",
+            message: {
+              id: obj.message.id ?? obj.uuid ?? `hist-${events.length}`,
+              model: obj.message.model ?? "unknown",
+              role: "assistant",
+              content,
+              stop_reason: obj.message.stop_reason,
+              usage: obj.message.usage
+            },
+            session_id: sessionId
+          });
+        }
+      } catch {
+      }
+    }
+    if (events.length > 0) {
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+      for (const ev of events) {
+        if (ev.type === "assistant" && ev.message.usage) {
+          totalInputTokens += ev.message.usage.input_tokens ?? 0;
+          totalOutputTokens += ev.message.usage.output_tokens ?? 0;
+        }
+      }
+      if (totalInputTokens > 0 || totalOutputTokens > 0) {
+        events.push({
+          type: "result",
+          subtype: "success",
+          is_error: false,
+          duration_ms: 0,
+          num_turns: events.filter((e) => e.type === "user").length,
+          result: "",
+          session_id: sessionId,
+          usage: { input_tokens: totalInputTokens, output_tokens: totalOutputTokens }
+        });
+      }
+    }
+    return { ok: true, value: events };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+async function extractFirstPrompt(filePath) {
+  let fileHandle;
+  try {
+    fileHandle = await (0, import_promises3.open)(filePath, "r");
+    const rl = (0, import_readline2.createInterface)({
+      input: fileHandle.createReadStream({ encoding: "utf-8" }),
+      crlfDelay: Infinity
+    });
+    let lineCount = 0;
+    for await (const line of rl) {
+      if (++lineCount > 20) break;
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "user" && obj.message) {
+          const msgContent = obj.message.content;
+          let text = "";
+          if (typeof msgContent === "string") {
+            text = msgContent;
+          } else if (Array.isArray(msgContent)) {
+            const textBlock = msgContent.find((b) => b.type === "text" && typeof b.text === "string");
+            text = textBlock?.text ?? "";
+          }
+          if (text && !text.includes("<local-command") && !text.includes("<command-name>")) {
+            text = text.replace(/<ide_opened_file>[\s\S]*?<\/ide_opened_file>/gi, "");
+            text = text.replace(/<[^>]+>/g, "").trim();
+            rl.close();
+            return text.length > 80 ? text.slice(0, 80) + "..." : text;
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  } finally {
+    await fileHandle?.close();
+  }
+  return void 0;
+}
+function decodeDirName(dirName) {
+  const placeholder = "\0";
+  const escaped = dirName.replace(/--/g, placeholder);
+  const decoded = escaped.replace(/-/g, "/");
+  return decoded.replace(new RegExp(placeholder, "g"), "-");
+}
+function encodeDirName(path2) {
+  const escaped = path2.replace(/-/g, "--");
+  return escaped.replace(/\//g, "-");
+}
+async function directoryExists(dirPath) {
+  try {
+    const s = await (0, import_promises3.stat)(dirPath);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function countJsonlFilesWithMtime(dirPath) {
+  try {
+    const entries = await (0, import_promises3.readdir)(dirPath, { withFileTypes: true });
+    const jsonlNames = new Set(
+      entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => e.name.slice(0, -6))
+    );
+    const uuidDirs = entries.filter(
+      (e) => e.isDirectory() && UUID_RE.test(e.name) && !jsonlNames.has(e.name)
+    );
+    let latestMtime = 0;
+    const allEntries = [
+      ...entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")),
+      ...uuidDirs
+    ];
+    for (const entry of allEntries) {
+      try {
+        const fileStat = await (0, import_promises3.stat)((0, import_path.join)(dirPath, entry.name));
+        if (fileStat.mtimeMs > latestMtime) latestMtime = fileStat.mtimeMs;
+      } catch {
+      }
+    }
+    return { count: jsonlNames.size + uuidDirs.length, latestMtime };
+  } catch {
+    return { count: 0, latestMtime: 0 };
+  }
+}
+
+// src/server.ts
+var import_promises5 = require("fs/promises");
+var WS_PORT = 3745;
+var HTTP_PORT = 3746;
+var execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
+async function killPortProcess(port) {
+  try {
+    const { stdout } = await execAsync(`lsof -ti :${port}`);
+    const pids = stdout.trim().split("\n").filter((p) => p && /^\d+$/.test(p));
+    if (pids.length > 0) {
+      await execAsync(`kill -9 ${pids.join(" ")}`);
+      await new Promise((resolve) => setTimeout(resolve, 600));
+    }
+  } catch {
+  }
+}
+async function createWithRetry(label, port, factory) {
+  try {
+    return await factory();
+  } catch (err) {
+    if (err?.code === "EADDRINUSE") {
+      console.warn(`[Server] \u7AEF\u53E3 ${port} \u88AB\u5360\u7528\uFF0C\u5C1D\u8BD5\u91CA\u653E\u65E7\u8FDB\u7A0B...`);
+      await killPortProcess(port);
+      console.log(`[Server] \u91CD\u65B0\u542F\u52A8 ${label}...`);
+      return await factory();
+    }
+    throw err;
+  }
+}
+async function start(opts = {}) {
+  const configDir = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".sessix");
+  const tokenFile = (0, import_node_path4.join)(configDir, "token");
+  let token;
+  if (opts.token !== void 0) {
+    token = opts.token;
+  } else {
+    const envToken = process.env.SESSIX_TOKEN;
+    if (envToken !== void 0) {
+      token = envToken;
+    } else {
+      try {
+        token = (await (0, import_promises4.readFile)(tokenFile, "utf8")).trim();
+      } catch {
+        token = (0, import_uuid4.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 expoChannel = new ExpoNotificationChannel();
+  const notificationService = new NotificationService(sessionManager, expoChannel);
+  notificationService.addChannel("expo", expoChannel, opts.enableExpoPush !== false);
+  notificationService.addChannel("mac", new MacNotificationChannel(), opts.enableMacNotification !== false);
+  if (opts.activityPush) {
+    try {
+      const activityChannel = new ActivityPushChannel(opts.activityPush);
+      notificationService.setActivityPushChannel(activityChannel);
+      console.log("[Server] ActivityKit Push \u5DF2\u542F\u7528");
+    } catch (err) {
+      console.warn("[Server] ActivityKit Push \u521D\u59CB\u5316\u5931\u8D25:", err);
+      console.log("[Server] \u7EE7\u7EED\u542F\u52A8\uFF08Live Activity \u540E\u53F0\u63A8\u9001\u4E0D\u53EF\u7528\uFF09");
+    }
+  }
+  const wsBridge = await createWithRetry(
+    "WsBridge",
+    WS_PORT,
+    () => WsBridge.create({ port: WS_PORT, token })
+  );
+  const sessionFileWatcher = new SessionFileWatcher((event) => {
+    wsBridge.broadcast(event);
+  });
+  const approvalProxy = await createWithRetry(
+    "ApprovalProxy",
+    HTTP_PORT,
+    () => ApprovalProxy.create({ port: HTTP_PORT, token })
+  );
+  wsBridge.onConnection(async (ws) => {
+    const result = await getProjects();
+    if (result.ok) {
+      wsBridge.send(ws, { type: "project_list", projects: result.value });
+    }
+    wsBridge.send(ws, {
+      type: "session_list",
+      sessions: sessionManager.getActiveSessions()
+    });
+  });
+  wsBridge.onClientEvent(async (event, ws) => {
+    try {
+      switch (event.type) {
+        case "create_session": {
+          await (0, import_promises4.mkdir)(event.projectPath, { recursive: true });
+          await sessionManager.createSession(
+            event.projectPath,
+            event.message,
+            event.resumeSessionId,
+            event.newSessionId,
+            event.model,
+            event.permissionMode,
+            event.effort,
+            event.images
+          );
+          wsBridge.broadcast({
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions()
+          });
+          break;
+        }
+        case "send_message": {
+          await sessionManager.sendMessage(event.sessionId, event.message, event.permissionMode, event.images);
+          wsBridge.broadcast({
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions()
+          });
+          break;
+        }
+        case "kill_session": {
+          wsBridge.broadcast({ type: "status_change", sessionId: event.sessionId, status: "idle" });
+          await sessionManager.killSession(event.sessionId);
+          wsBridge.broadcast({
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions()
+          });
+          break;
+        }
+        case "approve": {
+          approvalProxy.resolveApproval(event.requestId, { decision: "allow" });
+          break;
+        }
+        case "reject": {
+          const decision = { decision: "deny", reason: event.reason };
+          approvalProxy.resolveApproval(event.requestId, decision);
+          break;
+        }
+        case "answer_question": {
+          sessionManager.handleQuestionResponse(event.requestId, event.answer);
+          break;
+        }
+        case "subscribe": {
+          wsBridge.send(ws, {
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions()
+          });
+          const bufferedEvents = sessionManager.getSessionEvents(event.sessionId);
+          if (bufferedEvents.length > 0) {
+            wsBridge.send(ws, {
+              type: "session_history",
+              sessionId: event.sessionId,
+              events: bufferedEvents
+            });
+          }
+          for (const req of approvalProxy.getPendingRequestsForSession(event.sessionId)) {
+            wsBridge.send(ws, { type: "approval_request", request: req });
+          }
+          break;
+        }
+        case "list_projects": {
+          const result = await getProjects();
+          if (result.ok) {
+            wsBridge.send(ws, { type: "project_list", projects: result.value });
+          } else {
+            wsBridge.send(ws, {
+              type: "error",
+              message: `\u83B7\u53D6\u9879\u76EE\u5217\u8868\u5931\u8D25: ${result.error.message}`,
+              code: "PROJECT_LIST_ERROR"
+            });
+          }
+          break;
+        }
+        case "list_sessions": {
+          wsBridge.send(ws, {
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions().filter(
+              (s) => s.projectPath === event.projectPath
+            )
+          });
+          break;
+        }
+        case "list_project_sessions": {
+          const histResult = await getHistoricalSessions(event.projectPath);
+          if (histResult.ok) {
+            wsBridge.send(ws, {
+              type: "project_sessions",
+              projectPath: event.projectPath,
+              sessions: histResult.value
+            });
+          } else {
+            wsBridge.send(ws, {
+              type: "error",
+              message: `\u83B7\u53D6\u9879\u76EE\u4F1A\u8BDD\u5931\u8D25: ${histResult.error.message}`,
+              code: "PROJECT_SESSIONS_ERROR"
+            });
+          }
+          break;
+        }
+        case "load_session_history": {
+          const historyResult = await getSessionHistory(event.projectPath, event.sessionId);
+          if (!historyResult.ok) {
+            wsBridge.send(ws, {
+              type: "error",
+              message: `\u8BFB\u53D6\u4F1A\u8BDD\u5386\u53F2\u5931\u8D25: ${historyResult.error.message}`,
+              code: "SESSION_HISTORY_ERROR",
+              sessionId: event.sessionId
+            });
+          } else if (historyResult.value.length > 0) {
+            wsBridge.send(ws, {
+              type: "session_history",
+              sessionId: event.sessionId,
+              events: historyResult.value
+            });
+            const activeSession = sessionManager.getActiveSessions().find((s) => s.id === event.sessionId);
+            const isStreaming = activeSession?.status === "running" || activeSession?.status === "waiting_approval";
+            if (!isStreaming) {
+              const filePath = getSessionFilePath(event.projectPath, event.sessionId);
+              try {
+                const fileStat = await (0, import_promises5.stat)(filePath);
+                sessionFileWatcher.watch(event.sessionId, filePath, fileStat.size);
+              } catch {
+              }
+            }
+          }
+          break;
+        }
+        case "suggest_next_prompt": {
+          const historyResult = await getSessionHistory(event.projectPath, event.sessionId);
+          let context = "\uFF08\u6682\u65E0\u5BF9\u8BDD\u5386\u53F2\uFF09";
+          if (historyResult.ok && historyResult.value.length > 0) {
+            const recent = historyResult.value.slice(-10);
+            context = recent.map((e) => {
+              if (e.type === "assistant") {
+                const text = e.message.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+                return `Assistant: ${text.substring(0, 300)}`;
+              }
+              if (e.type === "user") {
+                const text = e.message.content.filter((b) => b.type === "text" && !!b.text).map((b) => b.text).join("");
+                return text ? `User: ${text.substring(0, 300)}` : null;
+              }
+              return null;
+            }).filter(Boolean).join("\n");
+          }
+          const suggestion = await provider.generateSuggestion(context);
+          wsBridge.send(ws, {
+            type: "prompt_suggestion",
+            sessionId: event.sessionId,
+            suggestion
+          });
+          break;
+        }
+        case "register_push_token": {
+          notificationService.addPushToken(event.token);
+          break;
+        }
+        case "unregister_push_token": {
+          notificationService.removePushToken(event.token);
+          break;
+        }
+        case "update_notification_sounds": {
+          notificationService.setSoundPreferences(event.preferences);
+          break;
+        }
+        case "register_activity_push_token": {
+          notificationService.addActivityPushToken(event.sessionId, event.token);
+          break;
+        }
+        case "unregister_activity_push_token": {
+          notificationService.removeActivityPushToken(event.sessionId);
+          break;
+        }
+        case "set_yolo_mode": {
+          notificationService.setYoloMode(event.sessionId, event.enabled);
+          approvalProxy.setYoloMode(event.sessionId, event.enabled);
+          break;
+        }
+        case "viewing_session": {
+          wsBridge.setViewingSession(ws, event.sessionId);
+          break;
+        }
+        case "left_session": {
+          wsBridge.clearViewingSession(ws);
+          break;
+        }
+        case "always_allow_tool": {
+          approvalProxy.addToClaudeSettings(event.projectPath, event.toolName);
+          break;
+        }
+        default: {
+          wsBridge.send(ws, {
+            type: "error",
+            message: `\u672A\u77E5\u7684\u4E8B\u4EF6\u7C7B\u578B: ${event.type}`,
+            code: "UNKNOWN_EVENT"
+          });
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error("[Server] \u5904\u7406\u5BA2\u6237\u7AEF\u4E8B\u4EF6\u5F02\u5E38:", message);
+      const errorCodeMap = {
+        create_session: "SESSION_CREATE_ERROR",
+        send_message: "SEND_MESSAGE_ERROR",
+        kill_session: "KILL_SESSION_ERROR",
+        approve: "APPROVE_ERROR",
+        reject: "REJECT_ERROR",
+        answer_question: "ANSWER_QUESTION_ERROR",
+        suggest_next_prompt: "SUGGEST_PROMPT_ERROR"
+      };
+      const code = errorCodeMap[event.type] ?? "INTERNAL_ERROR";
+      wsBridge.send(ws, { type: "error", message, code });
+    }
+  });
+  sessionManager.onEvent((event) => {
+    wsBridge.broadcast(event);
+  });
+  wsBridge.onDisconnect(() => {
+    if (wsBridge.getConnectionCount() === 0 && approvalProxy.getPendingCount() > 0) {
+      approvalProxy.approveAll("\u624B\u673A\u7AEF\u5DF2\u65AD\u5F00");
+    }
+  });
+  approvalProxy.onApprovalRequest((request) => {
+    wsBridge.broadcast({ type: "approval_request", request });
+    setTimeout(() => {
+      if (!approvalProxy.isPending(request.id)) return;
+      if (wsBridge.isViewingSession(request.sessionId)) return;
+      if (wsBridge.getConnectionCount() > 0) return;
+      const pendingCount = approvalProxy.getPendingRequestsForSession(request.sessionId).length;
+      notificationService.notifyApproval(request, pendingCount);
+    }, 5e3);
+    setTimeout(() => {
+      if (!approvalProxy.isPending(request.id)) return;
+      if (wsBridge.isViewingSession(request.sessionId)) return;
+      if (wsBridge.getConnectionCount() > 0) return;
+      console.log(`[Server] \u5BA1\u6279\u8BF7\u6C42 ${request.id} 60\u79D2\u672A\u5904\u7406\uFF0C\u91CD\u8BD5\u63A8\u9001`);
+      const pendingCount = approvalProxy.getPendingRequestsForSession(request.sessionId).length;
+      notificationService.notifyApproval(request, pendingCount);
+    }, 6e4);
+  });
+  approvalProxy.setStatusInfoProvider(() => ({
+    connections: wsBridge.getConnectionCount(),
+    activeSessions: sessionManager.getActiveSessions().length
+  }));
+  const mdnsService = new MdnsService({ wsPort: WS_PORT, httpPort: HTTP_PORT });
+  mdnsService.start();
+  const hookInstaller = new HookInstaller();
+  try {
+    const installed = await hookInstaller.isInstalled();
+    if (!installed) {
+      await hookInstaller.install();
+      console.log("[Server] Sessix hook \u5DF2\u5B89\u88C5\u5230 Claude Code");
+    } else {
+      console.log("[Server] Sessix hook \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u5B89\u88C5");
+    }
+  } catch (err) {
+    console.error("[Server] Hook \u5B89\u88C5\u5931\u8D25:", err);
+    console.log("[Server] \u7EE7\u7EED\u542F\u52A8\uFF08hook \u529F\u80FD\u53EF\u80FD\u4E0D\u53EF\u7528\uFF09");
+  }
+  const stop = async () => {
+    console.log("[Server] \u6B63\u5728\u4F18\u96C5\u5173\u95ED...");
+    const errors = [];
+    const attempt = async (fn, label) => {
+      try {
+        await fn();
+      } catch (err) {
+        console.error(`[Server] \u5173\u95ED ${label} \u51FA\u9519:`, err);
+        errors.push(err);
+      }
+    };
+    await attempt(() => mdnsService.stop(), "mDNS");
+    await attempt(() => wsBridge.close(), "WebSocket");
+    await attempt(() => approvalProxy.close(), "ApprovalProxy");
+    await attempt(() => sessionManager.destroy(), "SessionManager");
+    await attempt(() => notificationService.destroy(), "NotificationService");
+    await attempt(() => sessionFileWatcher.destroy(), "SessionFileWatcher");
+    if (errors.length > 0) {
+      console.error(`[Server] \u5173\u95ED\u5B8C\u6210\uFF0C${errors.length} \u4E2A\u9519\u8BEF`);
+      throw errors[0];
+    }
+    console.log("[Server] \u6240\u6709\u670D\u52A1\u5DF2\u5173\u95ED");
+  };
+  return {
+    token,
+    wsPort: WS_PORT,
+    httpPort: HTTP_PORT,
+    getActiveSessions: () => sessionManager.getActiveSessions(),
+    getConnectionCount: () => wsBridge.getConnectionCount(),
+    stop,
+    setMacNotification: (enabled) => notificationService.setChannelEnabled("mac", enabled),
+    setExpoPush: (enabled) => notificationService.setChannelEnabled("expo", enabled),
+    onServerEvent: (cb) => sessionManager.onEvent(cb)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  start
+});