@dshfly/remote-connector 0.2.1

package/core/path-guard.js

@@ -0,0 +1,60 @@
+// packages/remote-connector/core/path-guard.js
+// 完整磁盘权限（fullDisk）门禁：手机被限制为"已登记工作区 ∪ 主机 cwd"范围内
+// （与文件树锚定一致，2026-08 新增）。
+//   浏览（mobile.files.browse）/ 新建目录（mobile.files.mkdir）/ 新建工作区
+//   （workspace.create 反代）三处共用本判定：fullDisk=true 直接放行；false 时
+//   path 的"最近存在祖先"必须位于允许根之内（mkdir 目标可能尚不存在）。
+// 纯函数 + 真实 fs，可单测。
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const fsp = fs.promises;
+
+/** 向上找"最近存在的祖先"的 realpath（目标可能尚不存在，如 mkdir 新建目录）。 */
+export async function nearestExistingReal(p) {
+  let cur = p;
+  for (;;) {
+    try {
+      return await fsp.realpath(cur);
+    } catch {
+      // 不存在，向上
+    }
+    const parent = path.dirname(cur);
+    if (parent === cur) return null; // 到根仍未找到（理论上不可达，防御）
+    cur = parent;
+  }
+}
+
+/** 判定 canonical 路径是否位于任一允许根之内（含根本身）。roots 已 canonical。 */
+export function insideRoots(real, roots) {
+  if (typeof real !== 'string' || !real) return false;
+  for (const r of roots) {
+    if (typeof r !== 'string' || !r) continue;
+    if (real === r || real.startsWith(r + path.sep)) return true;
+  }
+  return false;
+}
+
+/**
+ * 权限门禁。返回 null=放行；否则返回错误码（'files-root-forbidden'）。
+ * @param {{path: string, fullDisk: boolean, roots: string[]}} opts
+ *   roots 为"原始"允许根（工作区路径 ∪ 主机 cwd），内部 canonical 化后匹配。
+ */
+export async function guardPath({ path: p, fullDisk, roots }) {
+  if (fullDisk) return null;
+  if (typeof p !== 'string' || !p.trim()) return 'files-root-forbidden';
+  if (!path.isAbsolute(p.trim())) return 'files-root-forbidden';
+  const real = await nearestExistingReal(path.normalize(p.trim()));
+  if (!real) return 'files-root-forbidden';
+  const canon = [];
+  for (const r of roots) {
+    if (typeof r !== 'string' || !r) continue;
+    try {
+      canon.push(await fsp.realpath(r));
+    } catch {
+      // 允许根不可达（如已删除的工作区）忽略
+    }
+  }
+  return insideRoots(real, canon) ? null : 'files-root-forbidden';
+}

package/core/pending-approvals.js

