dsh-remote 0.8.47 → 0.8.48

package/lib/ignore.js

@@ -139,6 +139,52 @@ export const DEFAULT_SEARCH_IGNORE = [
   'Library/Caches/',
 ]
 
+/**
+ * Whether a normalized remote path is a FILESYSTEM ROOT: POSIX `/`, a Windows
+ * drive root (`D:\`), or a UNC share root (`\\server\share`).
+ *
+ * Root workspaces are legal (issue #60) but dangerous to walk naively: `/proc`
+ * and `/sys` are synthetic (new pids appear between readdirs, `/proc/kcore`
+ * advertises 128 TB), `/dev` holds never-ending character devices, and
+ * `/var/lib/docker` is tens of GB of image layers. ROOT_IGNORE exists so a
+ * root workspace skips exactly those trees.
+ */
+export function isFilesystemRoot(p) {
+  const s = String(p || '')
+  return s === '/' || /^[a-zA-Z]:\\?$/.test(s) || /^\\\\[^\\]+\\[^\\]+$/.test(s)
+}
+
+/**
+ * Patterns merged in ONLY when the workspace is the filesystem root
+ * (issue #60). Every entry is root-anchored AND directory-only, so even when
+ * merged they can only match at the workspace top level: `/` skips `/proc`,
+ * while a hypothetical `/home/u/proc` under a non-root workspace is ordinary
+ * content (and non-root workspaces never receive these patterns at all, so
+ * their behaviour is byte-identical to before).
+ */
+export const ROOT_IGNORE = [
+  '/proc/',
+  '/sys/',
+  '/dev/',
+  '/run/',
+  '/boot/',
+  '/var/lib/docker/',
+]
+
+/**
+ * Effective ignore patterns for a workspace rooted at `root`:
+ * the defaults, plus ROOT_IGNORE only for a root workspace, plus the user's
+ * own `.dsh-remote-ignore` lines (always last, they stack on top).
+ *
+ * @param {string} root - workspace root as passed to sync/push/search.
+ * @param {{search?: boolean, fromFile?: string[]}} [opts]
+ */
+export function ignorePatternsFor(root, { search = false, fromFile = [] } = {}) {
+  const base = search ? DEFAULT_SEARCH_IGNORE : DEFAULT_IGNORE
+  const extra = isFilesystemRoot(root) ? ROOT_IGNORE : []
+  return base.concat(extra, fromFile)
+}
+
 /**
  * Load the user ignore file (gitignore syntax) and merge with defaults.
  * Returns `{ patterns, fromFile }`.

package/lib/index.js

@@ -31,7 +31,7 @@ import {
   toShellPath, toDisplayPath, remotePathBase, truncate, shortHash,
 } from './paths.js'
 import { createHostKeyGuard, isHostKeyKnown as _isHostKeyKnown } from './hostkey.js'
-import { compileIgnore, DEFAULT_IGNORE, DEFAULT_SEARCH_IGNORE } from './ignore.js'
+import { compileIgnore, ignorePatternsFor, DEFAULT_IGNORE } from './ignore.js'
 import { friendlyMessage } from './errors.js'
 import { importableEntries, sshConfigPath, readSshConfigText, resolveMachineSshConfig } from './sshconfig.js'
 import { createRemoteFileReference, installFileReferenceOverlay, DEFAULT_EXCLUDED_DIRECTORIES } from './file-reference.js'
@@ -927,26 +927,21 @@ export async function apply(ctx, config) {
   // NOTE: this matcher is shared by mirror sync (rw_sync/rw_push) and search.
   // Do NOT add search-only cache excludes here: widening it would silently stop
   // syncing directories a user may rely on. Search uses searchIgnoreMatcher().
-  const ignoreMatcher = () => {
+  const readUserIgnore = () => {
     try {
-      const fromFile = readFileSync(ignoreFile(), 'utf8').split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#'))
-      return compileIgnore(DEFAULT_IGNORE.concat(fromFile))
+      return readFileSync(ignoreFile(), 'utf8').split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#'))
     } catch {
-      return compileIgnore(DEFAULT_IGNORE)
+      return []
     }
   }
+  /** Mirror-sync matcher for the workspace rooted at `root` (ROOT_IGNORE is
+   *  merged only for a filesystem-root workspace — issue #60). */
+  const ignoreMatcher = (root) => compileIgnore(ignorePatternsFor(root, { fromFile: readUserIgnore() }))
   /** Search-only matcher: same as ignoreMatcher() plus machine-local cache trees
    *  (`~/.npm`, `~/.cache`, …) that are huge, almost never what a human is
    *  looking for, and the main cause of the issue #44 hang. Mirror sync is
    *  deliberately unaffected. An explicit `path` still searches anywhere. */
