dsh-remote 0.8.48 → 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/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 {
@@ -38,6 +39,7 @@ import { createRemoteFileReference, installFileReferenceOverlay, DEFAULT_EXCLUDE
 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)
@@ -3731,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

package/lib/remote-shell-child.cjs

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+/**
+ * The program the host terminal runs when the user picks the "Remote SSH" shell.
+ *
+ * It is started by a generated launcher (see `remote-shell.js`) inside the
+ * session's working directory, resolves which remote checkout that directory
+ * belongs to, and then replaces itself with `ssh`. Inheriting stdio is the whole
+ * point: the local pty stays in charge of the screen, so resize and key handling
+ * keep working without this script knowing anything about terminals.
+ *
+ * Plain CommonJS on purpose: it is spawned as a standalone script, and it must
+ * not depend on how the plugin package itself is loaded.
+ */
+
+'use strict'
+
+const { spawn } = require('node:child_process')
+const { existsSync, readFileSync } = require('node:fs')
+const path = require('node:path')
+
+/** Name of the marker the host half writes into every local mirror root. */
+const META_FILE = '.dsh-remote-meta.json'
+/** How far up from the working directory a marker may be found. */
+const MAX_WALK_UP = 12
+
+/**
+ * Read and parse a JSON file, returning undefined for anything unusable.
+ * @param {string} file
+ * @returns {any}
+ */
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'))
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Find the mirror root that contains `cwd` by walking upwards for the marker.
+ * @param {string} cwd - session working directory
+ * @param {{ exists?: (p: string) => boolean, readJsonFile?: (p: string) => any, maxUp?: number }} deps
+ * @returns {{ dir: string, meta: object } | null}
+ */
+function findMirror(cwd, deps = {}) {
+  const exists = deps.exists || ((p) => existsSync(p))
+  const read = deps.readJsonFile || readJson
+  const maxUp = deps.maxUp || MAX_WALK_UP
+  let dir = path.resolve(cwd || '.')
+  for (let depth = 0; depth <= maxUp; depth += 1) {
+    const marker = path.join(dir, META_FILE)
+    if (exists(marker)) {
+      const meta = read(marker)
+      if (meta && typeof meta === 'object' && meta.host) return { dir, meta }
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+/**
+ * Pick the saved connection that owns a mirror.
+ *
+ * The marker records the SSH alias when the machine was saved from
+ * `~/.ssh/config` (issue #38), so the alias is the most precise key; otherwise
+ * host + user + port identify it. A missing entry is not fatal — the marker
+ * alone is enough to connect, and ssh will use its own defaults for the key.
+ *
+ * @param {object} meta - mirror marker
+ * @param {{ list?: object[] }} registry - parsed `machines.json`
+ * @returns {object | undefined}
+ */
+function matchMachine(meta, registry) {
+  const list = registry && Array.isArray(registry.list) ? registry.list : []
+  const port = Number(meta.port || 22)
+  if (meta.alias) {
+    const byAlias = list.find((m) => m && m.host === meta.alias)
+    if (byAlias) return byAlias
+  }
+  return list.find((m) => m && m.host === meta.host
+    && String(m.username || '') === String(meta.username || '')
+    && Number(m.port || 22) === port)
+}
+
+/**
+ * Quote one path for a POSIX shell, single quotes only.
+ * @param {string} value
+ * @returns {string}
+ */
+function quotePosix(value) {
+  return "'" + String(value).replace(/'/g, "'\\''") + "'"
+}
+
+/**
+ * Build the `cd` half of the remote command, keeping `~` for the *remote* shell
+ * to expand: the local home is not the remote home, so expanding it here would
+ * silently land in the wrong directory.
+ * @param {string} remotePath
+ * @returns {string}
+ */
+function remoteCd(remotePath) {
+  const raw = String(remotePath || '').trim()
+  if (raw === '' || raw === '~') return 'cd "$HOME"'
+  if (raw === '~/') return 'cd "$HOME"'
+  if (raw.startsWith('~/')) return 'cd "$HOME"/' + quotePosix(raw.slice(2))
+  return 'cd ' + quotePosix(raw)
+}
+
+/**
+ * The remote command: land in the workspace, then hand over to a login shell.
+ *
+ * `exec` keeps the pty attached to a single interactive shell, so the exit code
+ * the terminal sees is the shell's own, and a deleted workspace falls back to
+ * `$HOME` instead of leaving a broken terminal.
+ *
+ * @param {string} remotePath
+ * @returns {string}
+ */
+function remoteCommand(remotePath) {
+  return `${remoteCd(remotePath)} 2>/dev/null || cd "$HOME"; exec "\${SHELL:-/bin/bash}" -l`
+}
+
+/** Absolute Windows path: `D:\x`, `D:/x`, or a `\\server\share` UNC path.
+ * These cannot be the operand of a POSIX `cd`. */
+const WINDOWS_REMOTE_PATH = /^(?:[a-zA-Z]:[\\/]|\\\\)/
+
+/**
+ * Whether a remote workspace path is a Windows one.
+ *
+ * A Windows remote speaks cmd or PowerShell in its default shell, so the POSIX
+ * `cd … || …; exec "$SHELL"` line would fail outright there — `2>/dev/null`,
+ * `||` and `exec` are not cmd syntax at all. The marker records no remote
+ * platform, but the path form is unambiguous: `/srv/x` and `~/x` are POSIX,
+ * while `D:\x` and `\\server\share` are not valid POSIX paths.
+ *
+ * @param {string} p - `remotePath` from the mirror marker
+ * @returns {boolean}
+ */
+function isWindowsRemotePath(p) {
+  return WINDOWS_REMOTE_PATH.test(String(p || '').trim())
+}
+
+/**
+ * Argument list (without the ssh binary) for one connection.
+ *
+ * `-tt` is mandatory: the terminal needs a tty even though a command is given,
+ * otherwise the shell comes up non-interactive and every key press is ignored.
+ * Options are pushed in order and never spliced between an `-o` and its value —
+ * an inserted `-J` there once reached ssh as the value of `-o`, which aborted
+ * every connection that used a jump host (issue #21).
+ *
+ * @param {object} target - `{ host, port, username, alias, remotePath }`
+ * @param {object} [machine] - saved connection, for the key and transport hints
+ * @returns {string[]}
+ */
+function buildSshArgs(target, machine) {
+  const args = ['-tt']
+  const alias = target.alias || (machine && machine.useSshConfig ? machine.host : '')
+  if (alias) {
+    args.push(String(alias))
+  } else {
+    const port = Number(target.port || (machine && machine.port) || 22)
+    if (port !== 22) args.push('-p', String(port))
+    const key = machine && machine.privateKeyPath
+    if (key && !machine.useAgent) args.push('-i', String(key))
+    const user = target.username || (machine && machine.username) || ''
+    args.push(user ? `${user}@${target.host}` : String(target.host))
+  }
+  // A Windows workspace cannot be reached with the POSIX line: the remote's
+  // default shell may be cmd or PowerShell, and picking one would be a guess.
+  // Opening ssh with no command leaves the remote's own default shell in charge,
+  // so the terminal still works; only the automatic `cd` is given up.
+  if (!isWindowsRemotePath(target.remotePath)) args.push(remoteCommand(target.remotePath))
+  return args
+}
+
+/**
+ * Prefer the OS OpenSSH binary on Windows. A PATH lookup there can reach an
+ * MSYS2/git-bash `ssh`, which resolves `~/.ssh` against a different home and
+ * makes keys saved by the host half look missing.
+ * @param {string} [platform]
+ * @param {object} [env]
+ * @param {(p: string) => boolean} [exists]
+ * @returns {string}
+ */
+function sshBinary(platform = process.platform, env = process.env, exists = existsSync) {
+  if (platform === 'win32') {
+    const system = env.SystemRoot || env.windir || 'C:\\Windows'
+    const native = path.join(system, 'System32', 'OpenSSH', 'ssh.exe')
+    if (exists(native)) return native
+  }
+  return 'ssh'
+}
+
+/**
+ * The shell to fall back to when this directory is not a remote checkout.
+ * @param {string} [platform]
+ * @param {object} [env]
+ * @returns {string}
+ */
+function localShell(platform = process.platform, env = process.env) {
+  if (platform === 'win32') return env.ComSpec || 'cmd.exe'
+  return env.SHELL || '/bin/sh'
+}
+
+/**
+ * Parse the arguments the launcher passes.
+ * @param {string[]} argv
+ * @returns {{ machines?: string }}
+ */
+function parseArgs(argv) {
+  const out = {}
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === '--machines' && argv[i + 1]) {
+      out.machines = argv[i + 1]
+      i += 1
+    }
+  }
+  return out
+}
+
+/**
+ * Resolve everything needed to connect from a working directory.
+ * @param {{ cwd?: string, machines?: string, exists?: Function, readJsonFile?: Function }} input
+ * @returns {{ target?: object, machine?: object, found: boolean }}
+ */
+function resolveTarget(input = {}) {
+  const cwd = input.cwd || process.cwd()
+  const mirror = findMirror(cwd, input)
+  if (!mirror) return { found: false }
+  const registry = input.machines ? (input.readJsonFile || readJson)(input.machines) : undefined
+  const machine = matchMachine(mirror.meta, registry)
+  const target = {
+    host: mirror.meta.host,
+    port: mirror.meta.port || (machine && machine.port) || 22,
+    username: mirror.meta.username || (machine && machine.username) || '',
+    alias: mirror.meta.alias || '',
+    remotePath: mirror.meta.remotePath || (machine && machine.workspace) || '',
+  }
+  return { found: true, target, machine, dir: mirror.dir }
+}
+
+/**
+ * Hand the current process over to `file args…`, propagating the exit code.
+ * @param {string} file
+ * @param {string[]} args
+ * @returns {import('node:child_process').ChildProcess}
+ */
+function handover(file, args) {
+  const child = spawn(file, args, { stdio: 'inherit' })
+  child.on('error', (error) => {
+    process.stderr.write(`[dsh-remote] cannot run ${file}: ${error && error.message}\n`)
+    process.exit(127)
+  })
+  child.on('exit', (code, signal) => {
+    if (signal) process.kill(process.pid, signal)
+    else process.exit(code == null ? 0 : code)
+  })
+  return child
+}
+
+/**
+ * Entry point: connect, or explain why a local shell was used instead.
+ * @param {string[]} [argv]
+ * @param {{ cwd?: string, platform?: string, env?: object }} [deps]
+ */
+function main(argv = process.argv.slice(2), deps = {}) {
+  const platform = deps.platform || process.platform
+  const env = deps.env || process.env
+  const options = parseArgs(argv)
+  const resolved = resolveTarget({ cwd: deps.cwd || process.cwd(), machines: options.machines })
+  if (!resolved.found) {
+    process.stderr.write('[dsh-remote] this directory is not a remote workspace; opening a local shell.\n')
+    process.stderr.write('[dsh-remote] 当前目录不是远程工作区，已打开本地终端。\n')
+    return handover(localShell(platform, env), platform === 'win32' ? [] : ['-l'])
+  }
+  const ssh = sshBinary(platform, env)
+  const args = buildSshArgs(resolved.target, resolved.machine)
+  const user = resolved.target.username || (resolved.machine && resolved.machine.username) || ''
+  process.stderr.write(`[dsh-remote] connecting to ${user ? user + '@' : ''}${resolved.target.host}…\n`)
+  if (isWindowsRemotePath(resolved.target.remotePath)) {
+    process.stderr.write('[dsh-remote] the remote workspace is a Windows path; opening the remote default shell without changing directory.\n')
+    process.stderr.write('[dsh-remote] 远端工作区是 Windows 路径，已打开默认 shell（未自动切换目录）。\n')
+  }
+  return handover(ssh, args)
+}
+
+module.exports = {
+  META_FILE,
+  buildSshArgs,
+  findMirror,
+  isWindowsRemotePath,
+  localShell,
+  main,
+  matchMachine,
+  parseArgs,
+  remoteCd,
+  remoteCommand,
+  resolveTarget,
+  sshBinary,
+}
+
+if (require.main === module) main()