@dbx-tools/lakebox 0.0.0-stage → 0.9.132

package/lib/src/rest.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+export declare const LakeboxEntrySchema: z.ZodObject<{
+    sandboxId: z.ZodString;
+    status: z.ZodString;
+    gatewayHost: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    createTime: z.ZodOptional<z.ZodString>;
+    lastStartTime: z.ZodOptional<z.ZodString>;
+    idleTimeout: z.ZodOptional<z.ZodString>;
+    noAutostop: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/** Lakebox record returned by the Databricks Lakebox REST API. */
+export type LakeboxEntry = z.infer<typeof LakeboxEntrySchema>;
+export declare const LakeboxSshKeySchema: z.ZodObject<{
+    keyHash: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    gatewayHost: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** Registered SSH key returned by the Databricks Lakebox REST API. */
+export type LakeboxSshKey = z.infer<typeof LakeboxSshKeySchema>;
+/**
+ * Workspace credentials for Lakebox REST calls.
+ *
+ * The Databricks SDK and AppKit `WorkspaceClient.config` satisfy this shape, as
+ * does a small adapter over `@dbx-tools/auth`. Lakebox lifecycle calls must use
+ * the app service principal, never request-scoped OBO credentials.
+ */
+export interface LakeboxAuth {
+    /** Workspace URL. */
+    readonly host?: string;
+    /** Numeric workspace identifier, when known. */
+    readonly workspaceId?: string;
+    /** Resolves lazy configuration before `host` is read. */
+    ensureResolved?(): Promise<void>;
+    /** Adds authentication headers to one request. */
+    authenticate(headers: Headers): Promise<void>;
+}
+/** Error raised for a non-success Lakebox REST response. */
+export declare class LakeboxApiError extends Error {
+    readonly status: number;
+    readonly errorCode?: string | undefined;
+    readonly requestId?: string | undefined;
+    constructor(message: string, status: number, errorCode?: string | undefined, requestId?: string | undefined);
+}
+/**
+ * REST client for Databricks Lakeboxes and registered SSH keys.
+ *
+ * Responses are validated before they reach callers. Diagnostics never include
+ * tokens or request headers.
+ */
+export declare class LakeboxClient {
+    private readonly auth;
+    /** Creates a client for one workspace credential. */
+    constructor(auth: LakeboxAuth);
+    /** Returns the workspace identifier, or the workspace origin when the identifier is unknown. */
+    workspaceScope(): Promise<string>;
+    /** Lists every Lakebox visible to the caller, following pagination. */
+    list(signal?: AbortSignal): Promise<LakeboxEntry[]>;
+    /** Returns one Lakebox by ID. */
+    get(id: string, signal?: AbortSignal): Promise<LakeboxEntry>;
+    /** Creates a Lakebox with a Databricks-assigned display name. */
+    create(signal?: AbortSignal): Promise<LakeboxEntry>;
+    /** Sets the platform idle timeout that stops the Lakebox after inactivity. */
+    setIdleTimeout(id: string, seconds: number, signal?: AbortSignal): Promise<LakeboxEntry>;
+    /** Permanently deletes one Lakebox and its persistent home. */
+    delete(id: string, signal?: AbortSignal): Promise<void>;
+    /** Requests a start and returns the updated record. */
+    start(id: string, signal?: AbortSignal): Promise<LakeboxEntry>;
+    /** Requests a stop and returns the updated record. */
+    stop(id: string, signal?: AbortSignal): Promise<LakeboxEntry>;
+    /** Lists SSH public keys registered by the caller. */
+    listKeys(signal?: AbortSignal): Promise<LakeboxSshKey[]>;
+    /** Registers an SSH public key and returns the Databricks key record. */
+    registerKey(publicKey: string, name: string, signal?: AbortSignal): Promise<LakeboxSshKey>;
+    private request;
+}
+/**
+ * Returns whether an API error indicates that Lakeboxes are unavailable in the
+ * workspace or region.
+ */
+export declare function isLakeboxUnavailable(error: unknown): boolean;

package/lib/src/rest.js

@@ -0,0 +1,199 @@
+import { errorUtils, log, net } from "@dbx-tools/shared-core";
+import { z } from "zod";
+const LAKEBOX_ROOT = "/api/2.0/lakebox";
+const LAKEBOXES_PATH = `${LAKEBOX_ROOT}/sandboxes`;
+const SSH_KEYS_PATH = `${LAKEBOX_ROOT}/ssh-keys`;
+const ORG_ID_HEADER = "X-Databricks-Org-Id";
+const logger = log.logger("lakebox:rest");
+export const LakeboxEntrySchema = z
+    .object({
+    sandboxId: z.string().describe("Lakebox identifier; also the SSH gateway username."),
+    status: z.string().describe("Upstream lifecycle status, such as Running or Stopped."),
+    gatewayHost: z.string().optional().describe("SSH gateway hostname."),
+    name: z.string().optional().describe("Display label."),
+    createTime: z.string().optional().describe("Creation time."),
+    lastStartTime: z.string().optional().describe("Last start time."),
+    idleTimeout: z.string().optional().describe("Platform idle timeout, such as 600s."),
+    noAutostop: z.boolean().optional().describe("Whether idle auto-stop is disabled."),
+})
+    .passthrough()
+    .describe("Lakebox record returned by the Databricks Lakebox REST API.");
+const LakeboxListSchema = z
+    .object({
+    sandboxes: z.array(LakeboxEntrySchema).default([]),
+    nextPageToken: z.string().optional(),
+})
+    .passthrough();
+export const LakeboxSshKeySchema = z
+    .object({
+    keyHash: z.string().describe("Registered public key hash."),
+    name: z.string().optional().describe("Key label."),
+    gatewayHost: z.string().optional().describe("Gateway hostname for this key."),
+})
+    .passthrough()
+    .describe("Registered SSH key returned by the Databricks Lakebox REST API.");
+const LakeboxSshKeyListSchema = z
+    .object({ sshKeys: z.array(LakeboxSshKeySchema).default([]) })
+    .passthrough();
+/** Error raised for a non-success Lakebox REST response. */
+export class LakeboxApiError extends Error {
+    status;
+    errorCode;
+    requestId;
+    constructor(message, status, errorCode, requestId) {
+        super(message);
+        this.status = status;
+        this.errorCode = errorCode;
+        this.requestId = requestId;
+        this.name = "LakeboxApiError";
+    }
+}
+/**
+ * REST client for Databricks Lakeboxes and registered SSH keys.
+ *
+ * Responses are validated before they reach callers. Diagnostics never include
+ * tokens or request headers.
+ */
+export class LakeboxClient {
+    auth;
+    /** Creates a client for one workspace credential. */
+    constructor(auth) {
+        this.auth = auth;
+    }
+    /** Returns the workspace identifier, or the workspace origin when the identifier is unknown. */
+    async workspaceScope() {
+        await this.auth.ensureResolved?.();
+        return (process.env.DATABRICKS_WORKSPACE_ID?.trim() ||
+            this.auth.workspaceId?.trim() ||
+            net.urlBuilder(this.auth.host ?? "")?.origin ||
+            "workspace");
+    }
+    /** Lists every Lakebox visible to the caller, following pagination. */
+    async list(signal) {
+        const entries = [];
+        let pageToken;
+        do {
+            const query = new URLSearchParams({ page_size: "100" });
+            if (pageToken)
+                query.set("page_token", pageToken);
+            const response = LakeboxListSchema.parse(await this.request("GET", `${LAKEBOXES_PATH}?${query}`, undefined, signal));
+            entries.push(...response.sandboxes);
+            pageToken = response.nextPageToken || undefined;
+        } while (pageToken);
+        return entries;
+    }
+    /** Returns one Lakebox by ID. */
+    async get(id, signal) {
+        return LakeboxEntrySchema.parse(await this.request("GET", lakeboxPath(id), undefined, signal));
+    }
+    /** Creates a Lakebox with a Databricks-assigned display name. */
+    async create(signal) {
+        return LakeboxEntrySchema.parse(await this.request("POST", LAKEBOXES_PATH, { sandbox: {} }, signal));
+    }
+    /** Sets the platform idle timeout that stops the Lakebox after inactivity. */
+    async setIdleTimeout(id, seconds, signal) {
+        return LakeboxEntrySchema.parse(await this.request("PATCH", lakeboxPath(id), { sandbox_id: id, idle_timeout: `${seconds}s` }, signal));
+    }
+    /** Permanently deletes one Lakebox and its persistent home. */
+    async delete(id, signal) {
+        await this.request("DELETE", lakeboxPath(id), undefined, signal);
+    }
+    /** Requests a start and returns the updated record. */
+    async start(id, signal) {
+        return LakeboxEntrySchema.parse(await this.request("POST", `${lakeboxPath(id)}/start`, { sandbox_id: id }, signal));
+    }
+    /** Requests a stop and returns the updated record. */
+    async stop(id, signal) {
+        return LakeboxEntrySchema.parse(await this.request("POST", `${lakeboxPath(id)}/stop`, { sandbox_id: id }, signal));
+    }
+    /** Lists SSH public keys registered by the caller. */
+    async listKeys(signal) {
+        return LakeboxSshKeyListSchema.parse(await this.request("GET", SSH_KEYS_PATH, undefined, signal)).sshKeys;
+    }
+    /** Registers an SSH public key and returns the Databricks key record. */
+    async registerKey(publicKey, name, signal) {
+        return LakeboxSshKeySchema.parse(await this.request("POST", SSH_KEYS_PATH, { public_key: publicKey, name }, signal));
+    }
+    async request(method, path, payload, signal) {
+        await this.auth.ensureResolved?.();
+        const host = this.auth.host?.replace(/\/+$/, "");
+        if (!host)
+            throw new Error("Lakebox REST requests require a Databricks workspace host");
+        const headers = new Headers({ Accept: "application/json" });
+        const workspaceId = this.auth.workspaceId;
+        if (workspaceId && workspaceId !== "none")
+            headers.set(ORG_ID_HEADER, workspaceId);
+        if (payload !== undefined)
+            headers.set("Content-Type", "application/json");
+        await this.auth.authenticate(headers);
+        const startedAt = Date.now();
+        const metadata = { method, path: path.split("?")[0], hasPayload: payload !== undefined };
+        logger.debug("lakebox REST request", metadata);
+        let response;
+        try {
+            response = await fetch(`${host}${path}`, {
+                method,
+                headers,
+                ...(payload === undefined ? {} : { body: JSON.stringify(payload) }),
+                ...(signal ? { signal } : {}),
+            });
+        }
+        catch (error) {
+            logger.warn("lakebox REST request failed", {
+                ...metadata,
+                durationMs: Date.now() - startedAt,
+                error: errorUtils.toError(error),
+            });
+            throw error;
+        }
+        const text = await response.text();
+        const body = parseBody(text);
+        if (!response.ok) {
+            const record = z
+                .object({
+                message: z.string().optional(),
+                error_code: z.string().optional(),
+                request_id: z.string().optional(),
+            })
+                .passthrough()
+                .safeParse(body);
+            const details = record.success ? record.data : {};
+            const error = new LakeboxApiError(details.message || `Lakebox request failed (${response.status})`, response.status, details.error_code, details.request_id ?? response.headers.get("x-request-id") ?? undefined);
+            logger.warn("lakebox REST request failed", {
+                ...metadata,
+                durationMs: Date.now() - startedAt,
+                status: error.status,
+                errorCode: error.errorCode,
+                requestId: error.requestId,
+            });
+            throw error;
+        }
+        logger.debug("lakebox REST response", { ...metadata, durationMs: Date.now() - startedAt });
+        return body ?? {};
+    }
+}
+/**
+ * Returns whether an API error indicates that Lakeboxes are unavailable in the
+ * workspace or region.
+ */
+export function isLakeboxUnavailable(error) {
+    if (!(error instanceof LakeboxApiError))
+        return false;
+    return (error.status === 404 ||
+        error.status === 503 ||
+        /not available in your region/i.test(error.message));
+}
+function lakeboxPath(id) {
+    return `${LAKEBOXES_PATH}/${encodeURIComponent(id)}`;
+}
+function parseBody(text) {
+    if (!text.trim())
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { message: text.slice(0, 4_000) };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest.js","sourceRoot":"","sources":["../../src/rest.ts"],"names":[],"mappings":"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","sourcesContent":["import { errorUtils, log, net } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\n\nconst LAKEBOX_ROOT = \"/api/2.0/lakebox\";\nconst LAKEBOXES_PATH = `${LAKEBOX_ROOT}/sandboxes`;\nconst SSH_KEYS_PATH = `${LAKEBOX_ROOT}/ssh-keys`;\nconst ORG_ID_HEADER = \"X-Databricks-Org-Id\";\nconst logger = log.logger(\"lakebox:rest\");\n\nexport const LakeboxEntrySchema = z\n  .object({\n    sandboxId: z.string().describe(\"Lakebox identifier; also the SSH gateway username.\"),\n    status: z.string().describe(\"Upstream lifecycle status, such as Running or Stopped.\"),\n    gatewayHost: z.string().optional().describe(\"SSH gateway hostname.\"),\n    name: z.string().optional().describe(\"Display label.\"),\n    createTime: z.string().optional().describe(\"Creation time.\"),\n    lastStartTime: z.string().optional().describe(\"Last start time.\"),\n    idleTimeout: z.string().optional().describe(\"Platform idle timeout, such as 600s.\"),\n    noAutostop: z.boolean().optional().describe(\"Whether idle auto-stop is disabled.\"),\n  })\n  .passthrough()\n  .describe(\"Lakebox record returned by the Databricks Lakebox REST API.\");\n/** Lakebox record returned by the Databricks Lakebox REST API. */\nexport type LakeboxEntry = z.infer<typeof LakeboxEntrySchema>;\n\nconst LakeboxListSchema = z\n  .object({\n    sandboxes: z.array(LakeboxEntrySchema).default([]),\n    nextPageToken: z.string().optional(),\n  })\n  .passthrough();\n\nexport const LakeboxSshKeySchema = z\n  .object({\n    keyHash: z.string().describe(\"Registered public key hash.\"),\n    name: z.string().optional().describe(\"Key label.\"),\n    gatewayHost: z.string().optional().describe(\"Gateway hostname for this key.\"),\n  })\n  .passthrough()\n  .describe(\"Registered SSH key returned by the Databricks Lakebox REST API.\");\n/** Registered SSH key returned by the Databricks Lakebox REST API. */\nexport type LakeboxSshKey = z.infer<typeof LakeboxSshKeySchema>;\n\nconst LakeboxSshKeyListSchema = z\n  .object({ sshKeys: z.array(LakeboxSshKeySchema).default([]) })\n  .passthrough();\n\n/**\n * Workspace credentials for Lakebox REST calls.\n *\n * The Databricks SDK and AppKit `WorkspaceClient.config` satisfy this shape, as\n * does a small adapter over `@dbx-tools/auth`. Lakebox lifecycle calls must use\n * the app service principal, never request-scoped OBO credentials.\n */\nexport interface LakeboxAuth {\n  /** Workspace URL. */\n  readonly host?: string;\n  /** Numeric workspace identifier, when known. */\n  readonly workspaceId?: string;\n  /** Resolves lazy configuration before `host` is read. */\n  ensureResolved?(): Promise<void>;\n  /** Adds authentication headers to one request. */\n  authenticate(headers: Headers): Promise<void>;\n}\n\n/** Error raised for a non-success Lakebox REST response. */\nexport class LakeboxApiError extends Error {\n  constructor(\n    message: string,\n    readonly status: number,\n    readonly errorCode?: string,\n    readonly requestId?: string,\n  ) {\n    super(message);\n    this.name = \"LakeboxApiError\";\n  }\n}\n\ntype RequestMethod = \"GET\" | \"POST\" | \"PATCH\" | \"DELETE\";\n\n/**\n * REST client for Databricks Lakeboxes and registered SSH keys.\n *\n * Responses are validated before they reach callers. Diagnostics never include\n * tokens or request headers.\n */\nexport class LakeboxClient {\n  /** Creates a client for one workspace credential. */\n  constructor(private readonly auth: LakeboxAuth) {}\n\n  /** Returns the workspace identifier, or the workspace origin when the identifier is unknown. */\n  async workspaceScope(): Promise<string> {\n    await this.auth.ensureResolved?.();\n    return (\n      process.env.DATABRICKS_WORKSPACE_ID?.trim() ||\n      this.auth.workspaceId?.trim() ||\n      net.urlBuilder(this.auth.host ?? \"\")?.origin ||\n      \"workspace\"\n    );\n  }\n\n  /** Lists every Lakebox visible to the caller, following pagination. */\n  async list(signal?: AbortSignal): Promise<LakeboxEntry[]> {\n    const entries: LakeboxEntry[] = [];\n    let pageToken: string | undefined;\n    do {\n      const query = new URLSearchParams({ page_size: \"100\" });\n      if (pageToken) query.set(\"page_token\", pageToken);\n      const response = LakeboxListSchema.parse(\n        await this.request(\"GET\", `${LAKEBOXES_PATH}?${query}`, undefined, signal),\n      );\n      entries.push(...response.sandboxes);\n      pageToken = response.nextPageToken || undefined;\n    } while (pageToken);\n    return entries;\n  }\n\n  /** Returns one Lakebox by ID. */\n  async get(id: string, signal?: AbortSignal): Promise<LakeboxEntry> {\n    return LakeboxEntrySchema.parse(await this.request(\"GET\", lakeboxPath(id), undefined, signal));\n  }\n\n  /** Creates a Lakebox with a Databricks-assigned display name. */\n  async create(signal?: AbortSignal): Promise<LakeboxEntry> {\n    return LakeboxEntrySchema.parse(\n      await this.request(\"POST\", LAKEBOXES_PATH, { sandbox: {} }, signal),\n    );\n  }\n\n  /** Sets the platform idle timeout that stops the Lakebox after inactivity. */\n  async setIdleTimeout(id: string, seconds: number, signal?: AbortSignal): Promise<LakeboxEntry> {\n    return LakeboxEntrySchema.parse(\n      await this.request(\n        \"PATCH\",\n        lakeboxPath(id),\n        { sandbox_id: id, idle_timeout: `${seconds}s` },\n        signal,\n      ),\n    );\n  }\n\n  /** Permanently deletes one Lakebox and its persistent home. */\n  async delete(id: string, signal?: AbortSignal): Promise<void> {\n    await this.request(\"DELETE\", lakeboxPath(id), undefined, signal);\n  }\n\n  /** Requests a start and returns the updated record. */\n  async start(id: string, signal?: AbortSignal): Promise<LakeboxEntry> {\n    return LakeboxEntrySchema.parse(\n      await this.request(\"POST\", `${lakeboxPath(id)}/start`, { sandbox_id: id }, signal),\n    );\n  }\n\n  /** Requests a stop and returns the updated record. */\n  async stop(id: string, signal?: AbortSignal): Promise<LakeboxEntry> {\n    return LakeboxEntrySchema.parse(\n      await this.request(\"POST\", `${lakeboxPath(id)}/stop`, { sandbox_id: id }, signal),\n    );\n  }\n\n  /** Lists SSH public keys registered by the caller. */\n  async listKeys(signal?: AbortSignal): Promise<LakeboxSshKey[]> {\n    return LakeboxSshKeyListSchema.parse(\n      await this.request(\"GET\", SSH_KEYS_PATH, undefined, signal),\n    ).sshKeys;\n  }\n\n  /** Registers an SSH public key and returns the Databricks key record. */\n  async registerKey(publicKey: string, name: string, signal?: AbortSignal): Promise<LakeboxSshKey> {\n    return LakeboxSshKeySchema.parse(\n      await this.request(\"POST\", SSH_KEYS_PATH, { public_key: publicKey, name }, signal),\n    );\n  }\n\n  private async request(\n    method: RequestMethod,\n    path: string,\n    payload: unknown,\n    signal?: AbortSignal,\n  ): Promise<unknown> {\n    await this.auth.ensureResolved?.();\n    const host = this.auth.host?.replace(/\\/+$/, \"\");\n    if (!host) throw new Error(\"Lakebox REST requests require a Databricks workspace host\");\n    const headers = new Headers({ Accept: \"application/json\" });\n    const workspaceId = this.auth.workspaceId;\n    if (workspaceId && workspaceId !== \"none\") headers.set(ORG_ID_HEADER, workspaceId);\n    if (payload !== undefined) headers.set(\"Content-Type\", \"application/json\");\n    await this.auth.authenticate(headers);\n    const startedAt = Date.now();\n    const metadata = { method, path: path.split(\"?\")[0], hasPayload: payload !== undefined };\n    logger.debug(\"lakebox REST request\", metadata);\n    let response: Response;\n    try {\n      response = await fetch(`${host}${path}`, {\n        method,\n        headers,\n        ...(payload === undefined ? {} : { body: JSON.stringify(payload) }),\n        ...(signal ? { signal } : {}),\n      });\n    } catch (error) {\n      logger.warn(\"lakebox REST request failed\", {\n        ...metadata,\n        durationMs: Date.now() - startedAt,\n        error: errorUtils.toError(error),\n      });\n      throw error;\n    }\n    const text = await response.text();\n    const body = parseBody(text);\n    if (!response.ok) {\n      const record = z\n        .object({\n          message: z.string().optional(),\n          error_code: z.string().optional(),\n          request_id: z.string().optional(),\n        })\n        .passthrough()\n        .safeParse(body);\n      const details = record.success ? record.data : {};\n      const error = new LakeboxApiError(\n        details.message || `Lakebox request failed (${response.status})`,\n        response.status,\n        details.error_code,\n        details.request_id ?? response.headers.get(\"x-request-id\") ?? undefined,\n      );\n      logger.warn(\"lakebox REST request failed\", {\n        ...metadata,\n        durationMs: Date.now() - startedAt,\n        status: error.status,\n        errorCode: error.errorCode,\n        requestId: error.requestId,\n      });\n      throw error;\n    }\n    logger.debug(\"lakebox REST response\", { ...metadata, durationMs: Date.now() - startedAt });\n    return body ?? {};\n  }\n}\n\n/**\n * Returns whether an API error indicates that Lakeboxes are unavailable in the\n * workspace or region.\n */\nexport function isLakeboxUnavailable(error: unknown): boolean {\n  if (!(error instanceof LakeboxApiError)) return false;\n  return (\n    error.status === 404 ||\n    error.status === 503 ||\n    /not available in your region/i.test(error.message)\n  );\n}\n\nfunction lakeboxPath(id: string): string {\n  return `${LAKEBOXES_PATH}/${encodeURIComponent(id)}`;\n}\n\nfunction parseBody(text: string): unknown {\n  if (!text.trim()) return undefined;\n  try {\n    return JSON.parse(text) as unknown;\n  } catch {\n    return { message: text.slice(0, 4_000) };\n  }\n}\n"]}

package/lib/src/session.d.ts

@@ -0,0 +1,89 @@
+import type { Duplex } from "node:stream";
+import { SshCommand } from "./_ssh.ts";
+import type { Ssh2PatchMode, SshTransportMode } from "./transport.ts";
+export { SshCommand, sshCommandScript, type SshCommandIdentity } from "./_ssh.ts";
+/** Connection, key, host-verification, and command settings for one SSH machine. */
+export interface SshSessionOptions {
+    /** Databricks Lakebox gateway hostname. */
+    host: string;
+    /** SSH gateway port. */
+    port: number;
+    /** SSH username accepted by the gateway: the Lakebox ID. */
+    username: string;
+    /** In-memory private key used for the verified SSH handshake and ssh2 fallback. */
+    privateKey: string;
+    /** Private key file used by native OpenSSH. */
+    privateKeyPath: string;
+    /** Dedicated OpenSSH known-host file for this workspace, user, and gateway. */
+    knownHostsPath: string;
+    /** Connection timeout in milliseconds. */
+    connectTimeoutMs: number;
+    /** SSH transport selected for this session. */
+    sshTransport: SshTransportMode;
+    /** ssh2 missing-exec-reply patch policy. */
+    ssh2Patch: Ssh2PatchMode;
+    /** Previously trusted SHA-256 host-key fingerprint. */
+    knownHost?: string;
+    /** Persists the accepted host key for both ssh2 and native OpenSSH. */
+    rememberHost?: (fingerprint: string, key: Buffer) => Promise<void>;
+    /** Native OpenSSH executable. Defaults to `ssh` on `PATH`. */
+    sshCommand?: string;
+    /** Resolves public fallback addresses for a service-direct gateway. */
+    resolvePublicAddresses?: (host: string) => Promise<string[]>;
+}
+/**
+ * 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 declare class SshSession {
+    private readonly options;
+    private readonly activeCommands;
+    private readonly pendingClients;
+    private transport?;
+    private connecting?;
+    private closing?;
+    private knownHost?;
+    private closed;
+    /** Creates a disconnected session. Call {@link connect} or another operation to connect. */
+    constructor(options: SshSessionOptions);
+    /**
+     * Verifies the gateway, resolves its public fallback when necessary, and
+     * selects the command and forwarding transport.
+     */
+    connect(): Promise<void>;
+    private connectWithFallback;
+    private connectHost;
+    private createVerifiedClient;
+    /**
+     * Starts one command as a Lakebox user and returns its live output and
+     * completion state immediately.
+     */
+    execute(command: string, args: string[], options: {
+        user: {
+            name: string;
+            home: string;
+        };
+        cwd?: string;
+        env?: Record<string, string>;
+        timeoutMs: number;
+        signal?: AbortSignal;
+    }): SshCommand;
+    private startCommand;
+    /** Opens a remote TCP connection through native SOCKS5 or ssh2 direct forwarding. */
+    forwardOut(remoteHost: string, remotePort: number): Promise<Duplex>;
+    /** Cancels active commands, closes the selected transport, and clears connection state. */
+    close(): Promise<void>;
+    private closeResources;
+}
+/**
+ * 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 declare function resolvePublicGatewayAddresses(host: string, fetcher?: typeof fetch): Promise<string[]>;