@dbx-tools/lakebox 0.0.0-stage → 0.9.131

package/lib/src/_ssh.js

@@ -0,0 +1,489 @@
+import { PassThrough } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { createPool } from "generic-pool";
+const logger = log.logger("lakebox:ssh-transport");
+/** Maximum authenticated resources maintained by each SSH operation pool. */
+export const SSH_POOL_MAX = 10;
+/** Live SSH command that streams output and awaits to its numeric exit code. */
+export class SshCommand {
+    command;
+    args;
+    [Symbol.toStringTag] = "SshCommand";
+    /** Live standard output decoded as UTF-8 strings. */
+    stdout;
+    /** Live standard error decoded as UTF-8 strings. */
+    stderr;
+    /** Completed result with captured output, timing, and timeout metadata. */
+    result;
+    /** Numeric exit code after completion. */
+    exitCode;
+    startedAt = Date.now();
+    stdoutStream = new PassThrough();
+    stderrStream = new PassThrough();
+    stdoutDecoder = new StringDecoder("utf8");
+    stderrDecoder = new StringDecoder("utf8");
+    abortController = new AbortController();
+    completion;
+    resolveCompletion;
+    rejectCompletion;
+    cancelBackend;
+    cancellation;
+    stdoutText = "";
+    stderrText = "";
+    settled = false;
+    timedOut = false;
+    /** Creates a command and schedules its asynchronous setup and execution. */
+    constructor(command, args, options, start) {
+        this.command = command;
+        this.args = args;
+        this.stdoutStream.setEncoding("utf8");
+        this.stderrStream.setEncoding("utf8");
+        this.stdout = this.stdoutStream;
+        this.stderr = this.stderrStream;
+        this.completion = new Promise((resolve, reject) => {
+            this.resolveCompletion = resolve;
+            this.rejectCompletion = reject;
+        });
+        this.result = this.completion.then((exitCode) => ({
+            success: exitCode === 0 && !this.timedOut,
+            exitCode,
+            stdout: this.stdoutText,
+            stderr: this.stderrText,
+            executionTimeMs: Date.now() - this.startedAt,
+            ...(this.timedOut ? { timedOut: true } : {}),
+            command: this.command,
+            args: [...this.args],
+        }));
+        void this.completion.catch(() => undefined);
+        void this.result.catch(() => undefined);
+        const externalAbort = () => {
+            void this.cancel().catch(() => undefined);
+        };
+        if (options.signal?.aborted)
+            externalAbort();
+        else
+            options.signal?.addEventListener("abort", externalAbort, { once: true });
+        const timeout = setTimeout(() => {
+            this.timedOut = true;
+            void this.cancel(124).catch(() => undefined);
+        }, options.timeoutMs);
+        timeout.unref?.();
+        const cleanup = () => {
+            clearTimeout(timeout);
+            options.signal?.removeEventListener("abort", externalAbort);
+        };
+        void this.completion.then(cleanup, cleanup);
+        queueMicrotask(() => {
+            if (this.settled)
+                return;
+            void start({
+                signal: this.abortController.signal,
+                stdout: (chunk) => this.writeOutput("stdout", chunk),
+                stderr: (chunk) => this.writeOutput("stderr", chunk),
+                setCancel: (cancel) => {
+                    this.cancelBackend = cancel;
+                    if (this.abortController.signal.aborted) {
+                        void this.invokeCancel().catch(() => undefined);
+                    }
+                },
+                follow: (command) => this.follow(command),
+            }).then((exitCode) => this.finish(exitCode), (error) => this.fail(error));
+        });
+    }
+    /** Cancel the command once. Caller cancellation resolves with exit code 130. */
+    cancel(exitCode = 130) {
+        if (this.settled)
+            return this.cancellation ?? Promise.resolve();
+        if (!this.abortController.signal.aborted)
+            this.abortController.abort();
+        const cancellation = this.invokeCancel();
+        this.finish(exitCode);
+        return cancellation;
+    }
+    then(onfulfilled, onrejected) {
+        return this.completion.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.completion.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.completion.finally(onfinally ?? undefined);
+    }
+    invokeCancel() {
+        if (this.cancellation)
+            return this.cancellation;
+        if (!this.cancelBackend)
+            return Promise.resolve();
+        const cancelBackend = this.cancelBackend;
+        this.cancellation = Promise.resolve()
+            .then(() => cancelBackend())
+            .then(() => undefined);
+        void this.cancellation.catch(() => undefined);
+        return this.cancellation;
+    }
+    writeOutput(stream, chunk) {
+        if (this.settled)
+            return;
+        const decoder = stream === "stdout" ? this.stdoutDecoder : this.stderrDecoder;
+        const value = decoder.write(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+        if (!value)
+            return;
+        if (stream === "stdout") {
+            this.stdoutText += value;
+            this.stdoutStream.write(value);
+        }
+        else {
+            this.stderrText += value;
+            this.stderrStream.write(value);
+        }
+    }
+    async follow(command) {
+        this.cancelBackend = () => command.cancel();
+        if (this.abortController.signal.aborted) {
+            void this.invokeCancel().catch(() => undefined);
+        }
+        const stdout = this.pipe(command.stdout, (chunk) => this.writeOutput("stdout", chunk));
+        const stderr = this.pipe(command.stderr, (chunk) => this.writeOutput("stderr", chunk));
+        const exitCode = await command;
+        await Promise.all([stdout, stderr]);
+        return exitCode;
+    }
+    async pipe(stream, write) {
+        for await (const chunk of stream)
+            write(chunk);
+    }
+    finish(exitCode) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        this.exitCode = exitCode;
+        this.closeOutput();
+        this.resolveCompletion(exitCode);
+    }
+    fail(error) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        this.closeOutput();
+        this.rejectCompletion(error);
+    }
+    closeOutput() {
+        const stdoutRemainder = this.stdoutDecoder.end();
+        const stderrRemainder = this.stderrDecoder.end();
+        if (stdoutRemainder) {
+            this.stdoutText += stdoutRemainder;
+            this.stdoutStream.write(stdoutRemainder);
+        }
+        if (stderrRemainder) {
+            this.stderrText += stderrRemainder;
+            this.stderrStream.write(stderrRemainder);
+        }
+        this.stdoutStream.end();
+        this.stderrStream.end();
+    }
+}
+/**
+ * Exclusive, single-operation SSH resource pool.
+ *
+ * The command pool keeps one authenticated resource warm. Forwarding uses a
+ * separate zero-minimum pool so long-lived WebSockets cannot consume the warm
+ * command connection. Every borrowed resource is destroyed after its command
+ * or forwarded stream because the Databricks Russh gateway may accept only one
+ * operation during a connection's lifetime.
+ */
+export class PooledSshTransport {
+    lifecycle;
+    commandPool;
+    forwardingPool;
+    activeResources = new Map();
+    seededResources = [];
+    lastCreateError;
+    starting;
+    closing;
+    closed = false;
+    constructor(lifecycle, options = {}) {
+        this.lifecycle = lifecycle;
+        const factory = {
+            create: async () => {
+                try {
+                    const resource = this.seededResources.shift() ?? (await lifecycle.create());
+                    this.lastCreateError = undefined;
+                    return resource;
+                }
+                catch (error) {
+                    this.lastCreateError = error;
+                    throw error;
+                }
+            },
+            destroy: (resource) => lifecycle.destroy(resource),
+            validate: async (resource) => {
+                try {
+                    return await lifecycle.test(resource);
+                }
+                catch {
+                    return false;
+                }
+            },
+        };
+        const defaults = {
+            max: options.max ?? SSH_POOL_MAX,
+            acquireTimeoutMillis: options.acquireTimeoutMillis ?? 15_000,
+            idleTimeoutMillis: options.idleTimeoutMillis ?? 30_000,
+            evictionRunIntervalMillis: options.evictionRunIntervalMillis ?? 10_000,
+            numTestsPerEvictionRun: options.numTestsPerEvictionRun ?? 3,
+            testOnBorrow: true,
+            autostart: false,
+        };
+        this.commandPool = createPool(factory, { ...defaults, min: 1 });
+        this.forwardingPool = createPool(factory, { ...defaults, min: 0 });
+    }
+    /** Starts both pools and waits until one tested command resource is warm. */
+    start() {
+        if (this.closed)
+            return Promise.reject(new Error(`${this.kind} SSH transport is closed`));
+        if (this.starting)
+            return this.starting;
+        this.starting = this.startPools();
+        void this.starting
+            .catch(() => this.close())
+            .catch((error) => logger.warn("failed to close SSH transport after startup failure", {
+            kind: this.kind,
+            error: errorUtils.toError(error),
+        }));
+        return this.starting;
+    }
+    async startPools() {
+        if (this.closed)
+            throw new Error(`${this.kind} SSH transport is closed`);
+        const resource = await this.lifecycle.create();
+        if (this.closed) {
+            await this.lifecycle.destroy(resource);
+            throw new Error(`${this.kind} SSH transport is closed`);
+        }
+        this.seededResources.push(resource);
+        this.commandPool.start();
+        this.forwardingPool.start();
+        try {
+            const resource = await this.commandPool.acquire();
+            await this.commandPool.release(resource);
+        }
+        catch (error) {
+            throw this.lastCreateError ?? error;
+        }
+    }
+    async run(script, execution) {
+        const resource = await this.acquire(this.commandPool);
+        try {
+            if (execution.signal.aborted)
+                return 130;
+            return await this.runWithResource(resource, script, execution);
+        }
+        finally {
+            await this.destroy(this.commandPool, resource);
+        }
+    }
+    async connect(remoteHost, remotePort) {
+        const first = await this.acquire(this.forwardingPool);
+        try {
+            return await this.connectWithBorrowedResource(first, remoteHost, remotePort);
+        }
+        catch (error) {
+            await this.destroy(this.forwardingPool, first);
+            if (this.closed)
+                throw error;
+        }
+        const retry = await this.acquire(this.forwardingPool);
+        try {
+            return await this.connectWithBorrowedResource(retry, remoteHost, remotePort);
+        }
+        catch (error) {
+            await this.destroy(this.forwardingPool, retry);
+            throw error;
+        }
+    }
+    async close() {
+        if (this.closing)
+            return this.closing;
+        this.closed = true;
+        this.closing = this.closePools();
+        return this.closing;
+    }
+    async connectWithBorrowedResource(resource, remoteHost, remotePort) {
+        const stream = await this.connectWithResource(resource, remoteHost, remotePort);
+        let disposed = false;
+        const dispose = () => {
+            if (disposed)
+                return;
+            disposed = true;
+            void this.destroy(this.forwardingPool, resource);
+        };
+        stream.once("close", dispose);
+        stream.once("error", dispose);
+        if (stream.destroyed)
+            dispose();
+        return stream;
+    }
+    async acquire(pool) {
+        if (this.closed)
+            throw new Error(`${this.kind} SSH transport is closed`);
+        let resource;
+        try {
+            resource = await pool.acquire();
+        }
+        catch (error) {
+            throw this.lastCreateError ?? error;
+        }
+        this.activeResources.set(resource, pool);
+        if (this.closed) {
+            await this.destroy(pool, resource);
+            throw new Error(`${this.kind} SSH transport is closed`);
+        }
+        return resource;
+    }
+    async destroy(pool, resource) {
+        if (this.activeResources.get(resource) !== pool)
+            return;
+        this.activeResources.delete(resource);
+        try {
+            await pool.destroy(resource);
+        }
+        catch (error) {
+            logger.warn("failed to destroy pooled SSH resource", {
+                kind: this.kind,
+                error: errorUtils.toError(error),
+            });
+        }
+    }
+    async closePools() {
+        await this.starting?.catch(() => undefined);
+        const commandDrain = this.commandPool.drain();
+        const forwardingDrain = this.forwardingPool.drain();
+        await Promise.all([...this.activeResources].map(([resource, pool]) => this.destroy(pool, resource)));
+        await Promise.all([commandDrain, forwardingDrain]);
+        await Promise.all([this.commandPool.clear(), this.forwardingPool.clear()]);
+    }
+}
+/**
+ * Select one SSH transport from resolved policy and keep it for the session.
+ * Auto prefers native OpenSSH and otherwise selects ssh2.
+ */
+export async function createSshTransport(options, overrides = {}) {
+    const factories = { ...defaultSshTransportFactories, ...overrides };
+    const sshCommand = options.sshCommand ?? "ssh";
+    const transportMode = options.transport ?? "auto";
+    if (transportMode === "ssh2") {
+        return factories.createSsh2(options);
+    }
+    const openSshSupported = await factories.supportsOpenSsh(sshCommand);
+    if (transportMode === "openssh" && !openSshSupported) {
+        throw new Error("Native OpenSSH with SOCKS5 forwarding is unavailable");
+    }
+    if (openSshSupported) {
+        return factories.createOpenSsh(options, sshCommand);
+    }
+    if (transportMode !== "auto") {
+        throw new Error(`Unsupported SSH transport: ${transportMode}`);
+    }
+    return factories.createSsh2(options);
+}
+const defaultSshTransportFactories = {
+    supportsOpenSsh: async (command) => {
+        const { supportsNativeOpenSsh } = await import("./_ssh_openssh.js");
+        return supportsNativeOpenSsh(command);
+    },
+    createOpenSsh: async (options, command) => {
+        const { OpenSshTransport } = await import("./_ssh_openssh.js");
+        const transport = new OpenSshTransport(options, command);
+        try {
+            await transport.start();
+            return transport;
+        }
+        catch (error) {
+            await transport.close();
+            throw error;
+        }
+    },
+    createSsh2: async (options) => {
+        const { Ssh2Transport } = await import("./_ssh_ssh2.js");
+        const transport = new Ssh2Transport(options);
+        try {
+            await transport.start();
+            return transport;
+        }
+        catch (error) {
+            await transport.close();
+            throw error;
+        }
+    },
+};
+/** @internal Builds a remote command after clearing inherited machine credentials. */
+export function sshCommandScript(command, args, cwd, env, identity) {
+    assertSafeSshEnvironment(env);
+    const root = identity.kind === "root";
+    const home = root ? "/root" : identity.home;
+    const name = root ? "root" : identity.name;
+    const workingDirectory = cwd ?? home;
+    const invocation = [command, ...scrubLoginShellCommand(command, args)].map(shellQuote).join(" ");
+    const environment = Object.entries({
+        HOME: home,
+        USER: name,
+        LOGNAME: name,
+        SHELL: "/bin/bash",
+        PWD: workingDirectory,
+        PATH: root
+            ? "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
+            : `${home}/.local/bin:/usr/local/bin:/usr/bin:/bin`,
+        DATABRICKS_CONFIG_FILE: "/dev/null",
+        ...env,
+    })
+        .map(([key, value]) => `${environmentName(key)}=${shellQuote(value)}`)
+        .join(" ");
+    const run = `cd -- ${shellQuote(workingDirectory)} && ${invocation}`;
+    const sudoArgs = root ? ["-n", "-H"] : ["-n", "-H", "-u", name];
+    const switched = ["sudo", ...sudoArgs, "--", "env", "-i"].map(shellQuote).join(" ");
+    return `${SSH_AUTH_ENVIRONMENT_SCRUB}\nexec ${switched} ${environment} '/bin/sh' '-c' ${shellQuote(run)} </dev/null`;
+}
+function scrubLoginShellCommand(command, args) {
+    const executable = command.split("/").at(-1);
+    if (!executable || !["sh", "bash", "zsh"].includes(executable) || args[0] !== "-lc") {
+        return args;
+    }
+    const [flags, script, ...rest] = args;
+    if (script === undefined)
+        return args;
+    return [flags, `${SSH_AUTH_ENVIRONMENT_SCRUB}\n${script}`, ...rest];
+}
+const SSH_AUTH_ENVIRONMENT_SCRUB = `for __dbx_tools_name in $(env | sed -n 's/^\\([A-Za-z_][A-Za-z0-9_]*\\)=.*/\\1/p'); do
+  case "$__dbx_tools_name" in
+    DATABRICKS_*|SSH_AUTH_SOCK)
+      unset "$__dbx_tools_name"
+      ;;
+  esac
+done
+export DATABRICKS_CONFIG_FILE=/dev/null`;
+function assertSafeSshEnvironment(env) {
+    for (const name of Object.keys(env ?? {})) {
+        if (name === "HOME" ||
+            name === "USER" ||
+            name === "LOGNAME" ||
+            name === "SHELL" ||
+            name === "PWD" ||
+            name === "PATH" ||
+            name.startsWith("SUDO_") ||
+            name.startsWith("DATABRICKS_") ||
+            name === "SSH_AUTH_SOCK") {
+            throw new Error("SSH environment overlays cannot replace the Lakebox identity or restore Databricks or SSH agent credentials.");
+        }
+    }
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function environmentName(value) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+        throw new Error(`Invalid SSH environment variable name: ${value}`);
+    }
+    return value;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_ssh.js","sourceRoot":"","sources":["../../src/_ssh.ts"],"names":[],"mappings":"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","sourcesContent":["import { PassThrough, type Duplex, type Readable } from \"node:stream\";\nimport { StringDecoder } from \"node:string_decoder\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport type { LakeboxCommandResult } from \"@dbx-tools/shared-lakebox\";\nimport { createPool, type Factory, type Options, type Pool } from \"generic-pool\";\nimport type { Client as Ssh2Client } from \"ssh2\";\nimport type { Ssh2PatchMode, SshTransportMode } from \"./transport.ts\";\n\nconst logger = log.logger(\"lakebox:ssh-transport\");\n/** Maximum authenticated resources maintained by each SSH operation pool. */\nexport const SSH_POOL_MAX = 10;\n\n/** One command execution request after the remote shell script is assembled. */\nexport interface SshExecutionOptions {\n  timeoutMs: number;\n  signal?: AbortSignal;\n}\n\n/** Transport callbacks owned by one live SSH command. */\nexport interface SshCommandExecution {\n  readonly signal: AbortSignal;\n  stdout(chunk: Buffer | string): void;\n  stderr(chunk: Buffer | string): void;\n  setCancel(cancel: () => void | Promise<void>): void;\n  follow(command: SshCommand): Promise<number>;\n}\n\n/** Live SSH command that streams output and awaits to its numeric exit code. */\nexport class SshCommand implements Promise<number> {\n  readonly [Symbol.toStringTag] = \"SshCommand\";\n  /** Live standard output decoded as UTF-8 strings. */\n  readonly stdout: Readable & AsyncIterable<string>;\n  /** Live standard error decoded as UTF-8 strings. */\n  readonly stderr: Readable & AsyncIterable<string>;\n  /** Completed result with captured output, timing, and timeout metadata. */\n  readonly result: Promise<LakeboxCommandResult>;\n  /** Numeric exit code after completion. */\n  exitCode: number | undefined;\n\n  private readonly startedAt = Date.now();\n  private readonly stdoutStream = new PassThrough();\n  private readonly stderrStream = new PassThrough();\n  private readonly stdoutDecoder = new StringDecoder(\"utf8\");\n  private readonly stderrDecoder = new StringDecoder(\"utf8\");\n  private readonly abortController = new AbortController();\n  private readonly completion: Promise<number>;\n  private resolveCompletion!: (exitCode: number) => void;\n  private rejectCompletion!: (error: unknown) => void;\n  private cancelBackend?: () => void | Promise<void>;\n  private cancellation?: Promise<void>;\n  private stdoutText = \"\";\n  private stderrText = \"\";\n  private settled = false;\n  private timedOut = false;\n\n  /** Creates a command and schedules its asynchronous setup and execution. */\n  constructor(\n    readonly command: string,\n    readonly args: readonly string[],\n    options: SshExecutionOptions,\n    start: (execution: SshCommandExecution) => Promise<number>,\n  ) {\n    this.stdoutStream.setEncoding(\"utf8\");\n    this.stderrStream.setEncoding(\"utf8\");\n    this.stdout = this.stdoutStream as Readable & AsyncIterable<string>;\n    this.stderr = this.stderrStream as Readable & AsyncIterable<string>;\n    this.completion = new Promise<number>((resolve, reject) => {\n      this.resolveCompletion = resolve;\n      this.rejectCompletion = reject;\n    });\n    this.result = this.completion.then((exitCode) => ({\n      success: exitCode === 0 && !this.timedOut,\n      exitCode,\n      stdout: this.stdoutText,\n      stderr: this.stderrText,\n      executionTimeMs: Date.now() - this.startedAt,\n      ...(this.timedOut ? { timedOut: true } : {}),\n      command: this.command,\n      args: [...this.args],\n    }));\n    void this.completion.catch(() => undefined);\n    void this.result.catch(() => undefined);\n\n    const externalAbort = () => {\n      void this.cancel().catch(() => undefined);\n    };\n    if (options.signal?.aborted) externalAbort();\n    else options.signal?.addEventListener(\"abort\", externalAbort, { once: true });\n    const timeout = setTimeout(() => {\n      this.timedOut = true;\n      void this.cancel(124).catch(() => undefined);\n    }, options.timeoutMs);\n    timeout.unref?.();\n    const cleanup = () => {\n      clearTimeout(timeout);\n      options.signal?.removeEventListener(\"abort\", externalAbort);\n    };\n    void this.completion.then(cleanup, cleanup);\n\n    queueMicrotask(() => {\n      if (this.settled) return;\n      void start({\n        signal: this.abortController.signal,\n        stdout: (chunk) => this.writeOutput(\"stdout\", chunk),\n        stderr: (chunk) => this.writeOutput(\"stderr\", chunk),\n        setCancel: (cancel) => {\n          this.cancelBackend = cancel;\n          if (this.abortController.signal.aborted) {\n            void this.invokeCancel().catch(() => undefined);\n          }\n        },\n        follow: (command) => this.follow(command),\n      }).then(\n        (exitCode) => this.finish(exitCode),\n        (error) => this.fail(error),\n      );\n    });\n  }\n\n  /** Cancel the command once. Caller cancellation resolves with exit code 130. */\n  cancel(exitCode = 130): Promise<void> {\n    if (this.settled) return this.cancellation ?? Promise.resolve();\n    if (!this.abortController.signal.aborted) this.abortController.abort();\n    const cancellation = this.invokeCancel();\n    this.finish(exitCode);\n    return cancellation;\n  }\n\n  then<TResult1 = number, TResult2 = never>(\n    onfulfilled?: ((value: number) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,\n  ): Promise<TResult1 | TResult2> {\n    return this.completion.then(onfulfilled, onrejected);\n  }\n\n  catch<TResult = never>(\n    onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,\n  ): Promise<number | TResult> {\n    return this.completion.catch(onrejected);\n  }\n\n  finally(onfinally?: (() => void) | null): Promise<number> {\n    return this.completion.finally(onfinally ?? undefined);\n  }\n\n  private invokeCancel(): Promise<void> {\n    if (this.cancellation) return this.cancellation;\n    if (!this.cancelBackend) return Promise.resolve();\n    const cancelBackend = this.cancelBackend;\n    this.cancellation = Promise.resolve()\n      .then(() => cancelBackend())\n      .then(() => undefined);\n    void this.cancellation.catch(() => undefined);\n    return this.cancellation;\n  }\n\n  private writeOutput(stream: \"stdout\" | \"stderr\", chunk: Buffer | string): void {\n    if (this.settled) return;\n    const decoder = stream === \"stdout\" ? this.stdoutDecoder : this.stderrDecoder;\n    const value = decoder.write(typeof chunk === \"string\" ? Buffer.from(chunk) : chunk);\n    if (!value) return;\n    if (stream === \"stdout\") {\n      this.stdoutText += value;\n      this.stdoutStream.write(value);\n    } else {\n      this.stderrText += value;\n      this.stderrStream.write(value);\n    }\n  }\n\n  private async follow(command: SshCommand): Promise<number> {\n    this.cancelBackend = () => command.cancel();\n    if (this.abortController.signal.aborted) {\n      void this.invokeCancel().catch(() => undefined);\n    }\n    const stdout = this.pipe(command.stdout, (chunk) => this.writeOutput(\"stdout\", chunk));\n    const stderr = this.pipe(command.stderr, (chunk) => this.writeOutput(\"stderr\", chunk));\n    const exitCode = await command;\n    await Promise.all([stdout, stderr]);\n    return exitCode;\n  }\n\n  private async pipe(stream: AsyncIterable<string>, write: (chunk: string) => void): Promise<void> {\n    for await (const chunk of stream) write(chunk);\n  }\n\n  private finish(exitCode: number): void {\n    if (this.settled) return;\n    this.settled = true;\n    this.exitCode = exitCode;\n    this.closeOutput();\n    this.resolveCompletion(exitCode);\n  }\n\n  private fail(error: unknown): void {\n    if (this.settled) return;\n    this.settled = true;\n    this.closeOutput();\n    this.rejectCompletion(error);\n  }\n\n  private closeOutput(): void {\n    const stdoutRemainder = this.stdoutDecoder.end();\n    const stderrRemainder = this.stderrDecoder.end();\n    if (stdoutRemainder) {\n      this.stdoutText += stdoutRemainder;\n      this.stdoutStream.write(stdoutRemainder);\n    }\n    if (stderrRemainder) {\n      this.stderrText += stderrRemainder;\n      this.stderrStream.write(stderrRemainder);\n    }\n    this.stdoutStream.end();\n    this.stderrStream.end();\n  }\n}\n\n/** Connection details shared by native OpenSSH and the guarded ssh2 fallback. */\nexport interface SshTransportOptions {\n  host: string;\n  connectHost: string;\n  port: number;\n  username: string;\n  privateKeyPath: string;\n  knownHostsPath: string;\n  connectTimeoutMs: number;\n  ssh2Client: Ssh2Client;\n  createSsh2CommandClient: () => Promise<Ssh2Client>;\n  transport?: SshTransportMode;\n  ssh2Patch?: Ssh2PatchMode;\n  sshCommand?: string;\n}\n\n/** Selected command and remote TCP transport for one verified SSH gateway. */\nexport interface SshTransport {\n  readonly kind: \"openssh\" | \"ssh2\";\n  run(script: string, execution: SshCommandExecution): Promise<number>;\n  connect(remoteHost: string, remotePort: number): Promise<Duplex>;\n  close(): Promise<void>;\n}\n\n/** Async lifecycle used by both native OpenSSH and ssh2 connection pools. */\nexport interface SshResourceLifecycle<T> {\n  create(): Promise<T>;\n  destroy(resource: T): Promise<void>;\n  test(resource: T): Promise<boolean>;\n}\n\n/** Optional pool overrides used by transport tests and constrained runtimes. */\nexport type SshPoolOptions = Pick<\n  Options,\n  | \"max\"\n  | \"acquireTimeoutMillis\"\n  | \"idleTimeoutMillis\"\n  | \"evictionRunIntervalMillis\"\n  | \"numTestsPerEvictionRun\"\n>;\n\n/**\n * Exclusive, single-operation SSH resource pool.\n *\n * The command pool keeps one authenticated resource warm. Forwarding uses a\n * separate zero-minimum pool so long-lived WebSockets cannot consume the warm\n * command connection. Every borrowed resource is destroyed after its command\n * or forwarded stream because the Databricks Russh gateway may accept only one\n * operation during a connection's lifetime.\n */\nexport abstract class PooledSshTransport<T> implements SshTransport {\n  abstract readonly kind: \"openssh\" | \"ssh2\";\n\n  private readonly commandPool: Pool<T>;\n  private readonly forwardingPool: Pool<T>;\n  private readonly activeResources = new Map<T, Pool<T>>();\n  private readonly seededResources: T[] = [];\n  private lastCreateError: unknown;\n  private starting?: Promise<void>;\n  private closing?: Promise<void>;\n  private closed = false;\n\n  protected constructor(\n    private readonly lifecycle: SshResourceLifecycle<T>,\n    options: SshPoolOptions = {},\n  ) {\n    const factory: Factory<T> = {\n      create: async () => {\n        try {\n          const resource = this.seededResources.shift() ?? (await lifecycle.create());\n          this.lastCreateError = undefined;\n          return resource;\n        } catch (error) {\n          this.lastCreateError = error;\n          throw error;\n        }\n      },\n      destroy: (resource) => lifecycle.destroy(resource),\n      validate: async (resource) => {\n        try {\n          return await lifecycle.test(resource);\n        } catch {\n          return false;\n        }\n      },\n    };\n    const defaults: Options = {\n      max: options.max ?? SSH_POOL_MAX,\n      acquireTimeoutMillis: options.acquireTimeoutMillis ?? 15_000,\n      idleTimeoutMillis: options.idleTimeoutMillis ?? 30_000,\n      evictionRunIntervalMillis: options.evictionRunIntervalMillis ?? 10_000,\n      numTestsPerEvictionRun: options.numTestsPerEvictionRun ?? 3,\n      testOnBorrow: true,\n      autostart: false,\n    };\n    this.commandPool = createPool(factory, { ...defaults, min: 1 });\n    this.forwardingPool = createPool(factory, { ...defaults, min: 0 });\n  }\n\n  /** Starts both pools and waits until one tested command resource is warm. */\n  start(): Promise<void> {\n    if (this.closed) return Promise.reject(new Error(`${this.kind} SSH transport is closed`));\n    if (this.starting) return this.starting;\n    this.starting = this.startPools();\n    void this.starting\n      .catch(() => this.close())\n      .catch((error) =>\n        logger.warn(\"failed to close SSH transport after startup failure\", {\n          kind: this.kind,\n          error: errorUtils.toError(error),\n        }),\n      );\n    return this.starting;\n  }\n\n  private async startPools(): Promise<void> {\n    if (this.closed) throw new Error(`${this.kind} SSH transport is closed`);\n    const resource = await this.lifecycle.create();\n    if (this.closed) {\n      await this.lifecycle.destroy(resource);\n      throw new Error(`${this.kind} SSH transport is closed`);\n    }\n    this.seededResources.push(resource);\n    this.commandPool.start();\n    this.forwardingPool.start();\n    try {\n      const resource = await this.commandPool.acquire();\n      await this.commandPool.release(resource);\n    } catch (error) {\n      throw this.lastCreateError ?? error;\n    }\n  }\n\n  async run(script: string, execution: SshCommandExecution): Promise<number> {\n    const resource = await this.acquire(this.commandPool);\n    try {\n      if (execution.signal.aborted) return 130;\n      return await this.runWithResource(resource, script, execution);\n    } finally {\n      await this.destroy(this.commandPool, resource);\n    }\n  }\n\n  async connect(remoteHost: string, remotePort: number): Promise<Duplex> {\n    const first = await this.acquire(this.forwardingPool);\n    try {\n      return await this.connectWithBorrowedResource(first, remoteHost, remotePort);\n    } catch (error) {\n      await this.destroy(this.forwardingPool, first);\n      if (this.closed) throw error;\n    }\n    const retry = await this.acquire(this.forwardingPool);\n    try {\n      return await this.connectWithBorrowedResource(retry, remoteHost, remotePort);\n    } catch (error) {\n      await this.destroy(this.forwardingPool, retry);\n      throw error;\n    }\n  }\n\n  async close(): Promise<void> {\n    if (this.closing) return this.closing;\n    this.closed = true;\n    this.closing = this.closePools();\n    return this.closing;\n  }\n\n  protected abstract runWithResource(\n    resource: T,\n    script: string,\n    execution: SshCommandExecution,\n  ): Promise<number>;\n\n  protected abstract connectWithResource(\n    resource: T,\n    remoteHost: string,\n    remotePort: number,\n  ): Promise<Duplex>;\n\n  private async connectWithBorrowedResource(\n    resource: T,\n    remoteHost: string,\n    remotePort: number,\n  ): Promise<Duplex> {\n    const stream = await this.connectWithResource(resource, remoteHost, remotePort);\n    let disposed = false;\n    const dispose = () => {\n      if (disposed) return;\n      disposed = true;\n      void this.destroy(this.forwardingPool, resource);\n    };\n    stream.once(\"close\", dispose);\n    stream.once(\"error\", dispose);\n    if (stream.destroyed) dispose();\n    return stream;\n  }\n\n  private async acquire(pool: Pool<T>): Promise<T> {\n    if (this.closed) throw new Error(`${this.kind} SSH transport is closed`);\n    let resource: T;\n    try {\n      resource = await pool.acquire();\n    } catch (error) {\n      throw this.lastCreateError ?? error;\n    }\n    this.activeResources.set(resource, pool);\n    if (this.closed) {\n      await this.destroy(pool, resource);\n      throw new Error(`${this.kind} SSH transport is closed`);\n    }\n    return resource;\n  }\n\n  private async destroy(pool: Pool<T>, resource: T): Promise<void> {\n    if (this.activeResources.get(resource) !== pool) return;\n    this.activeResources.delete(resource);\n    try {\n      await pool.destroy(resource);\n    } catch (error) {\n      logger.warn(\"failed to destroy pooled SSH resource\", {\n        kind: this.kind,\n        error: errorUtils.toError(error),\n      });\n    }\n  }\n\n  private async closePools(): Promise<void> {\n    await this.starting?.catch(() => undefined);\n    const commandDrain = this.commandPool.drain();\n    const forwardingDrain = this.forwardingPool.drain();\n    await Promise.all(\n      [...this.activeResources].map(([resource, pool]) => this.destroy(pool, resource)),\n    );\n    await Promise.all([commandDrain, forwardingDrain]);\n    await Promise.all([this.commandPool.clear(), this.forwardingPool.clear()]);\n  }\n}\n\n/** Injectable transport constructors used to isolate policy selection in tests. */\nexport interface SshTransportFactories {\n  supportsOpenSsh(command: string): Promise<boolean>;\n  createOpenSsh(options: SshTransportOptions, command: string): Promise<SshTransport>;\n  createSsh2(options: SshTransportOptions): Promise<SshTransport>;\n}\n\n/**\n * Select one SSH transport from resolved policy and keep it for the session.\n * Auto prefers native OpenSSH and otherwise selects ssh2.\n */\nexport async function createSshTransport(\n  options: SshTransportOptions,\n  overrides: Partial<SshTransportFactories> = {},\n): Promise<SshTransport> {\n  const factories = { ...defaultSshTransportFactories, ...overrides };\n  const sshCommand = options.sshCommand ?? \"ssh\";\n  const transportMode = options.transport ?? \"auto\";\n  if (transportMode === \"ssh2\") {\n    return factories.createSsh2(options);\n  }\n  const openSshSupported = await factories.supportsOpenSsh(sshCommand);\n  if (transportMode === \"openssh\" && !openSshSupported) {\n    throw new Error(\"Native OpenSSH with SOCKS5 forwarding is unavailable\");\n  }\n  if (openSshSupported) {\n    return factories.createOpenSsh(options, sshCommand);\n  }\n  if (transportMode !== \"auto\") {\n    throw new Error(`Unsupported SSH transport: ${transportMode}`);\n  }\n  return factories.createSsh2(options);\n}\n\nconst defaultSshTransportFactories: SshTransportFactories = {\n  supportsOpenSsh: async (command) => {\n    const { supportsNativeOpenSsh } = await import(\"./_ssh_openssh.ts\");\n    return supportsNativeOpenSsh(command);\n  },\n  createOpenSsh: async (options, command) => {\n    const { OpenSshTransport } = await import(\"./_ssh_openssh.ts\");\n    const transport = new OpenSshTransport(options, command);\n    try {\n      await transport.start();\n      return transport;\n    } catch (error) {\n      await transport.close();\n      throw error;\n    }\n  },\n  createSsh2: async (options) => {\n    const { Ssh2Transport } = await import(\"./_ssh_ssh2.ts\");\n    const transport = new Ssh2Transport(options);\n    try {\n      await transport.start();\n      return transport;\n    } catch (error) {\n      await transport.close();\n      throw error;\n    }\n  },\n};\n\n/**\n * Account that runs one remote command.\n *\n * `user` targets a locked, non-sudo Lakebox account. `root` is reserved for\n * fixed package-owned bootstrap scripts and is never reachable from REST,\n * agent tools, or service definitions.\n */\nexport type SshCommandIdentity = { kind: \"user\"; name: string; home: string } | { kind: \"root\" };\n\n/** @internal Builds a remote command after clearing inherited machine credentials. */\nexport function sshCommandScript(\n  command: string,\n  args: string[],\n  cwd: string | undefined,\n  env: Record<string, string> | undefined,\n  identity: SshCommandIdentity,\n): string {\n  assertSafeSshEnvironment(env);\n  const root = identity.kind === \"root\";\n  const home = root ? \"/root\" : identity.home;\n  const name = root ? \"root\" : identity.name;\n  const workingDirectory = cwd ?? home;\n  const invocation = [command, ...scrubLoginShellCommand(command, args)].map(shellQuote).join(\" \");\n  const environment = Object.entries({\n    HOME: home,\n    USER: name,\n    LOGNAME: name,\n    SHELL: \"/bin/bash\",\n    PWD: workingDirectory,\n    PATH: root\n      ? \"/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin\"\n      : `${home}/.local/bin:/usr/local/bin:/usr/bin:/bin`,\n    DATABRICKS_CONFIG_FILE: \"/dev/null\",\n    ...env,\n  })\n    .map(([key, value]) => `${environmentName(key)}=${shellQuote(value)}`)\n    .join(\" \");\n  const run = `cd -- ${shellQuote(workingDirectory)} && ${invocation}`;\n  const sudoArgs = root ? [\"-n\", \"-H\"] : [\"-n\", \"-H\", \"-u\", name];\n  const switched = [\"sudo\", ...sudoArgs, \"--\", \"env\", \"-i\"].map(shellQuote).join(\" \");\n  return `${SSH_AUTH_ENVIRONMENT_SCRUB}\\nexec ${switched} ${environment} '/bin/sh' '-c' ${shellQuote(run)} </dev/null`;\n}\n\nfunction scrubLoginShellCommand(command: string, args: string[]): string[] {\n  const executable = command.split(\"/\").at(-1);\n  if (!executable || ![\"sh\", \"bash\", \"zsh\"].includes(executable) || args[0] !== \"-lc\") {\n    return args;\n  }\n  const [flags, script, ...rest] = args;\n  if (script === undefined) return args;\n  return [flags, `${SSH_AUTH_ENVIRONMENT_SCRUB}\\n${script}`, ...rest];\n}\n\nconst SSH_AUTH_ENVIRONMENT_SCRUB = `for __dbx_tools_name in $(env | sed -n 's/^\\\\([A-Za-z_][A-Za-z0-9_]*\\\\)=.*/\\\\1/p'); do\n  case \"$__dbx_tools_name\" in\n    DATABRICKS_*|SSH_AUTH_SOCK)\n      unset \"$__dbx_tools_name\"\n      ;;\n  esac\ndone\nexport DATABRICKS_CONFIG_FILE=/dev/null`;\n\nfunction assertSafeSshEnvironment(env: Readonly<Record<string, string>> | undefined): void {\n  for (const name of Object.keys(env ?? {})) {\n    if (\n      name === \"HOME\" ||\n      name === \"USER\" ||\n      name === \"LOGNAME\" ||\n      name === \"SHELL\" ||\n      name === \"PWD\" ||\n      name === \"PATH\" ||\n      name.startsWith(\"SUDO_\") ||\n      name.startsWith(\"DATABRICKS_\") ||\n      name === \"SSH_AUTH_SOCK\"\n    ) {\n      throw new Error(\n        \"SSH environment overlays cannot replace the Lakebox identity or restore Databricks or SSH agent credentials.\",\n      );\n    }\n  }\n}\n\nfunction shellQuote(value: string): string {\n  return `'${value.replaceAll(\"'\", \"'\\\\''\")}'`;\n}\n\nfunction environmentName(value: string): string {\n  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {\n    throw new Error(`Invalid SSH environment variable name: ${value}`);\n  }\n  return value;\n}\n"]}

