@linxin666/dsh-ssh 0.4.5 → 0.4.6

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   node scripts/verify-docs.mjs --write <dir>
-README.md: bd5c0cb0afa9dc65e65b1fdfb6ba5205b66019df
-README.zh.md: 84f564e99c5c7a42ae2a48fce5772b940d18ff3e
+README.md: 9031d9df52f51011cc951cba61665da91b42c65b
+README.zh.md: ddae66eb2e06138a8c9157dcfd07da00acdba0f1

package/README.md

@@ -40,6 +40,7 @@ The panel loads its contents on first open. Closing and reopening it preserves t
 - ssh-agent auth stores only the agent socket path (or the special value `pageant`); it never reads or stores private-key material.
 - Tunnels only listen on `127.0.0.1`.
 - Deleting a host or changing its connection fields (host / port / user / auth / proxyJump / proxyCommand) immediately closes that alias's pooled connection and tunnels; later operations reconnect with the new configuration and never reuse a connection authenticated with the old credentials.
+- When the SSH connection behind a tunnel drops, the tunnel retires itself: the local port stops accepting, the tunnel leaves the list, and the connection that arrives during the drop is closed without traffic instead of interrupting the host process.
 - A `proxyCommand` value is a shell command executed by the DSH host process with its privileges — exactly the trust `ssh(1)` gives the same line in `~/.ssh/config`. It can only come from the user's own 0600 store file: the Agent cannot create or edit hosts, and `ssh_list` reports only whether a host has one, never the command text.
 - Before the Agent uses a tool, the host must first be configured in the GUI (or imported from ~/.ssh/config).
 - `ssh_upload` / `ssh_download` read/write arbitrary local paths on this machine with host-process privileges (not through the bash sandbox) — same host-local-path semantics as ssh-skill, be aware of that permission surface.

package/README.zh.md

@@ -40,6 +40,7 @@
 - ssh-agent 认证仅保存 agent socket 路径（或 `pageant` 特殊值），不读取也不保存任何私钥材料。
 - 隧道只监听 `127.0.0.1`。
 - 删除主机或修改其连接字段（host / port / user / auth / proxyJump / proxyCommand）会立即断开该别名的池化连接与隧道，后续操作按新配置重新建连，不会复用旧凭据的已认证连接。
+- 隧道背后的 SSH 连接一旦断开，隧道会自行退役：本地端口不再接受连接，隧道从列表中消失；断开期间到达的连接被直接关闭且没有流量，不会打断宿主进程。
 - `proxyCommand` 是一条由 DSH 宿主进程以其自身权限执行的 shell 命令——与 `ssh(1)` 执行 `~/.ssh/config` 里同一行的信任模型一致。它只能来自用户自己的 0600 配置文件：Agent 无法创建或修改主机，`ssh_list` 只报告该主机是否配置了 ProxyCommand，不返回命令原文。
 - Agent 使用工具前，主机需先在 GUI 中配置（或从 ~/.ssh/config 导入）。
 - `ssh_upload` / `ssh_download` 以宿主进程权限直接读写本机任意路径（不经 bash 沙箱）——与 ssh-skill 的宿主本地路径语义一致，注意该权限面。

package/lib/client.js

