dsh-over-ssh 0.1.1 → 0.2.1

package/lib/file-references.js

@@ -49,14 +49,26 @@ var DEFAULTS = {
 function rankMatches(paths, query, limit) {
   const needle = query.trim().toLowerCase();
   if (needle === "") {
-    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 top = [];
+    const better = (left, right) => {
+      const leftDepth = depth(paths[left]);
+      const rightDepth = depth(paths[right]);
+      if (leftDepth !== rightDepth) return leftDepth < rightDepth;
+      return paths[left] < paths[right];
+    };
+    for (let index = 0; index < paths.length; index += 1) {
+      if (top.length >= limit && !better(index, top[top.length - 1])) continue;
+      let low = 0;
+      let high = top.length;
+      while (low < high) {
+        const middle = low + high >> 1;
+        if (better(index, top[middle])) high = middle;
+        else low = middle + 1;
+      }
+      top.splice(low, 0, index);
+      if (top.length > limit) top.pop();
+    }
+    return top.map((index) => paths[index]);
   }
   const scored = [];
   for (const path of paths) {

package/lib/fs.js

@@ -381,6 +381,9 @@ function normalizePosixPath(path) {
 
 // src/host/domain/path-grammar.ts
 function normalizeRemotePath(path) {
+  if (/[\u0000-\u001f]/.test(path)) {
+    throw new SshDevError("ROOT_INVALID", "\u8FDC\u7A0B\u8DEF\u5F84\u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26", { path: JSON.stringify(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", {});
@@ -542,8 +545,21 @@ function relativeDirectory(root, path) {
 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/app/roots/user-roots.ts
+var USER_ROOTS_FILE_NAME = "user-roots.json";
+var USER_ROOTS_LOCK_FILE_NAME = `${USER_ROOTS_FILE_NAME}.lock`;
 
 // src/shared/routes.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;
@@ -636,7 +652,7 @@ function messageOf(error) {
 }
 
 // src/host/infra/transport/git-status-route.ts
-var GIT_STATUS_API_PATH = "/api/over-ssh/git-status";
+var GIT_STATUS_API_PATH2 = GIT_STATUS_API_PATH;
 function toPublicAnswer(snapshot) {
   return {
     ok: true,
@@ -705,7 +721,7 @@ function registerGitStatusRoute(provider, deps) {
       const host = asRouteHost(scoped.get("webServer"));
       if (host === void 0) return void 0;
       try {
-        const dispose = host.register({ kind: "exact", path: GIT_STATUS_API_PATH, handler: api.handle });
+        const dispose = host.register({ kind: "exact", path: GIT_STATUS_API_PATH2, handler: api.handle });
         return () => dispose();
       } catch {
         return void 0;
@@ -823,6 +839,92 @@ function walkAncestors(ctx, sessionId) {
   }
   return { ancestors, settled };
 }
+function readSessionCwd(ctx, sessionId) {
+  const cached = sessionCwdCache.get(sessionId);
+  if (cached !== void 0) {
+    sessionCwdCache.delete(sessionId);
+    sessionCwdCache.set(sessionId, cached);
+    return cached.value === "" ? void 0 : cached.value;
+  }
+  const found = walkSessionCwd(ctx, sessionId);
+  if (found.settled) {
+    sessionCwdCache.set(sessionId, { value: found.cwd ?? "" });
+    while (sessionCwdCache.size > SESSION_CWD_CACHE_MAX) {
+      const oldest = sessionCwdCache.keys().next();
+      if (oldest.done === true) break;
+      sessionCwdCache.delete(oldest.value);
+    }
+  }
+  return found.cwd;
+}
+function readSessionCwds(ctx) {
+  let list;
+  try {
+    const sessions = ctx.get("sessions");
+    list = sessions?.list?.();
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(list)) return [];
+  const cwds = [];
+  for (const session of list) {
+    const cwd = session?.header?.cwd;
+    if (typeof cwd === "string" && cwd !== "") cwds.push(cwd);
+  }
+  return cwds;
+}
+var sessionCwdCache = /* @__PURE__ */ new Map();
+var SESSION_CWD_CACHE_MAX = 256;
+function walkSessionCwd(ctx, sessionId) {
+  let list;
+  try {
+    const sessions = ctx.get("sessions");
+    list = sessions?.list?.();
+  } catch {
+    return { cwd: void 0, settled: false };
+  }
+  if (!Array.isArray(list)) return { cwd: void 0, settled: false };
+  for (const session of list) {
+    if (session?.header?.id !== sessionId) continue;
+    const cwd = session.header.cwd;
+    return { cwd: typeof cwd === "string" && cwd !== "" ? cwd : void 0, settled: true };
+  }
+  return { cwd: void 0, settled: false };
+}
+
+// src/host/domain/roots/session-roots.ts
+function workspaceWriteArea(root, workspaceRoot, cwd, identity = {}) {
+  const sessions = root.sessions ?? [];
+  if (sessions.length > 0 && identity.sessionId !== void 0 && identity.sessionId !== "") {
+    if (addedBySession(sessions, identity)) return "whole-root";
+  } else if (sessions.length === 0 && cwd !== void 0 && cwd !== "") {
+    if ((root.workspaces ?? []).some((candidate) => sameWorkspacePath(candidate, cwd))) return "whole-root";
+  }
+  if (workspaceRoot === void 0 || workspaceRoot === "") return "deny";
+  if (root.location === "remote") {
+    const anchor = root.anchorPath;
+    if (anchor === void 0 || anchor === "") return "deny";
+    if (sameWorkspacePath(anchor, workspaceRoot) || localPathContains(anchor, workspaceRoot)) return "whole-root";
+    if (localPathContains(workspaceRoot, anchor)) return "whole-root";
+    return "deny";
+  }
+  if (localPathContains(root.path, workspaceRoot)) return "workspace-only";
+  if (cwd !== void 0 && cwd !== "" && sameWorkspacePath(root.path, cwd)) return "workspace-only";
+  return "deny";
+}
+function addedBySession(sessions, identity) {
+  const sessionId = identity.sessionId;
+  if (sessionId === void 0 || sessionId === "") return false;
+  if (sessions.includes(sessionId)) return true;
+  return (identity.ancestors ?? []).some((ancestor) => sessions.includes(ancestor));
+}
+function sameWorkspacePath(left, right) {
+  const fold = (value) => {
+    const normalized = normalizeLocalPath2(value, { caseInsensitive: false }).replace(/\/+/g, "/");
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  };
+  return fold(left) === fold(right);
+}
 
 // src/host/integration/fs/fs-provider.ts
 var MAX_WHOLE_READ_BYTES = 16 * 1024 * 1024;
@@ -1051,7 +1153,7 @@ var RoutedFsProvider = class extends FileSystem {
     }
     const guard = expected?.kind === "replaceIfVersion" ? expected.version : void 0;
     const outcome = await this.call(
-      () => routed.backend.writeText(routed.absolute, content, guard, signal)
+      () => routed.backend.writeText(routed.absolute, content, guard, signal, sandboxPolicy)
     ).catch((error) => {
       throw mapWriteError(error, routed.displayPath);
     });
@@ -1096,7 +1198,8 @@ var RoutedFsProvider = class extends FileSystem {
             edit.newString,
             edit.replaceAll === true,
             chunk.version,
-            signal
+            signal,
+            sandboxPolicy
           )
         );
         return { version: FsVersion(native.version), before, after };
@@ -1107,7 +1210,7 @@ var RoutedFsProvider = class extends FileSystem {
       }
     }
     const outcome = await this.call(
-      () => routed.backend.writeText(routed.absolute, restoreLineEndings(after, lineEndings), chunk.version, signal)
+      () => routed.backend.writeText(routed.absolute, restoreLineEndings(after, lineEndings), chunk.version, signal, sandboxPolicy)
     ).catch((error) => {
       throw mapWriteError(error, routed.displayPath);
     });
@@ -1236,7 +1339,24 @@ var RoutedFsProvider = class extends FileSystem {
       throw isSshDevError(error) ? toFsError(error) : error;
     }
   }
-  /** Enforce the per-call policy and the root's own writability. */
+  /**
+   * Enforce the per-call policy and the root's own writability.
+   *
+   * Three gates, in order:
+   *  1. `read-only` denies every mutation (the platform's own contract);
+   *  2. a root registered `writable: false` denies;
+   *  3. under **`workspace-write`**, the target must be inside the session's workspace — where "workspace"
+   *     includes the directories **this session added** (product decision 2026-11-04: 「添加到会话的目录」=
+   *     该目录临时成为 workspace 的一部分). Before that decision the plugin admitted every writable root it
+   *     could route, which made the mode wider than the platform's own `fs-sandbox` fence
+   *     (`workspace-write` = "canonicalizes under `workspaceRoot` or the platform temp area").
+   *
+   * A call without a per-call policy keeps the historical behaviour (the mode comes from
+   * {@link sandboxMode}); the area rule needs `workspaceRoot`, which only the policy carries.
+   *
+   * @param routed - the resolved target.
+   * @param policy - the per-call sandbox policy the tool layer resolved.
+   */
   assertWritable(routed, policy) {
     const mode = policy?.mode ?? this.sandboxMode;
     if (mode === "read-only") {
@@ -1245,6 +1365,19 @@ var RoutedFsProvider = class extends FileSystem {
     if (routed.root.writable === false) {
       throw platformFsError(`the root of "${routed.displayPath}" is registered read-only`, "FS_SANDBOX_DENIED");
     }
+    if (mode !== "workspace-write" || policy === void 0) return;
+    const sessionId = currentSessionId();
+    const identity = sessionId === void 0 || sessionId === "" ? {} : { sessionId, ancestors: this.sessionAncestors(sessionId) };
+    const cwd = sessionId === void 0 || sessionId === "" ? void 0 : this.sessionWorkspaceCwdOf(sessionId);
+    const area = workspaceWriteArea(routed.root, policy.workspaceRoot, cwd, identity);
+    if (area === "whole-root") return;
+    if (area === "workspace-only" && routed.root.location === "local" && localPathContains(policy.workspaceRoot, routed.absolute, { caseInsensitive: process.platform === "win32" })) {
+      return;
+    }
+    throw platformFsError(
+      `sandbox denies writing "${routed.displayPath}": the path is outside this session's workspace (its workspace, or a directory this session added with \u300C\u6DFB\u52A0\u76EE\u5F55\u300D)`,
+      "FS_SANDBOX_DENIED"
+    );
   }
   /**
    * Previous text content, when it is readable text inside the cap; `undefined` otherwise.
@@ -1260,9 +1393,8 @@ var RoutedFsProvider = class extends FileSystem {
       return void 0;
     });
     if (chunk === void 0 || chunk.truncated) return void 0;
-    const bytes = Buffer.from(chunk.text, "utf8");
-    const sniff = bytes.subarray(0, BINARY_SNIFF_BYTES);
-    if (sniff.includes(0)) return void 0;
+    const nul = chunk.text.indexOf("\0");
+    if (nul !== -1 && nul < BINARY_SNIFF_BYTES) return void 0;
     return chunk.text;
   }
   /** Run a backend call, translating domain errors into core codes. */
@@ -1352,38 +1484,6 @@ function sessionSyncSignature(cwds, registry) {
   const roots = registry.sessionWorkspaceRecords.map((record) => record.key).join("\0");
   return `${cwds.join("\0")}
${roots}`;
 }
-function readSessionCwd(ctx, sessionId) {
-  let list;
-  try {
-    const sessions = ctx.get("sessions");
-    list = sessions?.list?.();
-  } catch {
-    return void 0;
-  }
-  if (!Array.isArray(list)) return void 0;
-  for (const session of list) {
-    if (session?.header?.id !== sessionId) continue;
-    const cwd = session.header.cwd;
-    return typeof cwd === "string" && cwd !== "" ? cwd : void 0;
-  }
-  return void 0;
-}
-function readSessionCwds(ctx) {
-  let list;
-  try {
-    const sessions = ctx.get("sessions");
-    list = sessions?.list?.();
-  } catch {
-    return [];
-  }
-  if (!Array.isArray(list)) return [];
-  const cwds = [];
-  for (const session of list) {
-    const cwd = session?.header?.cwd;
-    if (typeof cwd === "string" && cwd !== "") cwds.push(cwd);
-  }
-  return cwds;
-}
 function assertText(displayPath, bytes) {
   if (bytes.subarray(0, BINARY_SNIFF_BYTES).includes(0)) {
     throw platformFsError(`cannot read "${displayPath}": not a UTF-8 text file`, "FS_NOT_TEXT");