package/lib/src/_ssh_openssh.d.ts

@@ -0,0 +1,18 @@
+import type { Duplex } from "node:stream";
+import { PooledSshTransport, type SshCommandExecution, type SshPoolOptions, type SshResourceLifecycle, type SshTransportOptions } from "./_ssh.ts";
+/** One authenticated native OpenSSH ControlMaster resource. */
+export interface OpenSshResource {
+    run(script: string, execution: SshCommandExecution): Promise<number>;
+    connect(remoteHost: string, remotePort: number): Promise<Duplex>;
+    test(): Promise<boolean>;
+    close(): Promise<void>;
+}
+/** Exclusive native OpenSSH ControlMaster pool. */
+export declare class OpenSshTransport extends PooledSshTransport<OpenSshResource> {
+    readonly kind: "openssh";
+    constructor(options: SshTransportOptions, command: string, poolOptions?: SshPoolOptions, lifecycle?: SshResourceLifecycle<OpenSshResource>);
+    protected runWithResource(resource: OpenSshResource, script: string, execution: SshCommandExecution): Promise<number>;
+    protected connectWithResource(resource: OpenSshResource, remoteHost: string, remotePort: number): Promise<Duplex>;
+}
+/** Return whether an executable is OpenSSH and accepts dynamic SOCKS5 forwarding. */
+export declare function supportsNativeOpenSsh(command?: string): Promise<boolean>;