dsh-over-ssh 0.2.2 → 0.2.4

package/lib/file-references.js

@@ -2,7 +2,7 @@
 import "@deepseek-ai/cordis";
 
 // src/host/integration/fs/file-reference-provider.ts
-import { readdir } from "node:fs/promises";
+import { readdir, realpath, stat } from "node:fs/promises";
 import { join } from "node:path";
 import "@deepseek-ai/cordis";
 import FileReferenceService from "@deepseek-ai/dsh-file-reference";
@@ -47,7 +47,7 @@ var DEFAULTS = {
   outputCap: 8 * 1024 * 1024
 };
 function rankMatches(paths, query, limit) {
-  const needle = query.trim().toLowerCase();
+  const needle = separatorsForMatching(query.trim().toLowerCase());
   if (needle === "") {
     const top = [];
     const better = (left, right) => {
@@ -72,7 +72,8 @@ function rankMatches(paths, query, limit) {
   }
   const scored = [];
   for (const path of paths) {
-    const lower = path.toLowerCase();
+    const normalized = separatorsForMatching(path);
+    const lower = normalized.toLowerCase();
     const base = lower.slice(lower.lastIndexOf("/") + 1);
     let score;
     if (base.startsWith(needle)) score = 0;
@@ -87,11 +88,15 @@ function rankMatches(paths, query, limit) {
   );
   return scored.slice(0, limit).map((entry) => entry.path);
 }
+function separatorsForMatching(path) {
+  return path.includes("\\") && !path.includes("/") ? path.replaceAll("\\", "/") : path;
+}
 function depth(path) {
   let segments = 0;
   let inSegment = false;
   for (let index = 0; index < path.length; index += 1) {
-    if (path.charCodeAt(index) === 47) {
+    const code = path.charCodeAt(index);
+    if (code === 47 || code === 92) {
       inSegment = false;
       continue;
     }
@@ -153,6 +158,14 @@ function makeLocalRoot(path, options = {}) {
 function normalizeLocalPath2(path, options = {}) {
   return normalizeLocalPath(path, { caseInsensitive: options.caseInsensitive ?? process.platform === "win32" });
 }
+function localPathContains(root, candidate, options = {}) {
+  const normalizedRoot = normalizeLocalPath2(root, options);
+  const normalizedCandidate = normalizeLocalPath2(candidate, options);
+  if (normalizedRoot === "/" || /^[a-z]:\/$/.test(normalizedRoot)) {
+    return normalizedCandidate.startsWith(normalizedRoot);
+  }
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
+}
 
 // src/host/integration/session-fork-pending.ts
 var pending = /* @__PURE__ */ new Map();
@@ -248,6 +261,17 @@ var RemoteFileReferenceService = class extends FileReferenceService {
    * (`local-backend.ts:53`), so there is no change signal to hook — only a short TTL.
    */
   #localCache = /* @__PURE__ */ new Map();
+  /**
+   * 正在进行中的本地走查，按根合并。
+   *
+   * 为什么需要它：缓存只覆盖"上一次走查**已完成**"的情况。用户敲 `@mo` 时的间隔可能短于一次走查
+   * （10 000 条目约 68 ms），于是几次击键会各自发起一次全树走查——同一棵树在宿主事件循环上被重复
+   * 扫描。这里让并发的同根调用共享一次走查；查询不同不影响，因为**排序仍按每次调用自己的 query 现算**，
+   * 共享的只有与 query 无关的树枚举。
+   */
+  #inflight = /* @__PURE__ */ new Map();
+  /** 已经告警过的来源标签；一次故障只提示一次，避免每个按键都刷一行日志。 */
+  #warned = /* @__PURE__ */ new Set();
   constructor(ctx, options = {}) {
     super(ctx);
     this.#options = options;
@@ -279,20 +303,53 @@ var RemoteFileReferenceService = class extends FileReferenceService {
    *   without an index, or a cwd that is not an absolute host path.
    */
   async list(agent, query, signal) {
+    signal.throwIfAborted();
     const cwd = agent.session.header.cwd ?? process.cwd();
     const registry = this.ctx.sshDevRoots;
     if (registry === void 0) return [];
     const identity = sessionIdentityOf(this.ctx, agent.session.header.id);
     const gated = identity.sessionId === void 0 ? registry.routed.tryResolve(cwd) : registry.routed.tryResolve(cwd, { session: identity });
-    const addedTask = this.#addedRemoteCandidates(cwd, identity, query, signal);
+    const addedTask = this.#degrade(
+      "\u672C\u4F1A\u8BDD\u6DFB\u52A0\u7684\u8FDC\u7AEF\u6839",
+      void 0,
+      () => this.#addedRemoteCandidates(cwd, identity, query, signal)
+    );
     const ungated = gated.ok ? void 0 : registry.routed.tryResolve(cwd);
     const implicit = gated.ok || ungated?.ok === true ? void 0 : sessionLocalRoot(cwd);
-    const namedTask = gated.ok ? this.#namedCandidates(gated.target.root, query, signal) : implicit === void 0 ? void 0 : this.#localCandidates(implicit.path, query, signal);
+    const namedTask = gated.ok ? this.#degrade("cwd \u547D\u540D\u7684\u6839", [], () => this.#namedCandidates(gated.target.root, query, signal)) : implicit === void 0 ? void 0 : this.#degrade("cwd \u81EA\u8EAB\u76EE\u5F55", [], () => this.#localCandidates(implicit.path, query, signal));
     const [added, named] = await Promise.all([addedTask, namedTask]);
+    signal.throwIfAborted();
     if (gated.ok) return this.#merge(added, named ?? []);
     if (ungated?.ok === true) return added ?? [];
     return this.#merge(added, named ?? []);
   }
+  /**
+   * Run one candidate source, degrading a failure to `fallback`.
+   *
+   * 为什么不让一次失败冒到上层：`@` 补全有两个独立来源（本会话「添加目录」的远端根、cwd 命名的根）。
+   * 旧写法直接 `Promise.all`，其中**任何一个**失败（连接断、远端超时、walk 抛错）都会让整个 `list()`
+   * 拒绝——明明本地候选已经拿到，也会一起消失。取消是例外：调用方已经取消时必须继续抛出，不能把
+   * "取消"伪装成"空结果"。
+   *
+   * @param label - 日志里标识来源的短名，同一来源只告警一次。
+   * @param fallback - 失败时返回的降级值。
+   * @param task - 真正的枚举任务。
+   * @returns 任务结果，或降级值。
+   */
+  async #degrade(label, fallback, task) {
+    try {
+      return await task();
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      if (!this.#warned.has(label)) {
+        this.#warned.add(label);
+        this.ctx.logger?.warn?.(
+          `file-references: ${label} \u53D6\u5019\u9009\u5931\u8D25\uFF0C\u672C\u6B21\u53EA\u8DF3\u8FC7\u8BE5\u6765\u6E90\uFF1A${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      return fallback;
+    }
+  }
   /** cwd 命名的那个根自己的候选：远端走索引，本地走有界走查。 */
   #namedCandidates(root, query, signal) {
     return root.location === "remote" && root.connectionId !== void 0 ? this.#remoteCandidates(root.connectionId, root.path, query, signal) : this.#localCandidates(root.path, query, signal);
@@ -359,6 +416,7 @@ var RemoteFileReferenceService = class extends FileReferenceService {
    * @returns the entries, from cache when the previous walk is still fresh.
    */
   async #walkCached(root, walk, signal) {
+    signal.throwIfAborted();
     const started = this.#now();
     const cached = this.#localCache.get(root);
     if (cached !== void 0) {
@@ -369,10 +427,33 @@ var RemoteFileReferenceService = class extends FileReferenceService {
       }
       this.#localCache.delete(root);
     }
-    const entries = await walk(root, signal);
-    signal.throwIfAborted();
-    this.#rememberLocal(root, entries, started);
-    return entries;
+    let shared = this.#inflight.get(root);
+    if (shared === void 0) {
+      const controller = new AbortController();
+      const entry = { controller, waiters: 0, promise: Promise.resolve([]) };
+      const promise = (async () => {
+        const entries = await walk(root, controller.signal);
+        controller.signal.throwIfAborted();
+        this.#rememberLocal(root, entries, started);
+        return entries;
+      })();
+      entry.promise = promise;
+      void promise.catch(() => void 0).finally(() => {
+        if (this.#inflight.get(root) === entry) this.#inflight.delete(root);
+      });
+      this.#inflight.set(root, entry);
+      shared = entry;
+    }
+    shared.waiters += 1;
+    try {
+      return await raceAbort(shared.promise, signal);
+    } finally {
+      shared.waiters -= 1;
+      if (shared.waiters === 0 && this.#inflight.get(root) === shared) {
+        this.#inflight.delete(root);
+        shared.controller.abort(new DOMException("no active @ completion callers", "AbortError"));
+      }
+    }
   }
   /** Store one local enumeration, evicting the least recently used root past the cap. */
   #rememberLocal(root, entries, at) {
@@ -388,6 +469,12 @@ var RemoteFileReferenceService = class extends FileReferenceService {
     const maxEntries = this.#options.maxEntries ?? LOCAL_MAX_ENTRIES;
     const maxDepth = this.#options.maxDepth ?? LOCAL_MAX_DEPTH;
     const found = [];
+    const visited = /* @__PURE__ */ new Set();
+    const rootReal = await realpath(root).catch(() => root);
+    const caseInsensitive = process.platform === "win32";
+    const withinRoot = (candidate) => localPathContains(rootReal, candidate, { caseInsensitive });
+    visited.add(rootReal);
+    const excluded = (name) => LOCAL_EXCLUDED_DIRECTORIES.includes(caseInsensitive ? name.toLowerCase() : name);
     let frontier = [{ path: root, depth: 0 }];
     while (frontier.length > 0 && found.length < maxEntries) {
       signal.throwIfAborted();
@@ -403,11 +490,27 @@ var RemoteFileReferenceService = class extends FileReferenceService {
         }
         for (const child of children) {
           if (found.length >= maxEntries) break;
-          const isDirectory = child.isDirectory();
-          if (isDirectory && LOCAL_EXCLUDED_DIRECTORIES.includes(child.name)) continue;
+          let isDirectory = child.isDirectory();
+          let traversable = child.isDirectory();
           const path = join(entry.path, child.name);
+          if (!isDirectory && child.isSymbolicLink()) {
+            try {
+              const target = await stat(path);
+              isDirectory = target.isDirectory();
+              if (isDirectory) {
+                const real = await realpath(path);
+                if (visited.has(real) || !withinRoot(real)) traversable = false;
+                else {
+                  visited.add(real);
+                  traversable = true;
+                }
+              }
+            } catch {
+            }
+          }
+          if (isDirectory && excluded(child.name)) continue;
           found.push({ path, kind: isDirectory ? "directory" : "file" });
-          if (isDirectory) next.push({ path, depth: entry.depth + 1 });
+          if (traversable) next.push({ path, depth: entry.depth + 1 });
         }
       }
       frontier = next;
@@ -415,6 +518,26 @@ var RemoteFileReferenceService = class extends FileReferenceService {
     return found;
   }
 };
+function raceAbort(promise, signal) {
+  if (signal.aborted) return Promise.reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError") || typeof error === "object" && error !== null && "name" in error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
 function sessionLocalRoot(cwd) {
   if (cwd === "" || !isAbsoluteLocalPath(cwd)) return void 0;
   return makeLocalRoot(cwd);

package/lib/fs.js

@@ -787,7 +787,8 @@ function wireGitStatus(ctx) {
       if (connections === void 0 || transports === void 0) return void 0;
       const profile = connections.get(connectionId);
       if (profile === void 0) return void 0;
-      const acquired = await transports.acquire(profile);
+      const lanes = ctx.get("sshDevTransportLanes");
+      const acquired = lanes === void 0 ? await transports.acquire(profile) : await lanes.acquire(profile, "compute");
       return acquired.transport;
     },
     resolveRoot: (connectionId, path) => {