dsh-any-agent 0.5.2 → 0.6.0

package/src/git-snapshot.mjs

@@ -0,0 +1,196 @@
+/**
+ * 工作区 git 快照：回合前后各取一次，用来回答"这一轮有没有改工作区"（workspace_changed）。
+ *
+ * 从 hub.mjs 拆出来：这部分只有纯函数与异步 git 子进程调用，不依赖任何会话/注册表状态，
+ * 所以能单独加载与测试（test/workspace-snapshot.mjs）。hub.mjs 仍然重新导出
+ * `gitStatus` / `sameWorkspaceSnapshot`，外部的导入路径不变。
+ */
+
+import { lstatSync, readdirSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { promisify } from 'node:util';
+
+/**
+ * 两次 workspace 快照是否表示同一组工作区变更。
+ *
+ * 优先比较 `fingerprint`（覆盖**全量**条目：状态行 + 每个路径的 size/mtime，
+ * 未跟踪目录递归展开）。只比较前 40 条 entries 会把"同一状态行但内容变了"
+ * 和第 41 条之后的改动都漏掉（workspace_changed 假阴性）。
+ */
+export function sameWorkspaceSnapshot(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  if (typeof a.fingerprint === 'string' && typeof b.fingerprint === 'string') {
+    return a.fingerprint === b.fingerprint;
+  }
+  // 兼容旧快照/测试里手写的 { changed_files, entries }。
+  return JSON.stringify(a.entries ?? []) === JSON.stringify(b.entries ?? []);
+}
+
+/** 干净工作区的固定指纹（任何非空状态的指纹都至少包含一条状态行，不会与它相同）。 */
+const CLEAN_FINGERPRINT = createHash('sha256').update('clean\0').digest('hex');
+
+const GIT_TIMEOUT_MS = 8000;
+const GIT_MAX_BUFFER = 64 * 1024 * 1024;
+const MAX_UNTRACKED_DIR_ENTRIES = 2000;
+const execFileAsync = promisify(execFile);
+
+/**
+ * 安全 git 参数（放 subcommand 之前）。
+ *
+ * `--no-optional-locks` 是 **git 全局选项**，放在 `status` 之后会被 git 当成
+ * 未知参数直接退出 129 —— 那样快照永远是 null，workspace_changed 恒为 false。
+ */
+const GIT_SAFE = ['--no-optional-locks', '-c', 'core.fsmonitor=false'];
+
+function gitEnv() {
+  return { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+}
+
+/** 异步跑一次 git 并取 stdout；非 git 目录/超时/输出过大都抛给调用方。 */
+async function gitOutput(cwd, args) {
+  const { stdout } = await execFileAsync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_MAX_BUFFER,
+    windowsHide: true,
+    env: gitEnv(),
+  });
+  return stdout;
+}
+
+/** 解析 porcelain v1 -z 状态行；rename/copy 的“原路径”是下一个 NUL 段。 */
+function parsePorcelainZ(stdout) {
+  const tokens = String(stdout ?? '').split('\0');
+  const rows = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    // 形如 "XY path"；posix 允许路径里有空格，所以只切前三个字符。
+    if (token.length < 4 || token[2] !== ' ') continue;
+    const status = token.slice(0, 2);
+    const path = token.slice(3);
+    let orig = null;
+    if (/[RC]/.test(status)) orig = tokens[++i] || null;
+    rows.push({ status, path, orig });
+  }
+  return rows;
+}
+
+/**
+ * 把一个路径的当前状态（类型 + size + mtimeMs）混进指纹。
+ *
+ * - 普通文件：size + mtimeMs 足以识别"状态行没变、内容变了"；
+ * - 未跟踪目录（`?? dir/`）：目录 mtime 只在直接子项增删时变，光看它不够，
+ *   所以递归展开（只用 lstat，不跟随符号链接/不钻 .git，且有预算上限）；
+ * - 已跟踪的目录条目（子模块）：只看它自己的 lstat，避免把子模块整个走一遍。
+ */
+function hashPathStat(hash, full, label, budget) {
+  let st;
+  try {
+    st = lstatSync(full);
+  } catch {
+    hash.update(`${label}\0missing\0`);
+    return;
+  }
+  if (st.isDirectory() && budget) {
+    hash.update(`${label}\0dir\0${st.mtimeMs}\0`);
+    let entries;
+    try {
+      entries = readdirSync(full, { withFileTypes: true });
+    } catch {
+      hash.update('unreadable\0');
+      return;
+    }
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const ent of entries) {
+      if (ent.name === '.git') continue;
+      if (budget.left <= 0) {
+        hash.update(`${label}\0truncated\0`);
+        return;
+      }
+      budget.left -= 1;
+      hashPathStat(hash, join(full, ent.name), `${label}/${ent.name}`, budget);
+    }
+    return;
+  }
+  const kind = st.isSymbolicLink() ? 'link' : st.isFile() ? 'file' : st.isDirectory() ? 'dir' : 'other';
+  hash.update(`${label}\0${kind}\0${st.size}\0${st.mtimeMs}\0`);
+}
+
+/**
+ * 收集当前工作区的 git 变更摘要（非 git 目录返回 null）。
+ *
+ * 异步实现：`execFile` 不占用事件循环 —— 一个 MCP 服务进程承载多个会话，
+ * 同步 `spawnSync` 最长 8s 会把所有会话的 ACP 消息/审批一起卡住。
+ *
+ * 返回对象向后兼容：`changed_files` = 全量状态条目数，`entries` = 前 40 条
+ * 展示用状态行；新增 `fingerprint` 覆盖**全量**条目（含逐路径 size/mtime），
+ * 供 `sameWorkspaceSnapshot` 判断"内容是否真的变了"。
+ */
+export async function gitStatus(cwd) {
+  if (process.env.DSH_MCP_GIT_STATUS === '0') return null;
+  try {
+    // ★ 在不可信仓库里 `git status` 可能触发仓库配置的 fsmonitor/filter；这些
+    //   命令发生在 DSH 沙箱与审批层之外。禁用可选锁与 fsmonitor，并允许用
+    //   DSH_MCP_GIT_STATUS=0 完全关掉。
+    // porcelain 的路径相对 **仓库根**（cwd 是子目录时也是），所以同时取 top-level。
+    const [statusOut, rootOut] = await Promise.all([
+      gitOutput(cwd, [...GIT_SAFE, 'status', '--porcelain', '-z']),
+      gitOutput(cwd, [...GIT_SAFE, 'rev-parse', '--show-toplevel']),
+    ]);
+    const rows = parsePorcelainZ(statusOut);
+    // ★ 干净的仓库返回“0 个改动”的快照，而不是 null：null 专指“拿不到快照”（非 git 目录、
+    //   git 不可用、总开关关闭）。以前两者混用，一轮把唯一的改动删干净时就会出现
+    //   workspace_changed=true 却 diff_stat=null —— 看不出是“现在干净了”还是“没查成”。
+    if (!rows.length) return { changed_files: 0, entries: [], fingerprint: CLEAN_FINGERPRINT };
+    // git 输出的是 `C:/...` 风格，统一成原生分隔符，后面 startsWith 才不会误判越界。
+    const root = resolve(String(rootOut ?? '').trim() || cwd);
+
+    // 状态行按路径排序后参与指纹，避免依赖 git 的输出顺序。
+    const sorted = rows
+      .slice()
+      .sort((a, b) =>
+        a.path === b.path
+          ? a.status < b.status
+            ? -1
+            : a.status > b.status
+              ? 1
+              : 0
+          : a.path < b.path
+            ? -1
+            : 1,
+      );
+
+    const hash = createHash('sha256');
+    const budget = { left: MAX_UNTRACKED_DIR_ENTRIES };
+    const entries = [];
+    const rootPrefix = root.endsWith(sep) ? root : root + sep;
+    for (const row of sorted) {
+      const display = row.orig ? `${row.status} ${row.orig} -> ${row.path}` : `${row.status} ${row.path}`;
+      if (entries.length < 40) entries.push(display);
+      hash.update(display);
+      hash.update('\0');
+
+      const cleanPath = row.path.endsWith('/') ? row.path.slice(0, -1) : row.path;
+      const full = resolve(root, cleanPath);
+      if (full !== root && !full.startsWith(rootPrefix)) {
+        hash.update('outside-worktree\0');
+        continue;
+      }
+      // 只有未跟踪目录需要递归；已跟踪条目（含子模块）看 lstat 即可。
+      hashPathStat(hash, full, cleanPath, row.status === '??' ? budget : null);
+    }
+
+    return {
+      changed_files: rows.length,
+      entries,
+      fingerprint: hash.digest('hex'),
+    };
+  } catch {
+    return null;
+  }
+}