@@ -0,0 +1,80 @@
+// packages/remote-connector/core/pending-approvals.js
+// PendingApprovalCache —— connector 侧 pending 审批/提问的镜像缓存（方案 A）。
+//
+// 背景：审批/提问是实时瞬态事件——手机离线期间 relay 直接丢弃 EVENT 帧（无缓冲无重发）；
+// DSH 的 pending 重放只在"新 mux 订阅建立"时触发（mux-open replay），而 connector 对
+// dsh web 是单条长连接（手机重连不产生新订阅）→ 手机永远收不到离线期间产生的审批：
+// PC 侧一直挂着（agent 阻塞等待），手机无弹窗、无法响应。
+// 修复：connector 在 dsh 事件流上镜像 pending 审批/提问帧；手机连接恢复时经
+// mobile.approvals.list 拉取，与实时帧同路径分发（全局审批窗照常弹出、响应可回）。
+//
+// 数据来源：dsh web events.mux 的 server-request 帧（method ∈ approval/question 域）。
+// 剪枝：
+//   - approval/resolved：按 payload.approvalId 匹配 requested 帧删除；
+//   - question/resolved：按 payload.questionRpcId（= 原 requested 帧的 rpcId）删除；
+//   - TTL 兜底：resolved 帧只在存活 mux 订阅上广播（broadcast 语义），事件流断线窗口
+//     可能丢失 → TTL 过期清除，防止陈旧条目永久残留（正常路径靠 resolved 帧剪枝）；
+//   - mux 重开时 clear()：DSH 会把全部 pending 重放进新队列（mux-open replay），
+//     等重放重建缓存即可。
+
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24h：resolved 帧丢失时的兜底过期；正常剪枝走 resolved 帧。
+// 2026-08 从 1h 调大：手机端「方案 A」补拉（mobile.approvals.list）读本缓存；TTL 太短会让
+// 超过 1h 仍未处理的审批/提问在手机重连补拉时丢失（角标/弹窗提前消失）。调 24h 后长时间
+// pending 仍能补拉；mux 重开时 DSH 重放当前 pending 会重建缓存，正常解析仍走 resolved 帧剪枝。
+
+// 快速预过滤：只命中 method 为审批/提问域的四类帧；其余高频帧（session/event 等）零开销跳过
+const APPROVAL_FRAME_RE = /"method"\s*:\s*"(approval|question)\/(requested|resolved)"/;
+
+export class PendingApprovalCache {
+  constructor({ ttlMs = DEFAULT_TTL_MS } = {}) {
+    this.ttlMs = ttlMs;
+    /** @type {Map<string, {frame: object, at: number}>} key: 'approval:<approvalId>' | 'question:<rpcId>' */
+    this.entries = new Map();
+  }
+
+  /** 事件流帧入口：文本 → 快速预过滤 → JSON 解析 → 更新缓存。 */
+  ingest(text) {
+    if (typeof text !== 'string') return;
+    if (!APPROVAL_FRAME_RE.test(text)) return;
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const method = frame?.method;
+    const payload = frame?.payload || {};
+    if (method === 'approval/requested' || method === 'question/requested') {
+      const key = method === 'approval/requested' ? `approval:${payload.approvalId}` : `question:${frame.rpcId}`;
+      if (!key) return;
+      this.entries.set(key, { frame, at: Date.now() });
+      return;
+    }
+    if (method === 'approval/resolved') {
+      if (payload.approvalId) this.entries.delete(`approval:${payload.approvalId}`);
+      return;
+    }
+    if (method === 'question/resolved') {
+      if (payload.questionRpcId) this.entries.delete(`question:${payload.questionRpcId}`);
+    }
+  }
+
+  /** 拉取入口：返回与实时 mux 帧同形的 server-request 帧数组（含 TTL 惰性清扫）。 */
+  list() {
+    const now = Date.now();
+    const frames = [];
+    for (const [key, { frame, at }] of this.entries) {
+      if (now - at > this.ttlMs) {
+        this.entries.delete(key);
+        continue;
+      }
+      frames.push(frame);
+    }
+    return { frames };
+  }
+
+  /** mux 重开时清空（DSH 重放全部 pending，缓存随之重建）。 */
+  clear() {
+    this.entries.clear();
+  }
+}

package/core/push-notifier.js

@@ -0,0 +1,79 @@
+// packages/remote-connector/core/push-notifier.js
+// 在 dsh 事件流上检测"需要通知离线手机"的事件（与 pending-approvals 同风格、同位置被调）。
+// 触发：
+//   ① approval/requested、question/requested → kind='approval'
+//   ② host/session-status 的 running true→false 边沿 → kind='completion'
+// 只对 offline 集合内的手机触发；每手机×kind 去抖（默认 60s）。
+
+const APPROVAL_RE = /"method"\s*:\s*"(approval|question)\/requested"/;
+const STATUS_RE = /"method"\s*:\s*"host\/session-status"/;
+const MAX_RUNNING = 5000; // running 边沿表容量上限（每会话一条，超限整体重置，防无界增长）
+
+export function createPushNotifier({ onNotify, throttleMs = 60_000 } = {}) {
+  const running = new Map(); // sessionId -> boolean
+  const lastAt = new Map(); // `${phonePk}:${kind}` -> ts
+
+  function emit(offlineSet, kind, sessionId) {
+    if (typeof onNotify !== 'function') return;
+    const now = Date.now();
+    const targets = [];
+    for (const phonePk of offlineSet) {
+      const key = `${phonePk}:${kind}`;
+      if (now - (lastAt.get(key) ?? 0) < throttleMs) {
+        continue;
+      }
+      targets.push(phonePk);
+      lastAt.set(key, now);
+    }
+    if (targets.length === 0) return;
+    for (const phonePk of targets) {
+      try {
+        onNotify(phonePk, kind, sessionId);
+      } catch {
+        // 推送回调异常静默（推送日志整体不显示，避免刷屏）
+      }
+    }
+  }
+
+  function ingest(text, offlineSet) {
+    if (typeof text !== 'string' || !offlineSet || offlineSet.size === 0) return;
+
+    if (APPROVAL_RE.test(text)) {
+      let f;
+      try {
+        f = JSON.parse(text);
+      } catch {
+        return;
+      }
+      if (f?.method === 'approval/requested' || f?.method === 'question/requested') {
+        emit(offlineSet, 'approval', f?.payload?.sessionId ?? null);
+      }
+      return;
+    }
+
+    if (STATUS_RE.test(text)) {
+      let f;
+      try {
+        f = JSON.parse(text);
+      } catch {
+        return;
+      }
+      const p = f?.payload;
+      const sid = typeof p?.sessionId === 'string' ? p.sessionId : null;
+      if (!sid || typeof p.running !== 'boolean') return;
+      if (running.size >= MAX_RUNNING && !running.has(sid)) running.clear();
+      const before = running.get(sid);
+      running.set(sid, p.running);
+      if (before === true && p.running === false) {
+        emit(offlineSet, 'completion', sid);
+      }
+    }
+  }
+
+  function clear() {
+    running.clear();
+    lastAt.clear();
+  }
+
+  return { ingest, clear };
+}

