dsh-any-agent 0.3.9 → 0.5.0

package/src/config.mjs

@@ -42,15 +42,60 @@ function findInNpxCache() {
     } catch {
       continue;
     }
+    const found = [];
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const p = join(root, e.name, 'node_modules', DSH_ENTRY);
-      if (existsSync(p)) return p;
+      if (!existsSync(p)) continue;
+      let version = '0.0.0';
+      try {
+        version =
+          JSON.parse(readFileSync(join(dirname(p), '..', 'package.json'), 'utf8')).version ?? version;
+      } catch {
+        // 版本读不到就当 0.0.0，仍可作为候选
+      }
+      found.push({ p, version });
+    }
+    if (found.length) {
+      // ★ 取**最高版本**，不是目录枚举顺序。本机可以同时缓存 0.1.5 和 0.1.7，
+      //   按目录顺序会随机选中旧版，导致实验性能力（如 Agent Teams）根本加载不到。
+      found.sort((a, b) => cmpVersion(b.version, a.version));
+      return found[0].p;
     }
   }
   return undefined;
 }
 
+/** 极简 semver 比较（够用于 npx 缓存里挑最新）；返回 a-b 的符号。 */
+export function cmpVersion(a, b) {
+  const [ac, ap] = String(a).split('-', 2);
+  const [bc, bp] = String(b).split('-', 2);
+  const an = ac.split('.').map(Number);
+  const bn = bc.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const d = (an[i] || 0) - (bn[i] || 0);
+    if (d) return d;
+  }
+  if (!ap && bp) return 1; // release > prerelease
+  if (ap && !bp) return -1;
+  if (ap && bp) {
+    const ar = ap.split('.');
+    const br = bp.split('.');
+    for (let i = 0; i < Math.max(ar.length, br.length); i++) {
+      const x = ar[i] ?? '';
+      const y = br[i] ?? '';
+      const xn = x !== '' && Number.isFinite(Number(x));
+      const yn = y !== '' && Number.isFinite(Number(y));
+      if (xn && yn) {
+        if (Number(x) !== Number(y)) return Number(x) - Number(y);
+      } else if (xn) return -1;
+      else if (yn) return 1;
+      else if (x !== y) return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+
 /**
  * 解析 DSH CLI 入口。按顺序尝试：
  *   1) DSH_BIN 环境变量（最可靠，推荐显式设置）
@@ -83,9 +128,6 @@ export function resolveDshBin() {
   );
 }
 
-/** 用于驱动 DSH 的 profile（由 bootstrap 在首启时按 acp 模板创建）。 */
-export const DSH_PROFILE = process.env.DSH_MCP_PROFILE ?? 'dsh-mcp';
-
 /**
  * DSH 主目录。**默认就是本机用户自己的 ~/.dsh** —— 本服务不拥有独立的 home，
  * 因此凭据（.credentials.yaml）、会话历史、工作区登记与 GUI 完全共用一份。
@@ -95,6 +137,80 @@ export const DSH_PROFILE = process.env.DSH_MCP_PROFILE ?? 'dsh-mcp';
  */
 export const DSH_HOME = process.env.DSH_HOME ?? join(homedir(), '.dsh');
 
+/**
+ * 团队开关（0.5.0 起默认关闭，按需开启）。
+ *
+ * 优先级：`DSH_MCP_TEAM` 环境变量 > `<DSH_HOME>/.dsh-any-agent/settings.json`
+ * 的 `team` 字段 > 默认关闭。用 `dsh-any-agent team on|off` 写这个文件，
+ * 不必手改客户端配置。
+ */
+export const TEAM_SETTINGS_FILE =
+  process.env.DSH_MCP_SETTINGS ?? join(DSH_HOME, '.dsh-any-agent', 'settings.json');
+
+function readTeamSetting() {
+  try {
+    const j = JSON.parse(readFileSync(TEAM_SETTINGS_FILE, 'utf8'));
+    return typeof j.team === 'boolean' ? j.team : null;
+  } catch {
+    return null;
+  }
+}
+
+export const TEAM_MODE_SOURCE = (() => {
+  const v = process.env.DSH_MCP_TEAM;
+  if (v !== undefined && String(v).trim() !== '') return 'env';
+  return readTeamSetting() === null ? 'default' : 'file';
+})();
+
+export const TEAM_MODE = (() => {
+  const v = process.env.DSH_MCP_TEAM;
+  if (v !== undefined && String(v).trim() !== '') {
+    return !['0', 'false', 'off', 'no'].includes(String(v).trim().toLowerCase());
+  }
+  return readTeamSetting() ?? false;
+})();
+
+/** 运行中的 DSH 版本（读不到为 null）。 */
+export const DSH_VERSION = (() => {
+  try {
+    const bin = resolveDshBin();
+    return (
+      JSON.parse(readFileSync(join(dirname(bin), '..', 'package.json'), 'utf8')).version ?? null
+    );
+  } catch {
+    return null;
+  }
+})();
+
+// 注意用 `0.1.7-0` 而不是 `0.1.7`：semver 里 `0.1.7-rc.1 < 0.1.7`，
+// 但 team 包正是随 0.1.7-rc.1 发布的。
+const teamVersionOk = DSH_VERSION === null || cmpVersion(DSH_VERSION, '0.1.7-0') >= 0;
+
+/** 用于驱动 DSH 的 profile（由 bootstrap 在首启时按 acp 模板创建）。 */
+export const DSH_PROFILE =
+  process.env.DSH_MCP_PROFILE ?? (TEAM_MODE && teamVersionOk ? 'dsh-team' : 'dsh-mcp');
+
+/**
+ * 团队能力是否真正可用：
+ *   - 用户没有关（TEAM_MODE）；
+ *   - DSH >= 0.1.7（team 包从 0.1.7 才有）；
+ *   - **profile 里真的含 team 包**（显式指定了不含 team 的 profile 时不注入，
+ *     否则模型会看到一个不存在的工具）。
+ * profile 还不存在时（首启）交给 bootstrap 创建，视为可用。
+ */
+const profileTeamText = (() => {
+  try {
+    return readFileSync(join(DSH_HOME, 'profiles', DSH_PROFILE, 'cordis.patch.yml'), 'utf8');
+  } catch {
+    return null;
+  }
+})();
+
+export const TEAM_ACTIVE =
+  TEAM_MODE &&
+  teamVersionOk &&
+  (profileTeamText === null || profileTeamText.includes('@deepseek-ai/dsh-experimental-agent-team'));
+
 /**
  * 是否允许 bootstrap 自动创建/同步 DSH profile（默认开）。
  * 关掉（DSH_MCP_BOOTSTRAP=0）后本服务只驱动已存在的 profile，不再写任何文件。
@@ -240,7 +356,10 @@ export function numEnv(name, fallback) {
   return Number.isFinite(n) ? n : fallback;
 }
 
-const rawIdle = numEnv('DSH_MCP_IDLE_TTL_MS', 0);
+// 0.4.0：默认从"永不回收"改为 10 分钟。
+// 代价是锁可能空出来被 GUI 拿走；收益是并发一高不会把内存堆到几 GB。
+// 需要"永远握住写锁"的会话用 dsh_start(keep_alive=true) 显式保活。
+const rawIdle = numEnv('DSH_MCP_IDLE_TTL_MS', 10 * 60 * 1000);
 /** ★ `<= 0` 或非法值一律当作"永不回收"。
  *  否则 `-1` 会被算成 `cutoff = now + 1` → **立刻回收**（谁会想到负数=马上收 ✗），
  *  `NaN` 更糟：比较永远为假，行为取决于具体分支。宁可把"奇怪的输入"统一压到安全侧。 */
@@ -261,13 +380,54 @@ export const REAP_INTERVAL_MS = Number.isFinite(rawReap) && rawReap >= 200 ? raw
  *   - 窗口外的：进程回收、内存释放 ✓（下次派活自动 resume，无损 ✓）
  * 即"**内存有界，锁尽量在手**"。
  *
- * **默认 8**（按实测 300-480MB/个，最坏约 2.5-4GB）：让"内存有界"成为默认行为，而不是要用户先发现再配 ✗。
+ * **默认 4**（按实测 300-480MB/个，最坏约 1.2-1.9GB）：让"内存有界"成为默认行为。
  * 被回收是无损的（会话日志在磁盘上 ✓），代价只是那个会话的写锁会空出来、
  * 且下次派活要 cold start。想做更多并行就调大；机器大也可以设 0（不限）。
+ * `keep_alive=true` 的会话不受本上限约束（由调用方自己负责内存）。
  */
-const rawMaxLive = numEnv('DSH_MCP_MAX_LIVE', 8);
+const rawMaxLive = numEnv('DSH_MCP_MAX_LIVE', 4);
 export const MAX_LIVE = Number.isFinite(rawMaxLive) && rawMaxLive > 0 ? Math.floor(rawMaxLive) : 0;
 
+/**
+ * 全局子进程内存预算（MB）。`0` = 关闭。
+ *
+ * 超过预算时按"最久未用"回收空闲会话，直到回到预算内。
+ * 与 `MAX_LIVE` 的区别：那个按**会话数**，这个按**实际 RSS**——
+ * 会话的上下文大小差异很大，按个数限制经常低估。
+ * 读 RSS 失败时静默跳过（不能因为量不到就把会话全收了）。
+ */
+const rawMaxRss = numEnv('DSH_MCP_MAX_RSS_MB', 0);
+export const MAX_RSS_MB = Number.isFinite(rawMaxRss) && rawMaxRss > 0 ? Math.floor(rawMaxRss) : 0;
+
+/**
+ * 给每个 DSH 子进程的 V8 老生代设上限（MB）。`0` = 不设。
+ *
+ * 只是兜底：DSH 正常不会吃满默认堆，但失控的上下文可以把 RSS 顶到很高。
+ * 设太小会让长会话 OOM，所以默认关闭、由用户按机器情况调。
+ */
+const rawChildHeap = numEnv('DSH_MCP_CHILD_MAX_OLD_SPACE_MB', 0);
+export const CHILD_MAX_OLD_SPACE_MB =
+  Number.isFinite(rawChildHeap) && rawChildHeap > 0 ? Math.floor(rawChildHeap) : 0;
+
+/**
+ * 同一 `(cwd, permission)` 的多个会话共享一个 ACP 进程（0.4.0 引入，**0.5.0 起默认开启**）。
+ *
+ * 为什么默认开：DSH 的 ACP 服务端支持一条连接上多会话，且每个 session 有独立 Agent。
+ * 实测（DSH 0.1.7）：两个会话 → 一个 PID，第二个 `session/new` 约 300ms，独立进程约 4s；
+ * 内存也从"每会话 300-480MB"降到"每个 (cwd, 权限) 组一份"。
+ *
+ * 为什么仍然分组：`sandbox-policy.workspaceRoot` / `mode` 与 `approval.policy` 在
+ * `dsh-base` 里是**进程级**配置，不同工作区/权限档混进一个进程会让沙箱边界失真 ——
+ * 那两种情况仍各起一个进程（硬约束，不是实现偷懒）。
+ *
+ * 代价（已写进文档，别当它不存在）：共享进程崩溃会连坐同组的**所有**会话。崩溃时统一写
+ * error 哨兵并唤醒等待者，下次派活各自 resume —— 会话本体无损，但进行中的回合会断。
+ * 所以 `dsh_takeover` 在杀一个还挂着其它会话的共享进程前，会要求显式 `force=true`。
+ *
+ * 设 `DSH_MCP_SHARED_PROCESS=0` 回到"一会话一进程"（拿内存换隔离性）。
+ */
+export const SHARED_PROCESS = numEnv('DSH_MCP_SHARED_PROCESS', 1) === 1;
+
 /**
  * `dsh_list` 的"磁盘探测"结果缓存多久（毫秒）。
  *
@@ -279,10 +439,19 @@ export const LIST_PROBE_TTL_MS = numEnv('DSH_MCP_LIST_PROBE_TTL_MS', 10_000);
 
 /** 权限档 → 该档下的默认审批策略。 */
 export const PERMISSION_TIERS = ['read-only', 'workspace-write', 'danger-full-access'];
-/** 空串/非法值一律回落到 danger-full-access（保持旧默认），而不是让 Hub.create 每次都失败。 */
+/**
+ * 新建会话的默认权限档。0.5.0 起默认 **workspace-write**（沙箱把写入限制在工作区内），
+ * 不再是 danger-full-access；空串/非法值也回落到它。
+ *
+ * `danger-full-access` 需要机器侧显式允许（`DSH_MCP_ALLOW_FULL_ACCESS=1`），
+ * 避免"任何 MCP 客户端都能驱动"的服务默认把整机写权限交出去。
+ */
 export const DEFAULT_PERMISSION = PERMISSION_TIERS.includes(process.env.DSH_MCP_PERMISSION)
   ? process.env.DSH_MCP_PERMISSION
-  : 'danger-full-access';
+  : 'workspace-write';
+
+/** 是否允许 `permission=danger-full-access`（默认关）。 */
+export const ALLOW_FULL_ACCESS = process.env.DSH_MCP_ALLOW_FULL_ACCESS === '1';
 
 /**
  * 审批处理策略：

package/src/host.mjs

@@ -0,0 +1,148 @@
+/**
+ * 共享 ACP 进程宿主（0.4.0 引入，0.5.0 起默认开启；`DSH_MCP_SHARED_PROCESS=0` 关闭）。
+ *
+ * DSH 的 ACP 服务端支持一条连接上多会话，每个 session 有自己的 Agent 与上下文。
+ * 但 `dsh-base` 的 `sandbox-policy.workspaceRoot` / `mode` 与 `approval.policy`
+ * 都是**进程级**配置，所以只能按 `(cwd, permission)` 分组共享：
+ *   - 同一工作区、同一权限档的会话可以共用一个 DSH 进程；
+ *   - 不同工作区/权限档仍然各起一个进程（这是硬约束，不是实现偷懒）。
+ *
+ * 代价：共享进程崩溃会连坐同组的所有会话。`onExit` 会把它们统一标成失败、
+ * 写 error 哨兵并唤醒等待者；下次派活各自重新 resume。
+ */
+
+import { AcpProcess } from './acp.mjs';
+
+const now = () => Date.now();
+
+export class SessionHost {
+  constructor({ cwd, permission, log, hub, AcpProcessClass = AcpProcess }) {
+    this.cwd = cwd;
+    this.permission = permission;
+    this.log = log;
+    this.hub = hub;
+    this.AcpProcessClass = AcpProcessClass;
+    this.proc = null;
+    this.initializing = null;
+    this.stopping = null;
+    /** sessionId → Conversation */
+    this.conversations = new Map();
+    this.lastUsedAt = now();
+  }
+
+  get alive() {
+    return !!this.proc?.alive;
+  }
+
+  get pid() {
+    return this.proc?.pid ?? null;
+  }
+
+  get stderrTail() {
+    return this.proc?.stderrTail ?? '';
+  }
+
+  get size() {
+    return this.conversations.size;
+  }
+
+  has(id) {
+    return this.conversations.has(id);
+  }
+
+  attach(conv) {
+    this.conversations.set(conv.id, conv);
+    this.lastUsedAt = now();
+  }
+
+  /** 拉起并完成 ACP 握手；并发调用共享同一个 in-flight promise。 */
+  async initialize() {
+    if (this.proc?.alive) return;
+    if (this.initializing) return this.initializing;
+    this.initializing = (async () => {
+      const proc = new this.AcpProcessClass({
+        cwd: this.cwd,
+        permission: this.permission,
+        log: this.log,
+        onNotification: (params) => {
+          const conv = this.conversations.get(params.sessionId);
+          if (conv) conv.onUpdate(params);
+          else this.log?.debug?.(`[host] 丢弃未知会话的通知: ${params.sessionId}`);
+        },
+        onPermissionRequest: (params) => {
+          const conv = this.conversations.get(params.sessionId);
+          // 找不到会话时必须拒绝，绝不能自动放行。
+          if (!conv) return { outcome: { outcome: 'cancelled' } };
+          return conv.onPermissionRequest(params);
+        },
+        onExit: (reason) => this.#onExit(reason),
+      });
+      proc.start();
+      this.proc = proc;
+      await proc.initialize();
+    })().finally(() => {
+      this.initializing = null;
+    });
+    return this.initializing;
+  }
+
+  #onExit(reason) {
+    const convs = [...this.conversations.values()];
+    this.conversations.clear();
+    this.proc = null;
+    for (const conv of convs) {
+      try {
+        conv.onProcessExit?.(reason);
+      } catch (e) {
+        this.log?.info?.(`[host] 处理会话 ${conv.id} 的进程退出失败: ${e.message}`);
+      }
+    }
+    this.hub?.forgetHost?.(this);
+  }
+
+  request(method, params, timeoutMs) {
+    if (!this.proc) return Promise.reject(new Error('共享 DSH 进程未运行'));
+    return this.proc.request(method, params, timeoutMs);
+  }
+
+  notify(method, params) {
+    return this.proc?.notify(method, params) ?? false;
+  }
+
+  /**
+   * 让一个会话离开宿主。默认顺手 `session/close` 释放该会话的 Agent 与写锁；
+   * 最后一个会话离开时停掉进程。
+   */
+  async detach(conv, { closeSession = true } = {}) {
+    if (closeSession && this.proc?.alive && this.conversations.has(conv.id)) {
+      try {
+        await this.request('session/close', { sessionId: conv.id }, 10_000);
+      } catch {
+        // 已经关闭/进程正在退出都无所谓
+      }
+    }
+    this.conversations.delete(conv.id);
+    if (this.conversations.size === 0) return this.stop();
+    return true;
+  }
+
+  /** 只有在没有会话附加时才真正停进程。 */
+  async stop() {
+    if (this.conversations.size > 0) return true;
+    if (this.stopping) return this.stopping;
+    const proc = this.proc;
+    this.proc = null;
+    if (!proc) {
+      this.hub?.forgetHost?.(this);
+      return true;
+    }
+    this.stopping = proc
+      .stop()
+      .catch(() => false)
+      .finally(() => {
+        this.stopping = null;
+        this.hub?.forgetHost?.(this);
+      });
+    return this.stopping;
+  }
+}