sessix-server 0.4.2 → 0.4.3

package/dist/index.js

@@ -24,10 +24,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_node_os9 = require("os");
+var import_node_os10 = require("os");
 var import_node_fs4 = require("fs");
-var import_node_path8 = require("path");
-var import_node_child_process11 = require("child_process");
+var import_node_path10 = require("path");
+var import_node_child_process12 = require("child_process");
 
 // src/i18n/locales/zh.ts
 var zh = {
@@ -302,12 +302,12 @@ function t(key, params) {
 }
 
 // src/server.ts
-var import_uuid7 = require("uuid");
-var import_promises5 = require("fs/promises");
-var import_node_os8 = require("os");
-var import_node_path7 = require("path");
-var import_node_child_process10 = require("child_process");
-var import_node_util2 = require("util");
+var import_uuid9 = require("uuid");
+var import_promises7 = require("fs/promises");
+var import_node_os9 = require("os");
+var import_node_path9 = require("path");
+var import_node_child_process11 = require("child_process");
+var import_node_util3 = require("util");
 
 // src/providers/ProcessProvider.ts
 var import_child_process = require("child_process");
@@ -538,6 +538,77 @@ var ProcessProvider = class {
   getActiveSessions() {
     return Array.from(this.activeSessions.values()).map((entry) => entry.session);
   }
+  /**
+   * 清理空闲进程
+   *
+   * 找出所有 status='idle' 且 lastActiveAt 距今超过 maxIdleMs 的活跃进程，
+   * kill 进程释放内存。entry 保留在 activeSessions 中，用户下次 sendMessage
+   * 走 slow path 自动 --resume 重启进程。
+   *
+   * @returns 被 sweep 的 sessionId 列表
+   */
+  async sweepIdleProcesses(maxIdleMs) {
+    const now = Date.now();
+    const swept = [];
+    for (const [sessionId, entry] of this.activeSessions) {
+      if (entry.process.exitCode !== null || entry.process.signalCode !== null) continue;
+      if (entry.session.status !== "idle") continue;
+      if (now - entry.session.lastActiveAt < maxIdleMs) continue;
+      const idleMin = Math.round((now - entry.session.lastActiveAt) / 6e4);
+      console.log(`[ProcessProvider] sweeping idle process: ${sessionId} (idle ${idleMin}m)`);
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      try {
+        await killProcessCrossPlatform(entry.process);
+      } catch (err) {
+        console.error(`[ProcessProvider] sweep kill failed for ${sessionId}:`, err);
+        continue;
+      }
+      swept.push(sessionId);
+    }
+    return swept;
+  }
+  /**
+   * LRU 上限清理
+   *
+   * 当活跃进程数超过 maxAlive 时，按 lastActiveAt 升序（最久未用优先）kill
+   * 状态为 idle 的进程，直到活跃数回到上限以内。
+   * running / waiting_question 状态的进程永远不会被 kill。
+   *
+   * @returns 被 sweep 的 sessionId 列表
+   */
+  async sweepLruProcesses(maxAlive) {
+    const swept = [];
+    if (maxAlive <= 0) return swept;
+    const aliveEntries = Array.from(this.activeSessions.entries()).filter(
+      ([, e]) => e.process.exitCode === null && e.process.signalCode === null
+    );
+    if (aliveEntries.length <= maxAlive) return swept;
+    const idleSorted = aliveEntries.filter(([, e]) => e.session.status === "idle").sort((a, b) => a[1].session.lastActiveAt - b[1].session.lastActiveAt);
+    let aliveCount = aliveEntries.length;
+    for (const [sessionId, entry] of idleSorted) {
+      if (aliveCount <= maxAlive) break;
+      const idleMin = Math.round((Date.now() - entry.session.lastActiveAt) / 6e4);
+      console.log(`[ProcessProvider] LRU sweep: ${sessionId} (idle ${idleMin}m, alive=${aliveCount}/${maxAlive})`);
+      try {
+        entry.process.stdin?.end();
+      } catch {
+      }
+      try {
+        await killProcessCrossPlatform(entry.process);
+        swept.push(sessionId);
+        aliveCount--;
+      } catch (err) {
+        console.error(`[ProcessProvider] LRU kill failed for ${sessionId}:`, err);
+      }
+    }
+    if (aliveCount > maxAlive) {
+      console.warn(`[ProcessProvider] LRU sweep: ${aliveCount} alive after sweep > limit ${maxAlive}; remaining are running/waiting`);
+    }
+    return swept;
+  }
   // ============================================
   // 私有方法
   // ============================================
@@ -1765,6 +1836,20 @@ var SessionManager = class {
   isBufferTruncated(sessionId) {
     return this.bufferTruncated.has(sessionId);
   }
+  /**
+   * 缩减指定会话的事件缓冲区到最后 N 条，并标记 truncated
+   *
+   * 用于空闲进程被 sweep 后释放内存：缓冲区只为新订阅者重放服务，
+   * 进程已死的会话可以通过 JSONL 文件补全完整历史，不需要保留全部内存事件。
+   * 设置 bufferTruncated 后，客户端 subscribe 收到 session_history 时会从 JSONL 补齐。
+   */
+  shrinkSessionBuffer(sessionId, keepLast = 100) {
+    const buffer = this.sessionEventBuffers.get(sessionId);
+    if (!buffer || buffer.length <= keepLast) return;
+    buffer.splice(0, buffer.length - keepLast);
+    this.bufferTruncated.add(sessionId);
+    console.log(`[SessionManager] Session ${sessionId}: buffer shrunk to ${keepLast}, marked truncated`);
+  }
   /**
    * 获取会话的项目路径（用于截断时从 JSONL 补全历史）
    */
@@ -4689,7 +4774,7 @@ var AuthManager = class extends import_events3.EventEmitter {
 };
 
 // src/server.ts
-var import_promises6 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 
 // src/terminal/TerminalExecutor.ts
 var import_node_child_process7 = require("child_process");
@@ -5192,8 +5277,762 @@ function kindOrder(k) {
   return k === "device" ? 0 : k === "simulator" ? 1 : k === "mac" ? 2 : 3;
 }
 
-// src/utils/cliCapabilities.ts
+// src/commands/CommandDiscovery.ts
+var import_promises5 = require("fs/promises");
+var import_node_path7 = require("path");
+var import_node_crypto = require("crypto");
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var MAX_README_BYTES = 256 * 1024;
+var SUBPACKAGE_DIRS = ["packages", "apps", "crates", "services"];
+var MAX_SCAN_PER_DIR = 30;
+var CommandDiscovery = class {
+  cache = /* @__PURE__ */ new Map();
+  async scan(projectPath, refresh = false) {
+    if (!refresh) {
+      const hit = this.cache.get(projectPath);
+      if (hit && hit.expiresAt > Date.now()) return hit.commands;
+    }
+    const collector = [];
+    await Promise.all([
+      this.scanPackageJson(projectPath, "", collector),
+      this.scanMakefile(projectPath, "", collector),
+      this.scanJustfile(projectPath, "", collector),
+      this.scanCargo(projectPath, "", collector),
+      this.scanCompose(projectPath, "", collector),
+      this.scanReadme(projectPath, "README.md", "readme", collector),
+      this.scanReadme(projectPath, "CLAUDE.md", "claude.md", collector)
+    ]);
+    for (const sub of SUBPACKAGE_DIRS) {
+      const subRoot = (0, import_node_path7.join)(projectPath, sub);
+      let entries;
+      try {
+        entries = await (0, import_promises5.readdir)(subRoot);
+      } catch {
+        continue;
+      }
+      let scanned = 0;
+      for (const name of entries) {
+        if (name.startsWith(".") || scanned >= MAX_SCAN_PER_DIR) continue;
+        const childAbs = (0, import_node_path7.join)(subRoot, name);
+        try {
+          const s = await (0, import_promises5.stat)(childAbs);
+          if (!s.isDirectory()) continue;
+        } catch {
+          continue;
+        }
+        scanned++;
+        const rel = `${sub}/${name}`;
+        await Promise.all([
+          this.scanPackageJson(projectPath, rel, collector),
+          this.scanCargo(projectPath, rel, collector)
+        ]);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const c of collector) {
+      if (seen.has(c.id)) continue;
+      seen.add(c.id);
+      deduped.push(c);
+    }
+    deduped.sort((a, b) => {
+      const ca = categoryWeight(a.category) - categoryWeight(b.category);
+      if (ca !== 0) return ca;
+      const sa = sourceWeight(a.source) - sourceWeight(b.source);
+      if (sa !== 0) return sa;
+      return a.title.localeCompare(b.title);
+    });
+    this.cache.set(projectPath, { commands: deduped, expiresAt: Date.now() + CACHE_TTL_MS });
+    return deduped;
+  }
+  invalidate(projectPath) {
+    if (projectPath) this.cache.delete(projectPath);
+    else this.cache.clear();
+  }
+  // ============================================
+  // 各来源扫描器
+  // ============================================
+  async scanPackageJson(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/package.json` : "package.json";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    let raw;
+    try {
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    let pkg;
+    try {
+      pkg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!pkg.scripts) return;
+    for (const [name, script] of Object.entries(pkg.scripts)) {
+      if (typeof script !== "string") continue;
+      const command = subDir ? `npm --workspace=${subDir} run ${name}` : `npm run ${name}`;
+      const title = subDir ? `${pkg.name ?? subDir.split("/").pop()}: ${name}` : name;
+      out.push(makeCommand({
+        title,
+        command,
+        cwd: "",
+        source: "package.json",
+        sourceFile: file,
+        description: script,
+        category: classifyByName(name) ?? classifyByCommand(script)
+      }));
+    }
+  }
+  async scanMakefile(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/Makefile` : "Makefile";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    let raw;
+    try {
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    const lines = raw.split("\n");
+    let lastComment;
+    const targetRegex = /^([a-zA-Z][a-zA-Z0-9_-]*)\s*:(?!=)/;
+    for (const line of lines) {
+      const trim = line.trim();
+      if (trim.startsWith("#")) {
+        lastComment = trim.replace(/^#+\s?/, "").trim() || void 0;
+        continue;
+      }
+      if (trim === "") {
+        lastComment = void 0;
+        continue;
+      }
+      const match = targetRegex.exec(line);
+      if (!match) {
+        lastComment = void 0;
+        continue;
+      }
+      const target = match[1];
+      if (target === ".PHONY" || target === "default" && trim.startsWith("default:")) continue;
+      out.push(makeCommand({
+        title: target,
+        command: `make ${target}`,
+        cwd: subDir,
+        source: "makefile",
+        sourceFile: file,
+        description: lastComment,
+        category: classifyByName(target)
+      }));
+      lastComment = void 0;
+    }
+  }
+  async scanJustfile(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/justfile` : "justfile";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    let raw;
+    try {
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    const lines = raw.split("\n");
+    let lastComment;
+    const recipeRegex = /^([a-zA-Z][a-zA-Z0-9_-]*)\s*(?:[a-zA-Z0-9_=" ]*)?\s*:/;
+    for (const line of lines) {
+      const trim = line.trim();
+      if (trim.startsWith("#")) {
+        lastComment = trim.replace(/^#+\s?/, "").trim() || void 0;
+        continue;
+      }
+      if (trim === "") {
+        lastComment = void 0;
+        continue;
+      }
+      if (line.startsWith(" ") || line.startsWith("	")) continue;
+      const match = recipeRegex.exec(line);
+      if (!match) {
+        lastComment = void 0;
+        continue;
+      }
+      const recipe = match[1];
+      out.push(makeCommand({
+        title: recipe,
+        command: `just ${recipe}`,
+        cwd: subDir,
+        source: "justfile",
+        sourceFile: file,
+        description: lastComment,
+        category: classifyByName(recipe)
+      }));
+      lastComment = void 0;
+    }
+  }
+  async scanCargo(rootPath, subDir, out) {
+    const file = subDir ? `${subDir}/Cargo.toml` : "Cargo.toml";
+    const abs = (0, import_node_path7.join)(rootPath, file);
+    try {
+      await (0, import_promises5.stat)(abs);
+    } catch {
+      return;
+    }
+    const presets = [
+      { title: "cargo build", command: "cargo build", category: "build", description: "Compile in debug mode" },
+      { title: "cargo build --release", command: "cargo build --release", category: "build", description: "Compile in release mode" },
+      { title: "cargo run", command: "cargo run", category: "dev", description: "Build and run" },
+      { title: "cargo test", command: "cargo test", category: "test", description: "Run all tests" },
+      { title: "cargo check", command: "cargo check", category: "lint", description: "Type-check without producing binary" },
+      { title: "cargo clippy", command: "cargo clippy", category: "lint", description: "Lint with clippy" },
+      { title: "cargo fmt", command: "cargo fmt", category: "lint", description: "Format source" }
+    ];
+    for (const p of presets) {
+      out.push(makeCommand({
+        title: subDir ? `${subDir.split("/").pop()}: ${p.title}` : p.title,
+        command: p.command,
+        cwd: subDir,
+        source: "cargo",
+        sourceFile: file,
+        description: p.description,
+        category: p.category
+      }));
+    }
+  }
+  async scanCompose(rootPath, subDir, out) {
+    for (const name of ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"]) {
+      const file = subDir ? `${subDir}/${name}` : name;
+      try {
+        await (0, import_promises5.stat)((0, import_node_path7.join)(rootPath, file));
+      } catch {
+        continue;
+      }
+      const presets = [
+        { title: "docker compose up", cmd: "docker compose up", cat: "dev", desc: "Start services" },
+        { title: "docker compose up -d", cmd: "docker compose up -d", cat: "dev", desc: "Start services in background" },
+        { title: "docker compose down", cmd: "docker compose down", cat: "other", desc: "Stop and remove services" },
+        { title: "docker compose build", cmd: "docker compose build", cat: "build", desc: "Build service images" },
+        { title: "docker compose logs -f", cmd: "docker compose logs -f", cat: "other", desc: "Tail service logs" }
+      ];
+      for (const p of presets) {
+        out.push(makeCommand({
+          title: p.title,
+          command: p.cmd,
+          cwd: subDir,
+          source: "compose",
+          sourceFile: file,
+          description: p.desc,
+          category: p.cat
+        }));
+      }
+      return;
+    }
+  }
+  async scanReadme(rootPath, fileName, source, out) {
+    const abs = (0, import_node_path7.join)(rootPath, fileName);
+    let raw;
+    try {
+      const s = await (0, import_promises5.stat)(abs);
+      if (s.size > MAX_README_BYTES) return;
+      raw = await (0, import_promises5.readFile)(abs, "utf8");
+    } catch {
+      return;
+    }
+    const fenceRegex = /```(?:bash|sh|shell|zsh)\s*\n([\s\S]*?)```/gi;
+    let match;
+    while ((match = fenceRegex.exec(raw)) !== null) {
+      const block = match[1];
+      const blockLines = block.split("\n");
+      let blockHeading;
+      const beforeText = raw.slice(0, match.index).split("\n").reverse();
+      for (const prev of beforeText) {
+        const t2 = prev.trim();
+        if (t2 === "") continue;
+        const head = /^#{1,6}\s+(.+)$/.exec(t2);
+        if (head) blockHeading = head[1].replace(/[#*`]/g, "").trim();
+        break;
+      }
+      const merged = [];
+      let pending = "";
+      for (const rawLine of blockLines) {
+        if (rawLine.trimEnd().endsWith("\\")) {
+          pending += rawLine.trimEnd().slice(0, -1) + " ";
+          continue;
+        }
+        merged.push(pending + rawLine);
+        pending = "";
+      }
+      if (pending) merged.push(pending);
+      for (const rawLine of merged) {
+        const cmd = sanitizeBashLine(rawLine);
+        if (!cmd) continue;
+        const { command: cleanCmd, inlineComment } = splitInlineComment(cmd);
+        const title = synthesizeTitle(cleanCmd);
+        out.push(makeCommand({
+          title,
+          command: cleanCmd,
+          cwd: "",
+          source,
+          sourceFile: fileName,
+          description: inlineComment ?? blockHeading,
+          category: classifyByCommand(cleanCmd)
+        }));
+      }
+    }
+  }
+};
+function makeCommand(input) {
+  const id = (0, import_node_crypto.createHash)("sha1").update(`${input.source}|${input.sourceFile}|${input.command}|${input.cwd}`).digest("hex").slice(0, 12);
+  return {
+    id,
+    title: input.title,
+    command: input.command,
+    cwd: input.cwd,
+    source: input.source,
+    sourceFile: input.sourceFile,
+    description: input.description,
+    category: input.category ?? classifyByCommand(input.command) ?? "other"
+  };
+}
+function sanitizeBashLine(line) {
+  let l = line.trim();
+  if (!l) return null;
+  if (l.startsWith("#")) return null;
+  l = l.replace(/^[$>]\s*/, "");
+  if (!l) return null;
+  if (/^[A-Z_]+=/.test(l) && !/\s/.test(l)) return null;
+  if (l === "EOF" || l === "EOT") return null;
+  if (l.startsWith("//") || l.startsWith("//#")) return null;
+  if (l.length > 400) return null;
+  if (/<.+>/.test(l) && /your[-_]/.test(l.toLowerCase())) return null;
+  return l;
+}
+function synthesizeTitle(cmd) {
+  let work = cmd;
+  while (/^[A-Z_][A-Z0-9_]*=/.test(work)) {
+    const m = /^[A-Z_][A-Z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+/.exec(work);
+    if (!m) break;
+    work = work.slice(m[0].length);
+  }
+  const cdMatch = /^cd\s+\S+\s*&&\s*(.+)$/.exec(work);
+  if (cdMatch) work = cdMatch[1];
+  const tokens = work.split(/\s+/).filter(Boolean);
+  const head = tokens.slice(0, 3).join(" ");
+  return head.length > 60 ? head.slice(0, 60) + "\u2026" : head;
+}
+function splitInlineComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (ch === "#" && !inSingle && !inDouble && (i === 0 || /\s/.test(line[i - 1]))) {
+      const cmd = line.slice(0, i).trim();
+      const comment = line.slice(i + 1).trim();
+      return { command: cmd, inlineComment: comment.length > 0 ? comment : void 0 };
+    }
+  }
+  return { command: line };
+}
+function classifyByName(name) {
+  const lower = name.toLowerCase();
+  if (/(^|[:_-])(build|compile|bundle|prebuild)([:_-]|$)/.test(lower)) return "build";
+  if (/(^|[:_-])(test|spec|jest|vitest|e2e)([:_-]|$)/.test(lower)) return "test";
+  if (/(^|[:_-])(dev|start|serve|watch|run)([:_-]|$)/.test(lower)) return "dev";
+  if (/(^|[:_-])(lint|format|fmt|check|typecheck)([:_-]|$)/.test(lower)) return "lint";
+  if (/(^|[:_-])(install|setup|init|bootstrap)([:_-]|$)/.test(lower)) return "install";
+  if (/(^|[:_-])(deploy|publish|release|ship)([:_-]|$)/.test(lower)) return "deploy";
+  return void 0;
+}
+function classifyByCommand(cmd) {
+  const lower = cmd.toLowerCase();
+  if (/\b(build|compile|bundle|prebuild|tsup|webpack|esbuild|vite build|next build)\b/.test(lower)) return "build";
+  if (/\b(test|jest|vitest|mocha|pytest|cargo test|go test)\b/.test(lower)) return "test";
+  if (/\b(dev|start|serve|watch|nodemon|tsx watch|next dev|expo start)\b/.test(lower)) return "dev";
+  if (/\b(lint|eslint|tsc|tslint|fmt|format|prettier|clippy)\b/.test(lower)) return "lint";
+  if (/\b(install|setup|bootstrap)\b/.test(lower) && !/\binstall\s+/.test(lower)) return "install";
+  if (/^npm install\b|^pnpm install\b|^yarn install\b|^yarn\s*$|^pnpm\s*$/.test(lower)) return "install";
+  if (/\b(deploy|publish|release)\b/.test(lower)) return "deploy";
+  return "other";
+}
+function categoryWeight(c) {
+  return {
+    dev: 0,
+    build: 1,
+    test: 2,
+    lint: 3,
+    install: 4,
+    deploy: 5,
+    other: 6
+  }[c];
+}
+function sourceWeight(s) {
+  return {
+    "package.json": 0,
+    makefile: 1,
+    justfile: 2,
+    taskfile: 3,
+    cargo: 4,
+    compose: 5,
+    readme: 6,
+    "claude.md": 7
+  }[s];
+}
+
+// src/git/GitExecutor.ts
 var import_node_child_process9 = require("child_process");
+var import_node_util2 = require("util");
+var import_uuid7 = require("uuid");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process9.exec);
+var STATUS_TIMEOUT_MS = 15e3;
+var COMMIT_TIMEOUT_MS = 6e4;
+var PUSH_TIMEOUT_MS = 5 * 60 * 1e3;
+var GitExecutor = class {
+  eventCallbacks = [];
+  onEvent(callback) {
+    this.eventCallbacks.push(callback);
+    return () => {
+      const idx = this.eventCallbacks.indexOf(callback);
+      if (idx !== -1) this.eventCallbacks.splice(idx, 1);
+    };
+  }
+  emit(event) {
+    for (const cb of this.eventCallbacks) {
+      try {
+        cb(event);
+      } catch (err) {
+        console.error("[GitExecutor] Event callback error:", err);
+      }
+    }
+  }
+  async detectStatus(projectPath) {
+    const opts = { cwd: projectPath, timeout: STATUS_TIMEOUT_MS, maxBuffer: 4 * 1024 * 1024 };
+    try {
+      await execAsync2("git rev-parse --is-inside-work-tree", opts);
+    } catch {
+      return { isRepo: false, hasRemote: false, changes: [] };
+    }
+    let root;
+    try {
+      const { stdout } = await execAsync2("git rev-parse --show-toplevel", opts);
+      root = stdout.trim();
+    } catch {
+    }
+    let branch;
+    try {
+      const { stdout } = await execAsync2("git symbolic-ref --short HEAD", opts);
+      branch = stdout.trim();
+    } catch {
+      branch = void 0;
+    }
+    let upstream;
+    try {
+      const { stdout } = await execAsync2("git rev-parse --abbrev-ref --symbolic-full-name @{u}", opts);
+      upstream = stdout.trim();
+    } catch {
+    }
+    let hasRemote = false;
+    try {
+      const { stdout } = await execAsync2("git remote", opts);
+      hasRemote = stdout.trim().length > 0;
+    } catch {
+    }
+    let ahead;
+    let behind;
+    if (upstream) {
+      try {
+        const { stdout } = await execAsync2("git rev-list --left-right --count HEAD...@{u}", opts);
+        const [a, b] = stdout.trim().split(/\s+/);
+        ahead = Number(a);
+        behind = Number(b);
+      } catch {
+      }
+    }
+    const changes = await this.parsePorcelain(projectPath);
+    return {
+      isRepo: true,
+      root,
+      branch,
+      upstream,
+      hasRemote,
+      changes,
+      ahead,
+      behind
+    };
+  }
+  async parsePorcelain(projectPath) {
+    let stdout;
+    try {
+      const r = await execAsync2("git status --porcelain=v1 -z", {
+        cwd: projectPath,
+        timeout: STATUS_TIMEOUT_MS,
+        maxBuffer: 8 * 1024 * 1024
+      });
+      stdout = r.stdout;
+    } catch {
+      return [];
+    }
+    const changes = [];
+    const records = stdout.split("\0");
+    for (let i = 0; i < records.length; i++) {
+      const rec = records[i];
+      if (!rec) continue;
+      if (rec.length < 3) continue;
+      const x = rec.charAt(0);
+      const y = rec.charAt(1);
+      const path2 = rec.slice(3);
+      const isRename = x === "R" || x === "C";
+      if (isRename) {
+        i += 1;
+      }
+      const untracked = x === "?" && y === "?";
+      const staged = !untracked && x !== " " && x !== "?";
+      changes.push({
+        path: path2,
+        staged,
+        untracked,
+        code: `${x}${y}`
+      });
+    }
+    return changes;
+  }
+  /**
+   * 执行 commit（可选连带 push）。
+   * - 若提供 files：先 git add 这些路径
+   * - 若未提供 files：默认 git add -A（提交所有变更）
+   */
+  async commit(sessionId, projectPath, message, files, alsoPush) {
+    const opId = (0, import_uuid7.v4)();
+    this.runSequence(sessionId, opId, "commit", projectPath, [
+      files && files.length > 0 ? ["git", "add", "--", ...files] : ["git", "add", "-A"],
+      ["git", "commit", "-m", message]
+    ], COMMIT_TIMEOUT_MS).then(async (ok) => {
+      if (ok && alsoPush) {
+        await this.runSequence(sessionId, opId, "push", projectPath, [
+          ["git", "push"]
+        ], PUSH_TIMEOUT_MS);
+      }
+    }).catch((err) => {
+      console.error("[GitExecutor] commit error:", err);
+    });
+    return opId;
+  }
+  async push(sessionId, projectPath) {
+    const opId = (0, import_uuid7.v4)();
+    this.runSequence(sessionId, opId, "push", projectPath, [
+      ["git", "push"]
+    ], PUSH_TIMEOUT_MS).catch((err) => {
+      console.error("[GitExecutor] push error:", err);
+    });
+    return opId;
+  }
+  /**
+   * 顺序执行一组命令，任一失败则停止。返回是否全部成功。
+   * 每条命令的输出和最后一条命令的退出事件统一打到同一 phase。
+   */
+  async runSequence(sessionId, opId, phase, projectPath, commands, timeoutMs) {
+    let lastCode = 0;
+    let lastSignal = null;
+    for (const cmd of commands) {
+      const { code, signal } = await this.runOne(sessionId, opId, phase, projectPath, cmd, timeoutMs);
+      lastCode = code;
+      lastSignal = signal;
+      if (code !== 0) break;
+    }
+    this.emit({ type: "git_exit", sessionId, opId, phase, code: lastCode, signal: lastSignal });
+    return lastCode === 0;
+  }
+  runOne(sessionId, opId, phase, projectPath, cmd, timeoutMs) {
+    return new Promise((resolve) => {
+      const display = cmd.map((p) => /\s/.test(p) ? `"${p}"` : p).join(" ");
+      this.emit({
+        type: "git_output",
+        sessionId,
+        opId,
+        phase,
+        stream: "stdout",
+        data: `$ ${display}
+`
+      });
+      let proc;
+      try {
+        proc = (0, import_node_child_process9.spawn)(cmd[0], cmd.slice(1), {
+          cwd: projectPath,
+          stdio: ["ignore", "pipe", "pipe"],
+          env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stderr", data: `[spawn error] ${msg}
+` });
+        resolve({ code: 1, signal: null });
+        return;
+      }
+      proc.stdout?.on("data", (chunk) => {
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stdout", data: chunk.toString() });
+      });
+      proc.stderr?.on("data", (chunk) => {
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stderr", data: chunk.toString() });
+      });
+      proc.on("error", (err) => {
+        this.emit({ type: "git_output", sessionId, opId, phase, stream: "stderr", data: `[error] ${err.message}
+` });
+      });
+      const timer = setTimeout(() => {
+        try {
+          proc.kill("SIGTERM");
+        } catch {
+        }
+      }, timeoutMs);
+      proc.on("exit", (code, signal) => {
+        clearTimeout(timer);
+        resolve({ code, signal });
+      });
+    });
+  }
+};
+
+// src/scheduling/ScheduledSessionManager.ts
+var import_promises6 = require("fs/promises");
+var import_node_os8 = require("os");
+var import_node_path8 = require("path");
+var import_uuid8 = require("uuid");
+var MAX_TIMEOUT_MS = 2147483647;
+var ScheduledSessionManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  storeFile;
+  onFire;
+  onChange;
+  onFired;
+  persistTimer = null;
+  constructor(opts) {
+    this.storeFile = opts.storeFile ?? (0, import_node_path8.join)((0, import_node_os8.homedir)(), ".sessix", "scheduled-sessions.json");
+    this.onFire = opts.onFire;
+    this.onChange = opts.onChange;
+    this.onFired = opts.onFired;
+  }
+  /** 启动时从磁盘恢复任务表，已过期的立刻触发 */
+  async load() {
+    let raw;
+    try {
+      raw = await (0, import_promises6.readFile)(this.storeFile, "utf8");
+    } catch {
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!Array.isArray(parsed)) return;
+    for (const item of parsed) {
+      if (!isValidTask(item)) continue;
+      this.scheduleTimer(item);
+    }
+  }
+  /** 注册一个定时任务（payload 由调用方校验） */
+  schedule(scheduledAt, payload) {
+    const task = {
+      id: (0, import_uuid8.v4)(),
+      scheduledAt,
+      createdAt: Date.now(),
+      payload
+    };
+    this.scheduleTimer(task);
+    this.persist();
+    this.notifyChange();
+    return task;
+  }
+  /** 取消任务，返回是否成功 */
+  cancel(id) {
+    const entry = this.tasks.get(id);
+    if (!entry) return false;
+    clearTimeout(entry.timer);
+    this.tasks.delete(id);
+    this.persist();
+    this.notifyChange();
+    return true;
+  }
+  /** 列出所有未触发的任务（按时间升序） */
+  list() {
+    return [...this.tasks.values()].map((e) => e.task).sort((a, b) => a.scheduledAt - b.scheduledAt);
+  }
+  /** 优雅关闭（清空定时器，不删除磁盘任务） */
+  destroy() {
+    for (const { timer } of this.tasks.values()) clearTimeout(timer);
+    this.tasks.clear();
+    if (this.persistTimer) {
+      clearTimeout(this.persistTimer);
+      this.persistTimer = null;
+    }
+  }
+  // ============================================
+  // 内部
+  // ============================================
+  scheduleTimer(task) {
+    const delay = Math.max(0, task.scheduledAt - Date.now());
+    const armDelay = Math.min(delay, MAX_TIMEOUT_MS);
+    const timer = setTimeout(() => {
+      const remaining = task.scheduledAt - Date.now();
+      if (remaining > 1e3) {
+        this.scheduleTimer(task);
+        return;
+      }
+      this.fire(task).catch((err) => {
+        console.error("[ScheduledSessionManager] fire error:", err);
+      });
+    }, armDelay);
+    this.tasks.set(task.id, { task, timer });
+  }
+  async fire(task) {
+    const entry = this.tasks.get(task.id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.tasks.delete(task.id);
+    this.persist();
+    this.notifyChange();
+    try {
+      const result = await this.onFire(task);
+      this.onFired?.({ id: task.id, sessionId: result.sessionId });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`[ScheduledSessionManager] fire failed for task ${task.id}: ${message}`);
+      this.onFired?.({ id: task.id, error: message });
+    }
+  }
+  notifyChange() {
+    if (!this.onChange) return;
+    this.onChange(this.list());
+  }
+  /** 防抖持久化（500ms） */
+  persist() {
+    if (this.persistTimer) clearTimeout(this.persistTimer);
+    this.persistTimer = setTimeout(() => {
+      this.persistTimer = null;
+      const tasks = [...this.tasks.values()].map((e) => e.task);
+      (0, import_promises6.mkdir)((0, import_node_path8.join)(this.storeFile, ".."), { recursive: true }).then(() => (0, import_promises6.writeFile)(this.storeFile, JSON.stringify(tasks, null, 2), "utf8")).catch((err) => {
+        console.error("[ScheduledSessionManager] persist error:", err);
+      });
+    }, 500);
+  }
+};
+function isValidTask(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (typeof v.id !== "string" || typeof v.scheduledAt !== "number" || typeof v.createdAt !== "number") {
+    return false;
+  }
+  const payload = v.payload;
+  if (!payload || typeof payload !== "object") return false;
+  const p = payload;
+  if (p.kind === "create") {
+    return typeof p.projectPath === "string" && typeof p.message === "string";
+  }
+  if (p.kind === "send") {
+    return typeof p.sessionId === "string" && typeof p.message === "string";
+  }
+  return false;
+}
+
+// src/utils/cliCapabilities.ts
+var import_node_child_process10 = require("child_process");
 var DEFAULT_CAPABILITIES = {
   effortLevels: ["low", "medium", "high", "xhigh", "max"]
 };
@@ -5221,7 +6060,7 @@ async function parseCliCapabilities() {
 }
 function runCli(path2, args) {
   return new Promise((resolve) => {
-    (0, import_node_child_process9.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
+    (0, import_node_child_process10.execFile)(path2, args, { timeout: 5e3 }, (err, stdout) => {
       if (err) {
         console.warn(`[CliCapabilities] Failed to run ${path2} ${args.join(" ")}:`, err.message);
         resolve(null);
@@ -5235,11 +6074,11 @@ function runCli(path2, args) {
 // src/server.ts
 var WS_PORT = 3745;
 var HTTP_PORT = 3746;
-var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process10.exec);
+var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process11.exec);
 async function killPortProcess(port) {
   try {
     if (isWindows) {
-      const { stdout } = await execAsync2(
+      const { stdout } = await execAsync3(
         `netstat -ano | findstr :${port} | findstr LISTENING`
       );
       const pids = /* @__PURE__ */ new Set();
@@ -5249,14 +6088,14 @@ async function killPortProcess(port) {
         if (pid && /^\d+$/.test(pid) && pid !== "0") pids.add(pid);
       }
       for (const pid of pids) {
-        await execAsync2(`taskkill /PID ${pid} /F`).catch(() => {
+        await execAsync3(`taskkill /PID ${pid} /F`).catch(() => {
         });
       }
     } else {
-      const { stdout } = await execAsync2(`lsof -ti :${port}`);
+      const { stdout } = await execAsync3(`lsof -ti :${port}`);
       const pids = stdout.trim().split("\n").filter((p) => p && /^\d+$/.test(p));
       if (pids.length > 0) {
-        await execAsync2(`kill -9 ${pids.join(" ")}`);
+        await execAsync3(`kill -9 ${pids.join(" ")}`);
       }
     }
     await new Promise((resolve) => setTimeout(resolve, 600));
@@ -5277,8 +6116,8 @@ async function createWithRetry(label, port, factory) {
   }
 }
 async function start(opts = {}) {
-  const configDir = (0, import_node_path7.join)((0, import_node_os8.homedir)(), ".sessix");
-  const tokenFile = (0, import_node_path7.join)(configDir, "token");
+  const configDir = (0, import_node_path9.join)((0, import_node_os9.homedir)(), ".sessix");
+  const tokenFile = (0, import_node_path9.join)(configDir, "token");
   let token;
   if (opts.token !== void 0) {
     token = opts.token;
@@ -5288,11 +6127,11 @@ async function start(opts = {}) {
       token = envToken;
     } else {
       try {
-        token = (await (0, import_promises5.readFile)(tokenFile, "utf8")).trim();
+        token = (await (0, import_promises7.readFile)(tokenFile, "utf8")).trim();
       } catch {
-        token = (0, import_uuid7.v4)();
-        await (0, import_promises5.mkdir)(configDir, { recursive: true });
-        await (0, import_promises5.writeFile)(tokenFile, token, "utf8");
+        token = (0, import_uuid9.v4)();
+        await (0, import_promises7.mkdir)(configDir, { recursive: true });
+        await (0, import_promises7.writeFile)(tokenFile, token, "utf8");
       }
     }
   }
@@ -5300,6 +6139,9 @@ async function start(opts = {}) {
   const sessionManager = new SessionManager(providerFactory);
   const terminalExecutor = new TerminalExecutor();
   const xcodeBuildExecutor = new XcodeBuildExecutor();
+  const commandDiscovery = new CommandDiscovery();
+  const gitExecutor = new GitExecutor();
+  let scheduledManager = null;
   const approvalProxy = await createWithRetry(
     "ApprovalProxy",
     HTTP_PORT,
@@ -5338,7 +6180,7 @@ async function start(opts = {}) {
   let mdnsService = null;
   const pairingManager = new PairingManager({
     token,
-    serverName: (0, import_node_os8.hostname)(),
+    serverName: (0, import_node_os9.hostname)(),
     version: "0.2.0",
     onStateChange: (state) => mdnsService?.updatePairingState(state)
   });
@@ -5367,6 +6209,49 @@ async function start(opts = {}) {
   const broadcastUnreadSessions = () => {
     wsBridge.broadcast({ type: "unread_sessions", sessionIds: Array.from(unreadSessionIds) });
   };
+  scheduledManager = new ScheduledSessionManager({
+    onFire: async (task) => {
+      const p = task.payload;
+      if (p.kind === "create") {
+        await (0, import_promises7.mkdir)(p.projectPath, { recursive: true });
+        const session = await sessionManager.createSession(
+          p.projectPath,
+          p.message,
+          p.resumeSessionId,
+          p.newSessionId,
+          p.model,
+          p.permissionMode,
+          p.effort,
+          void 0,
+          p.agentType
+        );
+        wsBridge.broadcast({ type: "session_list", sessions: sessionManager.getActiveSessions() });
+        return { sessionId: session.id };
+      }
+      const active = sessionManager.getActiveSessions().find((s) => s.id === p.sessionId);
+      if (active) {
+        await sessionManager.sendMessage(p.sessionId, p.message, p.permissionMode);
+      } else {
+        await sessionManager.createSession(
+          p.projectPath,
+          p.message,
+          p.sessionId,
+          void 0,
+          void 0,
+          p.permissionMode
+        );
+      }
+      wsBridge.broadcast({ type: "session_list", sessions: sessionManager.getActiveSessions() });
+      return { sessionId: p.sessionId };
+    },
+    onChange: (tasks) => {
+      wsBridge.broadcast({ type: "scheduled_session_list", tasks });
+    },
+    onFired: (event) => {
+      wsBridge.broadcast({ type: "scheduled_session_fired", ...event });
+    }
+  });
+  await scheduledManager.load();
   wsBridge.onConnection(async (ws) => {
     const result = await getProjects();
     if (result.ok) {
@@ -5388,12 +6273,15 @@ async function start(opts = {}) {
     if (cliCapabilities) {
       wsBridge.send(ws, { type: "cli_info", effortLevels: cliCapabilities.effortLevels, version: cliCapabilities.version });
     }
+    if (scheduledManager) {
+      wsBridge.send(ws, { type: "scheduled_session_list", tasks: scheduledManager.list() });
+    }
   });
   wsBridge.onClientEvent(async (event, ws) => {
     try {
       switch (event.type) {
         case "create_session": {
-          await (0, import_promises5.mkdir)(event.projectPath, { recursive: true });
+          await (0, import_promises7.mkdir)(event.projectPath, { recursive: true });
           const resumeId = event.resumeSessionId ?? event.newSessionId;
           if (resumeId) sessionFileWatcher.unwatch(resumeId);
           await sessionManager.createSession(
@@ -5581,7 +6469,7 @@ async function start(opts = {}) {
             if (!isStreaming) {
               const filePath = getSessionFilePath(event.projectPath, event.sessionId);
               try {
-                const fileStat = await (0, import_promises6.stat)(filePath);
+                const fileStat = await (0, import_promises8.stat)(filePath);
                 sessionFileWatcher.watch(event.sessionId, filePath, fileStat.size);
               } catch {
               }
@@ -5744,6 +6632,66 @@ async function start(opts = {}) {
           xcodeBuildExecutor.killInstall(event.installId);
           break;
         }
+        case "schedule_session": {
+          if (!scheduledManager) break;
+          const scheduledAt = Number(event.scheduledAt);
+          if (!Number.isFinite(scheduledAt)) {
+            wsBridge.send(ws, { type: "error", code: "INVALID_MESSAGE", message: "Invalid scheduledAt" });
+            break;
+          }
+          scheduledManager.schedule(scheduledAt, event.payload);
+          break;
+        }
+        case "cancel_scheduled_session": {
+          scheduledManager?.cancel(event.id);
+          break;
+        }
+        case "list_scheduled_sessions": {
+          if (scheduledManager) {
+            wsBridge.send(ws, { type: "scheduled_session_list", tasks: scheduledManager.list() });
+          }
+          break;
+        }
+        case "git_status": {
+          const status = await gitExecutor.detectStatus(event.projectPath);
+          wsBridge.send(ws, { type: "git_status_result", sessionId: event.sessionId, status });
+          break;
+        }
+        case "git_commit": {
+          await gitExecutor.commit(
+            event.sessionId,
+            event.projectPath,
+            event.message,
+            event.files,
+            event.alsoPush
+          );
+          break;
+        }
+        case "git_push": {
+          await gitExecutor.push(event.sessionId, event.projectPath);
+          break;
+        }
+        case "list_project_commands": {
+          try {
+            const commands = await commandDiscovery.scan(event.projectPath, event.refresh ?? false);
+            wsBridge.send(ws, {
+              type: "commands_result",
+              sessionId: event.sessionId,
+              projectPath: event.projectPath,
+              commands
+            });
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            wsBridge.send(ws, {
+              type: "commands_result",
+              sessionId: event.sessionId,
+              projectPath: event.projectPath,
+              commands: [],
+              error: message
+            });
+          }
+          break;
+        }
         default: {
           wsBridge.send(ws, {
             type: "error",
@@ -5782,6 +6730,9 @@ async function start(opts = {}) {
   xcodeBuildExecutor.onEvent((event) => {
     wsBridge.broadcast(event);
   });
+  gitExecutor.onEvent((event) => {
+    wsBridge.broadcast(event);
+  });
   wsBridge.onDisconnect(() => {
     if (wsBridge.getConnectionCount() === 0 && approvalProxy.getPendingCount() > 0) {
       approvalProxy.approveAll(t("server.phoneDisconnected"));
@@ -5871,6 +6822,42 @@ async function start(opts = {}) {
     console.error(`[Server] ${t("server.hookInstallFailed")}`, err);
     console.log(`[Server] ${t("server.hookContinue")}`);
   }
+  const idleTimeoutMs = Number(process.env.SESSIX_IDLE_TIMEOUT_MS ?? 30 * 60 * 1e3);
+  const idleSweepIntervalMs = Number(process.env.SESSIX_IDLE_SWEEP_INTERVAL_MS ?? 5 * 60 * 1e3);
+  const maxActiveProcesses = Number(process.env.SESSIX_MAX_ACTIVE_PROCESSES ?? 15);
+  let idleSweepTimer = null;
+  if (idleSweepIntervalMs > 0 && (idleTimeoutMs > 0 || maxActiveProcesses > 0)) {
+    idleSweepTimer = setInterval(async () => {
+      try {
+        let totalSwept = 0;
+        const broadcastShrink = (sessionId) => {
+          sessionManager.shrinkSessionBuffer(sessionId, 100);
+        };
+        for (const agentType of ["claude-code", "codex"]) {
+          const provider = providerFactory.getProvider(agentType);
+          if (idleTimeoutMs > 0 && typeof provider.sweepIdleProcesses === "function") {
+            const swept = await provider.sweepIdleProcesses(idleTimeoutMs);
+            swept.forEach(broadcastShrink);
+            totalSwept += swept.length;
+          }
+          if (maxActiveProcesses > 0 && typeof provider.sweepLruProcesses === "function") {
+            const swept = await provider.sweepLruProcesses(maxActiveProcesses);
+            swept.forEach(broadcastShrink);
+            totalSwept += swept.length;
+          }
+        }
+        if (totalSwept > 0) {
+          console.log(`[Server] Idle GC: swept ${totalSwept} idle session(s)`);
+          wsBridge.broadcast({
+            type: "session_list",
+            sessions: sessionManager.getActiveSessions()
+          });
+        }
+      } catch (err) {
+        console.error("[Server] Idle GC failed:", err);
+      }
+    }, idleSweepIntervalMs);
+  }
   const stop = async () => {
     console.log(`[Server] ${t("server.shuttingDown")}`);
     const errors = [];
@@ -5882,6 +6869,7 @@ async function start(opts = {}) {
         errors.push(err);
       }
     };
+    if (idleSweepTimer) clearInterval(idleSweepTimer);
     await attempt(() => authManager.destroy(), "AuthManager");
     await attempt(() => stopMdns(), "mDNS");
     await attempt(() => pairingManager.destroy(), "PairingManager");
@@ -5892,6 +6880,7 @@ async function start(opts = {}) {
     await attempt(() => xcodeBuildExecutor.destroy(), "XcodeBuildExecutor");
     await attempt(() => notificationService.destroy(), "NotificationService");
     await attempt(() => sessionFileWatcher.destroy(), "SessionFileWatcher");
+    await attempt(() => scheduledManager?.destroy(), "ScheduledSessionManager");
     if (errors.length > 0) {
       console.error(`[Server] ${t("server.shutdownWithErrors", { count: errors.length })}`);
       throw errors[0];
@@ -5918,9 +6907,9 @@ async function start(opts = {}) {
     openPairing: (duration) => pairingManager.open(duration),
     closePairing: () => pairingManager.close(),
     regenerateToken: async () => {
-      const newToken = (0, import_uuid7.v4)();
-      await (0, import_promises5.mkdir)(configDir, { recursive: true });
-      await (0, import_promises5.writeFile)(tokenFile, newToken, "utf8");
+      const newToken = (0, import_uuid9.v4)();
+      await (0, import_promises7.mkdir)(configDir, { recursive: true });
+      await (0, import_promises7.writeFile)(tokenFile, newToken, "utf8");
       instance.token = newToken;
       wsBridge.updateToken(newToken);
       approvalProxy.updateToken(newToken);
@@ -5937,7 +6926,7 @@ async function start(opts = {}) {
 var import_qrcode_terminal = __toESM(require("qrcode-terminal"));
 function getPackageVersion() {
   try {
-    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path8.join)(__dirname, "..", "package.json"), "utf8"));
+    const pkg = JSON.parse((0, import_node_fs4.readFileSync)((0, import_node_path10.join)(__dirname, "..", "package.json"), "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -5975,7 +6964,7 @@ async function autoUpdateIfNeeded() {
   console.log(`  \u{1F4E6} ${t("startup.autoUpdating", { current: PKG_VERSION, latest })}`);
   console.log();
   try {
-    (0, import_node_child_process11.execFileSync)("npx", [`sessix-server@${latest}`], {
+    (0, import_node_child_process12.execFileSync)("npx", [`sessix-server@${latest}`], {
       stdio: "inherit",
       env: { ...process.env, __SESSIX_UPDATED: "1" }
     });
@@ -6081,7 +7070,7 @@ ${t("startup.pairingReopened")}`);
   }
 }
 function getLocalIp() {
-  const interfaces = (0, import_node_os9.networkInterfaces)();
+  const interfaces = (0, import_node_os10.networkInterfaces)();
   for (const iface of Object.values(interfaces)) {
     for (const addr of iface ?? []) {
       if (addr.family === "IPv4" && !addr.internal) {