-  const searchIgnoreMatcher = () => {
-    try {
-      const fromFile = readFileSync(ignoreFile(), 'utf8').split('\n').map((l) => l.trim()).filter((l) => l && !l.startsWith('#'))
-      return compileIgnore(DEFAULT_SEARCH_IGNORE.concat(fromFile))
-    } catch {
-      return compileIgnore(DEFAULT_SEARCH_IGNORE)
-    }
-  }
+  const searchIgnoreMatcher = (root) => compileIgnore(ignorePatternsFor(root, { search: true, fromFile: readUserIgnore() }))
 
   // ── task + forward managers ───────────────────────────────────────────────
   const tasks = new TaskManager()
@@ -991,7 +986,7 @@ export async function apply(ctx, config) {
     const target = poolForMachine(machine)
     let sftp
     try { sftp = await target.sftp() } catch { return }
-    const matcher = ignoreMatcher()
+    const matcher = ignoreMatcher(ws)
     const state = loadSyncState(localDir)
     const next = { ...state }
     if (rels.includes('*')) {
@@ -1711,8 +1706,15 @@ export async function apply(ctx, config) {
       },
       output: textOut,
       async execute(args, exec) {
-        const p = normalizeRemotePath(String(args.path || ''))
-        if (!p || p === '/') throw new Error('rw_pick_workspace: path must be an absolute directory')
+        // Blank input is the only upfront rejection: normalizeRemotePath('')
+        // returns '/', so the old `!p || p === '/'` guard actually meant "no
+        // root" — but a filesystem root is a legal workspace (issue #60), and
+        // its synthetic-tree risk is handled by ROOT_IGNORE in sync/search.
+        // Any non-blank path, root included, is answered by the real directory
+        // probe below (a missing path still fails there).
+        const rawPath = String(args.path || '').trim()
+        if (!rawPath) throw new Error('rw_pick_workspace: path must be an absolute directory')
+        const p = normalizeRemotePath(rawPath)
         // Picking a workspace targets the machine this session is already bound
         // to when it has one. A LOCAL session deliberately falls back to the
         // active machine here: this is the setup flow that runs right after
@@ -1755,7 +1757,7 @@ export async function apply(ctx, config) {
         mkdirSync(local, { recursive: true })
         const depth = Math.min(Math.max(Number(args.depth) || 8, 1), 16)
         const maxFiles = Math.min(Math.max(Number(args.maxFiles) || 2000, 1), 20000)
-        const isIgnored = ignoreMatcher()
+        const isIgnored = ignoreMatcher(p)
         const body = { depth, maxFiles, dryRun: !!args.dryRun, force: !!args.force, isIgnored }
         const runSync = async () => {
           let sftp
@@ -1805,7 +1807,7 @@ export async function apply(ctx, config) {
         const local = b.mirrorDir || mirrorDirFor(p, b.host, b.username, b.port)
         if (!existsSync(local)) throw new Error(`rw_push: local mirror does not exist — run rw_sync first (${local})`)
         const maxFiles = Math.min(Math.max(Number(args.maxFiles) || 2000, 1), 20000)
-        const isIgnored = ignoreMatcher()
+        const isIgnored = ignoreMatcher(p)
         const body = { maxFiles, dryRun: !!args.dryRun, force: !!args.force, isIgnored }
         const runPush = async () => {
           let sftp
@@ -2227,7 +2229,7 @@ export async function apply(ctx, config) {
         // `running` and cancel/steer did nothing (issue #44).
         const maxFiles = Math.min(Math.max(Number(args.maxEntries) || config.searchMaxEntries, 1), 500000)
         const maxDurationMs = Math.min(Math.max(Number(args.maxDurationMs) || config.searchTimeoutMs, 1000), 600000)
-        const matcher = searchIgnoreMatcher()
+        const matcher = searchIgnoreMatcher(dir)
         const { matches, scanned, truncated, cancelled } = await searchRemote(b.pool, dir, {
           pattern,
           regex,
@@ -2832,8 +2834,11 @@ export async function apply(ctx, config) {
         if (req.method !== 'POST') return sendJson(res, 405, { error: 'method not allowed' })
         try {
           const payload = JSON.parse((await readBody(req)) || '{}')
-          const p = normalizeRemotePath(String(payload.path || ''))
-          if (!p || p === '/') return sendJson(res, 400, { error: 'path must be an absolute directory' })
+          // Blank-only guard: a filesystem root is a legal workspace (issue
+          // #60); the real directory probe below answers everything else.
+          const rawPath = String(payload.path || '').trim()
+          if (!rawPath) return sendJson(res, 400, { error: 'path must be an absolute directory' })
+          const p = normalizeRemotePath(rawPath)
           const okDir = await isRemoteDir(p)
           if (!okDir) return sendJson(res, 400, { ok: false, error: `not a directory: ${p}` })
           persistWorkspace(p)
@@ -2852,8 +2857,11 @@ export async function apply(ctx, config) {
         if (req.method !== 'POST') return sendJson(res, 405, { error: 'method not allowed' })
         try {
           const payload = JSON.parse((await readBody(req)) || '{}')
-          const p = normalizeRemotePath(String(payload.path || ''))
-          if (!p || p === '/') return sendJson(res, 400, { ok: false, error: 'path must be an absolute directory' })
+          // Blank-only guard: a filesystem root is a legal workspace (issue
+          // #60); the real directory probe below answers everything else.
+          const rawPath = String(payload.path || '').trim()
+          if (!rawPath) return sendJson(res, 400, { ok: false, error: 'path must be an absolute directory' })
+          const p = normalizeRemotePath(rawPath)
           if (!config.host) return sendJson(res, 400, { ok: false, error: 'no remote host configured/connected — connect first' })
           // The picker names the machine it was browsing. Re-assert it so a
           // switch made elsewhere between the listing and this commit cannot

package/lib/search.js

@@ -2,7 +2,7 @@
 // Replaces `find … -exec grep` (which needs a POSIX shell and dies on
 // Windows remotes). Walks the remote tree over SFTP readdir/stat/readFile with
 // the same bounded-parallelism + ignore rules as the mirror sync.
-import { joinRemotePath, shq } from './paths.js'
+import { joinRemotePath, relPathUnder, shq } from './paths.js'
 
 function mapLimit(items, limit, fn) {
   const limitN = Math.max(1, Math.min(Math.floor(limit) || 1, items.length))
@@ -105,7 +105,12 @@ export async function searchTree(sftp, rootDir, opts = {}) {
       if (shouldStop() || scanned >= maxFiles) return
       if (depth <= 0) continue
       const sub = joinRemotePath(dir, name)
-      if (isIgnored(name, true)) continue
+      // isIgnored receives the path RELATIVE to the search root (the same
+      // contract sync has), so root-anchored ignore rules — `/proc/` when the
+      // workspace is the filesystem root (issue #60), `Library/Caches/` in the
+      // default search set — actually match here; a bare basename would never
+      // satisfy an anchored pattern and those rules were silently dead.
+      if (isIgnored(relPathUnder(rootDir, sub) || name, true)) continue
       await walk(sub, depth - 1)
     }
     if (shouldStop() || scanned >= maxFiles) return
@@ -118,8 +123,8 @@ export async function searchTree(sftp, rootDir, opts = {}) {
       // Checked per entry: this is the loop that used to run for hours.
       if (shouldStop() || scanned >= maxFiles || matches.length >= maxMatches) return
       if (glob && !matchGlob(name, glob)) return
-      if (isIgnored(name, false)) return
       const fp = joinRemotePath(dir, name)
+      if (isIgnored(relPathUnder(rootDir, fp) || name, false)) return
       scanned++
       let st
       try { st = await sftp.stat(fp) } catch { return }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.47",
+  "version": "0.8.48",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 22 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, one-click remote dsh deploy + web UI attach, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",
@@ -93,3 +93,4 @@
     "test": "node --import ./test/setup-telemetry-off.mjs --test --test-timeout=20000 --test-force-exit"
   }
 }
+