dsh-remote 0.8.7 → 0.8.9

package/lib/index.js

@@ -30,7 +30,7 @@ import iconv from 'iconv-lite'
 
 import {
   shq, normalizeRemotePath, joinRemotePath, remoteDirname, mkdirRemoteDirs,
-  toSftpPath, remotePathBase, truncate, shortHash, relPathUnder,
+  toSftpPath, toShellPath, toDisplayPath, remotePathBase, truncate, shortHash, relPathUnder,
 } from './paths.js'
 import { blobAlgorithm, keyFingerprint } from './hostkey.js'
 import { compileIgnore, DEFAULT_IGNORE } from './ignore.js'
@@ -42,6 +42,7 @@ import { searchTree } from './search.js'
 import { TaskManager } from './tasks.js'
 import { ForwardManager } from './forwards.js'
 import { selfDir, readVersion, gtVersion, fetchLatestVersion, applyUpdate, persistUpdateMode, readUpdateMode } from './update.js'
+import { loadMachines as _loadMachines, saveMachines as _saveMachines, sanitizeMachine as _sanitizeMachine, applyMachine as _applyMachine, machineId as _machineId } from './registry.js'
 
 const { Client } = ssh2
 
@@ -67,6 +68,12 @@ export const Config = z.object({
   passphrase: z.string().default(''),
   /** Initial remote workspace path (absolute dir the agent should treat as root). */
   workspace: z.string().default(''),
+  /** Remote command terminal strategy. '' = auto-detect (Windows remotes look
+   * for Git Bash and pipe every command through `bash -s`); 'git-bash' = prefer
+   * Git Bash on Windows; 'native' = never wrap; any other value = explicit
+   * bash.exe path (e.g. 'C:\\Program Files\\Git\\bin\\bash.exe'). Git Bash makes
+   * a Windows remote behave like a POSIX host (/c/Users/... paths). */
+  shell: z.string().default(''),
   /** Per-command timeout. */
   commandTimeoutMs: z.number().step(1).min(1000).default(20000),
   /** SSH connection establishment timeout. */
@@ -220,6 +227,9 @@ function migrateLegacyData() {
 }
 
 // ── persistent multi-machine registry ─────────────────────────────────────
+// Pure registry logic lives in lib/registry.js (unit-tested): saved machines
+// are STANDBY connections; only an explicit "set current" activates one.
+// (issue #13 — Saved Connections != Active Remote Context)
 const MACHINES_FILE = 'machines.json'
 const machinesFile = () => path.join(remoteWorkspacesRoot(), MACHINES_FILE)
 const secretsDir = () => path.join(remoteWorkspacesRoot(), '.secrets')
@@ -227,40 +237,11 @@ const forwardsFile = () => path.join(remoteWorkspacesRoot(), 'forwards.json')
 const auditFile = () => path.join(remoteWorkspacesRoot(), 'audit.log')
 const ignoreFile = () => path.join(remoteWorkspacesRoot(), '.dsh-remote-ignore')
 
-function loadMachines() {
-  try {
-    const j = JSON.parse(readFileSync(machinesFile(), 'utf8'))
-    if (Array.isArray(j.list)) return { list: j.list, currentId: j.currentId || (j.list[0] && j.list[0].id) || null }
-  } catch {}
-  return { list: [], currentId: null }
-}
-function saveMachines(list, currentId) {
-  try { mkdirSync(path.dirname(machinesFile()), { recursive: true }) } catch {}
-  writeFileSync(machinesFile(), JSON.stringify({ list, currentId }, null, 2))
-}
-function sanitizeMachine(m) {
-  if (!m) return m
-  const { password, proxy, ...rest } = m
-  const out = { ...rest, passwordSet: !!(m.password && m.password.length) }
-  if (proxy) out.proxy = { ...proxy, password: proxy.password ? '' : undefined, passwordSet: !!(proxy.password && proxy.password.length) }
-  return out
-}
-/** Apply a machine's fields onto the live config object (pool + tools read it). */
-function applyMachine(config, m) {
-  if (!m) return
-  config.host = m.host
-  config.port = Number(m.port) || 22
-  config.username = m.username || ''
-  config.password = m.password || ''
-  config.privateKeyPath = m.privateKeyPath || ''
-  config.passphrase = m.passphrase || ''
-  config.workspace = m.workspace || (config.workspace || '')
-  if (m.hostKeyMode) config.hostKeyMode = m.hostKeyMode
-  if (typeof m.useAgent === 'boolean') config.useAgent = m.useAgent
-  if (typeof m.keyboardInteractive === 'boolean') config.keyboardInteractive = m.keyboardInteractive
-  config.proxy = m.proxy && m.proxy.host ? m.proxy : undefined
-}
-function machineId() { return 'm-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6) }
+const loadMachines = () => _loadMachines(machinesFile())
+const saveMachines = (list, currentId, keepCurrentKey) => _saveMachines(machinesFile(), list, currentId, keepCurrentKey)
+const sanitizeMachine = _sanitizeMachine
+const applyMachine = _applyMachine
+const machineId = _machineId
 
 // ── host-key registry (TOFU) ──────────────────────────────────────────────
 const KNOWN_HOSTS_FILE = 'known_hosts.json'
@@ -331,6 +312,14 @@ class SshPool {
     // Generational token: bumped on every target change / close so a stale
     // in-flight connect can never hand this pool a connection to an old host.
     this.epoch = 0
+    /** Auto-detected remote platform: unknown | windows | posix (per target). */
+    this.platform = 'unknown'
+    /** Resolved Git Bash bash.exe path on Windows remotes ('' when none). */
+    this.gitBashPath = ''
+    /** Resolved terminal strategy: native | git-bash. */
+    this.shellMode = 'native'
+    /** In-flight platform detection promise (cached). */
+    this._detecting = null
     /** Optional async resolver for a machine-stored (keychain) password. */
     this.passwordResolver = null
     /** Optional hook called with the live client after a successful connect. */
@@ -358,6 +347,11 @@ class SshPool {
     if (keyboardInteractive !== undefined) this.config.keyboardInteractive = !!keyboardInteractive
     if (proxy !== undefined) this.config.proxy = proxy
     if (hostKeyMode !== undefined) this.config.hostKeyMode = String(hostKeyMode)
+    // the new target may be a different OS — re-detect on the next command
+    this.platform = 'unknown'
+    this.gitBashPath = ''
+    this.shellMode = 'native'
+    this._detecting = null
     this.close()
     return this
   }
@@ -495,25 +489,133 @@ class SshPool {
     })
   }
 
+  /** Detect the remote platform + locate Git Bash once; cached per target. */
+  detect() {
+    if (this.platform !== 'unknown') return Promise.resolve()
+    if (this._detecting) return this._detecting
+    this._detecting = this._detect().finally(() => {
+      this._detecting = null
+    })
+    return this._detecting
+  }
+
+  async _detect() {
+    let res
+    try {
+      // `cmd /c ver` works under cmd.exe, PowerShell AND Git Bash (all print
+      // "Microsoft Windows …"); on POSIX hosts `cmd` simply doesn't exist.
+      res = await this._execRaw('cmd /c ver', { timeoutMs: Math.min(this.config.commandTimeoutMs, 8000) })
+    } catch (err) {
+      this.platform = 'unknown'
+      this.shellMode = 'native'
+      return
+    }
+    const out = String(res.stdout || '') + '\n' + String(res.stderr || '')
+    if (res.code === 0 && /microsoft windows/i.test(out)) {
+      this.platform = 'windows'
+      await this._resolveGitBash()
+      return
+    }
+    // inconclusive — probe for a Git-Bash/MSYS remote (uname prints MINGW64_NT…)
+    try {
+      const u = await this._execRaw('uname -s', { timeoutMs: Math.min(this.config.commandTimeoutMs, 8000) })
+      if (/mingw|msys|cygwin/i.test(String(u.stdout || ''))) {
+        this.platform = 'windows'
+        await this._resolveGitBash()
+        return
+      }
+    } catch {}
+    this.platform = 'posix'
+    this.shellMode = 'native'
+    this.gitBashPath = ''
+  }
+
+  /** On a Windows remote, locate Git Bash (config path → PATH → common installs). */
+  async _resolveGitBash() {
+    const cfg = String(this.config.shell || '').trim()
+    if (cfg && cfg !== 'git-bash' && cfg !== 'native') {
+      if (await this._cmdExists(cfg)) {
+        this.gitBashPath = cfg
+        this.shellMode = 'git-bash'
+        return
+      }
+    }
+    if (cfg === 'native') {
+      this.shellMode = 'native'
+      this.gitBashPath = ''
+      return
+    }
+    try {
+      const r = await this._execRaw('cmd /c where bash', { timeoutMs: 8000 })
+      const first = String(r.stdout || '').trim().split(/\r?\n/)[0].trim()
+      if (first) {
+        this.gitBashPath = first
+        this.shellMode = 'git-bash'
+        return
+      }
+    } catch {}
+    const candidates = [
+      'C:\\Program Files\\Git\\bin\\bash.exe',
+      'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+      ...(process.env.LOCALAPPDATA ? [process.env.LOCALAPPDATA + '\\Programs\\Git\\bin\\bash.exe'] : []),
+      '%LOCALAPPDATA%\\Programs\\Git\\bin\\bash.exe',
+    ]
+    for (const c of candidates) {
+      if (await this._cmdExists(c)) {
+        this.gitBashPath = c
+        this.shellMode = 'git-bash'
+        return
+      }
+    }
+    this.shellMode = 'git-bash' // wanted but not found — commands fall back to raw
+    this.gitBashPath = ''
+  }
+
+  async _cmdExists(p) {
+    try {
+      const r = await this._execRaw(`cmd /c if exist "${p}" (echo Y) else (echo N)`, { timeoutMs: 8000 })
+      return /Y/.test(String(r.stdout || ''))
+    } catch {
+      return false
+    }
+  }
+
   /** Run one remote command; resolves { code, signal, stdout, stderr }.
-   * Accepts `exec(cmd, timeoutMs)` (legacy) or `exec(cmd, {timeoutMs, pty, env})`. */
+   * On Windows remotes with Git Bash the script is piped to `bash -s` over the
+   * exec-channel stdin — no shell quoting round-trip, so any content (quotes,
+   * backslashes, newlines) survives verbatim. */
   exec(command, timeoutMsOrOpts) {
     const opts = timeoutMsOrOpts && typeof timeoutMsOrOpts === 'object' ? timeoutMsOrOpts : { timeoutMs: timeoutMsOrOpts }
-    const timeoutMs = opts.timeoutMs || this.config.commandTimeoutMs
+    return this.detect().then(() => {
+      if (this.platform === 'windows' && this.gitBashPath) {
+        const script = String(command)
+        return this._execRaw(`"${this.gitBashPath}" -s`, { ...opts, timeoutMs: opts.timeoutMs || this.config.commandTimeoutMs }, (stream) => {
+          try { stream.end(script) } catch {}
+        })
+      }
+      return this._execRaw(command, opts)
+    })
+  }
+
+  /** Raw exec (no detection / no wrapper). Optional stdinWriter(stream) feeds
+   * the remote process stdin (used by the Git Bash `-s` mode). */
+  _execRaw(command, opts, stdinWriter) {
+    const timeoutMs = (opts && opts.timeoutMs) || this.config.commandTimeoutMs
     return this.connect().then(
       (client) =>
         new Promise((resolve, reject) => {
           let retried = false
           const runOn = (c) => {
             const execOpts = {}
-            if (opts.pty) execOpts.pty = true
-            if (opts.env && typeof opts.env === 'object') execOpts.env = opts.env
+            if (opts && opts.pty) execOpts.pty = true
+            if (opts && opts.env && typeof opts.env === 'object') execOpts.env = opts.env
             c.exec(command, execOpts, (err, stream) => {
               if (err) {
-                // Channel-open failure usually means the pooled connection died
-                // server-side (idle timeout / network reset) while keepalive
-                // hadn't noticed. Drop it and retry ONCE on a fresh connection.
-                if (!retried && /channel open failure|open failed/i.test(String((err && err.message) || err))) {
+                // Channel-open failure — or a session termination — usually
+                // means the pooled connection died server-side (idle timeout /
+                // network reset) while keepalive hadn't noticed. Drop it and
+                // retry ONCE on a fresh connection.
+                if (!retried && /channel open failure|open failed|unexpected .* session termination|session termination|disconnect/i.test(String((err && err.message) || err))) {
                   retried = true
                   this.invalidate()
                   return this.connect().then(
@@ -574,6 +676,9 @@ class SshPool {
                 clearTimeout(timer)
                 reject(new Error('ssh stream error: ' + ((e && e.message) || e)))
               })
+              if (stdinWriter) {
+                try { stdinWriter(stream) } catch {}
+              }
             })
           }
           runOn(client)
@@ -591,9 +696,11 @@ class SshPool {
             c.sftp((err, sftp) => {
               if (err) {
                 // Same dead-connection recovery as exec(): a channel open
-                // failure means the pooled connection is stale — drop it and
+                // failure — or a session termination (remote closed the
+                // SFTP subchannel, e.g. transient network blip / sshd idle
+                // drop) — means the pooled connection is stale: drop it and
                 // retry ONCE on a fresh connection.
-                if (!retried && /channel open failure|open failed/i.test(String((err && err.message) || err))) {
+                if (!retried && /channel open failure|open failed|unexpected sftp session termination|session termination|disconnect/i.test(String((err && err.message) || err))) {
                   retried = true
                   this.invalidate()
                   return this.connect().then(
@@ -753,6 +860,15 @@ export async function apply(ctx, config) {
   }
 
   const setCurrent = async (id) => {
+    if (!id) {
+      // Explicit "active remote = none": saved machines stay in the registry
+      // (issue #13) but nothing is bound to the pool anymore.
+      store.currentId = null
+      ephemeral = null
+      saveMachines(machines, null)
+      await clearActiveMachine()
+      return true
+    }
     const i = machineIndex(id)
     if (i < 0) return false
     store.currentId = id
@@ -762,10 +878,62 @@ export async function apply(ctx, config) {
     return true
   }
 
-  // If no stored current, adopt a CLI-provided default as the active machine.
+  /** Unbind the pool + live config from any machine: the plugin starts in a
+   * pure "no remote context" state (issue #13). The host stays configured for
+   * tool fallback, but no machine workspace leaks into this session. */
+  const clearActiveMachine = async () => {
+    ephemeral = null
+    if (!config.host) return
+    // Clear host + workspace directly (applyMachine keeps the old workspace
+    // when the incoming value is empty — it must not be used for a full reset).
+    config.host = ''
+    config.port = 22
+    config.username = ''
+    config.password = ''
+    config.workspace = ''
+    pool.setTarget({ host: '', port: 22, username: '', workspace: '' })
+    // Also stop any auto-push watcher bound to the old machine workspace.
+    // (autoPushWatchers is declared later; read it lazily to avoid TDZ.)
+    if (typeof autoPushWatchers !== 'undefined' && autoPushWatchers) {
+      for (const [, entry] of autoPushWatchers) {
+        if (!entry) continue
+        try { entry.watcher && entry.watcher.close() } catch {}
+        if (entry.timer) clearTimeout(entry.timer)
+      }
+      autoPushWatchers.clear()
+    }
+  }
+
+  // If no stored current, adopt a CLI-provided default as the active machine —
+  // UNLESS the user explicitly cleared the current machine (currentId: null in
+  // the registry = "active remote = none", issue #13). A registry that exists
+  // with currentId null must stay inert; only a fresh/absent registry lets the
+  // config host serve as the bootstrap default.
   {
     const cur = currentMachine()
-    if (cur && cur.host && !store.currentId) applyMachine(config, cur)
+    const registryExplicitNone = store.explicitNone
+    if (cur && cur.host && !store.currentId && !registryExplicitNone) applyMachine(config, cur)
+  }
+
+  // ── auto-restore the last active machine (best-effort) ───────────────────
+  // When the harness (re)starts, bring back the machine that was "current"
+  // last time: apply its config to the pool and probe a real SSH connection so
+  // the sidebar shows connected instead of a disconnected 500-spamming state.
+  // Failures are swallowed — an unreachable host must never break plugin boot
+  // (the sidebar will show「未连接」and the user can reconnect or set current).
+  if (store.currentId) {
+    const i = machineIndex(store.currentId)
+    if (i >= 0 && machines[i] && machines[i].host) {
+      setImmediate(async () => {
+        try {
+          await applyActiveMachine()
+          await pool.exec('echo dsh-remote-restore', { timeoutMs: Math.min(config.commandTimeoutMs || 20000, 15000) })
+        } catch {
+          // Offline / bad credentials: leave pool unconnected; UI falls back
+          // to the "未连接" state and the user can reconnect manually.
+        }
+      })
+    }
   }
 
   /** Persist the active workspace on the machine the pool is actually bound to
@@ -905,7 +1073,14 @@ export async function apply(ctx, config) {
     try {
       list = await sftp.readdir(target)
     } catch (err) {
-      throw new Error('browse failed: ' + ((err && err.message) || err))
+      // Missing directory / deleted folder: not an internal error. Report it
+      // distinctly so the UI can show「目录不存在」without treating it as a
+      // hard failure (500) that collapses the whole tree.
+      const msg = String((err && err.message) || err)
+      if (/no such file|not found|does not exist|ENOENT/i.test(msg)) {
+        return { path: target, items: [], missing: true }
+      }
+      throw new Error('browse failed: ' + msg)
     }
     const items = []
     const symIdx = []
@@ -943,6 +1118,29 @@ export async function apply(ctx, config) {
     return { path: target, items }
   }
 
+  /** Windows drive letters as display-form dir entries (the "This PC" root view).
+   * `cmd /c fsutil fsinfo drives` works under cmd/PowerShell/Git Bash and prints
+   * e.g. "Drives: C:\\ D:\\ E:\\"; falls back to listing Git-Bash mount points
+   * (/c /d …). Returns [] on POSIX hosts or when enumeration fails. */
+  const listRemoteDrives = async () => {
+    let letters = []
+    try {
+      const res = await pool.exec('cmd /c fsutil fsinfo drives', { timeoutMs: Math.min(config.commandTimeoutMs, 8000) })
+      letters = [...String(res.stdout || '').matchAll(/([a-zA-Z]):\\?/g)].map((mm) => mm[1].toUpperCase())
+    } catch {}
+    if (!letters.length) {
+      try {
+        const res = await pool.exec('ls -d /[a-z] 2>/dev/null', { timeoutMs: Math.min(config.commandTimeoutMs, 8000) })
+        letters = String(res.stdout || '')
+          .split(/\s+/)
+          .map((s) => s.replace(/^\/+|\/+$/g, ''))
+          .filter((s) => /^[a-zA-Z]$/.test(s))
+          .map((s) => s.toUpperCase())
+      } catch {}
+    }
+    return [...new Set(letters)].sort().map((l) => ({ name: l + ':\\', path: l + ':\\', type: 'dir', drive: true, size: 0, mtime: 0 }))
+  }
+
   const isRemoteDir = async (p) => {
     const target = normalizeRemotePath(p)
     try {
@@ -980,24 +1178,84 @@ export async function apply(ctx, config) {
 
   // ── remote workspace state ────────────────────────────────────────────────
   const wsPath = () => (config.workspace || '').trim()
+  /** Map a LOCAL path to the remote path its mirror represents ('' when the
+   *  path is not inside any dsh-remote mirror). Shared by the resolve-mirror
+   *  route, the session-aware system-prompt injection, and status(). */
+  const resolveMirrorForLocal = (local) => {
+    const root = remoteWorkspacesRoot()
+    const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '') || ''
+    let matched = ''
+    let matchedRemote = ''
+    if (local && existsSync(root)) {
+      const base = norm(local)
+      for (const hostDir of readdirSync(root)) {
+        const hostPath = path.join(root, hostDir)
+        if (!statSync(hostPath, { throwIfNoEntry: false })?.isDirectory?.()) continue
+        for (const mirrorDir of readdirSync(hostPath)) {
+          const metaPath = path.join(hostPath, mirrorDir, '.dsh-remote-meta.json')
+          if (!existsSync(metaPath)) continue
+          try {
+            const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+            const mirrorAbs = norm(path.join(hostPath, mirrorDir))
+            if (mirrorAbs === base || base.startsWith(mirrorAbs + path.sep) || base.startsWith(mirrorAbs + '/')) {
+              if (mirrorAbs.length > matched.length) {
+                matched = mirrorAbs
+                matchedRemote = String(meta.remotePath || '')
+              }
+            }
+          } catch { /* skip unparsable meta */ }
+        }
+      }
+    }
+    return { mirrorDir: matched || null, remotePath: matchedRemote || '' }
+  }
   if (config.autoPush && wsPath()) {
     startAutoPush(mirrorDirFor(wsPath(), config.host, config.username, config.port))
   }
+  /** The remote path the CURRENT agent session is really bound to, or '' when
+   *  the session is a plain local one. Walks the mirror registry (host side
+   *  copy of the resolve-mirror logic) so status / prompt / sidebar agree.
+   *  `sessionId` narrows to one session; without it the first live session's
+   *  cwd is used (best effort — status is informational, the per-session
+   *  resolve-mirror endpoint is authoritative). */
+  const sessionRemotePath = (sessionId) => {
+    let cwd = ''
+    try {
+      const sessions = ctx && typeof ctx.get === 'function' ? ctx.get('sessions') : null
+      if (sessions && typeof sessions.get === 'function' && sessionId) {
+        const s = sessions.get(sessionId)
+        if (s && s.header && s.header.cwd) cwd = String(s.header.cwd)
+      } else if (sessions && typeof sessions.list === 'function') {
+        const s = sessions.list()[0]
+        if (s && s.header && s.header.cwd) cwd = String(s.header.cwd)
+      }
+    } catch { /* sessions service unavailable */ }
+    if (!cwd) return ''
+    return resolveMirrorForLocal(cwd).remotePath
+  }
   const status = () => ({
     host: config.host,
     port: config.port,
     username: config.username,
     connected: !!pool.client,
-    workspace: wsPath(),
+    workspace: toDisplayPath(wsPath(), pool.platform),
     localMirror: wsPath() ? mirrorDirFor(wsPath(), config.host, config.username, config.port) : '',
     currentId: store.currentId || null,
     activeSource: ephemeral ? 'ephemeral' : (store.currentId ? 'machine' : (config.host ? 'config' : 'none')),
+    // Issue #13: whether THIS session is in remote mode (cwd inside a mirror).
+    // `none`/`local` means the plugin is present but no remote context is
+    // active — saved machines stay standby-only.
+    sessionMode: sessionRemotePath() ? 'remote' : (store.currentId ? 'standby' : 'local'),
+    sessionRemotePath: sessionRemotePath(),
     machines: machines.map(sanitizeMachine),
     hostKeyMode: config.hostKeyMode === 'verify' || config.hostKeyMode === 'off' ? config.hostKeyMode : 'accept-new',
     hostKeyKnown: config.host ? isHostKeyKnown(config.host, config.port) : false,
     forwards: forwards.list(),
     auditEnabled: !!config.auditLog,
     backend: platformBackend(),
+    platform: pool.platform,
+    shell: pool.shellMode,
+    gitBash: pool.gitBashPath || '',
   })
 
   // ── tools ─────────────────────────────────────────────────────────────────
@@ -1015,16 +1273,18 @@ export async function apply(ctx, config) {
     defineTool({
       name: 'rw_info',
       description:
-        'Show the remote environment: host/user/port, connection health, current remote workspace path, active port forwards. Call this first to orient, or when an rw_* call fails to check connectivity.',
+        'Show the remote environment: host/user/port, connection health, current remote workspace path, active port forwards. Call this first to orient, or when an rw_* call fails to check connectivity. Note: remote context is session-scoped — a saved machine only becomes active when you explicitly rw_connect to it (issue #13).',
       parameters: {},
       output: textOut,
       async execute() {
         const s = status()
         const lines = [
           `Remote host: ${s.username || '<user>'}@${s.host || '<host>'}:${s.port}${s.activeSource !== 'machine' ? ` (source: ${s.activeSource})` : ''}`,
-          `Current remote workspace: ${s.workspace || '(none — call rw_pick_workspace to set one)'}`,
+          `Current remote workspace: ${s.workspace || '(none — call rw_connect then rw_pick_workspace to set one)'}`,
           `Local mirror: ${s.localMirror || '(none)'}`,
+          `Session remote context: ${s.sessionRemotePath ? s.sessionRemotePath : '(this session is LOCAL — no remote workspace bound)'}`,
           `Connected: ${s.connected ? 'yes' : 'no'}`,
+          `Remote shell: ${s.platform === 'windows' ? (s.gitBash ? 'Git Bash (' + s.gitBash + ')' : 'Windows (Git Bash not found — set config.shell to a bash.exe path)') : (s.platform === 'posix' ? 'native POSIX' : 'detecting…')}`,
           `Active forwards: ${s.forwards.filter((f) => f.active).length} / ${s.forwards.length}`,
           `Host key: ${s.hostKeyKnown ? 'trusted' : 'not yet trusted'} (mode=${s.hostKeyMode})`,
           '',
@@ -1111,21 +1371,22 @@ export async function apply(ctx, config) {
     defineTool({
       name: 'rw_pick_workspace',
       description:
-        'Set the remote workspace directory this session should treat as its working root on the connected remote. Verifies it exists (a directory). Use rw_list_dir to browse first if unsure.',
+        'Set the remote workspace directory this session should treat as its working root on the connected remote. Verifies it exists (a directory). Use rw_list_dir to browse first if unsure. Accepts POSIX (/home/dev/project) or Windows (C:\\Users\\dev\\project) paths.',
       parameters: {
-        path: { type: 'string', required: true, description: 'Absolute remote directory path, e.g. /home/dev/code/project' },
+        path: { type: 'string', required: true, description: 'Absolute remote directory path, e.g. /home/dev/code/project or C:\\Users\\dev\\project' },
       },
       output: textOut,
       async execute(args) {
         const p = normalizeRemotePath(String(args.path || ''))
         if (!p || p === '/') throw new Error('rw_pick_workspace: path must be an absolute directory')
         const ok = await isRemoteDir(p)
-        if (!ok) return { text: `not a directory (or missing) on ${p}` }
+        const shown = toDisplayPath(p, pool.platform)
+        if (!ok) return { text: `not a directory (or missing) on ${shown}` }
         persistWorkspace(p)
         const local = ensureMirror(p, config.host, config.username, config.port)
         startAutoPush(local)
         return {
-          text: `Remote workspace set to ${p} on ${config.username}@${config.host} (saved for this machine).\nLocal mirror (native workspace path): ${local}\n\nRun rw_sync to download its files into the local mirror.`,
+          text: `Remote workspace set to ${shown} on ${config.username}@${config.host} (saved for this machine).\nLocal mirror (native workspace path): ${local}\n\nRun rw_sync to download its files into the local mirror.`,
         }
       },
     }),
@@ -1233,7 +1494,7 @@ export async function apply(ctx, config) {
     defineTool({
       name: 'rw_list_dir',
       description:
-        'List a remote directory (or a single file) via SSH. Path is absolute; if omitted, lists the current remote workspace. Shows type, size, mtime.',
+        'List a remote directory (or a single file) via SSH. Path is absolute; accepts Windows paths like C:\\Users\\dev\\project on Git Bash remotes. If omitted, lists the current remote workspace. Shows type, size, mtime.',
       parameters: {
         path: { type: 'string', description: 'Absolute remote path (default: current remote workspace)' },
       },
@@ -1515,7 +1776,15 @@ export async function apply(ctx, config) {
         if (!cmd) throw new Error('rw_exec: command is required')
         const ws = wsPath()
         const cwd = args.cwd ? normalizeRemotePath(String(args.cwd)) : (ws || '')
-        const full = cwd && !cwd.includes('\\') ? `cd ${shq(cwd)} && ${cmd}` : cmd
+        let full = cmd
+        if (cwd) {
+          if (pool.platform === 'windows' && pool.gitBashPath) {
+            // Git Bash terminal: cd in the /c/Users/… mount form
+            full = `cd ${shq(toShellPath(cwd))} && ${cmd}`
+          } else if (!cwd.includes('\\')) {
+            full = `cd ${shq(cwd)} && ${cmd}`
+          }
+        }
         try {
           const res = await pool.exec(full, { timeoutMs: config.commandTimeoutMs, pty: !!args.pty, env: args.env })
           audit('exec', cmd, res.code)
@@ -1689,19 +1958,30 @@ export async function apply(ctx, config) {
     ctx.tools.register(t)
   }
 
-  // ── system-prompt injection: the current remote workspace ─────────────────
+  // ── system-prompt injection: session-aware remote workspace ──────────────
+  // Issue #13: remote context must be SESSION-scoped, not machine-global.
+  // The section text is evaluated per assembly with the current agent's
+  // session; it is injected ONLY when that session's cwd actually maps to a
+  // dsh-remote mirror (i.e. the user picked a remote workspace as the session
+  // workspace). A plain local session gets no remote section — saved machines
+  // never leak their workspace into an unrelated local session's prompt.
+  // (resolveMirrorForLocal is defined above, next to wsPath.)
   ctx.systemPrompt.section({
     name: 'dsh-remote',
     order: 88,
-    text: () => {
-      const w = wsPath()
-      if (!w || !config.host) return ''
+    text: (promptContext) => {
+      const agent = promptContext && promptContext.agent
+      const session = agent && agent.session
+      const cwd = session && session.header && session.header.cwd
+      if (!cwd) return '' // no session cwd → nothing to map → stay quiet
+      const { remotePath } = resolveMirrorForLocal(cwd)
+      if (!remotePath) return '' // this session is NOT a remote session (issue #13)
       const fwd = forwards.list().filter((f) => f.active).map((f) => `${f.direction}:127.0.0.1:${f.listenPort}→${f.targetHost}:${f.targetPort}`)
       let extra = ''
       if (fwd.length) extra = `\nActive port forwards: ${fwd.join(', ')}`
       return (
         '## Remote workspace\n' +
-        `Current remote workspace: ${config.username}@${config.host}:${w}\n` +
+        `Current remote workspace: ${config.username || 'user'}@${config.host}:${toDisplayPath(remotePath, pool.platform)}\n` +
         'Use the rw_* tools (rw_list_dir / rw_read_file / rw_write_file / rw_edit / rw_exec / rw_search / rw_sync / rw_push) to inspect and act on files on the remote host. Treat this directory as the working root for this task.' +
         extra
       )
@@ -1852,15 +2132,23 @@ export async function apply(ctx, config) {
       kind: 'exact',
       path: '/dsh-remote/status',
       handler: async (req, res) => {
-        if (req.method === 'GET') return sendJson(res, 200, status())
+        if (req.method === 'GET') {
+          const q = new URL(req.url, 'http://localhost').searchParams
+          const sessionId = q.get('sessionId') ? decodeURIComponent(q.get('sessionId')) : ''
+          // Per-session remote context (issue #13): when a sessionId is given,
+          // sessionMode reflects THAT session's cwd, not the machine default.
+          return sendJson(res, 200, sessionId ? { ...status(), sessionMode: sessionRemotePath(sessionId) ? 'remote' : 'local', sessionRemotePath: sessionRemotePath(sessionId) } : status())
+        }
         sendJson(res, 405, { error: 'method not allowed' })
       },
     },
     {
       // Map a LOCAL path (typically a session cwd that sits inside a remote
       // mirror dir) to the remote path it mirrors, by reading each mirror
-      // dir's .dsh-remote-meta.json. Falls back to the machine workspace so
-      // the sidebar still shows something sensible for non-mirror cwds.
+      // dir's .dsh-remote-meta.json. NO machine-workspace fallback (issue #13):
+      // a session whose cwd is not inside any mirror is a pure LOCAL session —
+      // the sidebar must show "no remote workspace", never another machine's
+      // remembered default.
       // Accepts either ?local=<abs path> or ?sessionId=<id> (resolved via
       // the host sessions service header.cwd).
       kind: 'exact',
@@ -1909,7 +2197,6 @@ export async function apply(ctx, config) {
               } catch { /* session log scan failed */ }
             }
           }
-          const remote = status().workspace || ''
           const root = remoteWorkspacesRoot()
           const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '') || ''
           let matched = ''
@@ -1936,8 +2223,16 @@ export async function apply(ctx, config) {
               }
             }
           }
-          const remotePath = matchedRemote || remote
-          return sendJson(res, 200, { local, remotePath, mirrorDir: matched || null, fallback: !matchedRemote, resolvedVia })
+          // Issue #13: a non-mirror session is LOCAL — remotePath stays empty.
+          const remotePath = matchedRemote || ''
+          return sendJson(res, 200, {
+            local, remotePath, mirrorDir: matched || null,
+            // `fallback:true` now means "this session is NOT a remote session"
+            // (used to mean "fell back to machine workspace").
+            fallback: !matchedRemote,
+            mode: matchedRemote ? 'remote' : 'local',
+            resolvedVia,
+          })
         } catch (err) {
           return sendJson(res, 500, { error: String((err && err.message) || err) })
         }
@@ -1970,10 +2265,29 @@ export async function apply(ctx, config) {
       path: '/dsh-remote/ls',
       handler: async (req, res) => {
         try {
+          await pool.detect()
           const q = new URL(req.url, 'http://localhost').searchParams
-          const p = q.get('path') ? decodeURIComponent(q.get('path')) : wsPath()
-          const out = await listDirStructured(p || '/')
-          return sendJson(res, 200, { path: out.path, items: out.items })
+          const raw = q.get('path') ? decodeURIComponent(q.get('path')) : wsPath()
+          const canon = normalizeRemotePath(raw)
+          const win = pool.platform === 'windows'
+          // Windows root → "This PC" drive view (C:\ D:\ E:\), not the Git-Bash
+          // MSYS root. When the platform probe was inconclusive we still try — a
+          // real Windows box answers fsutil, a POSIX box yields no letters and
+          // falls through to the normal root listing.
+          if (canon === '/' || raw === '' || raw === '/') {
+            if (win || pool.platform !== 'posix') {
+              const drives = await listRemoteDrives()
+              if (drives.length) return sendJson(res, 200, { path: '', platform: 'windows', items: drives })
+            }
+            if (win) return sendJson(res, 200, { path: '', platform: 'windows', items: [] })
+          }
+          const out = await listDirStructured(canon)
+          const items = out.items.map((it) => ({
+            ...it,
+            // full display-form path so the client never joins paths itself
+            path: toDisplayPath(joinRemotePath(canon, it.name), pool.platform),
+          }))
+          return sendJson(res, 200, { path: toDisplayPath(out.path, pool.platform), platform: win ? 'windows' : 'posix', items })
         } catch (err) {
           return sendJson(res, 500, { error: String((err && err.message) || err) })
         }
@@ -2347,9 +2661,13 @@ export async function apply(ctx, config) {
                 rec.password = prev.password
               }
               if (i >= 0) machines[i] = rec; else machines.push(rec)
-              if (!store.currentId) store.currentId = id
-              saveMachines(machines, store.currentId)
-              if (store.currentId === id) await applyActiveMachine()
+              // Issue #13: saving a machine must NOT make it the active
+              // remote context. `currentId` stays untouched on add/update —
+              // only an explicit "设为当前" (or rw_connect) activates one.
+              // keepCurrentKey:false leaves the stored `currentId` byte-for-byte
+              // alone, so a fresh registry stays "no choice yet" (not an
+              // explicit none) and a previously-cleared registry stays cleared.
+              saveMachines(machines, store.currentId, false)
               return sendJson(res, 200, { ok: true, machine: sanitizeMachine(rec), machines: machines.map(sanitizeMachine), currentId: store.currentId })
             }
             if (action === 'delete') {
@@ -2360,9 +2678,17 @@ export async function apply(ctx, config) {
                 await deleteSecret(m.id, secretsDir()).catch(() => {})
               }
               machines.splice(i, 1)
-              if (store.currentId === body.id) store.currentId = machines[0] ? machines[0].id : null
-              saveMachines(machines, store.currentId)
-              if (store.currentId) await applyActiveMachine()
+              const wasCurrent = store.currentId === m.id
+              if (wasCurrent) {
+                // Issue #13: deleting the current machine leaves NO active
+                // remote context (never auto-promote a sibling — that would
+                // make an unrelated machine leak into the session again).
+                store.currentId = null
+                saveMachines(machines, null)
+                await clearActiveMachine()
+              } else {
+                saveMachines(machines, store.currentId)
+              }
               return sendJson(res, 200, { ok: true, machines: machines.map(sanitizeMachine), currentId: store.currentId })
             }
             return sendJson(res, 400, { ok: false, error: 'unknown action' })
@@ -2409,7 +2735,7 @@ export async function apply(ctx, config) {
             machines[mi].latencyMs = latencyMs
             saveMachines(machines, store.currentId)
           }
-          return sendJson(res, 200, { ok: true, host: probe.config.host, user: probe.config.username, latencyMs, lastConnectedAt: new Date().toISOString() })
+          return sendJson(res, 200, { ok: true, host: probe.config.host, user: probe.config.username, latencyMs, lastConnectedAt: new Date().toISOString(), platform: probe.platform, shell: probe.shellMode, gitBash: probe.gitBashPath || '' })
         } catch (err) {
           return sendJson(res, 200, { ok: false, error: friendlyMessage(err, { host: body && body.host, port: body && body.port }) })
         }
@@ -2422,7 +2748,14 @@ export async function apply(ctx, config) {
         if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
         try {
           const body = JSON.parse((await readBody(req)) || '{}')
-          const okSet = await setCurrent(String(body.id || ''))
+          const id = String(body.id || '').trim()
+          // Issue #13: an empty id is an explicit "active remote = none" —
+          // saved machines stay in the registry but nothing is current.
+          if (!id) {
+            await setCurrent('')
+            return sendJson(res, 200, { ok: true, currentId: null, ...status() })
+          }
+          const okSet = await setCurrent(id)
           if (!okSet) return sendJson(res, 404, { ok: false, error: 'machine not found' })
           return sendJson(res, 200, { ok: true, ...status() })
         } catch (err) {