@dbx-tools/lakebox 0.0.0-stage → 0.9.132

package/lib/src/session.js

@@ -0,0 +1,309 @@
+import { createHash } from "node:crypto";
+import { isIP } from "node:net";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import ssh2 from "ssh2";
+import { z } from "zod";
+import { createSshTransport, SshCommand, sshCommandScript, } from "./_ssh.js";
+export { SshCommand, sshCommandScript } from "./_ssh.js";
+const { Client } = ssh2;
+const logger = log.logger("lakebox:ssh");
+const SERVICE_DIRECT_SUFFIX = ".service-direct.cloud.databricks.com";
+const DnsAnswerSchema = z
+    .object({
+    type: z.number().int().describe("DNS record type number."),
+    data: z.string().describe("DNS record value."),
+})
+    .passthrough()
+    .describe("One DNS-over-HTTPS answer record.");
+const DnsResponseSchema = z
+    .object({
+    Answer: z.array(DnsAnswerSchema).optional().describe("Resolved DNS answer records."),
+})
+    .passthrough()
+    .describe("Google DNS-over-HTTPS JSON response.");
+/**
+ * Verified SSH session that delegates commands and remote TCP connections to
+ * the transport selected by `src/_ssh.ts`.
+ *
+ * The initial ssh2 handshake verifies and persists the Databricks gateway host
+ * key. The selected transport then starts its pooled command and forwarding
+ * resources. Resolved transport and patch policy determine whether the verified
+ * client seeds the ssh2 pool or is replaced by native OpenSSH ControlMasters.
+ */
+export class SshSession {
+    options;
+    activeCommands = new Set();
+    pendingClients = new Set();
+    transport;
+    connecting;
+    closing;
+    knownHost;
+    closed = false;
+    /** Creates a disconnected session. Call {@link connect} or another operation to connect. */
+    constructor(options) {
+        this.options = options;
+        this.knownHost = options.knownHost;
+    }
+    /**
+     * Verifies the gateway, resolves its public fallback when necessary, and
+     * selects the command and forwarding transport.
+     */
+    async connect() {
+        if (this.closed)
+            throw new Error("SSH session is closed");
+        if (this.transport)
+            return;
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = this.connectWithFallback().catch((error) => {
+            this.connecting = undefined;
+            throw error;
+        });
+        return this.connecting;
+    }
+    async connectWithFallback() {
+        try {
+            await this.connectHost(this.options.host);
+        }
+        catch (error) {
+            if (!shouldResolvePublicGateway(this.options.host, error))
+                throw error;
+            const resolveAddresses = this.options.resolvePublicAddresses ?? resolvePublicGatewayAddresses;
+            let addresses;
+            try {
+                addresses = await resolveAddresses(this.options.host);
+            }
+            catch (resolveError) {
+                logger.warn("public Lakebox gateway resolution failed", {
+                    host: this.options.host,
+                    error: errorUtils.toError(resolveError),
+                });
+                throw error;
+            }
+            logger.warn("private Lakebox gateway unreachable; retrying public addresses", {
+                host: this.options.host,
+                addressCount: addresses.length,
+            });
+            let lastError = error;
+            for (const address of addresses) {
+                try {
+                    await this.connectHost(address);
+                    return;
+                }
+                catch (connectError) {
+                    lastError = connectError;
+                }
+            }
+            throw lastError;
+        }
+    }
+    async connectHost(connectHost) {
+        if (this.closed)
+            throw new Error("SSH session is closed");
+        const client = await this.createVerifiedClient(connectHost, true);
+        if (this.closed) {
+            client.destroy();
+            throw new Error("SSH session is closed");
+        }
+        try {
+            const transport = await createSshTransport({
+                host: this.options.host,
+                connectHost,
+                port: this.options.port,
+                username: this.options.username,
+                privateKeyPath: this.options.privateKeyPath,
+                knownHostsPath: this.options.knownHostsPath,
+                connectTimeoutMs: this.options.connectTimeoutMs,
+                ssh2Client: client,
+                createSsh2CommandClient: () => this.createVerifiedClient(connectHost, false),
+                transport: this.options.sshTransport,
+                ssh2Patch: this.options.ssh2Patch,
+                ...(this.options.sshCommand ? { sshCommand: this.options.sshCommand } : {}),
+            });
+            if (this.closed) {
+                await transport.close();
+                throw new Error("SSH session is closed");
+            }
+            this.transport = transport;
+            this.connecting = undefined;
+            if (transport.kind === "openssh")
+                client.destroy();
+        }
+        catch (error) {
+            client.destroy();
+            throw error;
+        }
+    }
+    createVerifiedClient(connectHost, rememberHost) {
+        return new Promise((resolve, reject) => {
+            if (this.closed) {
+                reject(new Error("SSH session is closed"));
+                return;
+            }
+            const client = new Client();
+            this.pendingClients.add(client);
+            let verifiedHost;
+            let settled = false;
+            const finishSettlement = () => {
+                this.pendingClients.delete(client);
+            };
+            client.once("ready", () => {
+                const finish = async () => {
+                    if (!verifiedHost)
+                        throw new Error("SSH gateway did not provide a verified host key");
+                    this.knownHost = verifiedHost.fingerprint;
+                    if (rememberHost) {
+                        await this.options.rememberHost?.(verifiedHost.fingerprint, verifiedHost.key);
+                    }
+                    settled = true;
+                    finishSettlement();
+                    resolve(client);
+                };
+                void finish().catch((error) => {
+                    client.destroy();
+                    if (settled)
+                        return;
+                    settled = true;
+                    finishSettlement();
+                    reject(error);
+                });
+            });
+            client.once("error", (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                finishSettlement();
+                reject(error);
+            });
+            client.once("close", () => {
+                if (settled)
+                    return;
+                settled = true;
+                finishSettlement();
+                reject(new Error("SSH gateway closed before authentication completed"));
+            });
+            try {
+                client.connect({
+                    host: connectHost,
+                    port: this.options.port,
+                    username: this.options.username,
+                    privateKey: this.options.privateKey,
+                    readyTimeout: this.options.connectTimeoutMs,
+                    keepaliveInterval: 15_000,
+                    keepaliveCountMax: 3,
+                    hostVerifier: (key) => {
+                        const fingerprint = createHash("sha256").update(key).digest("base64");
+                        if (this.knownHost && fingerprint !== this.knownHost)
+                            return false;
+                        verifiedHost = { fingerprint, key: Buffer.from(key) };
+                        return true;
+                    },
+                });
+            }
+            catch (error) {
+                settled = true;
+                finishSettlement();
+                client.destroy();
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Starts one command as a Lakebox user and returns its live output and
+     * completion state immediately.
+     */
+    execute(command, args, options) {
+        const { user, ...rest } = options;
+        return this.startCommand(command, args, rest, { kind: "user", ...user });
+    }
+    /**
+     * @internal Starts one fixed package-owned bootstrap command as root.
+     *
+     * Never route REST, agent-tool, service, or environment input here.
+     */
+    executePrivileged(command, args, options) {
+        return this.startCommand(command, args, options, { kind: "root" });
+    }
+    startCommand(command, args, options, identity) {
+        const script = sshCommandScript(command, args, options.cwd, options.env, identity);
+        const sshCommand = new SshCommand(command, args, options, async (execution) => {
+            await this.connect();
+            if (execution.signal.aborted)
+                return 130;
+            const transport = this.transport;
+            if (!transport)
+                throw new Error("SSH transport did not initialize");
+            return transport.run(script, execution);
+        });
+        this.activeCommands.add(sshCommand);
+        const remove = () => this.activeCommands.delete(sshCommand);
+        void sshCommand.result.then(remove, remove);
+        return sshCommand;
+    }
+    /** Opens a remote TCP connection through native SOCKS5 or ssh2 direct forwarding. */
+    async forwardOut(remoteHost, remotePort) {
+        await this.connect();
+        const transport = this.transport;
+        if (!transport)
+            throw new Error("SSH transport did not initialize");
+        return transport.connect(remoteHost, remotePort);
+    }
+    /** Cancels active commands, closes the selected transport, and clears connection state. */
+    close() {
+        if (this.closing)
+            return this.closing;
+        this.closed = true;
+        this.closing = this.closeResources();
+        return this.closing;
+    }
+    async closeResources() {
+        const cancellations = [...this.activeCommands].map((command) => command.cancel());
+        this.activeCommands.clear();
+        for (const client of this.pendingClients)
+            client.destroy();
+        this.pendingClients.clear();
+        const transport = this.transport;
+        const connecting = this.connecting;
+        this.transport = undefined;
+        this.connecting = undefined;
+        const results = await Promise.allSettled([
+            ...cancellations,
+            ...(transport ? [transport.close()] : []),
+            ...(connecting ? [connecting] : []),
+        ]);
+        for (const result of results) {
+            if (result.status === "rejected") {
+                logger.warn("failed to close SSH session resource", {
+                    error: errorUtils.toError(result.reason),
+                });
+            }
+        }
+    }
+}
+/**
+ * Resolves public IPv4 addresses for a Databricks service-direct gateway.
+ *
+ * Returns an empty list for other hostnames. DNS-over-HTTPS requests time out
+ * after five seconds and reject invalid responses.
+ */
+export async function resolvePublicGatewayAddresses(host, fetcher = fetch) {
+    if (!host.toLowerCase().endsWith(SERVICE_DIRECT_SUFFIX))
+        return [];
+    const response = await fetcher(`https://dns.google/resolve?name=${encodeURIComponent(host)}&type=A`, { headers: { Accept: "application/dns-json" }, signal: AbortSignal.timeout(5_000) });
+    if (!response.ok)
+        throw new Error(`Public DNS resolution failed (${response.status})`);
+    const payload = DnsResponseSchema.parse(await response.json());
+    return [
+        ...new Set((payload.Answer ?? [])
+            .filter((answer) => answer.type === 1 && isIP(answer.data) === 4)
+            .map((answer) => answer.data)),
+    ];
+}
+function shouldResolvePublicGateway(host, error) {
+    if (!host.toLowerCase().endsWith(SERVICE_DIRECT_SUFFIX))
+        return false;
+    const code = error?.code ??
+        error?.cause?.code;
+    return code === "EHOSTUNREACH" || code === "ENETUNREACH" || code === "ETIMEDOUT";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session.js","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from \"node:crypto\";\nimport { isIP } from \"node:net\";\nimport type { Duplex } from \"node:stream\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport ssh2, { type Client as Ssh2Client } from \"ssh2\";\nimport { z } from \"zod\";\nimport {\n  createSshTransport,\n  SshCommand,\n  sshCommandScript,\n  type SshCommandIdentity,\n  type SshTransport,\n} from \"./_ssh.ts\";\nimport type { Ssh2PatchMode, SshTransportMode } from \"./transport.ts\";\n\nexport { SshCommand, sshCommandScript, type SshCommandIdentity } from \"./_ssh.ts\";\n\nconst { Client } = ssh2;\nconst logger = log.logger(\"lakebox:ssh\");\nconst SERVICE_DIRECT_SUFFIX = \".service-direct.cloud.databricks.com\";\n\nconst DnsAnswerSchema = z\n  .object({\n    type: z.number().int().describe(\"DNS record type number.\"),\n    data: z.string().describe(\"DNS record value.\"),\n  })\n  .passthrough()\n  .describe(\"One DNS-over-HTTPS answer record.\");\n\nconst DnsResponseSchema = z\n  .object({\n    Answer: z.array(DnsAnswerSchema).optional().describe(\"Resolved DNS answer records.\"),\n  })\n  .passthrough()\n  .describe(\"Google DNS-over-HTTPS JSON response.\");\n\n/** Connection, key, host-verification, and command settings for one SSH machine. */\nexport interface SshSessionOptions {\n  /** Databricks Lakebox gateway hostname. */\n  host: string;\n  /** SSH gateway port. */\n  port: number;\n  /** SSH username accepted by the gateway: the Lakebox ID. */\n  username: string;\n  /** In-memory private key used for the verified SSH handshake and ssh2 fallback. */\n  privateKey: string;\n  /** Private key file used by native OpenSSH. */\n  privateKeyPath: string;\n  /** Dedicated OpenSSH known-host file for this workspace, user, and gateway. */\n  knownHostsPath: string;\n  /** Connection timeout in milliseconds. */\n  connectTimeoutMs: number;\n  /** SSH transport selected for this session. */\n  sshTransport: SshTransportMode;\n  /** ssh2 missing-exec-reply patch policy. */\n  ssh2Patch: Ssh2PatchMode;\n  /** Previously trusted SHA-256 host-key fingerprint. */\n  knownHost?: string;\n  /** Persists the accepted host key for both ssh2 and native OpenSSH. */\n  rememberHost?: (fingerprint: string, key: Buffer) => Promise<void>;\n  /** Native OpenSSH executable. Defaults to `ssh` on `PATH`. */\n  sshCommand?: string;\n  /** Resolves public fallback addresses for a service-direct gateway. */\n  resolvePublicAddresses?: (host: string) => Promise<string[]>;\n}\n\n/**\n * Verified SSH session that delegates commands and remote TCP connections to\n * the transport selected by `src/_ssh.ts`.\n *\n * The initial ssh2 handshake verifies and persists the Databricks gateway host\n * key. The selected transport then starts its pooled command and forwarding\n * resources. Resolved transport and patch policy determine whether the verified\n * client seeds the ssh2 pool or is replaced by native OpenSSH ControlMasters.\n */\nexport class SshSession {\n  private readonly activeCommands = new Set<SshCommand>();\n  private readonly pendingClients = new Set<Ssh2Client>();\n  private transport?: SshTransport;\n  private connecting?: Promise<void>;\n  private closing?: Promise<void>;\n  private knownHost?: string;\n  private closed = false;\n\n  /** Creates a disconnected session. Call {@link connect} or another operation to connect. */\n  constructor(private readonly options: SshSessionOptions) {\n    this.knownHost = options.knownHost;\n  }\n\n  /**\n   * Verifies the gateway, resolves its public fallback when necessary, and\n   * selects the command and forwarding transport.\n   */\n  async connect(): Promise<void> {\n    if (this.closed) throw new Error(\"SSH session is closed\");\n    if (this.transport) return;\n    if (this.connecting) return this.connecting;\n    this.connecting = this.connectWithFallback().catch((error) => {\n      this.connecting = undefined;\n      throw error;\n    });\n    return this.connecting;\n  }\n\n  private async connectWithFallback(): Promise<void> {\n    try {\n      await this.connectHost(this.options.host);\n    } catch (error) {\n      if (!shouldResolvePublicGateway(this.options.host, error)) throw error;\n      const resolveAddresses = this.options.resolvePublicAddresses ?? resolvePublicGatewayAddresses;\n      let addresses: string[];\n      try {\n        addresses = await resolveAddresses(this.options.host);\n      } catch (resolveError) {\n        logger.warn(\"public Lakebox gateway resolution failed\", {\n          host: this.options.host,\n          error: errorUtils.toError(resolveError),\n        });\n        throw error;\n      }\n      logger.warn(\"private Lakebox gateway unreachable; retrying public addresses\", {\n        host: this.options.host,\n        addressCount: addresses.length,\n      });\n      let lastError: unknown = error;\n      for (const address of addresses) {\n        try {\n          await this.connectHost(address);\n          return;\n        } catch (connectError) {\n          lastError = connectError;\n        }\n      }\n      throw lastError;\n    }\n  }\n\n  private async connectHost(connectHost: string): Promise<void> {\n    if (this.closed) throw new Error(\"SSH session is closed\");\n    const client = await this.createVerifiedClient(connectHost, true);\n    if (this.closed) {\n      client.destroy();\n      throw new Error(\"SSH session is closed\");\n    }\n    try {\n      const transport = await createSshTransport({\n        host: this.options.host,\n        connectHost,\n        port: this.options.port,\n        username: this.options.username,\n        privateKeyPath: this.options.privateKeyPath,\n        knownHostsPath: this.options.knownHostsPath,\n        connectTimeoutMs: this.options.connectTimeoutMs,\n        ssh2Client: client,\n        createSsh2CommandClient: () => this.createVerifiedClient(connectHost, false),\n        transport: this.options.sshTransport,\n        ssh2Patch: this.options.ssh2Patch,\n        ...(this.options.sshCommand ? { sshCommand: this.options.sshCommand } : {}),\n      });\n      if (this.closed) {\n        await transport.close();\n        throw new Error(\"SSH session is closed\");\n      }\n      this.transport = transport;\n      this.connecting = undefined;\n      if (transport.kind === \"openssh\") client.destroy();\n    } catch (error) {\n      client.destroy();\n      throw error;\n    }\n  }\n\n  private createVerifiedClient(connectHost: string, rememberHost: boolean): Promise<Ssh2Client> {\n    return new Promise((resolve, reject) => {\n      if (this.closed) {\n        reject(new Error(\"SSH session is closed\"));\n        return;\n      }\n      const client = new Client();\n      this.pendingClients.add(client);\n      let verifiedHost: { fingerprint: string; key: Buffer } | undefined;\n      let settled = false;\n      const finishSettlement = () => {\n        this.pendingClients.delete(client);\n      };\n      client.once(\"ready\", () => {\n        const finish = async () => {\n          if (!verifiedHost) throw new Error(\"SSH gateway did not provide a verified host key\");\n          this.knownHost = verifiedHost.fingerprint;\n          if (rememberHost) {\n            await this.options.rememberHost?.(verifiedHost.fingerprint, verifiedHost.key);\n          }\n          settled = true;\n          finishSettlement();\n          resolve(client);\n        };\n        void finish().catch((error) => {\n          client.destroy();\n          if (settled) return;\n          settled = true;\n          finishSettlement();\n          reject(error);\n        });\n      });\n      client.once(\"error\", (error) => {\n        if (settled) return;\n        settled = true;\n        finishSettlement();\n        reject(error);\n      });\n      client.once(\"close\", () => {\n        if (settled) return;\n        settled = true;\n        finishSettlement();\n        reject(new Error(\"SSH gateway closed before authentication completed\"));\n      });\n      try {\n        client.connect({\n          host: connectHost,\n          port: this.options.port,\n          username: this.options.username,\n          privateKey: this.options.privateKey,\n          readyTimeout: this.options.connectTimeoutMs,\n          keepaliveInterval: 15_000,\n          keepaliveCountMax: 3,\n          hostVerifier: (key: Buffer) => {\n            const fingerprint = createHash(\"sha256\").update(key).digest(\"base64\");\n            if (this.knownHost && fingerprint !== this.knownHost) return false;\n            verifiedHost = { fingerprint, key: Buffer.from(key) };\n            return true;\n          },\n        });\n      } catch (error) {\n        settled = true;\n        finishSettlement();\n        client.destroy();\n        reject(error);\n      }\n    });\n  }\n\n  /**\n   * Starts one command as a Lakebox user and returns its live output and\n   * completion state immediately.\n   */\n  execute(\n    command: string,\n    args: string[],\n    options: {\n      user: { name: string; home: string };\n      cwd?: string;\n      env?: Record<string, string>;\n      timeoutMs: number;\n      signal?: AbortSignal;\n    },\n  ): SshCommand {\n    const { user, ...rest } = options;\n    return this.startCommand(command, args, rest, { kind: \"user\", ...user });\n  }\n\n  /**\n   * @internal Starts one fixed package-owned bootstrap command as root.\n   *\n   * Never route REST, agent-tool, service, or environment input here.\n   */\n  executePrivileged(\n    command: string,\n    args: string[],\n    options: { timeoutMs: number; signal?: AbortSignal },\n  ): SshCommand {\n    return this.startCommand(command, args, options, { kind: \"root\" });\n  }\n\n  private startCommand(\n    command: string,\n    args: string[],\n    options: {\n      cwd?: string;\n      env?: Record<string, string>;\n      timeoutMs: number;\n      signal?: AbortSignal;\n    },\n    identity: SshCommandIdentity,\n  ): SshCommand {\n    const script = sshCommandScript(command, args, options.cwd, options.env, identity);\n    const sshCommand = new SshCommand(command, args, options, async (execution) => {\n      await this.connect();\n      if (execution.signal.aborted) return 130;\n      const transport = this.transport;\n      if (!transport) throw new Error(\"SSH transport did not initialize\");\n      return transport.run(script, execution);\n    });\n    this.activeCommands.add(sshCommand);\n    const remove = () => this.activeCommands.delete(sshCommand);\n    void sshCommand.result.then(remove, remove);\n    return sshCommand;\n  }\n\n  /** Opens a remote TCP connection through native SOCKS5 or ssh2 direct forwarding. */\n  async forwardOut(remoteHost: string, remotePort: number): Promise<Duplex> {\n    await this.connect();\n    const transport = this.transport;\n    if (!transport) throw new Error(\"SSH transport did not initialize\");\n    return transport.connect(remoteHost, remotePort);\n  }\n\n  /** Cancels active commands, closes the selected transport, and clears connection state. */\n  close(): Promise<void> {\n    if (this.closing) return this.closing;\n    this.closed = true;\n    this.closing = this.closeResources();\n    return this.closing;\n  }\n\n  private async closeResources(): Promise<void> {\n    const cancellations = [...this.activeCommands].map((command) => command.cancel());\n    this.activeCommands.clear();\n    for (const client of this.pendingClients) client.destroy();\n    this.pendingClients.clear();\n    const transport = this.transport;\n    const connecting = this.connecting;\n    this.transport = undefined;\n    this.connecting = undefined;\n    const results = await Promise.allSettled([\n      ...cancellations,\n      ...(transport ? [transport.close()] : []),\n      ...(connecting ? [connecting] : []),\n    ]);\n    for (const result of results) {\n      if (result.status === \"rejected\") {\n        logger.warn(\"failed to close SSH session resource\", {\n          error: errorUtils.toError(result.reason),\n        });\n      }\n    }\n  }\n}\n\n/**\n * Resolves public IPv4 addresses for a Databricks service-direct gateway.\n *\n * Returns an empty list for other hostnames. DNS-over-HTTPS requests time out\n * after five seconds and reject invalid responses.\n */\nexport async function resolvePublicGatewayAddresses(\n  host: string,\n  fetcher: typeof fetch = fetch,\n): Promise<string[]> {\n  if (!host.toLowerCase().endsWith(SERVICE_DIRECT_SUFFIX)) return [];\n  const response = await fetcher(\n    `https://dns.google/resolve?name=${encodeURIComponent(host)}&type=A`,\n    { headers: { Accept: \"application/dns-json\" }, signal: AbortSignal.timeout(5_000) },\n  );\n  if (!response.ok) throw new Error(`Public DNS resolution failed (${response.status})`);\n  const payload = DnsResponseSchema.parse(await response.json());\n  return [\n    ...new Set(\n      (payload.Answer ?? [])\n        .filter((answer) => answer.type === 1 && isIP(answer.data) === 4)\n        .map((answer) => answer.data),\n    ),\n  ];\n}\n\nfunction shouldResolvePublicGateway(host: string, error: unknown): boolean {\n  if (!host.toLowerCase().endsWith(SERVICE_DIRECT_SUFFIX)) return false;\n  const code =\n    (error as { code?: unknown; cause?: { code?: unknown } })?.code ??\n    (error as { cause?: { code?: unknown } })?.cause?.code;\n  return code === \"EHOSTUNREACH\" || code === \"ENETUNREACH\" || code === \"ETIMEDOUT\";\n}\n"]}

package/lib/src/transport.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const SshTransportModeSchema: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
+    auto: "auto";
+    openssh: "openssh";
+    ssh2: "ssh2";
+}>>>;
+/** SSH transport selected for a Lakebox session. */
+export type SshTransportMode = z.output<typeof SshTransportModeSchema>;
+export declare const Ssh2PatchModeSchema: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
+    true: "true";
+    false: "false";
+    auto: "auto";
+}>>>;
+/** Missing exec-reply patch policy applied when ssh2 is selected. */
+export type Ssh2PatchMode = z.output<typeof Ssh2PatchModeSchema>;

package/lib/src/transport.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const SshTransportModeSchema = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .pipe(z.enum(["auto", "openssh", "ssh2"]))
+    .default("auto")
+    .describe("SSH transport: auto prefers native OpenSSH with SOCKS5 forwarding and otherwise selects ssh2; explicit modes never switch.");
+export const Ssh2PatchModeSchema = z
+    .string()
+    .trim()
+    .toLowerCase()
+    .pipe(z.enum(["auto", "true", "false"]))
+    .default("auto")
+    .describe("ssh2 missing-exec-reply workaround: auto patches only in development, true requires it, false never patches.");
+//# sourceMappingURL=data:application/json;base64,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

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/_ssh.ts","../src/_ssh_openssh.ts","../src/_ssh_ssh2.ts","../src/key-store.ts","../src/lifecycle.ts","../src/rest.ts","../src/session.ts","../src/transport.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,119 @@
 {
   "name": "@dbx-tools/lakebox",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Databricks Lakebox REST, pooled SSH transport, and deterministic user routing",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/node/lakebox"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "@types/ssh2": "^1",
+    "typescript": "^5.9.3",
+    "vitest": "3.2.4"
+  },
+  "dependencies": {
+    "@dbx-tools/core": "^0.9.132",
+    "@dbx-tools/shared-core": "^0.9.132",
+    "@dbx-tools/shared-lakebox": "^0.9.132",
+    "generic-pool": "^3.9.0",
+    "socks": "^2.8.10",
+    "ssh2": "^1.17.0",
+    "zod": "4.3.6"
+  },
+  "main": "./lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./key-store": {
+        "types": "./lib/src/key-store.d.ts",
+        "default": "./lib/src/key-store.js"
+      },
+      "./lifecycle": {
+        "types": "./lib/src/lifecycle.d.ts",
+        "default": "./lib/src/lifecycle.js"
+      },
+      "./rest": {
+        "types": "./lib/src/rest.d.ts",
+        "default": "./lib/src/rest.js"
+      },
+      "./session": {
+        "types": "./lib/src/session.d.ts",
+        "default": "./lib/src/session.js"
+      },
+      "./transport": {
+        "types": "./lib/src/transport.d.ts",
+        "default": "./lib/src/transport.js"
+      },
+      "./*": {
+        "types": "./lib/src/*/index.d.ts",
+        "default": "./lib/src/*/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.9.132",
+  "types": "./lib/index.d.ts",
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./key-store": {
+      "types": "./lib/src/key-store.d.ts",
+      "default": "./lib/src/key-store.js"
+    },
+    "./lifecycle": {
+      "types": "./lib/src/lifecycle.d.ts",
+      "default": "./lib/src/lifecycle.js"
+    },
+    "./rest": {
+      "types": "./lib/src/rest.d.ts",
+      "default": "./lib/src/rest.js"
+    },
+    "./session": {
+      "types": "./lib/src/session.d.ts",
+      "default": "./lib/src/session.js"
+    },
+    "./transport": {
+      "types": "./lib/src/transport.d.ts",
+      "default": "./lib/src/transport.js"
+    },
+    "./*": {
+      "types": "./lib/src/*/index.d.ts",
+      "default": "./lib/src/*/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}