dsh-remote 0.8.47 → 0.8.49

package/lib/client.js

@@ -2382,8 +2382,9 @@ window.__ModuleLoader__.load({
     }
 
     // ── better-sidebar integration (optional) ────────────────────────────────
+    // One descriptor only: the explorer page. The per-file viewer is a native
+    // resource type, never a better-sidebar card (see registerSidebarIntegration).
     const SIDEBAR_EXPLORER_ID = 'dsh-remote:explorer'
-    const SIDEBAR_FILE_ID = 'dsh-remote:file'
 
     function fetchRemoteStatus(sessionId) {
       return api('GET', withSessionQuery('/dsh-remote/status', sessionId)).catch(() => null)
@@ -2989,10 +2990,27 @@ window.__ModuleLoader__.load({
         return () => { clearTimeout(tid); document.removeEventListener('mousedown', close); host.remove() }
       }, [menu])
 
+      // Open one remote file. The viewer is a RESOURCE tab type: the address
+      // names the file, and the HOST's tab registry picks the type that claims
+      // it (ours, `dsh-resource://dsh-remote/**`). That is the same call the
+      // native explorer makes through `onOpenFile`, so one file behaves
+      // identically in both compositions — and it needs no better-sidebar
+      // descriptor, whose only effect would have been a switch that unregisters
+      // the viewer.
       const openFile = (p) => {
-        const name = String(p).split(/[\\/]/).pop() || p
-        if (props.onOpenFile) props.onOpenFile(p)
-        else props.ctx.betterSidebar.openTab({ type: SIDEBAR_FILE_ID, title: name, path: p }, props.scope)
+        if (props.onOpenFile) { props.onOpenFile(p); return }
+        const sessionId = (props.scope && props.scope.sessionId) || ''
+        try {
+          const right = props.ctx && props.ctx.get && props.ctx.get('sidebarRight')
+          if (right && typeof right.openResource === 'function') {
+            right.openResource(remoteFileAddress(sessionId, p))
+            return
+          }
+        } catch (e) {
+          console.warn('[dsh-remote] remote file open failed:', e)
+          return
+        }
+        console.warn('[dsh-remote] no right-sidebar resource opener; remote file not opened')
       }
 
       const doFs = (op, payload, refreshParent) => {
@@ -3302,13 +3320,14 @@ window.__ModuleLoader__.load({
           // Issue #32: own the expansion state (see RemoteExplorerTabOwned).
           component: RemoteExplorerTabOwned,
         }))
-        disposers.push(bs.registerTab({
-          id: SIDEBAR_FILE_ID,
-          title: () => tr('explorer.tabTitle'),
-          hidden: true, // not in the + menu; opened from the explorer tree
-          dedupeKey: (tab) => tab.path,
-          component: (props) => React.createElement(RemoteFileTab, props),
-        }))
+        // No descriptor for the FILE viewer on purpose. It is a resource tab
+        // type (`dsh-remote/file`, registered with `patterns` on the native
+        // registry), not a page: it only means something once an address names
+        // the file, so it has no card to draw and no page to open. A
+        // descriptor here would put a card in better-sidebar's 侧边栏内容
+        // inventory whose switch could only ever unregister the viewer — the
+        // "switch does nothing" report this replaced. The tree hands the HOST
+        // an address instead and the host routes it to that type (openFile).
       } catch (e) {
         console.warn('[dsh-remote] better-sidebar integration skipped:', e)
         disposers.forEach((d) => { try { d() } catch {} })
@@ -3522,11 +3541,65 @@ window.__ModuleLoader__.load({
       // built-in local preview. This is a warm-up, not a dependency: a failure
       // just leaves the conservative behaviour in place.
       try { ensureMirrors() } catch { /* the registry is best-effort */ }
-      inner.effect(() => tabs.register({
-        id: NATIVE_EXPLORER, kind: NATIVE_EXPLORER,
-        title: () => tr('explorer.tabTitle'),
-        guide: [{ order: 55, title: () => tr('explorer.tabTitle') }],
-      }), 'dsh-remote.native-explorer-type')
+      // ── Who owns the 开始 card ────────────────────────────────────────────
+      // The 远程文件 card on the right sidebar's start page (开始) is the
+      // `guide` entry of a native tab type, and TWO providers can publish one:
+      // this plugin (below) and dsh-better-sidebar, which registers a native
+      // type per tab descriptor it hosts — our `dsh-remote:explorer` gets a
+      // guide row of its own there, governed by its side-card settings switch.
+      //
+      // Publishing both is what made that switch look broken: turning the type
+      // off removed better-sidebar's row and left ours, so the card never went
+      // away. The card therefore belongs to exactly ONE provider:
+      //   · better-sidebar in the composition → ITS descriptor owns the card
+      //     (its switch IS the switch for it), and this type is registered
+      //     without a guide entry. The type and its body stay: a tab opened by
+      //     kind still renders, and nothing else about the panel changes.
+      //   · plain install → the card is ours, always, exactly as before.
+      //
+      // `guide` is captured at registration time and an id may not be
+      // registered twice, so a handover means dispose-then-register inside one
+      // synchronous block: no render can observe the gap.
+      let betterSidebar = false
+      let disposed = false
+      let disposeExplorer = null
+      let guideListed = null
+      const syncExplorerType = () => {
+        const withGuide = !betterSidebar
+        if (guideListed === withGuide && disposeExplorer) return
+        const previous = disposeExplorer
+        disposeExplorer = null
+        if (previous) { try { previous() } catch { /* already released */ } }
+        disposeExplorer = tabs.register({
+          id: NATIVE_EXPLORER, kind: NATIVE_EXPLORER,
+          title: () => tr('explorer.tabTitle'),
+          ...(withGuide ? { guide: [{ order: 55, title: () => tr('explorer.tabTitle') }] } : {}),
+        })
+        guideListed = withGuide
+      }
+      inner.effect(() => {
+        syncExplorerType()
+        return () => {
+          disposed = true
+          const dispose = disposeExplorer
+          disposeExplorer = null
+          guideListed = null
+          if (dispose) { try { dispose() } catch { /* already released */ } }
+        }
+      }, 'dsh-remote.native-explorer-type')
+      // The two plugins may activate in EITHER order, so the service has to be
+      // followed rather than read once: the card moves to better-sidebar when
+      // it arrives, and comes back here if it goes away.
+      inner.inject(['betterSidebar'], (withSidebar) => {
+        betterSidebar = true
+        try { syncExplorerType() } catch (e) { console.warn('[dsh-remote] start-page card handover skipped:', e) }
+        if (!withSidebar || typeof withSidebar.effect !== 'function') return
+        withSidebar.effect(() => () => {
+          betterSidebar = false
+          if (disposed) return
+          try { syncExplorerType() } catch (e) { console.warn('[dsh-remote] start-page card handover skipped:', e) }
+        }, 'dsh-remote.start-card-owner')
+      })
       inner.effect(() => tabs.register({
         id: NATIVE_FILE, kind: NATIVE_FILE,
         patterns: ['dsh-resource://dsh-remote/**'],

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

@@ -24,6 +24,7 @@ import { execFile } from 'node:child_process'
 import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync, statSync, renameSync, copyFileSync, appendFileSync, watch, rmSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import iconv from 'iconv-lite'
 
 import {
@@ -31,13 +32,14 @@ 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'
 import { getSecret, deleteSecret, platformBackend, persistPassword } from './credential.js'
 import { syncTree, pushTree, loadSyncState, saveSyncState, pushOneFile } from './sync.js'
 import { searchRemote } from './search.js'
+import { installTerminalShell } from './remote-shell.js'
 import { resolveMirror, poolKey, lookupSessionCwd, encodeSegmentSafe, readSessionHeaderCwd, requestSessionHint } from './binding.js'
 import { TaskManager } from './tasks.js'
 import { DeployTasks } from './deploy-tasks.js'
@@ -256,6 +258,30 @@ function mirrorRootFor(host, user, port) {
   return path.join(remoteWorkspacesRoot(), tag)
 }
 
+/** Generated terminal launchers. Deliberately NOT under `remote-workspaces`: a
+ * launcher there would sit next to the mirrors, where anything that scans the
+ * root for checkouts could pick it up as one. */
+function remoteTerminalRoot() {
+  return path.join(dshBase(), 'remote-terminal')
+}
+
+/**
+ * Every path the remote-shell contribution needs, resolved for this install.
+ *
+ * Split out from the registration itself so the wiring at the bottom of the
+ * plugin stays one readable line, and so the launcher path is a pure function
+ * of where the plugin lives.
+ *
+ * @returns {{ dir: string, childPath: string, machinesFile: string }}
+ */
+function remoteShellSpec() {
+  return {
+    dir: remoteTerminalRoot(),
+    childPath: fileURLToPath(new URL('./remote-shell-child.cjs', import.meta.url)),
+    machinesFile: machinesFile(),
+  }
+}
+
 /** Local mirror dir for a specific remote path (idempotent → returns same dir). */
 function mirrorDirFor(remotePath, host, user, port) {
   const base = remotePathBase(remotePath)
@@ -927,26 +953,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 +1012,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 +1732,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 +1783,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 +1833,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 +2255,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 +2860,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 +2883,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
@@ -3723,6 +3757,17 @@ export async function apply(ctx, config) {
     registerDeploySkill(skillCtx)
   })
 
+  // ── remote terminal: one extra shell in the host terminal's own list ──────
+  // Additive and optional: a composition without `terminalController` simply
+  // keeps the terminal it already had.
+  //
+  // The callback argument is a *new context*, not the service — reading the
+  // service off it (as if it were the controller) is a silent no-op, because a
+  // context has no `config.shellCandidates`.
+  ctx.inject(['terminalController'], (inner) => {
+    installTerminalShell(ctx, inner.get('terminalController'), remoteShellSpec())
+  })
+
   // ── auto-update: check on load + on an interval; apply silently ───────────
   // Failures are swallowed (never break the plugin). The persisted override
   // (settings UI) wins over the profile-config default, which wins over