package/core/session-titles.js

@@ -0,0 +1,85 @@
+// packages/remote-connector/core/session-titles.js
+// sessionId → title 轻量缓存（有界 LRU + TTL）。喂两个源：
+//   ① session.list 响应（权威；tunnel 反代 session.list 时顺手落表）
+//   ② session/projection、session/event 帧（改名/标题更新的增量，防御式提取）
+// 用途：connector 触发推送时给通知带上会话标题；查不到则 relay 用兜底文案。
+
+// 快速预过滤：事件流高频帧（assistant/chunk 等）零开销跳过，只在 session/projection、
+// session/event 帧上才 JSON.parse（对齐 pending-approvals / push-notifier 的预过滤模式）。
+const TITLE_FRAME_RE = /"method"\s*:\s*"(session\/projection|session\/event)"/;
+
+export function createSessionTitleCache({ maxEntries = 5000, ttlMs = 24 * 3600 * 1000 } = {}) {
+  const map = new Map(); // sessionId -> { title, at }
+
+  function set(sessionId, title) {
+    if (typeof sessionId !== 'string' || !sessionId) return;
+    if (typeof title !== 'string') return;
+    const clean = title.trim();
+    if (!clean) return;
+    map.delete(sessionId); // LRU：移到最后
+    map.set(sessionId, { title: clean, at: Date.now() });
+    while (map.size > maxEntries) {
+      const oldest = map.keys().next().value;
+      map.delete(oldest);
+    }
+  }
+
+  function titleOf(sessionId) {
+    if (typeof sessionId !== 'string' || !sessionId) return null;
+    const e = map.get(sessionId);
+    if (!e) return null;
+    if (Date.now() - e.at > ttlMs) {
+      map.delete(sessionId);
+      return null;
+    }
+    return e.title;
+  }
+
+  /** session.list 响应 JSON（字符串）：items[].sessionId + projections.values.title。 */
+  function ingestSessionList(jsonStr) {
+    if (typeof jsonStr !== 'string') return;
+    let full;
+    try {
+      full = JSON.parse(jsonStr);
+    } catch {
+      return;
+    }
+    const items = full?.result?.value?.items;
+    if (!Array.isArray(items)) return;
+    for (const it of items) {
+      const sid = it?.sessionId;
+      if (typeof sid !== 'string') continue;
+      set(sid, it?.projections?.values?.title);
+    }
+  }
+
+  /** 事件流帧文本：session/projection、session/event（含 rename）里可能带 title，防御式提取。 */
+  function ingest(text) {
+    if (typeof text !== 'string' || !TITLE_FRAME_RE.test(text)) return;
+    let f;
+    try {
+      f = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const method = f?.method;
+    if (method !== 'session/projection' && method !== 'session/event') return;
+    const p = f?.payload;
+    if (!p || typeof p !== 'object') return;
+    const sid = typeof p.sessionId === 'string' ? p.sessionId : null;
+    if (!sid) return;
+    const title =
+      typeof p.title === 'string' ? p.title
+        : typeof p.values?.title === 'string' ? p.values.title
+          : typeof p.projections?.values?.title === 'string' ? p.projections.values.title
+            : (p.event && typeof p.event.title === 'string') ? p.event.title
+              : null;
+    if (title) set(sid, title);
+  }
+
+  function clear() {
+    map.clear();
+  }
+
+  return { titleOf, ingest, ingestSessionList, clear };
+}