dsh-remote 0.8.49 → 0.8.50

package/README.md

@@ -53,6 +53,7 @@ DSH 的 Web 界面刻意只监听 `127.0.0.1`（CLI 为安全拒绝 `--host 0.0.
 - **Windows 主机** —— 自动探测平台并定位 Git Bash，命令经 `bash -s` 走 stdin 执行，不受引号/反斜杠转义困扰（`config.shell` 可指定或设 `native` 关闭）；`C:\Users\dev` 与 `/c/Users/dev` 两种写法都接受。
 - **长任务异步化** —— `rw_sync`/`rw_push` 传 `async: true` 返回 `taskId`，可查询进度/结果/取消。
 - **数据跟随 Harness 根目录** —— 机器清单与镜像在 `$DSH_HOME/remote-workspaces`；0.6 之前的数据首次启动自动迁移。
+- **`~/.ssh/config` 是连接四字段的唯一来源**（`0.8.50+`，issue #50）—— 保存机器时把 主机/用户/端口/私钥 写入 `~/.ssh/config` 的受管块（`# dsh-remote: managed` 标记，只动自己的块；你手写的同名 Host 块绝不覆盖，会提示冲突）。之后**改这个文件立即生效**：任何 Host 块点名的主机（含字面 IP），连接都按文件解析（裸 `Host *` 是通用默认，不算点名）；机器记录里的副本只做兜底，插件自己的状态（最近工作区/延迟等）仍存注册表。
 - **不改动 `dsh-workspace` 官方代码** —— 全部作为普通插件实现。
 
 ## 安装

package/lib/client.js