package/src/hub-store.mjs

@@ -0,0 +1,108 @@
+/**
+ * Hub 的两类磁盘小状态：会话元数据侧车与 forget 墓碑。
+ *
+ * 从 hub.mjs 拆出来：两者都只是"按 id 一个小 JSON 文件"的读写，不依赖 Hub/Conversation
+ * 的运行期状态（写侧车只用 `conv.toMeta()` 与 `conv.id`）。红线不变：只存元数据，
+ * 不存任何对话/思考正文。
+ */
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { DSH_HOME, STATE_FILE } from './config.mjs';
+import { findSessionHeaderStatus } from './workspace.mjs';
+
+/** 没有注入 logger 时的占位（Hub 构造器与 pruneStaleTombstones 的默认值共用）。 */
+export const NOOP_LOG = { info: () => {}, debug: () => {}, dshStderr: () => {} };
+
+/**
+ * 会话元数据侧车（`.state/meta/<id>.json`）。
+ *
+ * 为什么需要：`forget=true` 只从注册表移除；之后按 id 查询时，`Hub.get()` 会从
+ * DSH 会话存储重建会话（这是多实例恢复的刻意设计）。但 DSH 的会话记录里**没有**
+ * 本服务选择的 `onApproval` / `reasoning_effort` / `title_hint` / 轮数，
+ * 重建就会悄悄回落到默认值（实测 auto-allow→ask、low→max）。这个侧车保存
+ * **仅元数据**（不含任何对话/思考正文），让重建后仍与原会话一致。
+ */
+export const META_DIR = join(dirname(STATE_FILE), 'meta');
+const metaFilePath = (id) => join(META_DIR, `${id}.json`);
+
+export function writeConversationMeta(conv) {
+  try {
+    mkdirSync(META_DIR, { recursive: true });
+    const file = metaFilePath(conv.id);
+    const tmp = `${file}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
+    writeFileSync(tmp, JSON.stringify(conv.toMeta(), null, 2), 'utf8');
+    renameSync(tmp, file);
+  } catch {
+    /* 元数据侧车只是辅助信息，写失败不影响主流程 */
+  }
+}
+
+export function readConversationMetaFile(id) {
+  try {
+    return JSON.parse(readFileSync(metaFilePath(id), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * forget 墓碑：`release(forget=true)` 之后，按 id 查询必须**明确失败**，
+ * 而不是从 DSH 会话存储里悄悄复活。墓碑只含 id 与时间，不含任何内容；
+ * 删除 `.state/forgotten/<id>.json` 即可恢复按 id 找回（手动、可审计）。
+ */
+// 墓碑放在 DSH home 下而不是注册表旁边：不同实例即使注册表路径不同，
+// 也应该对同一个会话的 forget 达成一致（forget 是会话级终态，不是注册表级）。
+const FORGOTTEN_DIR = process.env.DSH_MCP_FORGOTTEN_DIR ?? join(DSH_HOME, '.dsh-any-agent-forgotten');
+export const forgottenPath = (id) => join(FORGOTTEN_DIR, `${id}.json`);
+
+export function writeTombstone(id) {
+  try {
+    mkdirSync(FORGOTTEN_DIR, { recursive: true });
+    const file = forgottenPath(id);
+    const tmp = `${file}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
+    writeFileSync(tmp, JSON.stringify({ id, forgottenAt: Date.now() }, null, 2), 'utf8');
+    renameSync(tmp, file);
+  } catch {
+    /* 墓碑写失败时 forget 仍从注册表移除；下次 get 可能仍会复活，但不影响主流程 */
+  }
+}
+
+export function isForgotten(id) {
+  try {
+    return existsSync(forgottenPath(id));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 启动时清掉“会话文件已经不存在”的墓碑：它们不再阻止任何 resurrection，
+ * 留着只会让测试/临时会话在 `$DSH_HOME/.dsh-any-agent-forgotten` 里堆积。
+ * 会话文件还在的墓碑必须保留 —— 那正是 forget 的效力所在。
+ */
+export async function pruneStaleTombstones(log = NOOP_LOG) {
+  let removed = 0;
+  try {
+    if (!existsSync(FORGOTTEN_DIR)) return 0;
+    for (const f of readdirSync(FORGOTTEN_DIR)) {
+      if (!f.endsWith('.json')) continue;
+      const id = f.slice(0, -5);
+      // 异步读会话头：启动路径不能被大日志的同步解压卡住。
+      // ★ 只有确认会话文件不存在时才删墓碑；读超时/损坏时保留，
+      //   否则一次慢盘/挂载异常就会让 forget 失效。
+      const found = await findSessionHeaderStatus(id);
+      if (found.status === 'found' || found.status === 'error') {
+        if (found.status === 'error') log.info(`[hub] 墓碑 ${id} 暂不清理：${found.reason}`);
+        continue;
+      }
+      try {
+        rmSync(join(FORGOTTEN_DIR, f), { force: true });
+        removed++;
+      } catch {}
+    }
+  } catch {
+    /* 清理失败不影响启动 */
+  }
+  return removed;
+}