@@ -16415,7 +16415,7 @@ window.__ModuleLoader__.load({
 		/** The building package's version, when the bundle carries it. */
 		function bakedVersion() {
 			try {
-				return "0.4.5";
+				return "0.4.6";
 			} catch {
 				return;
 			}

package/lib/index.js

@@ -1452,6 +1452,24 @@ function fastGet(sftp, src, dst, concurrency, onProgress) {
 * to a pooled connection so an idle sweep never closes it, with per-tunnel
 * socket tracking and stop (single / alias-scoped / all).
 */
+/** Destroy one socket or channel stream, tolerating an already-dead peer. */
+function destroyQuietly(target) {
+	try {
+		target.destroy();
+	} catch {}
+}
+/**
+* Tear down one tunnel because the SSH link behind it is gone. Idempotent: the
+* tunnel registry is the guard, so a socket callback or a link-death hook that
+* arrives after a manual stop does nothing instead of tearing down twice, and
+* no teardown error can escape into the net connection handler — an exception
+* there terminates the whole host process.
+*/
+function abortTunnel(engine, id) {
+	try {
+		stopTunnel(engine, id);
+	} catch {}
+}
 /** Start a local port-forward tunnel (listens on 127.0.0.1 only). */
 async function startTunnel(engine, alias, options) {
 	if (!Number.isInteger(options.remotePort) || options.remotePort < 1 || options.remotePort > 65535) throw new Error("remotePort must be an integer in 1..65535");
@@ -1474,30 +1492,44 @@ async function startTunnel(engine, alias, options) {
 	const record = engine.pool.get(alias) ?? await acquire(engine, alias);
 	const client = record.client;
 	const sockets = /* @__PURE__ */ new Set();
+	const onLinkClosed = () => {
+		abortTunnel(engine, id);
+	};
+	const detachLink = () => {
+		client.off("close", onLinkClosed);
+	};
 	const server = createServer((socket) => {
 		sockets.add(socket);
 		socket.on("close", () => {
 			sockets.delete(socket);
 		});
-		client.forwardOut("127.0.0.1", 0, remoteHost, options.remotePort, (error, stream) => {
-			if (error !== void 0) {
-				socket.destroy();
-				return;
-			}
-			const destroy = () => {
-				try {
-					socket.destroy();
-				} catch {}
-				try {
-					stream.close();
-				} catch {}
-			};
-			stream.on("error", destroy);
-			socket.on("error", destroy);
-			stream.on("close", destroy);
-			socket.on("close", destroy);
-			stream.pipe(socket).pipe(stream);
-		});
+		if (record.broken) {
+			destroyQuietly(socket);
+			abortTunnel(engine, id);
+			return;
+		}
+		try {
+			client.forwardOut("127.0.0.1", 0, remoteHost, options.remotePort, (error, stream) => {
+				if (error !== void 0) {
+					destroyQuietly(socket);
+					return;
+				}
+				const destroy = () => {
+					destroyQuietly(socket);
+					try {
+						stream.close();
+					} catch {}
+				};
+				stream.on("error", destroy);
+				socket.on("error", destroy);
+				stream.on("close", destroy);
+				socket.on("close", destroy);
+				stream.pipe(socket).pipe(stream);
+			});
+		} catch {
+			destroyQuietly(socket);
+			abortTunnel(engine, id);
+		}
 	});
 	try {
 		await new Promise((resolve, reject) => {
@@ -1520,8 +1552,15 @@ async function startTunnel(engine, alias, options) {
 		server,
 		alias,
 		record,
-		sockets
+		sockets,
+		detachLink
 	});
+	client.once("close", onLinkClosed);
+	if (record.broken) {
+		info.state = "failed";
+		info.error = "ssh link closed while the tunnel was starting";
+		abortTunnel(engine, id);
+	}
 	return info;
 }
 /** All active tunnels. */
@@ -1534,11 +1573,12 @@ function stopTunnel(engine, id) {
 	if (tunnel === void 0) return false;
 	engine.tunnels.delete(id);
 	try {
-		tunnel.server.close();
+		tunnel.detachLink?.();
 	} catch {}
-	for (const socket of tunnel.sockets) try {
-		socket.destroy();
+	try {
+		tunnel.server.close();
 	} catch {}
+	for (const socket of tunnel.sockets) destroyQuietly(socket);
 	tunnel.sockets.clear();
 	if (![...engine.tunnels.values()].some((candidate) => candidate.record === tunnel.record)) if (engine.pool.get(tunnel.alias) === tunnel.record) disposeRecord(engine, tunnel.alias, tunnel.record);
 	else endRecordChain(tunnel.record);

package/lib/types/engine/tunnel.d.ts

@@ -14,6 +14,8 @@ export interface TunnelRecord {
     /** The pooled connection this tunnel pins; siblings on one alias may share it. */
     record: PoolRecord;
     sockets: Set<Socket>;
+    /** Detach the link-death hook startTunnel installs on the pooled client. */
+    detachLink?: () => void;
 }
 /** The engine slice the tunnel module needs (adds the tunnel registry). */
 export interface TunnelEngine extends PoolEngine {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-ssh",
   "description": "Remote SSH operations for the dsh web GUI: host config store (~/.dsh/dsh-ssh.json, import from ~/.ssh/config), a persistent ssh2 connection pool with jump-host support, exec / PTY web terminal / SFTP transfer / local port-forward tunnels / cluster execution, plus agent tools (ssh_list, ssh_exec, ssh_upload, ssh_download, ssh_tunnel, ssh_cluster). Hot-pluggable — mounted via ~/.dsh/cordis.patch.yml + a profile node_modules symlink, no dsh source changes.",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "icon": "icon.svg",
   "type": "module",
   "engines": {
@@ -14,10 +14,6 @@
       "types": "./lib/types/index.d.ts",
       "default": "./lib/index.js"
     },
-    "./invariant": {
-      "types": "./lib/types/invariant.d.ts",
-      "default": "./lib/invariant.js"
-    },
     "./client": {
       "types": "./lib/types/client/index.d.ts",
       "default": "./lib/client.js"
@@ -99,7 +95,7 @@
     "url": "https://github.com/zhu1090093659/dsh-web.git"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsdown",
+    "build": "tsc -b tsconfig.build.json && tsdown",
     "bundle": "tsdown",
     "watch": "tsdown --watch",
     "typecheck": "tsc --noEmit",

package/src/engine/tunnel.ts

@@ -16,6 +16,8 @@ export interface TunnelRecord {
   /** The pooled connection this tunnel pins; siblings on one alias may share it. */
   record: PoolRecord
   sockets: Set<Socket>
+  /** Detach the link-death hook startTunnel installs on the pooled client. */
+  detachLink?: () => void
 }
 
 /** The engine slice the tunnel module needs (adds the tunnel registry). */
@@ -24,6 +26,22 @@ export interface TunnelEngine extends PoolEngine {
   nextTunnelId: number
 }
 
+/** Destroy one socket or channel stream, tolerating an already-dead peer. */
+function destroyQuietly(target: { destroy(): void }): void {
+  try { target.destroy() } catch { /* already closed */ }
+}
+
+/**
+ * Tear down one tunnel because the SSH link behind it is gone. Idempotent: the
+ * tunnel registry is the guard, so a socket callback or a link-death hook that
+ * arrives after a manual stop does nothing instead of tearing down twice, and
+ * no teardown error can escape into the net connection handler — an exception
+ * there terminates the whole host process.
+ */
+function abortTunnel(engine: TunnelEngine, id: string): void {
+  try { stopTunnel(engine, id) } catch { /* teardown already in progress */ }
+}
+
 /** Start a local port-forward tunnel (listens on 127.0.0.1 only). */
 export async function startTunnel(
   engine: TunnelEngine,
@@ -58,26 +76,47 @@ export async function startTunnel(
   const record = engine.pool.get(alias) ?? (await acquire(engine, alias))
   const client = record.client
   const sockets = new Set<Socket>()
+  // A tunnel whose SSH link died can only refuse what it is handed, so every
+  // path that learns the link is gone tears the tunnel down as well instead
+  // of leaving a listener alive on a connection that forwards nothing.
+  const onLinkClosed = (): void => { abortTunnel(engine, id) }
+  const detachLink = (): void => { client.off('close', onLinkClosed) }
   const server = createServer((socket) => {
     sockets.add(socket)
     socket.on('close', () => { sockets.delete(socket) })
-    client.forwardOut('127.0.0.1', 0, remoteHost, options.remotePort, (error, stream) => {
-      if (error !== undefined) {
-        socket.destroy()
-        return
-      }
-      // Both ends of the pipe can die independently; destroy the pair so an
-      // unhandled 'error' event can never crash the host process.
-      const destroy = (): void => {
-        try { socket.destroy() } catch { /* gone */ }
-        try { stream.close() } catch { /* gone */ }
-      }
-      stream.on('error', destroy)
-      socket.on('error', destroy)
-      stream.on('close', destroy)
-      socket.on('close', destroy)
-      stream.pipe(socket).pipe(stream)
-    })
+    // The link can die between taking the record above and this connection.
+    if (record.broken) {
+      destroyQuietly(socket)
+      abortTunnel(engine, id)
+      return
+    }
+    try {
+      client.forwardOut('127.0.0.1', 0, remoteHost, options.remotePort, (error, stream) => {
+        if (error !== undefined) {
+          // A refused remote channel is the remote service's answer, not a
+          // dead SSH link: the tunnel itself stays up for the next attempt.
+          destroyQuietly(socket)
+          return
+        }
+        // Both ends of the pipe can die independently; destroy the pair so an
+        // unhandled 'error' event can never crash the host process.
+        const destroy = (): void => {
+          destroyQuietly(socket)
+          try { stream.close() } catch { /* gone */ }
+        }
+        stream.on('error', destroy)
+        socket.on('error', destroy)
+        stream.on('close', destroy)
+        socket.on('close', destroy)
+        stream.pipe(socket).pipe(stream)
+      })
+    } catch {
+      // ssh2 reports 'Not connected' by throwing out of forwardOut rather than
+      // through the callback; an exception escaping this connection handler
+      // is an uncaught exception that takes the host process down with it.
+      destroyQuietly(socket)
+      abortTunnel(engine, id)
+    }
   })
   try {
     await new Promise<void>((resolve, reject) => {
@@ -96,7 +135,20 @@ export async function startTunnel(
   const address = server.address()
   info.localPort = typeof address === 'object' && address !== null ? address.port : 0
   info.state = 'forwarding'
-  engine.tunnels.set(id, { info, server, alias, record, sockets })
+  engine.tunnels.set(id, { info, server, alias, record, sockets, detachLink })
+  // A dead link must not keep a listener alive: without this hook the tunnel
+  // outlives its connection and every later local connection hits the dead
+  // forwardOut path above.
+  client.once('close', onLinkClosed)
+  if (record.broken) {
+    // A link that died while the listener was binding already emitted 'close',
+    // so the pool's broken flag is the only signal left for that window. The
+    // tunnel retires right away, and the start reports that instead of
+    // handing the caller a forwarding tunnel that no longer exists.
+    info.state = 'failed'
+    info.error = 'ssh link closed while the tunnel was starting'
+    abortTunnel(engine, id)
+  }
   return info
 }
 
@@ -110,9 +162,12 @@ export function stopTunnel(engine: TunnelEngine, id: string): boolean {
   const tunnel = engine.tunnels.get(id)
   if (tunnel === undefined) return false
   engine.tunnels.delete(id)
+  // Drop the link-death hook first: a stop is never the link's death, and a
+  // long-lived pooled client outlives many tunnels.
+  try { tunnel.detachLink?.() } catch { /* already detached */ }
   try { tunnel.server.close() } catch { /* already closed */ }
   for (const socket of tunnel.sockets) {
-    try { socket.destroy() } catch { /* already closed */ }
+    destroyQuietly(socket)
   }
   tunnel.sockets.clear()
   // Sibling tunnels on the same alias share the pinned connection: release it

package/lib/invariant.js

@@ -1,6 +0,0 @@
-//#region src/invariant.ts
-/** Invariant companion plugin (no assertions — nothing to check at runtime). */
-/** Provides no assertions: the ssh plugin owns no cross-package runtime invariants. */
-function apply() {}
-//#endregion
-export { apply };

package/lib/types/invariant.d.ts

@@ -1,3 +0,0 @@
-/** Invariant companion plugin (no assertions — nothing to check at runtime). */
-/** Provides no assertions: the ssh plugin owns no cross-package runtime invariants. */
-export declare function apply(): void;

package/src/invariant.ts

@@ -1,4 +0,0 @@
-/** Invariant companion plugin (no assertions — nothing to check at runtime). */
-
-/** Provides no assertions: the ssh plugin owns no cross-package runtime invariants. */
-export function apply(): void {}