@@ -73,6 +73,7 @@ window.__ModuleLoader__.load({
         'settings.sshAliasHint': '别名模式：机器只记住「{alias}」这个名字，主机/用户/端口/私钥/跳板每次连接都从 ~/.ssh/config 实时解析（改配置立刻生效）。',
         'settings.useSshConfig': '使用 ~/.ssh/config 别名（只存别名，不存副本）',
         'settings.useSshConfigHint': '留空或保持默认的字段（用户 root、端口 22、私钥、跳板）将从 ~/.ssh/config 实时解析；填了非默认值则覆盖。',
+        'settings.saveWritesSshConfig': '保存时会把 主机/用户/端口/私钥 写入 ~/.ssh/config 的受管块（# dsh-remote: managed 标记）；此后该文件优先——直接改它立即生效。',
         'settings.sshResolvedTo': '→ {user}@{host}:{port}',
         'settings.sshResolvedNone': '~/.ssh/config 中没有匹配「{alias}」的 Host 条目',
         'settings.sshResolvedWarn': '注意：{msg}',
@@ -360,6 +361,7 @@ window.__ModuleLoader__.load({
         'settings.sshAliasHint': 'Alias mode: the machine remembers only the name "{alias}"; host/user/port/key/jump host are resolved from ~/.ssh/config at every connect, so editing that file takes effect immediately.',
         'settings.useSshConfig': 'Use a ~/.ssh/config alias (keep the alias, not a copy)',
         'settings.useSshConfigHint': 'Fields left empty or at their default (user root, port 22, key, jump host) come from ~/.ssh/config at connect time; a non-default value overrides it.',
+        'settings.saveWritesSshConfig': 'Saving writes host/user/port/key into a managed block in ~/.ssh/config (marked # dsh-remote: managed); the file then takes precedence — edit it directly and it takes effect at once.',
         'settings.sshResolvedTo': '→ {user}@{host}:{port}',
         'settings.sshResolvedNone': 'no ~/.ssh/config block matches "{alias}"',
         'settings.sshResolvedWarn': 'Heads-up: {msg}',
@@ -1269,9 +1271,12 @@ window.__ModuleLoader__.load({
                   React.createElement('div', { style: { display: 'flex', gap: 6, alignItems: 'center', flexWrap: 'wrap' } },
                     React.createElement('span', { style: { fontWeight: 600 } }, m.name),
                     React.createElement('code', { style: { fontSize: 12, opacity: 0.8 } },
-                      m.useSshConfig ? (m.host + (m.sshConfigResolved && m.sshConfigResolved.matched ? '  ' + tr('settings.sshResolvedTo', { user: m.sshConfigResolved.username || '?', host: m.sshConfigResolved.host, port: m.sshConfigResolved.port }) : ''))
-                        : (m.username + '@' + m.host + ':' + m.port)),
-                    m.useSshConfig ? pill('', tr('settings.badgeSshConfig')) : null,
+                      (m.sshConfigResolved && m.sshConfigResolved.matched)
+                        // Issue #50: shown for literal machines too — a Host
+                        // block naming this machine's host now drives it.
+                        ? (m.host + '  ' + tr('settings.sshResolvedTo', { user: m.sshConfigResolved.username || m.username || '?', host: m.sshConfigResolved.host, port: m.sshConfigResolved.port || m.port }))
+                        : (m.useSshConfig ? m.host : (m.username + '@' + m.host + ':' + m.port))),
+                    (m.useSshConfig || (m.sshConfigResolved && m.sshConfigResolved.matched)) ? pill('', tr('settings.badgeSshConfig')) : null,
                     // Issue #51: a machine on the system-OpenSSH backend behaves
                     // differently enough (auth from ~/.ssh/config, GSSAPI) that
                     // the row must say so.
@@ -1314,6 +1319,9 @@ window.__ModuleLoader__.load({
           row(tr('settings.host'), React.createElement('input', { className: 'dsh-rw-input', value: form.host, onChange: setF('host'), placeholder: form.useSshConfig ? tr('settings.sshImport') + ' Host 别名' : 'IP or hostname', style: inputS }), 'h'),
           row(tr('settings.useSshConfig'), React.createElement('input', { type: 'checkbox', checked: !!form.useSshConfig, onChange: setFb('useSshConfig') }), 'sshc'),
           form.useSshConfig ? React.createElement('div', { style: { fontSize: 11, opacity: 0.8, marginBottom: 8, lineHeight: 1.5 } }, tr('settings.useSshConfigHint')) : null,
+          // Issue #50: a literal save also touches ~/.ssh/config (managed
+          // block) — say so where the choice is made.
+          !form.useSshConfig ? React.createElement('div', { style: { fontSize: 11, opacity: 0.8, marginBottom: 8, lineHeight: 1.5 } }, tr('settings.saveWritesSshConfig')) : null,
           form.useSshConfig ? (() => {
             // Preview where the alias points, from the same resolution the
             // connect path uses (the host list carries it — issue #38).

package/lib/index.js

@@ -34,7 +34,7 @@ import {
 import { createHostKeyGuard, isHostKeyKnown as _isHostKeyKnown } from './hostkey.js'
 import { compileIgnore, ignorePatternsFor, DEFAULT_IGNORE } from './ignore.js'
 import { friendlyMessage } from './errors.js'
-import { importableEntries, sshConfigPath, readSshConfigText, resolveMachineSshConfig } from './sshconfig.js'
+import { importableEntries, sshConfigPath, readSshConfigText, resolveMachineSshConfig, resolveLiteralSshConfig, readRawSshConfig, upsertManagedHostBlock, removeManagedHostBlock, writeSshConfig } 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'
@@ -431,25 +431,49 @@ export async function apply(ctx, config) {
    * keychain lookups and the settings UI keep working.
    */
   const loggedSshWarnings = new Map()
-  const withSshConfig = (m) => {
-    // Short-circuit BEFORE reading ~/.ssh/config: a deployment with no alias
-    // machine must never touch that file, and the 2s text memo must not be
-    // primed by unrelated machines.
-    if (!m || !m.useSshConfig) return m
-    const resolved = resolveMachineSshConfig(m, { text: sshConfigText() })
-    if (!resolved) return m
-    // Warn once per distinct warning set: this runs on every tool call, and an
-    // unmatched alias would otherwise fill the log with the same line.
-    const signature = resolved.warnings.join(' | ')
-    if (signature && loggedSshWarnings.get(resolved.alias) !== signature) {
-      loggedSshWarnings.set(resolved.alias, signature)
+  const warnSshOnce = (alias, warnings) => {
+    // Warn once per distinct warning set: withSshConfig runs on every tool
+    // call, and an unmatched alias would otherwise fill the log with the same
+    // line.
+    const signature = warnings.join(' | ')
+    if (signature && loggedSshWarnings.get(alias) !== signature) {
+      loggedSshWarnings.set(alias, signature)
       try {
         const logger = typeof ctx.get === 'function' ? ctx.get('logger') : undefined
         if (logger && typeof logger.warn === 'function') {
-          logger.warn(`[dsh-remote] ssh-config alias "${resolved.alias}": ${resolved.warnings.join(' ')}`)
+          logger.warn(`[dsh-remote] ssh-config alias "${alias}": ${warnings.join(' ')}`)
         }
       } catch { /* logging is best-effort */ }
     }
+  }
+  const withSshConfig = (m) => {
+    if (!m) return m
+    // Issue #50: ~/.ssh/config wins for ANY host it names, not only alias
+    // machines. A literal machine's stored host/user/port/key is a COPY that
+    // goes stale the moment the file is edited; when a Host block names the
+    // machine's host (a bare `Host *` does not name it), the file's values
+    // take over and the record fills the gaps.
+    if (!m.useSshConfig) {
+      const lit = resolveLiteralSshConfig(m, { text: sshConfigText() })
+      if (!lit) return m
+      warnSshOnce(lit.alias, lit.warnings)
+      return {
+        ...m,
+        sshConfigMatched: true,
+        sshConfigWarnings: lit.warnings,
+        // The name the user typed, kept for the system-OpenSSH backend: ssh
+        // must match its Host blocks against exactly this (connectTargetFor).
+        sshConfigName: m.host,
+        host: lit.host || m.host,
+        port: lit.port || m.port,
+        username: lit.username || m.username,
+        privateKeyPath: lit.privateKeyPath || m.privateKeyPath,
+        proxy: lit.proxy || m.proxy,
+      }
+    }
+    const resolved = resolveMachineSshConfig(m, { text: sshConfigText() })
+    if (!resolved) return m
+    warnSshOnce(resolved.alias, resolved.warnings)
     return {
       ...m,
       sshAlias: resolved.alias,
@@ -483,7 +507,10 @@ export async function apply(ctx, config) {
    * @returns {{host: string, port: number, username: string, privateKeyPath: string, proxy: object|undefined, aliasNative: boolean}}
    */
   const connectTargetFor = (eff) => {
-    const aliasNative = !!(eff && eff.useSshConfig && isSystemOpenSshBackend(eff))
+    // Issue #50: a LITERAL machine whose host a Host block names is in the same
+    // position as an alias machine on the OpenSSH backend — ssh must match its
+    // blocks against the ORIGINAL name, so it is handed over verbatim too.
+    const aliasNative = !!(eff && isSystemOpenSshBackend(eff) && (eff.useSshConfig || eff.sshConfigMatched))
     if (!aliasNative) {
       return {
         host: String((eff && eff.host) || ''),
@@ -494,7 +521,7 @@ export async function apply(ctx, config) {
         aliasNative: false,
       }
     }
-    const alias = String((eff && (eff.sshAlias || eff.host)) || '')
+    const alias = String((eff && (eff.sshAlias || eff.sshConfigName || eff.host)) || '')
     return {
       // The alias itself; ssh expands HostName/User/Port/IdentityFile and every
       // other directive while matching that Host block.
@@ -511,13 +538,14 @@ export async function apply(ctx, config) {
   const aliasOf = (m) => (m && m.sshAlias) || (m && m.useSshConfig ? String(m.host || '') : '')
 
   /** Machines as the settings UI sees them: secrets stripped, plus the
-   *  ~/.ssh/config resolution of an alias machine so a row can show where the
-   *  alias actually points without duplicating those values in the registry
-   *  (issue #38). */
+   *  ~/.ssh/config resolution of an alias machine (issue #38) — and, since
+   *  issue #50, of a LITERAL machine whose host a Host block names, so the row
+   *  can show that the file now drives it. */
   const machinesForClient = () => machines.map((m) => ({
     ...sanitizeMachine(m),
-    // Read ~/.ssh/config only when a machine actually uses an alias.
-    sshConfigResolved: m.useSshConfig ? resolveMachineSshConfig(m, { text: sshConfigText() }) : null,
+    sshConfigResolved: m.useSshConfig
+      ? resolveMachineSshConfig(m, { text: sshConfigText() })
+      : resolveLiteralSshConfig(m, { text: sshConfigText() }),
   }))
 
   /**
@@ -3090,12 +3118,49 @@ export async function apply(ctx, config) {
               // 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)
+              // Issue #50: host/user/port/key have ONE home — ~/.ssh/config.
+              // Saving a literal machine upserts a marker-tagged Host block,
+              // so the file and the registry can never drift; the record's
+              // copy remains only as a fallback for a missing/renamed block.
+              // A Host block the USER wrote for the same name is never
+              // touched — the conflict is reported instead. Failures here are
+              // best-effort: the registry copy is already saved.
+              let sshConfigWarning = ''
+              if (!rec.useSshConfig) {
+                try {
+                  const raw = readRawSshConfig(sshConfigPath())
+                  let next = upsertManagedHostBlock(raw, {
+                    alias: rec.host,
+                    hostName: rec.host,
+                    user: rec.username,
+                    port: rec.port,
+                    identityFile: rec.privateKeyPath,
+                  })
+                  // A RENAMED machine leaves the old managed block behind, and
+                  // that block is the plugin's own artifact of the edit —
+                  // retire it. (Deleting a machine removes nothing: the Host
+                  // block is the user's ssh access, not plugin state.)
+                  if (prev && prev.host && prev.host !== rec.host && !prev.useSshConfig) {
+                    const rm = removeManagedHostBlock(next.text, prev.host)
+                    next = { status: rm.status === 'removed' && next.status === 'unchanged' ? 'updated' : next.status, text: rm.text }
+                  }
+                  if (next.status === 'conflict') {
+                    sshConfigWarning = `~/.ssh/config already names "${rec.host}" in a Host block that is not managed by dsh-remote — it was left untouched, and it now wins over the saved copy.`
+                  } else if (next.status === 'appended' || next.status === 'updated') {
+                    writeSshConfig(next.text, sshConfigPath())
+                    sshConfigCache = { text: '', at: 0 }
+                  }
+                } catch (sshErr) {
+                  sshConfigWarning = `could not update ~/.ssh/config (${String((sshErr && sshErr.message) || sshErr)}); the registry copy was saved.`
+                }
+              }
               return sendJson(res, 200, {
                 ok: true,
                 machine: sanitizeMachine(rec),
                 machines: machinesForClient(),
                 currentId: store.currentId,
                 ...(warning ? { warning, warningDetail } : {}),
+                ...(sshConfigWarning ? { sshConfigWarning } : {}),
               })
             }
             if (action === 'delete') {
@@ -3154,6 +3219,12 @@ export async function apply(ctx, config) {
                 useSshConfig: true,
               }, { text: sshConfigText() })
             : null
+          // Issue #50: a LITERAL host named by a Host block resolves through
+          // the file as well — the probe must dial what a real connect would.
+          const literalTarget = !body.useSshConfig
+            ? resolveLiteralSshConfig({ host: String(body.host || '') }, { text: sshConfigText() })
+            : null
+          const probeTarget = aliasTarget || literalTarget
           // Issue #51: on the system-OpenSSH backend an alias is handed to `ssh`
           // VERBATIM (see connectTargetFor) — resolving it here would stop the
           // `Host` block from matching, so the ~/.ssh/config settings the probe
@@ -3161,13 +3232,13 @@ export async function apply(ctx, config) {
           const probe = createPool({
             ...config,
             backend: probeBackend,
-            host: aliasTarget && !probeIsOpenssh ? aliasTarget.host : String(body.host || config.host),
-            port: aliasTarget && !probeIsOpenssh ? aliasTarget.port : (Number(body.port) || config.port),
-            username: aliasTarget && !probeIsOpenssh ? aliasTarget.username : String(body.username || config.username),
+            host: probeTarget && !probeIsOpenssh ? probeTarget.host : String(body.host || config.host),
+            port: (probeTarget && !probeIsOpenssh && probeTarget.port) ? probeTarget.port : (Number(body.port) || config.port),
+            username: (probeTarget && !probeIsOpenssh && probeTarget.username) ? probeTarget.username : String(body.username || config.username),
             password: String(body.password || ''),
-            privateKeyPath: (aliasTarget && !probeIsOpenssh) ? aliasTarget.privateKeyPath : String(body.privateKeyPath || config.privateKeyPath),
+            privateKeyPath: (probeTarget && !probeIsOpenssh && probeTarget.privateKeyPath) ? probeTarget.privateKeyPath : String(body.privateKeyPath || config.privateKeyPath),
             passphrase: String(body.passphrase || ''),
-            proxy: (aliasTarget && !probeIsOpenssh && aliasTarget.proxy) ? aliasTarget.proxy : (body.proxy && body.proxy.host ? {
+            proxy: (probeTarget && !probeIsOpenssh && probeTarget.proxy) ? probeTarget.proxy : (body.proxy && body.proxy.host ? {
               host: String(body.proxy.host),
               port: Number(body.proxy.port) || 22,
               username: String(body.proxy.username || ''),

package/lib/sshconfig.js

@@ -28,7 +28,7 @@
 // The module is pure (I/O is injectable), so it is unit-testable without a real
 // home directory — see test/sshconfig.test.js.
 
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, chmodSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
 
@@ -362,23 +362,14 @@ export function parseProxyJump(value) {
 }
 
 /**
- * Connect target for an ssh-config alias: the shape the plugin's pool expects.
+ * Shared proxy/warning shaping for alias and literal resolutions (issue #50).
  *
  * `ProxyJump` maps onto the plugin's single jump host. A multi-hop chain cannot
  * be represented by one `proxy`, so the FIRST hop is used and `warnings` says so
  * — silently connecting through the wrong path would be worse. `ProxyCommand`
  * (an arbitrary local command) is reported but never executed.
- *
- * @param {string} alias
- * @param {object} [opts]
- * @param {string} [opts.text] - config text (else the real file is read).
- * @param {string} [opts.file]
- * @param {object} [opts.io]
- * @returns {{alias: string, matched: boolean, host: string, port: number, username: string, privateKeyPath: string, proxy: object|undefined, proxyJump: string, warnings: string[]}}
  */
-export function sshAliasTarget(alias, opts = {}) {
-  const text = opts.text !== undefined ? String(opts.text) : loadSshConfigText(opts.file || sshConfigPath(), opts.io || {})
-  const resolved = resolveSshHost(alias, text)
+function targetFromResolved(resolved, text, { defaultPort }) {
   const warnings = []
   let proxy
   const hops = parseProxyJump(resolved.proxyJump)
@@ -400,10 +391,10 @@ export function sshAliasTarget(alias, opts = {}) {
     warnings.push('ProxyCommand is not supported by dsh-remote (no jump host was applied).')
   }
   return {
-    alias,
+    alias: resolved.alias,
     matched: resolved.matched,
-    host: resolved.hostName || alias,
-    port: resolved.port || 22,
+    host: resolved.hostName || resolved.alias,
+    port: resolved.port || defaultPort,
     username: resolved.user || '',
     privateKeyPath: resolved.identityFile ? expandHome(resolved.identityFile) : '',
     proxy,
@@ -412,6 +403,72 @@ export function sshAliasTarget(alias, opts = {}) {
   }
 }
 
+/**
+ * Connect target for an ssh-config alias: the shape the plugin's pool expects.
+ *
+ * @param {string} alias
+ * @param {object} [opts]
+ * @param {string} [opts.text] - config text (else the real file is read).
+ * @param {string} [opts.file]
+ * @param {object} [opts.io]
+ * @returns {{alias: string, matched: boolean, host: string, port: number, username: string, privateKeyPath: string, proxy: object|undefined, proxyJump: string, warnings: string[]}}
+ */
+export function sshAliasTarget(alias, opts = {}) {
+  const text = opts.text !== undefined ? String(opts.text) : loadSshConfigText(opts.file || sshConfigPath(), opts.io || {})
+  return targetFromResolved(resolveSshHost(alias, text), text, { defaultPort: 22 })
+}
+
+/**
+ * Effective connect identity for a LITERAL machine (issue #50).
+ *
+ * A machine saved with literal host/user/port/key holds a COPY of what may also
+ * be written in ~/.ssh/config, and the copy goes stale the moment the file is
+ * edited. The file is the single source for any host it NAMES: when a Host
+ * block matches the machine's literal host — with at least one positive pattern
+ * that is not the bare `*` — the resolved values win per field and the record
+ * fills the gaps. A bare `Host *` block deliberately does NOT name a host:
+ * treating universal defaults as an override would hijack every saved machine
+ * at once. Group patterns (`*.corp`, `web-?`) DO name hosts, exactly as ssh
+ * itself applies them to a literal dial.
+ *
+ * `port` is 0 (not 22) when the file says nothing, so the caller falls back to
+ * the record instead of the default.
+ *
+ * @param {object} machine - a registry record with a literal `host`.
+ * @param {{text?: string, file?: string, io?: object}} [opts]
+ * @returns {null | {alias: string, matched: true, host: string, port: number, username: string, privateKeyPath: string, proxy: object|undefined, proxyJump: string, warnings: string[]}}
+ *   null when no Host block names the machine's host.
+ */
+export function resolveLiteralSshConfig(machine, opts = {}) {
+  if (!machine || machine.useSshConfig) return null
+  const name = String(machine.host || '').trim()
+  if (!name) return null
+  const text = opts.text !== undefined ? String(opts.text) : loadSshConfigText(opts.file || sshConfigPath(), opts.io || {})
+  const resolved = {
+    alias: name, matched: false, hostName: '', user: '', port: 0,
+    identityFile: '', proxyJump: '', proxyCommand: '', identitiesOnly: '',
+  }
+  for (const block of parseHostBlocks(text)) {
+    if (!hostBlockMatches(block.patterns, name)) continue
+    const positive = block.patterns.filter((p) => !p.startsWith('!'))
+    // A block whose only positive pattern is the bare `*` is a defaults block,
+    // not a block that names this host.
+    if (positive.length && positive.every((p) => p === '*')) continue
+    resolved.matched = true
+    for (const [key, value] of Object.entries(block.values)) {
+      if (key === 'hostname') { if (!resolved.hostName) resolved.hostName = String(value) }
+      else if (key === 'user') { if (!resolved.user) resolved.user = String(value) }
+      else if (key === 'port') { if (!resolved.port) resolved.port = Number(value) || 0 }
+      else if (key === 'identityfile') { if (!resolved.identityFile) resolved.identityFile = String(value) }
+      else if (key === 'proxyjump') { if (!resolved.proxyJump) resolved.proxyJump = String(value) }
+      else if (key === 'proxycommand') { if (!resolved.proxyCommand) resolved.proxyCommand = String(value) }
+      else if (key === 'identitiesonly') { if (!resolved.identitiesOnly) resolved.identitiesOnly = String(value) }
+    }
+  }
+  if (!resolved.matched) return null
+  return targetFromResolved(resolved, text, { defaultPort: 0 })
+}
+
 /**
  * Effective connect identity for a saved machine.
  *
@@ -452,3 +509,187 @@ export function resolveMachineSshConfig(machine, opts = {}) {
 function compareText(left, right) {
   return left < right ? -1 : left > right ? 1 : 0
 }
+
+// ── Writing: the managed Host block (issue #50) ─────────────────────────────
+//
+// The four connection fields (host/user/port/key) have ONE home: ~/.ssh/config.
+// When the plugin saves a literal machine it upserts a Host block tagged with
+// MANAGED_MARK, so the file and the registry can never drift — and so the
+// plugin can tell ITS OWN block apart from one the user wrote. Two rules keep
+// the file safe:
+//   • a Host block without the marker is never touched — a same-named user
+//     block is a CONFLICT, reported to the caller instead of overwritten;
+//   • inside a managed block, lines the plugin does not own (a user-added
+//     `ForwardAgent yes`, a comment) survive an update — only the four known
+//     parameters are rewritten.
+
+/** Marker comment that tags a Host block as owned by dsh-remote. */
+export const MANAGED_MARK = '# dsh-remote: managed'
+
+/** Parameters the managed block rewrites (lowercase). */
+const MANAGED_PARAMS = new Set(['hostname', 'user', 'port', 'identityfile'])
+
+/** Read the RAW config text — no Include expansion (a write targets ONE file). */
+export function readRawSshConfig(filePath = sshConfigPath()) {
+  try {
+    const text = readFileSync(filePath, 'utf8')
+    return typeof text === 'string' ? text : ''
+  } catch {
+    return ''
+  }
+}
+
+/** Quote one value for a config line when it contains whitespace. */
+function quoteCfg(value) {
+  const s = String(value)
+  return /[\s#]/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s
+}
+
+/** The values a managed block must carry for these fields ('' = omit). */
+function desiredValues(fields) {
+  const alias = String(fields.alias || '').trim()
+  const hostName = String(fields.hostName || '').trim()
+  const port = Number(fields.port) || 0
+  return {
+    hostname: hostName && hostName !== alias ? hostName : '',
+    user: String(fields.user || '').trim(),
+    port: port && port !== 22 ? port : '',
+    identityfile: String(fields.identityFile || '').trim(),
+  }
+}
+
+/** Render the owned body lines of a managed block. */
+function desiredLines(fields) {
+  const want = desiredValues(fields)
+  const out = []
+  if (want.hostname) out.push(`  HostName ${quoteCfg(want.hostname)}`)
+  if (want.user) out.push(`  User ${quoteCfg(want.user)}`)
+  if (want.port) out.push(`  Port ${want.port}`)
+  if (want.identityfile) out.push(`  IdentityFile ${quoteCfg(want.identityfile)}`)
+  return out
+}
+
+/**
+ * Locate the MANAGED Host block for `alias` in raw config lines.
+ * The marker must be the nearest non-blank line above the Host line; a block
+ * that names the alias without the marker is the user's, not ours.
+ */
+function locateManagedBlock(lines, alias) {
+  const wanted = alias.toLowerCase()
+  for (let i = 0; i < lines.length; i += 1) {
+    const m = lines[i].match(/^\s*host\s+(.+?)\s*$/i)
+    if (!m) continue
+    const names = splitValue(m[1]).map((p) => p.toLowerCase())
+    if (!names.includes(wanted)) continue
+    let j = i - 1
+    while (j >= 0 && lines[j].trim() === '') j -= 1
+    if (j < 0 || lines[j].trim().toLowerCase() !== MANAGED_MARK) continue
+    let end = lines.length
+    for (let k = i + 1; k < lines.length; k += 1) {
+      if (/^\s*(host|match)\s/i.test(lines[k])) { end = k; break }
+    }
+    return { markerLine: j, hostLine: i, end }
+  }
+  return null
+}
+
+/** Whether an UNMANAGED Host block names `alias` (exact token, case-insensitive). */
+function hasUnmanagedConflict(lines, alias) {
+  const wanted = alias.toLowerCase()
+  for (let i = 0; i < lines.length; i += 1) {
+    const m = lines[i].match(/^\s*host\s+(.+?)\s*$/i)
+    if (!m) continue
+    const names = splitValue(m[1]).map((p) => p.toLowerCase())
+    if (!names.includes(wanted)) continue
+    let j = i - 1
+    while (j >= 0 && lines[j].trim() === '') j -= 1
+    if (j >= 0 && lines[j].trim().toLowerCase() === MANAGED_MARK) continue // ours
+    return true
+  }
+  return false
+}
+
+/**
+ * Insert or refresh the managed Host block for a saved machine.
+ *
+ * @param {string} rawText - the RAW ~/.ssh/config text ('' when absent).
+ * @param {{alias: string, hostName?: string, user?: string, port?: number|string, identityFile?: string}} fields
+ * @returns {{status: 'appended'|'updated'|'unchanged'|'conflict'|'invalid', text: string}}
+ *   'conflict' — an unmanaged block already names the alias (text untouched);
+ *   'invalid' — the alias can never be a safe Host token (space/wildcard).
+ */
+export function upsertManagedHostBlock(rawText, fields) {
+  const text = String(rawText || '')
+  const alias = String((fields && fields.alias) || '').trim()
+  if (!alias || /[\s*?!,]/.test(alias)) return { status: 'invalid', text }
+  const lines = text.split('\n')
+  if (hasUnmanagedConflict(lines, alias)) return { status: 'conflict', text }
+
+  const want = desiredValues({ ...fields, alias })
+  const found = locateManagedBlock(lines, alias)
+  if (!found) {
+    const block = [MANAGED_MARK, `Host ${alias}`, ...desiredLines({ ...fields, alias })]
+    const trimmedEnd = text.replace(/\s+$/, '')
+    const prefix = trimmedEnd === '' ? '' : trimmedEnd + '\n\n'
+    return { status: 'appended', text: prefix + block.join('\n') + '\n' }
+  }
+
+  // Compare what the block HAS with what it MUST have; a rewrite that changes
+  // nothing would only cost the file's mtime.
+  const current = parseHostBlocks(lines.slice(found.hostLine, found.end).join('\n'))[0]
+  const cur = (current && current.values) || {}
+  const same = ['hostname', 'user', 'port', 'identityfile']
+    .every((k) => String(cur[k] ?? '') === String(want[k] ?? ''))
+  if (same) return { status: 'unchanged', text }
+
+  // Rewrite only the four owned parameters; user lines inside OUR block stay.
+  const body = lines.slice(found.hostLine + 1, found.end)
+  const kept = body.filter((l) => {
+    const m = l.match(/^\s*(\S+)\s/)
+    return !m || !MANAGED_PARAMS.has(m[1].toLowerCase())
+  })
+  const next = [
+    ...lines.slice(0, found.hostLine + 1),
+    ...desiredLines({ ...fields, alias }),
+    ...kept,
+    ...lines.slice(found.end),
+  ]
+  return { status: 'updated', text: next.join('\n') }
+}
+
+/**
+ * Remove the managed block for `alias` (used when a machine is RENAMED away:
+ * the old block is the plugin's own artifact of that edit). Deleting a machine
+ * deliberately does NOT call this — the Host block is the user's ssh access,
+ * not plugin state. Unmanaged blocks are never removed.
+ *
+ * @returns {{status: 'removed'|'absent', text: string}}
+ */
+export function removeManagedHostBlock(rawText, alias) {
+  const text = String(rawText || '')
+  const name = String(alias || '').trim()
+  if (!name) return { status: 'absent', text }
+  const lines = text.split('\n')
+  const found = locateManagedBlock(lines, name)
+  if (!found) return { status: 'absent', text }
+  let start = found.markerLine
+  while (start > 0 && lines[start - 1].trim() === '') start -= 1
+  const next = [...lines.slice(0, start), ...lines.slice(found.end)]
+  return { status: 'removed', text: next.join('\n') }
+}
+
+/**
+ * Persist a config text, creating ~/.ssh first. Permissions follow OpenSSH's
+ * expectations on POSIX (dir 0700, file 0600) and are a no-op elsewhere.
+ */
+export function writeSshConfig(text, filePath = sshConfigPath(), io = {}) {
+  const mkdir = io.mkdir || ((p) => mkdirSync(p, { recursive: true }))
+  const write = io.write || ((p, data) => writeFileSync(p, data, 'utf8'))
+  const chmod = io.chmod || ((p, mode) => { try { chmodSync(p, mode) } catch { /* no modes here */ } })
+  mkdir(path.dirname(filePath))
+  write(filePath, String(text))
+  if (process.platform !== 'win32') {
+    chmod(path.dirname(filePath), 0o700)
+    chmod(filePath, 0o600)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.49",
+  "version": "0.8.50",
   "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>",