@dbx-tools/lakebox 0.0.0-stage → 0.9.131

package/lib/src/_ssh_openssh.js

@@ -0,0 +1,382 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { exec } from "@dbx-tools/core";
+import { errorUtils, log, stringUtils } from "@dbx-tools/shared-core";
+import { SocksClient } from "socks";
+import { PooledSshTransport, } from "./_ssh.js";
+const SOCKS_HOST = "127.0.0.1";
+const OPENSSH_HELPER_TIMEOUT_MS = 2_000;
+const logger = log.logger("lakebox:openssh");
+const nativeOpenSshSupportByCommand = new Map();
+const activeNativeOpenSshProcesses = new Set();
+const parentBoundNativeOpenSshProcesses = new WeakSet();
+let stopParentTerminationSignal;
+let processExitHookInstalled = false;
+/** @internal JavaScript watchdog that terminates one child when its parent pipe closes. */
+export const OPENSSH_PARENT_WATCH_SOURCE = stringUtils.dedent(// ============================================================================
+/*js*/ `
+    const { spawn } = require("node:child_process");
+
+    const child = spawn(process.argv[1], process.argv.slice(2), {
+      stdio: ["ignore", "ignore", "inherit"],
+    });
+    let stopping = false;
+    const stopChild = () => {
+      if (stopping) return;
+      stopping = true;
+      child.kill("SIGKILL");
+    };
+
+    process.stdin.resume();
+    process.stdin.once("end", stopChild);
+    process.stdin.once("close", stopChild);
+    child.once("error", (error) => {
+      console.error(error);
+      process.exit(1);
+    });
+    child.once("exit", (code, signal) => {
+      process.stdin.pause();
+      process.exit(code ?? (signal ? 1 : 0));
+    });
+  `);
+/** Exclusive native OpenSSH ControlMaster pool. */
+export class OpenSshTransport extends PooledSshTransport {
+    kind = "openssh";
+    constructor(options, command, poolOptions = {}, lifecycle = openSshLifecycle(options, command)) {
+        super(lifecycle, {
+            acquireTimeoutMillis: options.connectTimeoutMs,
+            ...poolOptions,
+        });
+    }
+    runWithResource(resource, script, execution) {
+        return resource.run(script, execution);
+    }
+    connectWithResource(resource, remoteHost, remotePort) {
+        return resource.connect(remoteHost, remotePort);
+    }
+}
+/** Return whether an executable is OpenSSH and accepts dynamic SOCKS5 forwarding. */
+export async function supportsNativeOpenSsh(command = "ssh") {
+    const cached = nativeOpenSshSupportByCommand.get(command);
+    if (cached)
+        return cached;
+    const probe = probeNativeOpenSsh(command);
+    nativeOpenSshSupportByCommand.set(command, probe);
+    return probe;
+}
+/** @internal OpenSSH arguments shared by pooled ControlMaster processes. */
+export function nativeOpenSshArgs(options) {
+    return [
+        "-i",
+        options.privateKeyPath,
+        "-p",
+        String(options.port),
+        "-T",
+        "-o",
+        "BatchMode=yes",
+        "-o",
+        "IdentitiesOnly=yes",
+        "-o",
+        "ForwardAgent=no",
+        "-o",
+        "PreferredAuthentications=publickey",
+        "-o",
+        "StrictHostKeyChecking=yes",
+        "-o",
+        `UserKnownHostsFile=${options.knownHostsPath}`,
+        "-o",
+        `HostKeyAlias=[${options.host}]:${options.port}`,
+        "-o",
+        "LogLevel=ERROR",
+        "-o",
+        `ConnectTimeout=${Math.max(1, Math.ceil(options.connectTimeoutMs / 1_000))}`,
+        "-o",
+        "ServerAliveInterval=15",
+        "-o",
+        "ServerAliveCountMax=3",
+    ];
+}
+function openSshLifecycle(options, command) {
+    return {
+        create: () => NativeOpenSshResource.create(options, command),
+        destroy: (resource) => resource.close(),
+        test: (resource) => resource.test(),
+    };
+}
+class NativeOpenSshResource {
+    options;
+    command;
+    directory;
+    controlPath;
+    socksPort;
+    master;
+    alive = true;
+    closing;
+    constructor(options, command, directory, controlPath, socksPort, master) {
+        this.options = options;
+        this.command = command;
+        this.directory = directory;
+        this.controlPath = controlPath;
+        this.socksPort = socksPort;
+        this.master = master;
+        const closed = () => {
+            this.alive = false;
+        };
+        void master.then(closed, closed);
+    }
+    static async create(options, command) {
+        const directory = await mkdtemp(join(tmpdir(), "dbx-tools-ssh-"));
+        try {
+            const controlPath = join(directory, "control");
+            const socksPort = await availableLoopbackPort();
+            const target = `${options.username}@${options.connectHost}`;
+            const master = trackNativeOpenSshProcess(exec.spawn(process.execPath, [
+                "-e",
+                OPENSSH_PARENT_WATCH_SOURCE,
+                command,
+                ...nativeOpenSshArgs(options),
+                "-M",
+                "-N",
+                "-S",
+                controlPath,
+                "-o",
+                "ControlPersist=no",
+                "-o",
+                "ExitOnForwardFailure=yes",
+                "-D",
+                `${SOCKS_HOST}:${socksPort}`,
+                target,
+            ], {
+                stdin: "pipe",
+                stdout: "ignore",
+                stderr: "capture",
+                trim: false,
+                forwardTerminationSignals: false,
+            }), true);
+            const resource = new NativeOpenSshResource(options, command, directory, controlPath, socksPort, master);
+            try {
+                await resource.waitUntilReady();
+                return resource;
+            }
+            catch (error) {
+                await resource.close();
+                throw error;
+            }
+        }
+        catch (error) {
+            await rm(directory, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    async run(script, execution) {
+        const child = trackNativeOpenSshProcess(exec.spawn(this.command, [
+            ...nativeOpenSshArgs(this.options),
+            "-S",
+            this.controlPath,
+            "-o",
+            "ControlMaster=no",
+            `${this.options.username}@${this.options.connectHost}`,
+            script,
+        ], {
+            stdin: "ignore",
+            stdout: "pipe",
+            stderr: "pipe",
+            trim: false,
+            forwardTerminationSignals: false,
+        }));
+        child.stdout?.on("data", execution.stdout);
+        child.stderr?.on("data", execution.stderr);
+        let shutdown;
+        execution.setCancel(() => {
+            shutdown ??= child.shutdown({ terminateTimeout: 0, killTimeout: 1_000 }).catch((error) => {
+                logger.warn("failed to stop native SSH command", { error: errorUtils.toError(error) });
+            });
+            return shutdown;
+        });
+        return (await child).exitCode;
+    }
+    async connect(remoteHost, remotePort) {
+        const connection = await SocksClient.createConnection({
+            command: "connect",
+            destination: { host: remoteHost, port: remotePort },
+            proxy: { host: SOCKS_HOST, port: this.socksPort, type: 5 },
+            timeout: this.options.connectTimeoutMs,
+            set_tcp_nodelay: true,
+        });
+        return connection.socket;
+    }
+    async test() {
+        if (!this.alive || this.master.exitCode !== null)
+            return false;
+        try {
+            return (await this.control("check")).exitCode === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    async close() {
+        if (this.closing)
+            return this.closing;
+        this.alive = false;
+        this.closing = this.closeResource();
+        return this.closing;
+    }
+    async closeResource() {
+        try {
+            await this.control("exit").catch(() => undefined);
+        }
+        finally {
+            await this.master.shutdown({ terminateTimeout: 0, killTimeout: 1_000 }).catch((error) => logger.warn("failed to stop native SSH ControlMaster", {
+                error: errorUtils.toError(error),
+            }));
+            await rm(this.directory, { recursive: true, force: true });
+        }
+    }
+    async waitUntilReady() {
+        const deadline = Date.now() + this.options.connectTimeoutMs;
+        while (Date.now() < deadline) {
+            if (this.master.exitCode !== null) {
+                const result = await this.master;
+                throw new Error(`Native OpenSSH ControlMaster exited (${result.exitCode}): ${result.stderr.trim()}`);
+            }
+            if ((await this.test()) && (await canConnectLoopback(this.socksPort)))
+                return;
+            await delay(50);
+        }
+        throw new Error(`Native OpenSSH ControlMaster did not become ready within ${this.options.connectTimeoutMs}ms`);
+    }
+    control(operation) {
+        const child = trackNativeOpenSshProcess(exec.spawn(this.command, [
+            "-p",
+            String(this.options.port),
+            "-S",
+            this.controlPath,
+            "-O",
+            operation,
+            `${this.options.username}@${this.options.connectHost}`,
+        ], {
+            stdin: "ignore",
+            stdout: "ignore",
+            stderr: "ignore",
+            forwardTerminationSignals: false,
+        }));
+        return waitForNativeOpenSshChild(child, `ssh -O ${operation}`);
+    }
+}
+async function probeNativeOpenSsh(command) {
+    try {
+        const version = await waitForNativeOpenSshChild(trackNativeOpenSshProcess(exec.spawn(command, ["-V"], {
+            stdin: "ignore",
+            stdout: "capture",
+            stderr: "capture",
+            forwardTerminationSignals: false,
+        })), "ssh -V");
+        const versionOutput = `${version.stdout}\n${version.stderr}`;
+        if (version.exitCode !== 0 || !/(?:^|\s)OpenSSH_/m.test(versionOutput))
+            return false;
+        const dynamicForward = await waitForNativeOpenSshChild(trackNativeOpenSshProcess(exec.spawn(command, ["-G", "-D", `${SOCKS_HOST}:1`, "localhost"], {
+            stdin: "ignore",
+            stdout: "ignore",
+            stderr: "ignore",
+            forwardTerminationSignals: false,
+        })), "ssh -G");
+        return dynamicForward.exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForNativeOpenSshChild(child, operation) {
+    let timeout;
+    const timedOut = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            void child.shutdown({ terminateTimeout: 0, killTimeout: 1_000 }).then(() => reject(new Error(`${operation} timed out after ${OPENSSH_HELPER_TIMEOUT_MS}ms`)), (error) => reject(error));
+        }, OPENSSH_HELPER_TIMEOUT_MS);
+        timeout.unref?.();
+    });
+    try {
+        return await Promise.race([child, timedOut]);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function trackNativeOpenSshProcess(child, parentBound = false) {
+    activeNativeOpenSshProcesses.add(child);
+    if (parentBound)
+        parentBoundNativeOpenSshProcesses.add(child);
+    if (!stopParentTerminationSignal) {
+        stopParentTerminationSignal = exec.onParentTerminationSignal(forceStopNativeOpenSshProcesses);
+    }
+    if (!processExitHookInstalled) {
+        processExitHookInstalled = true;
+        process.once("exit", forceStopNativeOpenSshProcesses);
+    }
+    let tracked = true;
+    const untrack = () => {
+        if (!tracked)
+            return;
+        tracked = false;
+        void child.off("exit", untrack);
+        void child.off("error", untrack);
+        activeNativeOpenSshProcesses.delete(child);
+        if (activeNativeOpenSshProcesses.size === 0) {
+            stopParentTerminationSignal?.();
+            stopParentTerminationSignal = undefined;
+            process.off("exit", forceStopNativeOpenSshProcesses);
+            processExitHookInstalled = false;
+        }
+    };
+    void child.once("exit", untrack);
+    void child.once("error", untrack);
+    return child;
+}
+function forceStopNativeOpenSshProcesses() {
+    for (const child of activeNativeOpenSshProcesses) {
+        try {
+            if (parentBoundNativeOpenSshProcesses.has(child))
+                child.stdin?.end();
+            else
+                child.kill("SIGKILL");
+        }
+        catch {
+            // The child may have exited between the tracked-state check and kill.
+        }
+    }
+}
+async function availableLoopbackPort() {
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, SOCKS_HOST, resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new Error("Failed to allocate a loopback SOCKS5 port");
+    }
+    await new Promise((resolve) => server.close(() => resolve()));
+    return address.port;
+}
+function canConnectLoopback(port) {
+    return new Promise((resolve) => {
+        const socket = createConnection({ host: SOCKS_HOST, port });
+        let settled = false;
+        const finish = (connected) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            resolve(connected);
+        };
+        socket.unref();
+        socket.setTimeout(100, () => finish(false));
+        socket.once("error", () => finish(false));
+        socket.once("connect", () => finish(true));
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_ssh_openssh.js","sourceRoot":"","sources":["../../src/_ssh_openssh.ts"],"names":[],"mappings":"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","sourcesContent":["import { mkdtemp, rm } from \"node:fs/promises\";\nimport { createConnection, createServer } from \"node:net\";\nimport { tmpdir } from \"node:os\";\nimport { join } from \"node:path\";\nimport type { Duplex } from \"node:stream\";\nimport { setTimeout as delay } from \"node:timers/promises\";\nimport { exec } from \"@dbx-tools/core\";\nimport type { ChildProcessResult } from \"@dbx-tools/core/exec\";\nimport { errorUtils, log, stringUtils } from \"@dbx-tools/shared-core\";\nimport { SocksClient } from \"socks\";\nimport {\n  PooledSshTransport,\n  type SshCommandExecution,\n  type SshPoolOptions,\n  type SshResourceLifecycle,\n  type SshTransportOptions,\n} from \"./_ssh.ts\";\n\nconst SOCKS_HOST = \"127.0.0.1\";\nconst OPENSSH_HELPER_TIMEOUT_MS = 2_000;\nconst logger = log.logger(\"lakebox:openssh\");\nconst nativeOpenSshSupportByCommand = new Map<string, Promise<boolean>>();\nconst activeNativeOpenSshProcesses = new Set<ChildProcessResult>();\nconst parentBoundNativeOpenSshProcesses = new WeakSet<ChildProcessResult>();\nlet stopParentTerminationSignal: (() => void) | undefined;\nlet processExitHookInstalled = false;\n/** @internal JavaScript watchdog that terminates one child when its parent pipe closes. */\nexport const OPENSSH_PARENT_WATCH_SOURCE =\n  stringUtils.dedent(// ============================================================================\n  /*js*/ `\n    const { spawn } = require(\"node:child_process\");\n\n    const child = spawn(process.argv[1], process.argv.slice(2), {\n      stdio: [\"ignore\", \"ignore\", \"inherit\"],\n    });\n    let stopping = false;\n    const stopChild = () => {\n      if (stopping) return;\n      stopping = true;\n      child.kill(\"SIGKILL\");\n    };\n\n    process.stdin.resume();\n    process.stdin.once(\"end\", stopChild);\n    process.stdin.once(\"close\", stopChild);\n    child.once(\"error\", (error) => {\n      console.error(error);\n      process.exit(1);\n    });\n    child.once(\"exit\", (code, signal) => {\n      process.stdin.pause();\n      process.exit(code ?? (signal ? 1 : 0));\n    });\n  `);\n// ============================================================================\n\n/** One authenticated native OpenSSH ControlMaster resource. */\nexport interface OpenSshResource {\n  run(script: string, execution: SshCommandExecution): Promise<number>;\n  connect(remoteHost: string, remotePort: number): Promise<Duplex>;\n  test(): Promise<boolean>;\n  close(): Promise<void>;\n}\n\n/** Exclusive native OpenSSH ControlMaster pool. */\nexport class OpenSshTransport extends PooledSshTransport<OpenSshResource> {\n  readonly kind = \"openssh\" as const;\n\n  constructor(\n    options: SshTransportOptions,\n    command: string,\n    poolOptions: SshPoolOptions = {},\n    lifecycle: SshResourceLifecycle<OpenSshResource> = openSshLifecycle(options, command),\n  ) {\n    super(lifecycle, {\n      acquireTimeoutMillis: options.connectTimeoutMs,\n      ...poolOptions,\n    });\n  }\n\n  protected runWithResource(\n    resource: OpenSshResource,\n    script: string,\n    execution: SshCommandExecution,\n  ): Promise<number> {\n    return resource.run(script, execution);\n  }\n\n  protected connectWithResource(\n    resource: OpenSshResource,\n    remoteHost: string,\n    remotePort: number,\n  ): Promise<Duplex> {\n    return resource.connect(remoteHost, remotePort);\n  }\n}\n\n/** Return whether an executable is OpenSSH and accepts dynamic SOCKS5 forwarding. */\nexport async function supportsNativeOpenSsh(command = \"ssh\"): Promise<boolean> {\n  const cached = nativeOpenSshSupportByCommand.get(command);\n  if (cached) return cached;\n  const probe = probeNativeOpenSsh(command);\n  nativeOpenSshSupportByCommand.set(command, probe);\n  return probe;\n}\n\n/** @internal OpenSSH arguments shared by pooled ControlMaster processes. */\nexport function nativeOpenSshArgs(options: SshTransportOptions): string[] {\n  return [\n    \"-i\",\n    options.privateKeyPath,\n    \"-p\",\n    String(options.port),\n    \"-T\",\n    \"-o\",\n    \"BatchMode=yes\",\n    \"-o\",\n    \"IdentitiesOnly=yes\",\n    \"-o\",\n    \"ForwardAgent=no\",\n    \"-o\",\n    \"PreferredAuthentications=publickey\",\n    \"-o\",\n    \"StrictHostKeyChecking=yes\",\n    \"-o\",\n    `UserKnownHostsFile=${options.knownHostsPath}`,\n    \"-o\",\n    `HostKeyAlias=[${options.host}]:${options.port}`,\n    \"-o\",\n    \"LogLevel=ERROR\",\n    \"-o\",\n    `ConnectTimeout=${Math.max(1, Math.ceil(options.connectTimeoutMs / 1_000))}`,\n    \"-o\",\n    \"ServerAliveInterval=15\",\n    \"-o\",\n    \"ServerAliveCountMax=3\",\n  ];\n}\n\nfunction openSshLifecycle(\n  options: SshTransportOptions,\n  command: string,\n): SshResourceLifecycle<OpenSshResource> {\n  return {\n    create: () => NativeOpenSshResource.create(options, command),\n    destroy: (resource) => resource.close(),\n    test: (resource) => resource.test(),\n  };\n}\n\nclass NativeOpenSshResource implements OpenSshResource {\n  private alive = true;\n  private closing?: Promise<void>;\n\n  private constructor(\n    private readonly options: SshTransportOptions,\n    private readonly command: string,\n    private readonly directory: string,\n    private readonly controlPath: string,\n    private readonly socksPort: number,\n    private readonly master: ChildProcessResult,\n  ) {\n    const closed = () => {\n      this.alive = false;\n    };\n    void master.then(closed, closed);\n  }\n\n  static async create(\n    options: SshTransportOptions,\n    command: string,\n  ): Promise<NativeOpenSshResource> {\n    const directory = await mkdtemp(join(tmpdir(), \"dbx-tools-ssh-\"));\n    try {\n      const controlPath = join(directory, \"control\");\n      const socksPort = await availableLoopbackPort();\n      const target = `${options.username}@${options.connectHost}`;\n      const master = trackNativeOpenSshProcess(\n        exec.spawn(\n          process.execPath,\n          [\n            \"-e\",\n            OPENSSH_PARENT_WATCH_SOURCE,\n            command,\n            ...nativeOpenSshArgs(options),\n            \"-M\",\n            \"-N\",\n            \"-S\",\n            controlPath,\n            \"-o\",\n            \"ControlPersist=no\",\n            \"-o\",\n            \"ExitOnForwardFailure=yes\",\n            \"-D\",\n            `${SOCKS_HOST}:${socksPort}`,\n            target,\n          ],\n          {\n            stdin: \"pipe\",\n            stdout: \"ignore\",\n            stderr: \"capture\",\n            trim: false,\n            forwardTerminationSignals: false,\n          },\n        ),\n        true,\n      );\n      const resource = new NativeOpenSshResource(\n        options,\n        command,\n        directory,\n        controlPath,\n        socksPort,\n        master,\n      );\n      try {\n        await resource.waitUntilReady();\n        return resource;\n      } catch (error) {\n        await resource.close();\n        throw error;\n      }\n    } catch (error) {\n      await rm(directory, { recursive: true, force: true });\n      throw error;\n    }\n  }\n\n  async run(script: string, execution: SshCommandExecution): Promise<number> {\n    const child = trackNativeOpenSshProcess(\n      exec.spawn(\n        this.command,\n        [\n          ...nativeOpenSshArgs(this.options),\n          \"-S\",\n          this.controlPath,\n          \"-o\",\n          \"ControlMaster=no\",\n          `${this.options.username}@${this.options.connectHost}`,\n          script,\n        ],\n        {\n          stdin: \"ignore\",\n          stdout: \"pipe\",\n          stderr: \"pipe\",\n          trim: false,\n          forwardTerminationSignals: false,\n        },\n      ),\n    );\n    child.stdout?.on(\"data\", execution.stdout);\n    child.stderr?.on(\"data\", execution.stderr);\n    let shutdown: Promise<void> | undefined;\n    execution.setCancel(() => {\n      shutdown ??= child.shutdown({ terminateTimeout: 0, killTimeout: 1_000 }).catch((error) => {\n        logger.warn(\"failed to stop native SSH command\", { error: errorUtils.toError(error) });\n      });\n      return shutdown;\n    });\n    return (await child).exitCode;\n  }\n\n  async connect(remoteHost: string, remotePort: number): Promise<Duplex> {\n    const connection = await SocksClient.createConnection({\n      command: \"connect\",\n      destination: { host: remoteHost, port: remotePort },\n      proxy: { host: SOCKS_HOST, port: this.socksPort, type: 5 },\n      timeout: this.options.connectTimeoutMs,\n      set_tcp_nodelay: true,\n    });\n    return connection.socket;\n  }\n\n  async test(): Promise<boolean> {\n    if (!this.alive || this.master.exitCode !== null) return false;\n    try {\n      return (await this.control(\"check\")).exitCode === 0;\n    } catch {\n      return false;\n    }\n  }\n\n  async close(): Promise<void> {\n    if (this.closing) return this.closing;\n    this.alive = false;\n    this.closing = this.closeResource();\n    return this.closing;\n  }\n\n  private async closeResource(): Promise<void> {\n    try {\n      await this.control(\"exit\").catch(() => undefined);\n    } finally {\n      await this.master.shutdown({ terminateTimeout: 0, killTimeout: 1_000 }).catch((error) =>\n        logger.warn(\"failed to stop native SSH ControlMaster\", {\n          error: errorUtils.toError(error),\n        }),\n      );\n      await rm(this.directory, { recursive: true, force: true });\n    }\n  }\n\n  private async waitUntilReady(): Promise<void> {\n    const deadline = Date.now() + this.options.connectTimeoutMs;\n    while (Date.now() < deadline) {\n      if (this.master.exitCode !== null) {\n        const result = await this.master;\n        throw new Error(\n          `Native OpenSSH ControlMaster exited (${result.exitCode}): ${result.stderr.trim()}`,\n        );\n      }\n      if ((await this.test()) && (await canConnectLoopback(this.socksPort))) return;\n      await delay(50);\n    }\n    throw new Error(\n      `Native OpenSSH ControlMaster did not become ready within ${this.options.connectTimeoutMs}ms`,\n    );\n  }\n\n  private control(operation: \"check\" | \"exit\") {\n    const child = trackNativeOpenSshProcess(\n      exec.spawn(\n        this.command,\n        [\n          \"-p\",\n          String(this.options.port),\n          \"-S\",\n          this.controlPath,\n          \"-O\",\n          operation,\n          `${this.options.username}@${this.options.connectHost}`,\n        ],\n        {\n          stdin: \"ignore\",\n          stdout: \"ignore\",\n          stderr: \"ignore\",\n          forwardTerminationSignals: false,\n        },\n      ),\n    );\n    return waitForNativeOpenSshChild(child, `ssh -O ${operation}`);\n  }\n}\n\nasync function probeNativeOpenSsh(command: string): Promise<boolean> {\n  try {\n    const version = await waitForNativeOpenSshChild(\n      trackNativeOpenSshProcess(\n        exec.spawn(command, [\"-V\"], {\n          stdin: \"ignore\",\n          stdout: \"capture\",\n          stderr: \"capture\",\n          forwardTerminationSignals: false,\n        }),\n      ),\n      \"ssh -V\",\n    );\n    const versionOutput = `${version.stdout}\\n${version.stderr}`;\n    if (version.exitCode !== 0 || !/(?:^|\\s)OpenSSH_/m.test(versionOutput)) return false;\n    const dynamicForward = await waitForNativeOpenSshChild(\n      trackNativeOpenSshProcess(\n        exec.spawn(command, [\"-G\", \"-D\", `${SOCKS_HOST}:1`, \"localhost\"], {\n          stdin: \"ignore\",\n          stdout: \"ignore\",\n          stderr: \"ignore\",\n          forwardTerminationSignals: false,\n        }),\n      ),\n      \"ssh -G\",\n    );\n    return dynamicForward.exitCode === 0;\n  } catch {\n    return false;\n  }\n}\n\nasync function waitForNativeOpenSshChild(\n  child: ChildProcessResult,\n  operation: string,\n): Promise<Awaited<ChildProcessResult>> {\n  let timeout: ReturnType<typeof setTimeout>;\n  const timedOut = new Promise<never>((_resolve, reject) => {\n    timeout = setTimeout(() => {\n      void child.shutdown({ terminateTimeout: 0, killTimeout: 1_000 }).then(\n        () => reject(new Error(`${operation} timed out after ${OPENSSH_HELPER_TIMEOUT_MS}ms`)),\n        (error) => reject(error),\n      );\n    }, OPENSSH_HELPER_TIMEOUT_MS);\n    timeout.unref?.();\n  });\n  try {\n    return await Promise.race([child, timedOut]);\n  } finally {\n    clearTimeout(timeout!);\n  }\n}\n\nfunction trackNativeOpenSshProcess(\n  child: ChildProcessResult,\n  parentBound = false,\n): ChildProcessResult {\n  activeNativeOpenSshProcesses.add(child);\n  if (parentBound) parentBoundNativeOpenSshProcesses.add(child);\n  if (!stopParentTerminationSignal) {\n    stopParentTerminationSignal = exec.onParentTerminationSignal(forceStopNativeOpenSshProcesses);\n  }\n  if (!processExitHookInstalled) {\n    processExitHookInstalled = true;\n    process.once(\"exit\", forceStopNativeOpenSshProcesses);\n  }\n  let tracked = true;\n  const untrack = () => {\n    if (!tracked) return;\n    tracked = false;\n    void child.off(\"exit\", untrack);\n    void child.off(\"error\", untrack);\n    activeNativeOpenSshProcesses.delete(child);\n    if (activeNativeOpenSshProcesses.size === 0) {\n      stopParentTerminationSignal?.();\n      stopParentTerminationSignal = undefined;\n      process.off(\"exit\", forceStopNativeOpenSshProcesses);\n      processExitHookInstalled = false;\n    }\n  };\n  void child.once(\"exit\", untrack);\n  void child.once(\"error\", untrack);\n  return child;\n}\n\nfunction forceStopNativeOpenSshProcesses(): void {\n  for (const child of activeNativeOpenSshProcesses) {\n    try {\n      if (parentBoundNativeOpenSshProcesses.has(child)) child.stdin?.end();\n      else child.kill(\"SIGKILL\");\n    } catch {\n      // The child may have exited between the tracked-state check and kill.\n    }\n  }\n}\n\nasync function availableLoopbackPort(): Promise<number> {\n  const server = createServer();\n  await new Promise<void>((resolve, reject) => {\n    server.once(\"error\", reject);\n    server.listen(0, SOCKS_HOST, resolve);\n  });\n  const address = server.address();\n  if (!address || typeof address === \"string\") {\n    server.close();\n    throw new Error(\"Failed to allocate a loopback SOCKS5 port\");\n  }\n  await new Promise<void>((resolve) => server.close(() => resolve()));\n  return address.port;\n}\n\nfunction canConnectLoopback(port: number): Promise<boolean> {\n  return new Promise((resolve) => {\n    const socket = createConnection({ host: SOCKS_HOST, port });\n    let settled = false;\n    const finish = (connected: boolean) => {\n      if (settled) return;\n      settled = true;\n      socket.destroy();\n      resolve(connected);\n    };\n    socket.unref();\n    socket.setTimeout(100, () => finish(false));\n    socket.once(\"error\", () => finish(false));\n    socket.once(\"connect\", () => finish(true));\n  });\n}\n"]}

package/lib/src/_ssh_ssh2.d.ts

@@ -0,0 +1,16 @@
+import type { Duplex } from "node:stream";
+import type { Client as Ssh2Client } from "ssh2";
+import { PooledSshTransport, type SshCommandExecution, type SshPoolOptions, type SshTransportOptions } from "./_ssh.ts";
+interface Ssh2Resource {
+    readonly client: Ssh2Client;
+    alive: boolean;
+}
+/** Exclusive ssh2 connection pool for commands and direct TCP forwarding. */
+export declare class Ssh2Transport extends PooledSshTransport<Ssh2Resource> {
+    readonly kind: "ssh2";
+    private readonly connectTimeoutMs;
+    constructor(options: SshTransportOptions, poolOptions?: SshPoolOptions);
+    protected runWithResource(resource: Ssh2Resource, script: string, execution: SshCommandExecution): Promise<number>;
+    protected connectWithResource(resource: Ssh2Resource, remoteHost: string, remotePort: number): Promise<Duplex>;
+}
+export {};