dsh-over-ssh 0.1.0 → 0.1.1

package/lib/file-references.js

@@ -49,7 +49,14 @@ var DEFAULTS = {
 function rankMatches(paths, query, limit) {
   const needle = query.trim().toLowerCase();
   if (needle === "") {
-    return paths.map((path) => ({ path, depth: depth(path) })).sort((left, right) => left.depth - right.depth || (left.path < right.path ? -1 : 1)).slice(0, limit).map((entry) => entry.path);
+    const order = [];
+    for (let index = 0; index < paths.length; index += 1) order.push(index);
+    const depths = new Int32Array(paths.length);
+    for (let index = 0; index < paths.length; index += 1) depths[index] = depth(paths[index]);
+    order.sort(
+      (left, right) => depths[left] - depths[right] || (paths[left] < paths[right] ? -1 : 1)
+    );
+    return order.slice(0, limit).map((index) => paths[index]);
   }
   const scored = [];
   for (const path of paths) {
@@ -69,30 +76,27 @@ function rankMatches(paths, query, limit) {
   return scored.slice(0, limit).map((entry) => entry.path);
 }
 function depth(path) {
-  return path.split("/").filter((segment) => segment !== "").length;
-}
-
-// src/host/domain/roots/root.ts
-function makeLocalRoot(path, options = {}) {
-  const normalized = normalizeLocalPath(path, { caseInsensitive: false });
-  if (!isAbsoluteLocalPath(normalized)) {
-    throw new SshDevError("ROOT_INVALID", `\u672C\u5730\u6839\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${path}`, { path });
+  let segments = 0;
+  let inSegment = false;
+  for (let index = 0; index < path.length; index += 1) {
+    if (path.charCodeAt(index) === 47) {
+      inSegment = false;
+      continue;
+    }
+    if (!inSegment) {
+      segments += 1;
+      inSegment = true;
+    }
   }
-  return {
-    location: "local",
-    path: normalized,
-    writable: options.writable ?? true,
-    ...options.label === void 0 ? {} : { label: options.label },
-    ...options.workspaces === void 0 ? {} : { workspaces: options.workspaces },
-    ...options.sessions === void 0 ? {} : { sessions: options.sessions },
-    ...options.shared === void 0 ? {} : { shared: options.shared }
-  };
+  return segments;
 }
+
+// src/shared/root-keys.ts
 function isAbsoluteLocalPath(path) {
-  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("//") || path.startsWith("/");
+  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("/") || path.startsWith("\\\\");
 }
 function normalizeLocalPath(path, options = {}) {
-  const caseInsensitive = options.caseInsensitive ?? process.platform === "win32";
+  const caseInsensitive = options.caseInsensitive ?? false;
   const unified = path.replace(/\\/g, "/");
   const unc = unified.startsWith("//");
   const posixAbsolute = unified.startsWith("/");
@@ -118,15 +122,46 @@ function normalizeLocalPath(path, options = {}) {
   return caseInsensitive ? normalized.toLowerCase() : normalized;
 }
 
+// src/host/domain/roots/root.ts
+function makeLocalRoot(path, options = {}) {
+  const normalized = normalizeLocalPath2(path, { caseInsensitive: false });
+  if (!isAbsoluteLocalPath(normalized)) {
+    throw new SshDevError("ROOT_INVALID", `\u672C\u5730\u6839\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${path}`, { path });
+  }
+  return {
+    location: "local",
+    path: normalized,
+    writable: options.writable ?? true,
+    ...options.label === void 0 ? {} : { label: options.label },
+    ...options.workspaces === void 0 ? {} : { workspaces: options.workspaces },
+    ...options.sessions === void 0 ? {} : { sessions: options.sessions },
+    ...options.shared === void 0 ? {} : { shared: options.shared }
+  };
+}
+function normalizeLocalPath2(path, options = {}) {
+  return normalizeLocalPath(path, { caseInsensitive: options.caseInsensitive ?? process.platform === "win32" });
+}
+
 // src/host/integration/session-scope.ts
 var MAX_FORK_DEPTH = 32;
 var ancestorCache = /* @__PURE__ */ new Map();
 var ANCESTOR_CACHE_MAX = 256;
 function readSessionAncestors(ctx, sessionId) {
   const cached = ancestorCache.get(sessionId);
-  if (cached !== void 0) return cached;
+  if (cached !== void 0) {
+    ancestorCache.delete(sessionId);
+    ancestorCache.set(sessionId, cached);
+    return cached;
+  }
   const walked = walkAncestors(ctx, sessionId);
-  if (walked.settled && ancestorCache.size < ANCESTOR_CACHE_MAX) ancestorCache.set(sessionId, walked.ancestors);
+  if (walked.settled) {
+    ancestorCache.set(sessionId, walked.ancestors);
+    while (ancestorCache.size > ANCESTOR_CACHE_MAX) {
+      const oldest = ancestorCache.keys().next();
+      if (oldest.done === true) break;
+      ancestorCache.delete(oldest.value);
+    }
+  }
   return walked.ancestors;
 }
 function walkAncestors(ctx, sessionId) {
@@ -220,16 +255,18 @@ var RemoteFileReferenceService = class extends FileReferenceService {
     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 added = await this.#addedRemoteCandidates(cwd, identity, query, signal);
-    if (gated.ok) {
-      const root = gated.target.root;
-      const named = root.location === "remote" && root.connectionId !== void 0 ? await this.#remoteCandidates(root.connectionId, root.path, query, signal) : await this.#localCandidates(root.path, query, signal);
-      return this.#merge(added, named);
-    }
-    if (registry.routed.tryResolve(cwd).ok) return added ?? [];
-    const implicit = sessionLocalRoot(cwd);
-    const local = implicit === void 0 ? [] : await this.#localCandidates(implicit.path, query, signal);
-    return this.#merge(added, local);
+    const addedTask = 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 [added, named] = await Promise.all([addedTask, namedTask]);
+    if (gated.ok) return this.#merge(added, named ?? []);
+    if (ungated?.ok === true) return added ?? [];
+    return this.#merge(added, named ?? []);
+  }
+  /** 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);
   }
   /** Remote candidates for one root, or `[]` when the composition has no index. */
   async #remoteCandidates(connectionId, root, query, signal) {
@@ -241,12 +278,20 @@ var RemoteFileReferenceService = class extends FileReferenceService {
   async #localCandidates(rootPath, query, signal) {
     const walk = this.#options.walk ?? ((root, walkSignal) => this.#walkLocal(root, walkSignal));
     const entries = await this.#walkCached(rootPath, walk, signal);
-    const kinds = new Map(entries.map((entry) => [entry.path, entry.kind]));
-    return rankMatches(
+    const ranked = rankMatches(
       entries.map((entry) => entry.path),
       query,
       this.#options.maxResults ?? DEFAULT_MAX_RESULTS
-    ).map((path) => ({ path, kind: kinds.get(path) ?? "file" }));
+    );
+    if (ranked.length === 0) return [];
+    const wanted = new Set(ranked);
+    const kinds = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      if (!wanted.has(entry.path)) continue;
+      kinds.set(entry.path, entry.kind);
+      if (kinds.size === wanted.size) break;
+    }
+    return ranked.map((path) => ({ path, kind: kinds.get(path) ?? "file" }));
   }
   /**
    * Candidates from the remote directory this conversation added with 「添加目录」, when there is one.

package/lib/fs.js

@@ -128,6 +128,33 @@ var LruCache = class {
     this.#bytes -= entry.bytes;
     return true;
   }
+  /**
+   * Remove every entry whose key starts with `prefix`, in one pass over the internal map.
+   *
+   * 存在的理由：调用方（`VersionedCache.invalidatePrefix`）在**每次写**之后都要按前缀失效，而在此之前
+   * 它只有 `keys()` 可用——`keys()` 会把整张表**物化**成一个数组，随后又用 `delete(key)` 逐个做哈希
+   * 查找。这里直接在 `#entries` 上过一遍：不建中间数组，字节记账就地扣减，边迭代边删除（Map 迭代器
+   * 规范保证删除当前条目后仍会访问后续条目）。
+   *
+   * **为什么是"前缀"而不是更通用的"谓词"**：谓词要为每条 key 付一次 JS 回调，而一次 `keys()` 物化只是
+   * 一次指针批量拷贝。实测（20 000 条 × 2 000 次，只命中 1 条）旧写法 1 289 ms、前缀版 962 ms、
+   * 谓词版 953 ms——两者同量级；但在**生产上限**（读缓存 256 条 / 目录缓存 512 条）下谓词版反而比旧
+   * 写法慢（20 000 次：160 ms vs 148 ms），前缀版打平（147 ms）。也就是说：谓词版只在大表上不亏，
+   * 在小表上亏；前缀版两边都不亏。热路径上的方法按真实规模选形状。
+   *
+   * @param prefix - key prefix.
+   * @returns the number of removed entries.
+   */
+  deleteByPrefix(prefix) {
+    let removed = 0;
+    for (const [key, entry] of this.#entries) {
+      if (!key.startsWith(prefix)) continue;
+      this.#entries.delete(key);
+      this.#bytes -= entry.bytes;
+      removed++;
+    }
+    return removed;
+  }
   /** Remove everything. */
   clear() {
     this.#entries.clear();
@@ -148,16 +175,38 @@ var LruCache = class {
       rejectedOversize: this.#rejectedOversize
     };
   }
+  /**
+   * Drop the least-recently-used entry.
+   *
+   * Exposed so a shared {@link CacheBudget} can make this cache give bytes back; `#evictToBounds` is the
+   * same operation driven by this cache's own limits.
+   *
+   * @returns `false` when the cache is empty (the caller must not retry in a loop).
+   */
+  evictOldest() {
+    const oldest = this.#entries.keys().next();
+    if (oldest.done === true) return false;
+    const entry = this.#entries.get(oldest.value);
+    if (entry === void 0) return false;
+    this.#entries.delete(oldest.value);
+    this.#bytes -= entry.bytes;
+    this.#evictions++;
+    return true;
+  }
+  /**
+   * Come down to `maxBytes` by dropping the oldest entries.
+   *
+   * @param maxBytes - the ceiling to reach.
+   * @returns how many entries were dropped.
+   */
+  trimTo(maxBytes) {
+    let dropped = 0;
+    while (this.#bytes > maxBytes && this.evictOldest()) dropped++;
+    return dropped;
+  }
   #evictToBounds() {
     while (this.#entries.size > this.#maxEntries || this.#bytes > this.#maxBytes) {
-      const oldest = this.#entries.keys().next();
-      if (oldest.done === true) return;
-      const key = oldest.value;
-      const entry = this.#entries.get(key);
-      if (entry === void 0) return;
-      this.#entries.delete(key);
-      this.#bytes -= entry.bytes;
-      this.#evictions++;
+      if (!this.evictOldest()) return;
     }
   }
 };
@@ -167,6 +216,7 @@ var VersionedCache = class {
   #ttlMs;
   #now;
   #lru;
+  #budget;
   #hits = 0;
   #misses = 0;
   #freshHits = 0;
@@ -177,6 +227,29 @@ var VersionedCache = class {
     this.#ttlMs = options.ttlMs;
     this.#now = options.now ?? Date.now;
     this.#lru = new LruCache({ maxEntries: options.maxEntries, maxBytes: options.maxBytes }, (entry) => sizeOf(entry.value));
+    this.#budget = options.budget;
+    this.#budget?.join(this);
+  }
+  /** Bytes this cache holds (the budget member contract). */
+  get bytes() {
+    return this.#lru.stats.bytes;
+  }
+  /** Drop oldest entries down to `maxBytes` (the budget member contract). */
+  trimTo(maxBytes) {
+    return this.#lru.trimTo(maxBytes);
+  }
+  /** Drop the oldest entry (the budget member contract). */
+  evictOldest() {
+    return this.#lru.evictOldest();
+  }
+  /**
+   * Leave the shared budget, so a retired cache stops counting against the total.
+   *
+   * Called by whoever owns the cache when its root goes away. Without it a removed root's cache stayed in the
+   * accounting forever, which is the leak the budget exists to prevent.
+   */
+  leaveBudget() {
+    this.#budget?.leave(this);
   }
   /**
    * Look up an entry.
@@ -199,7 +272,9 @@ var VersionedCache = class {
   }
   /** Insert or replace an entry, stamping it as just-read. */
   set(key, value, version) {
-    return this.#lru.set(key, { value, version, storedAt: this.#now() });
+    const stored = this.#lru.set(key, { value, version, storedAt: this.#now() });
+    if (stored) this.#budget?.enforce(this);
+    return stored;
   }
   /**
    * Refresh an entry's timestamp after a cheap remote version check matched.
@@ -226,11 +301,7 @@ var VersionedCache = class {
    * @returns the number of removed entries.
    */
   invalidatePrefix(prefix) {
-    let removed = 0;
-    for (const key of this.#lru.keys()) {
-      if (key.startsWith(prefix) && this.#lru.delete(key)) removed++;
-    }
-    return removed;
+    return this.#lru.deleteByPrefix(prefix);
   }
   /** Remove everything. */
   clear() {
@@ -267,12 +338,35 @@ function isSshDevError(value) {
   return value instanceof SshDevError;
 }
 
-// src/host/domain/path-grammar.ts
-function normalizeRemotePath(path) {
-  if (path === "") throw new SshDevError("ROOT_INVALID", "\u8FDC\u7A0B\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A", {});
-  if (!path.startsWith("/")) {
-    throw new SshDevError("ROOT_INVALID", `\u8FDC\u7A0B\u8DEF\u5F84\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${path}`, { path });
+// src/shared/root-keys.ts
+function normalizeLocalPath(path, options = {}) {
+  const caseInsensitive = options.caseInsensitive ?? false;
+  const unified = path.replace(/\\/g, "/");
+  const unc = unified.startsWith("//");
+  const posixAbsolute = unified.startsWith("/");
+  const driveMatch = /^([A-Za-z]):/.exec(unified);
+  const driveLetter = driveMatch?.[1];
+  const drive = driveLetter === void 0 ? "" : `${driveLetter.toUpperCase()}:`;
+  const rest = unc ? unified.slice(2) : drive === "" ? unified : unified.slice(2);
+  const segments = [];
+  for (const segment of rest.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
   }
+  const body = segments.join("/");
+  let normalized;
+  if (unc) normalized = `//${body}`;
+  else if (drive !== "") normalized = body === "" ? `${drive}/` : `${drive}/${body}`;
+  else if (posixAbsolute) normalized = body === "" ? "/" : `/${body}`;
+  else normalized = body === "" ? "." : body;
+  return caseInsensitive ? normalized.toLowerCase() : normalized;
+}
+function normalizePosixPath(path) {
+  if (!path.startsWith("/")) return void 0;
   const segments = [];
   for (const segment of path.split("/")) {
     if (segment === "" || segment === ".") continue;
@@ -284,12 +378,28 @@ function normalizeRemotePath(path) {
   }
   return segments.length === 0 ? "/" : `/${segments.join("/")}`;
 }
+
+// src/host/domain/path-grammar.ts
+function normalizeRemotePath(path) {
+  const normalized = normalizePosixPath(path);
+  if (normalized !== void 0) return normalized;
+  if (path === "") throw new SshDevError("ROOT_INVALID", "\u8FDC\u7A0B\u8DEF\u5F84\u4E0D\u80FD\u4E3A\u7A7A", {});
+  throw new SshDevError("ROOT_INVALID", `\u8FDC\u7A0B\u8DEF\u5F84\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84\uFF1A${path}`, { path });
+}
 function remotePathContains(root, candidate) {
   const normalizedRoot = normalizeRemotePath(root);
   const normalizedCandidate = normalizeRemotePath(candidate);
   if (normalizedRoot === "/") return true;
   return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}/`);
 }
+function longestContainingRoot(roots, candidate) {
+  let best;
+  for (const root of roots) {
+    if (!remotePathContains(root, candidate)) continue;
+    if (best === void 0 || normalizeRemotePath(root).length > normalizeRemotePath(best).length) best = root;
+  }
+  return best;
+}
 
 // src/host/infra/transport/git-status.ts
 function isGitStatusTransport(value) {
@@ -429,31 +539,15 @@ function relativeDirectory(root, path) {
 }
 
 // src/host/domain/roots/root.ts
-function normalizeLocalPath(path, options = {}) {
-  const caseInsensitive = options.caseInsensitive ?? process.platform === "win32";
-  const unified = path.replace(/\\/g, "/");
-  const unc = unified.startsWith("//");
-  const posixAbsolute = unified.startsWith("/");
-  const driveMatch = /^([A-Za-z]):/.exec(unified);
-  const driveLetter = driveMatch?.[1];
-  const drive = driveLetter === void 0 ? "" : `${driveLetter.toUpperCase()}:`;
-  const rest = unc ? unified.slice(2) : drive === "" ? unified : unified.slice(2);
-  const segments = [];
-  for (const segment of rest.split("/")) {
-    if (segment === "" || segment === ".") continue;
-    if (segment === "..") {
-      segments.pop();
-      continue;
-    }
-    segments.push(segment);
-  }
-  const body = segments.join("/");
-  let normalized;
-  if (unc) normalized = `//${body}`;
-  else if (drive !== "") normalized = body === "" ? `${drive}/` : `${drive}/${body}`;
-  else if (posixAbsolute) normalized = body === "" ? "/" : `/${body}`;
-  else normalized = body === "" ? "." : body;
-  return caseInsensitive ? normalized.toLowerCase() : normalized;
+function normalizeLocalPath2(path, options = {}) {
+  return normalizeLocalPath(path, { caseInsensitive: options.caseInsensitive ?? process.platform === "win32" });
+}
+
+// src/shared/routes.ts
+function asRouteHost(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const register = value.register;
+  return typeof register === "function" ? value : void 0;
 }
 
 // src/host/app/roots/roots-api-contract.ts
@@ -507,14 +601,14 @@ function parseAuthority(authority) {
 }
 
 // src/host/app/roots/roots-api-http.ts
-async function readBody(req) {
+async function readBody(req, maxBytes) {
   const chunks = [];
   let total = 0;
   for await (const chunk of req) {
     const buffer = toBytes(chunk);
     total += buffer.length;
-    if (total > ROOTS_API_MAX_BODY_BYTES) {
-      throw new Error(`\u8BF7\u6C42\u4F53\u8D85\u8FC7\u4E0A\u9650 ${ROOTS_API_MAX_BODY_BYTES} \u5B57\u8282\uFF0C\u62D2\u7EDD`);
+    if (total > maxBytes) {
+      throw new SshDevError("ROOT_INVALID", `\u8BF7\u6C42\u4F53\u8D85\u8FC7\u4E0A\u9650 ${maxBytes} \u5B57\u8282\uFF0C\u62D2\u7EDD`);
     }
     chunks.push(buffer);
   }
@@ -543,11 +637,6 @@ function messageOf(error) {
 
 // src/host/infra/transport/git-status-route.ts
 var GIT_STATUS_API_PATH = "/api/over-ssh/git-status";
-function asRouteHost(value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  const register = value.register;
-  return typeof register === "function" ? value : void 0;
-}
 function toPublicAnswer(snapshot) {
   return {
     ok: true,
@@ -579,7 +668,7 @@ function createGitStatusApi(deps) {
       return;
     }
     try {
-      const body = asRecord(JSON.parse(await readBody(req)));
+      const body = asRecord(JSON.parse(await readBody(req, ROOTS_API_MAX_BODY_BYTES)));
       const connectionId = body?.["connectionId"];
       const path = body?.["path"];
       if (typeof connectionId !== "string" || connectionId === "") {
@@ -641,15 +730,8 @@ function wireGitStatus(ctx) {
     resolveRoot: (connectionId, path) => {
       const registry = ctx.get("sshDevRoots");
       if (registry === void 0) return void 0;
-      const normalized = normalizeRemotePath(path);
-      let best;
-      for (const record of registry.records) {
-        const root = record.root;
-        if (root.location !== "remote" || root.connectionId !== connectionId) continue;
-        if (!remotePathContains(root.path, normalized)) continue;
-        if (best === void 0 || root.path.length > best.length) best = root.path;
-      }
-      return best;
+      const roots = registry.records.map((record) => record.root).filter((root) => root.location === "remote" && root.connectionId === connectionId).map((root) => root.path);
+      return longestContainingRoot(roots, normalizeRemotePath(path));
     }
   });
   registerGitStatusRoute(ctx, { service });
@@ -699,9 +781,20 @@ var ancestorCache = /* @__PURE__ */ new Map();
 var ANCESTOR_CACHE_MAX = 256;
 function readSessionAncestors(ctx, sessionId) {
   const cached = ancestorCache.get(sessionId);
-  if (cached !== void 0) return cached;
+  if (cached !== void 0) {
+    ancestorCache.delete(sessionId);
+    ancestorCache.set(sessionId, cached);
+    return cached;
+  }
   const walked = walkAncestors(ctx, sessionId);
-  if (walked.settled && ancestorCache.size < ANCESTOR_CACHE_MAX) ancestorCache.set(sessionId, walked.ancestors);
+  if (walked.settled) {
+    ancestorCache.set(sessionId, walked.ancestors);
+    while (ancestorCache.size > ANCESTOR_CACHE_MAX) {
+      const oldest = ancestorCache.keys().next();
+      if (oldest.done === true) break;
+      ancestorCache.delete(oldest.value);
+    }
+  }
   return walked.ancestors;
 }
 function walkAncestors(ctx, sessionId) {
@@ -798,7 +891,7 @@ var RoutedFsProvider = class extends FileSystem {
    */
   processPathFromHostPath(hostPath) {
     if (!isAbsoluteHostPath(hostPath)) return void 0;
-    return normalizeLocalPath(hostPath, { caseInsensitive: false });
+    return normalizeLocalPath2(hostPath, { caseInsensitive: false });
   }
   /** Canonical `file:` URI in the target's world. */
   fileUrl(target) {
@@ -932,16 +1025,6 @@ var RoutedFsProvider = class extends FileSystem {
     const chunk = await this.call(() => routed.backend.readBytes(routed.absolute, end, signal));
     return chunk.bytes.subarray(start, Math.min(end, chunk.bytes.byteLength));
   }
-  /**
-   * Read a window through the injected offset reader.
-   *
-   * Kept as a thin method so the instance is the receiver here (a direct call is fine); the work happens in
-   * the free {@link readChunkedWindow}, because the public read path invokes it from inside `this.call(...)`,
-   * where `this` is the Cordis service Proxy and instance state would not be reachable.
-   */
-  #readChunkedWindow(routed, offset, length, signal) {
-    return readChunkedWindow(this.rangeReader, this.rangeChunkBytes, routed, offset, length, signal);
-  }
   /** Direct children, in stable name order, with resolved child targets. */
   async listDir(target, signal) {
     const routed = this.routedTarget(target);