@dbx-tools/lakebox 0.0.0-stage → 0.9.131

package/lib/src/_ssh_ssh2.js

@@ -0,0 +1,225 @@
+import { log } from "@dbx-tools/shared-core";
+import { PooledSshTransport, } from "./_ssh.js";
+const logger = log.logger("lakebox:ssh2");
+const patchedSsh2Protocols = new WeakSet();
+/** Exclusive ssh2 connection pool for commands and direct TCP forwarding. */
+export class Ssh2Transport extends PooledSshTransport {
+    kind = "ssh2";
+    connectTimeoutMs;
+    constructor(options, poolOptions = {}) {
+        super(ssh2Lifecycle(options), {
+            acquireTimeoutMillis: options.connectTimeoutMs,
+            ...poolOptions,
+        });
+        this.connectTimeoutMs = options.connectTimeoutMs;
+    }
+    runWithResource(resource, script, execution) {
+        return executeCommand(resource, script, execution);
+    }
+    connectWithResource(resource, remoteHost, remotePort) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let timeout;
+            const cleanup = () => {
+                clearTimeout(timeout);
+                resource.client.removeListener("close", clientClosed);
+                resource.client.removeListener("error", clientFailed);
+            };
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            const clientClosed = () => {
+                fail(new Error("ssh2 connection closed while opening forwarding"));
+            };
+            const clientFailed = (error) => {
+                fail(error);
+            };
+            timeout = setTimeout(() => fail(new Error(`ssh2 forwarding did not open within ${this.connectTimeoutMs}ms`)), this.connectTimeoutMs);
+            timeout.unref?.();
+            resource.client.once("close", clientClosed);
+            resource.client.once("error", clientFailed);
+            resource.client.forwardOut("127.0.0.1", 0, remoteHost, remotePort, (error, channel) => {
+                if (settled) {
+                    channel?.destroy();
+                    return;
+                }
+                settled = true;
+                cleanup();
+                if (error)
+                    reject(error);
+                else
+                    resolve(channel);
+            });
+        });
+    }
+}
+function ssh2Lifecycle(options) {
+    const patchMode = options.ssh2Patch ?? "auto";
+    const requirePatch = patchMode === "true";
+    const patchCommands = requirePatch || (patchMode === "auto" && isNodeDevelopment());
+    let initialClient = options.ssh2Client;
+    const initialPatched = patchCommands ? patchSsh2ExecWithoutReply(options.ssh2Client) : false;
+    if (requirePatch && !initialPatched) {
+        options.ssh2Client.destroy();
+        throw new Error("Installed ssh2 internals do not support the required exec no-reply patch");
+    }
+    let logged = false;
+    return {
+        create: async () => {
+            const seeded = initialClient !== undefined;
+            const client = initialClient ?? (await options.createSsh2CommandClient());
+            initialClient = undefined;
+            const resource = trackClient(client);
+            const patched = seeded
+                ? initialPatched
+                : patchCommands
+                    ? patchSsh2ExecWithoutReply(client)
+                    : false;
+            if (requirePatch && !patched) {
+                client.destroy();
+                throw new Error("Installed ssh2 internals do not support the required exec no-reply patch");
+            }
+            if (!logged) {
+                logged = true;
+                logger.warn("using pooled ssh2 Lakebox transport", {
+                    patchMode,
+                    patched,
+                    nodeEnv: process.env.NODE_ENV,
+                    transportMode: options.transport ?? "auto",
+                });
+            }
+            return resource;
+        },
+        destroy: (resource) => closeClient(resource, options.connectTimeoutMs),
+        // A remote no-op would consume the connection's only permitted operation.
+        test: async (resource) => resource.alive,
+    };
+}
+function trackClient(client) {
+    const resource = { client, alive: true };
+    const markClosed = () => {
+        resource.alive = false;
+    };
+    client.once("close", markClosed);
+    client.once("error", markClosed);
+    return resource;
+}
+async function closeClient(resource, timeoutMs) {
+    if (!resource.alive) {
+        resource.client.destroy();
+        return;
+    }
+    await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resource.alive = false;
+            resolve();
+        };
+        const timeout = setTimeout(() => {
+            resource.client.destroy();
+            finish();
+        }, Math.min(timeoutMs, 1_000));
+        timeout.unref?.();
+        resource.client.once("close", finish);
+        resource.client.once("error", finish);
+        resource.client.end();
+    });
+}
+function executeCommand(resource, script, execution) {
+    return new Promise((resolve, reject) => {
+        let channel;
+        let exitCode;
+        let settled = false;
+        const cleanup = () => {
+            resource.client.removeListener("close", clientClosed);
+            resource.client.removeListener("error", clientClosed);
+        };
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(code);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        const clientClosed = () => fail(new Error("ssh2 connection closed during command execution"));
+        resource.client.once("close", clientClosed);
+        resource.client.once("error", clientClosed);
+        execution.setCancel(() => {
+            if (settled)
+                return;
+            try {
+                channel?.signal("KILL");
+            }
+            catch {
+                // The remote may close the channel before the signal is written.
+            }
+            finish(130);
+            channel?.close();
+        });
+        if (execution.signal.aborted) {
+            finish(130);
+            return;
+        }
+        resource.client.exec(script, (error, openedChannel) => {
+            if (error) {
+                fail(error);
+                return;
+            }
+            if (settled) {
+                openedChannel.close();
+                return;
+            }
+            channel = openedChannel;
+            channel.on("data", execution.stdout);
+            channel.stderr.on("data", execution.stderr);
+            channel.on("exit", (code) => {
+                exitCode = code ?? 1;
+            });
+            channel.once("error", fail);
+            channel.once("close", () => finish(exitCode ?? 1));
+        });
+    });
+}
+/** Apply the Databricks gateway exec-request workaround when internals permit it. */
+function patchSsh2ExecWithoutReply(client) {
+    const internals = client;
+    const protocol = internals._protocol;
+    const channelManager = internals._chanMgr;
+    if (!protocol || typeof protocol.exec !== "function" || !channelManager) {
+        return false;
+    }
+    if (patchedSsh2Protocols.has(protocol))
+        return true;
+    const originalExec = protocol.exec.bind(protocol);
+    protocol.exec = (channelId, command) => {
+        originalExec(channelId, command, false);
+        const channel = Object.values(channelManager._channels).find((candidate) => candidate?.outgoing.id === channelId);
+        const callback = channel?._callbacks.shift();
+        if (!callback) {
+            throw new Error("ssh2 exec callback queue was not available for the no-reply workaround");
+        }
+        queueMicrotask(() => callback(false));
+    };
+    patchedSsh2Protocols.add(protocol);
+    return true;
+}
+function isNodeDevelopment() {
+    const nodeEnv = process.env.NODE_ENV?.trim().toLowerCase();
+    return nodeEnv === "development" || nodeEnv === "dev";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_ssh_ssh2.js","sourceRoot":"","sources":["../../src/_ssh_ssh2.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Duplex } from \"node:stream\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport type { Client as Ssh2Client, ClientChannel } from \"ssh2\";\nimport {\n  PooledSshTransport,\n  type SshCommandExecution,\n  type SshPoolOptions,\n  type SshResourceLifecycle,\n  type SshTransportOptions,\n} from \"./_ssh.ts\";\n\nconst logger = log.logger(\"lakebox:ssh2\");\nconst patchedSsh2Protocols = new WeakSet<Ssh2Protocol>();\n\ninterface Ssh2Resource {\n  readonly client: Ssh2Client;\n  alive: boolean;\n}\n\n/** Exclusive ssh2 connection pool for commands and direct TCP forwarding. */\nexport class Ssh2Transport extends PooledSshTransport<Ssh2Resource> {\n  readonly kind = \"ssh2\" as const;\n  private readonly connectTimeoutMs: number;\n\n  constructor(options: SshTransportOptions, poolOptions: SshPoolOptions = {}) {\n    super(ssh2Lifecycle(options), {\n      acquireTimeoutMillis: options.connectTimeoutMs,\n      ...poolOptions,\n    });\n    this.connectTimeoutMs = options.connectTimeoutMs;\n  }\n\n  protected runWithResource(\n    resource: Ssh2Resource,\n    script: string,\n    execution: SshCommandExecution,\n  ): Promise<number> {\n    return executeCommand(resource, script, execution);\n  }\n\n  protected connectWithResource(\n    resource: Ssh2Resource,\n    remoteHost: string,\n    remotePort: number,\n  ): Promise<Duplex> {\n    return new Promise((resolve, reject) => {\n      let settled = false;\n      let timeout: ReturnType<typeof setTimeout>;\n      const cleanup = () => {\n        clearTimeout(timeout);\n        resource.client.removeListener(\"close\", clientClosed);\n        resource.client.removeListener(\"error\", clientFailed);\n      };\n      const fail = (error: Error) => {\n        if (settled) return;\n        settled = true;\n        cleanup();\n        reject(error);\n      };\n      const clientClosed = () => {\n        fail(new Error(\"ssh2 connection closed while opening forwarding\"));\n      };\n      const clientFailed = (error: Error) => {\n        fail(error);\n      };\n      timeout = setTimeout(\n        () => fail(new Error(`ssh2 forwarding did not open within ${this.connectTimeoutMs}ms`)),\n        this.connectTimeoutMs,\n      );\n      timeout.unref?.();\n      resource.client.once(\"close\", clientClosed);\n      resource.client.once(\"error\", clientFailed);\n      resource.client.forwardOut(\"127.0.0.1\", 0, remoteHost, remotePort, (error, channel) => {\n        if (settled) {\n          channel?.destroy();\n          return;\n        }\n        settled = true;\n        cleanup();\n        if (error) reject(error);\n        else resolve(channel);\n      });\n    });\n  }\n}\n\nfunction ssh2Lifecycle(options: SshTransportOptions): SshResourceLifecycle<Ssh2Resource> {\n  const patchMode = options.ssh2Patch ?? \"auto\";\n  const requirePatch = patchMode === \"true\";\n  const patchCommands = requirePatch || (patchMode === \"auto\" && isNodeDevelopment());\n  let initialClient: Ssh2Client | undefined = options.ssh2Client;\n  const initialPatched = patchCommands ? patchSsh2ExecWithoutReply(options.ssh2Client) : false;\n  if (requirePatch && !initialPatched) {\n    options.ssh2Client.destroy();\n    throw new Error(\"Installed ssh2 internals do not support the required exec no-reply patch\");\n  }\n  let logged = false;\n  return {\n    create: async () => {\n      const seeded = initialClient !== undefined;\n      const client = initialClient ?? (await options.createSsh2CommandClient());\n      initialClient = undefined;\n      const resource = trackClient(client);\n      const patched = seeded\n        ? initialPatched\n        : patchCommands\n          ? patchSsh2ExecWithoutReply(client)\n          : false;\n      if (requirePatch && !patched) {\n        client.destroy();\n        throw new Error(\"Installed ssh2 internals do not support the required exec no-reply patch\");\n      }\n      if (!logged) {\n        logged = true;\n        logger.warn(\"using pooled ssh2 Lakebox transport\", {\n          patchMode,\n          patched,\n          nodeEnv: process.env.NODE_ENV,\n          transportMode: options.transport ?? \"auto\",\n        });\n      }\n      return resource;\n    },\n    destroy: (resource) => closeClient(resource, options.connectTimeoutMs),\n    // A remote no-op would consume the connection's only permitted operation.\n    test: async (resource) => resource.alive,\n  };\n}\n\nfunction trackClient(client: Ssh2Client): Ssh2Resource {\n  const resource: Ssh2Resource = { client, alive: true };\n  const markClosed = () => {\n    resource.alive = false;\n  };\n  client.once(\"close\", markClosed);\n  client.once(\"error\", markClosed);\n  return resource;\n}\n\nasync function closeClient(resource: Ssh2Resource, timeoutMs: number): Promise<void> {\n  if (!resource.alive) {\n    resource.client.destroy();\n    return;\n  }\n  await new Promise<void>((resolve) => {\n    let settled = false;\n    const finish = () => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timeout);\n      resource.alive = false;\n      resolve();\n    };\n    const timeout = setTimeout(\n      () => {\n        resource.client.destroy();\n        finish();\n      },\n      Math.min(timeoutMs, 1_000),\n    );\n    timeout.unref?.();\n    resource.client.once(\"close\", finish);\n    resource.client.once(\"error\", finish);\n    resource.client.end();\n  });\n}\n\nfunction executeCommand(\n  resource: Ssh2Resource,\n  script: string,\n  execution: SshCommandExecution,\n): Promise<number> {\n  return new Promise<number>((resolve, reject) => {\n    let channel: ClientChannel | undefined;\n    let exitCode: number | undefined;\n    let settled = false;\n    const cleanup = () => {\n      resource.client.removeListener(\"close\", clientClosed);\n      resource.client.removeListener(\"error\", clientClosed);\n    };\n    const finish = (code: number) => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      resolve(code);\n    };\n    const fail = (error: Error) => {\n      if (settled) return;\n      settled = true;\n      cleanup();\n      reject(error);\n    };\n    const clientClosed = () => fail(new Error(\"ssh2 connection closed during command execution\"));\n    resource.client.once(\"close\", clientClosed);\n    resource.client.once(\"error\", clientClosed);\n    execution.setCancel(() => {\n      if (settled) return;\n      try {\n        channel?.signal(\"KILL\");\n      } catch {\n        // The remote may close the channel before the signal is written.\n      }\n      finish(130);\n      channel?.close();\n    });\n    if (execution.signal.aborted) {\n      finish(130);\n      return;\n    }\n    resource.client.exec(script, (error, openedChannel) => {\n      if (error) {\n        fail(error);\n        return;\n      }\n      if (settled) {\n        openedChannel.close();\n        return;\n      }\n      channel = openedChannel;\n      channel.on(\"data\", execution.stdout);\n      channel.stderr.on(\"data\", execution.stderr);\n      channel.on(\"exit\", (code: number | null) => {\n        exitCode = code ?? 1;\n      });\n      channel.once(\"error\", fail);\n      channel.once(\"close\", () => finish(exitCode ?? 1));\n    });\n  });\n}\n\n/** Apply the Databricks gateway exec-request workaround when internals permit it. */\nfunction patchSsh2ExecWithoutReply(client: Ssh2Client): boolean {\n  const internals = client as unknown as Ssh2ClientInternals;\n  const protocol = internals._protocol;\n  const channelManager = internals._chanMgr;\n  if (!protocol || typeof protocol.exec !== \"function\" || !channelManager) {\n    return false;\n  }\n  if (patchedSsh2Protocols.has(protocol)) return true;\n  const originalExec = protocol.exec.bind(protocol);\n  protocol.exec = (channelId, command) => {\n    originalExec(channelId, command, false);\n    const channel = Object.values(channelManager._channels).find(\n      (candidate) => candidate?.outgoing.id === channelId,\n    );\n    const callback = channel?._callbacks.shift();\n    if (!callback) {\n      throw new Error(\"ssh2 exec callback queue was not available for the no-reply workaround\");\n    }\n    queueMicrotask(() => callback(false));\n  };\n  patchedSsh2Protocols.add(protocol);\n  return true;\n}\n\nfunction isNodeDevelopment(): boolean {\n  const nodeEnv = process.env.NODE_ENV?.trim().toLowerCase();\n  return nodeEnv === \"development\" || nodeEnv === \"dev\";\n}\n\ninterface Ssh2ExecChannel {\n  outgoing: { id: number };\n  _callbacks: Array<(hadError: boolean | Error) => void>;\n}\n\ninterface Ssh2Protocol {\n  exec(channelId: number, command: string | Buffer, wantReply?: boolean): void;\n}\n\ninterface Ssh2ClientInternals {\n  _protocol?: Ssh2Protocol;\n  _chanMgr?: { _channels: Record<number, Ssh2ExecChannel | undefined> };\n}\n"]}

package/lib/src/key-store.d.ts

@@ -0,0 +1,39 @@
+import type { LakeboxClient } from "./rest.ts";
+interface StoredKey {
+    privateKey: string;
+    privateKeyPath: string;
+    publicKey: string;
+    keyHash: string;
+}
+/**
+ * Stores caller-scoped SSH keys and trusted Databricks gateway host keys.
+ *
+ * Each workspace and caller identity receives a separate Ed25519 key pair. The
+ * store writes private keys, gateway fingerprints, and OpenSSH known-host files
+ * with owner-only permissions beneath the configured root directory.
+ */
+export declare class SshKeyStore {
+    private readonly root;
+    /** Creates a key store rooted at the default dbx-tools application-data path. */
+    constructor(root?: string);
+    /**
+     * Loads or creates the caller key pair and registers its public key when the
+     * workspace does not already contain the matching key hash.
+     *
+     * @returns The local key material and the gateway host returned by Databricks,
+     * when available.
+     */
+    ensureRegistered(api: LakeboxClient, owner: string, signal?: AbortSignal): Promise<StoredKey & {
+        gatewayHost?: string;
+    }>;
+    /** Returns the stored SHA-256 gateway fingerprint, or `undefined` when untrusted. */
+    knownHost(scope: string, owner: string, host: string, port: number): Promise<string | undefined>;
+    /** Returns the OpenSSH known-host file path for one workspace, user, and gateway. */
+    knownHostsPath(scope: string, owner: string, host: string, port: number): string;
+    /** Stores the accepted gateway fingerprint and OpenSSH host-key entry. */
+    rememberHost(scope: string, owner: string, host: string, port: number, fingerprint: string, key: Buffer): Promise<void>;
+    private loadOrCreate;
+    private hostFingerprintPath;
+    private directory;
+}
+export {};

package/lib/src/key-store.js

@@ -0,0 +1,145 @@
+import { createHash, randomBytes } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileLock } from "@dbx-tools/core";
+import ssh2 from "ssh2";
+const { utils } = ssh2;
+/**
+ * Stores caller-scoped SSH keys and trusted Databricks gateway host keys.
+ *
+ * Each workspace and caller identity receives a separate Ed25519 key pair. The
+ * store writes private keys, gateway fingerprints, and OpenSSH known-host files
+ * with owner-only permissions beneath the configured root directory.
+ */
+export class SshKeyStore {
+    root;
+    /** Creates a key store rooted at the default dbx-tools application-data path. */
+    constructor(root = join(homedir(), ".dbx-tools", "lakebox")) {
+        this.root = root;
+    }
+    /**
+     * Loads or creates the caller key pair and registers its public key when the
+     * workspace does not already contain the matching key hash.
+     *
+     * @returns The local key material and the gateway host returned by Databricks,
+     * when available.
+     */
+    async ensureRegistered(api, owner, signal) {
+        const key = await this.loadOrCreate(await api.workspaceScope(), owner);
+        const keys = await api.listKeys(signal);
+        const existing = keys.find((entry) => entry.keyHash === key.keyHash);
+        if (existing) {
+            return { ...key, ...(existing.gatewayHost ? { gatewayHost: existing.gatewayHost } : {}) };
+        }
+        const registered = await api.registerKey(key.publicKey, `dbx-tools-lakebox:${key.keyHash}`, signal);
+        return {
+            ...key,
+            ...(registered.gatewayHost ? { gatewayHost: registered.gatewayHost } : {}),
+        };
+    }
+    /** Returns the stored SHA-256 gateway fingerprint, or `undefined` when untrusted. */
+    async knownHost(scope, owner, host, port) {
+        try {
+            const value = await readFile(this.hostFingerprintPath(scope, owner, host, port), "utf8");
+            return value.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** Returns the OpenSSH known-host file path for one workspace, user, and gateway. */
+    knownHostsPath(scope, owner, host, port) {
+        return join(this.directory(scope, owner), `host-${digest(`${host}\0${port}`)}.known_hosts`);
+    }
+    /** Stores the accepted gateway fingerprint and OpenSSH host-key entry. */
+    async rememberHost(scope, owner, host, port, fingerprint, key) {
+        const directory = this.directory(scope, owner);
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const fingerprintPath = this.hostFingerprintPath(scope, owner, host, port);
+        const knownHostsPath = this.knownHostsPath(scope, owner, host, port);
+        const knownHost = `[${host}]:${port} ${sshKeyAlgorithm(key)} ${key.toString("base64")}\n`;
+        await Promise.all([
+            writeFile(fingerprintPath, `${fingerprint}\n`, { mode: 0o600 }),
+            writeFile(knownHostsPath, knownHost, { mode: 0o600 }),
+        ]);
+        await Promise.all([chmod(fingerprintPath, 0o600), chmod(knownHostsPath, 0o600)]);
+    }
+    async loadOrCreate(scope, owner) {
+        const directory = this.directory(scope, owner);
+        const privatePath = join(directory, "id_ed25519");
+        const publicPath = `${privatePath}.pub`;
+        const stored = await readStoredKey(privatePath, publicPath);
+        if (stored)
+            return stored;
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        return fileLock.withFileLock(["lakebox-ssh-key", privatePath], async () => {
+            const rechecked = await readStoredKey(privatePath, publicPath);
+            if (rechecked)
+                return rechecked;
+            const generated = utils.generateKeyPairSync("ed25519");
+            const privateKey = generated.private;
+            const publicKey = generated.public;
+            const suffix = `${process.pid}-${randomBytes(8).toString("hex")}`;
+            const stagedPrivate = `${privatePath}.${suffix}`;
+            const stagedPublic = `${publicPath}.${suffix}`;
+            try {
+                await writeFile(stagedPrivate, privateKey, { mode: 0o600 });
+                await writeFile(stagedPublic, `${publicKey.trim()}\n`, { mode: 0o600 });
+                await rename(stagedPrivate, privatePath);
+                await rename(stagedPublic, publicPath);
+                await Promise.all([chmod(privatePath, 0o600), chmod(publicPath, 0o600)]);
+                const created = await readStoredKey(privatePath, publicPath);
+                if (!created)
+                    throw new Error("SSH key files were not published atomically");
+                return created;
+            }
+            finally {
+                await Promise.all([rm(stagedPrivate, { force: true }), rm(stagedPublic, { force: true })]);
+            }
+        });
+    }
+    hostFingerprintPath(scope, owner, host, port) {
+        return join(this.directory(scope, owner), `host-${digest(`${host}\0${port}`)}.sha256`);
+    }
+    directory(scope, owner) {
+        return join(this.root, digest(`${scope}\0${owner}`));
+    }
+}
+async function readStoredKey(privatePath, publicPath) {
+    try {
+        const [privateKey, publicKey] = await Promise.all([
+            readFile(privatePath, "utf8"),
+            readFile(publicPath, "utf8"),
+        ]);
+        return {
+            privateKey,
+            privateKeyPath: privatePath,
+            publicKey,
+            keyHash: publicKeyHash(publicKey),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function publicKeyHash(publicKey) {
+    const normalized = publicKey.trim().split(/\s+/).slice(0, 2).join(" ");
+    return createHash("sha256").update(normalized).digest().subarray(0, 16).toString("hex");
+}
+function digest(value) {
+    return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function sshKeyAlgorithm(key) {
+    if (key.length < 5)
+        throw new Error("SSH gateway returned an invalid host key");
+    const length = key.readUInt32BE(0);
+    const end = 4 + length;
+    if (length === 0 || end > key.length)
+        throw new Error("SSH gateway returned an invalid host key");
+    const algorithm = key.subarray(4, end).toString("ascii");
+    if (/\s/.test(algorithm))
+        throw new Error("SSH gateway returned an invalid host key algorithm");
+    return algorithm;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-store.js","sourceRoot":"","sources":["../../src/key-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash, randomBytes } from \"node:crypto\";\nimport { chmod, mkdir, readFile, rename, rm, writeFile } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { fileLock } from \"@dbx-tools/core\";\nimport ssh2 from \"ssh2\";\nimport type { LakeboxClient } from \"./rest.ts\";\n\nconst { utils } = ssh2;\n\ninterface StoredKey {\n  privateKey: string;\n  privateKeyPath: string;\n  publicKey: string;\n  keyHash: string;\n}\n\n/**\n * Stores caller-scoped SSH keys and trusted Databricks gateway host keys.\n *\n * Each workspace and caller identity receives a separate Ed25519 key pair. The\n * store writes private keys, gateway fingerprints, and OpenSSH known-host files\n * with owner-only permissions beneath the configured root directory.\n */\nexport class SshKeyStore {\n  /** Creates a key store rooted at the default dbx-tools application-data path. */\n  constructor(private readonly root = join(homedir(), \".dbx-tools\", \"lakebox\")) {}\n\n  /**\n   * Loads or creates the caller key pair and registers its public key when the\n   * workspace does not already contain the matching key hash.\n   *\n   * @returns The local key material and the gateway host returned by Databricks,\n   * when available.\n   */\n  async ensureRegistered(\n    api: LakeboxClient,\n    owner: string,\n    signal?: AbortSignal,\n  ): Promise<StoredKey & { gatewayHost?: string }> {\n    const key = await this.loadOrCreate(await api.workspaceScope(), owner);\n    const keys = await api.listKeys(signal);\n    const existing = keys.find((entry) => entry.keyHash === key.keyHash);\n    if (existing) {\n      return { ...key, ...(existing.gatewayHost ? { gatewayHost: existing.gatewayHost } : {}) };\n    }\n    const registered = await api.registerKey(\n      key.publicKey,\n      `dbx-tools-lakebox:${key.keyHash}`,\n      signal,\n    );\n    return {\n      ...key,\n      ...(registered.gatewayHost ? { gatewayHost: registered.gatewayHost } : {}),\n    };\n  }\n\n  /** Returns the stored SHA-256 gateway fingerprint, or `undefined` when untrusted. */\n  async knownHost(\n    scope: string,\n    owner: string,\n    host: string,\n    port: number,\n  ): Promise<string | undefined> {\n    try {\n      const value = await readFile(this.hostFingerprintPath(scope, owner, host, port), \"utf8\");\n      return value.trim() || undefined;\n    } catch {\n      return undefined;\n    }\n  }\n\n  /** Returns the OpenSSH known-host file path for one workspace, user, and gateway. */\n  knownHostsPath(scope: string, owner: string, host: string, port: number): string {\n    return join(this.directory(scope, owner), `host-${digest(`${host}\\0${port}`)}.known_hosts`);\n  }\n\n  /** Stores the accepted gateway fingerprint and OpenSSH host-key entry. */\n  async rememberHost(\n    scope: string,\n    owner: string,\n    host: string,\n    port: number,\n    fingerprint: string,\n    key: Buffer,\n  ): Promise<void> {\n    const directory = this.directory(scope, owner);\n    await mkdir(directory, { recursive: true, mode: 0o700 });\n    const fingerprintPath = this.hostFingerprintPath(scope, owner, host, port);\n    const knownHostsPath = this.knownHostsPath(scope, owner, host, port);\n    const knownHost = `[${host}]:${port} ${sshKeyAlgorithm(key)} ${key.toString(\"base64\")}\\n`;\n    await Promise.all([\n      writeFile(fingerprintPath, `${fingerprint}\\n`, { mode: 0o600 }),\n      writeFile(knownHostsPath, knownHost, { mode: 0o600 }),\n    ]);\n    await Promise.all([chmod(fingerprintPath, 0o600), chmod(knownHostsPath, 0o600)]);\n  }\n\n  private async loadOrCreate(scope: string, owner: string): Promise<StoredKey> {\n    const directory = this.directory(scope, owner);\n    const privatePath = join(directory, \"id_ed25519\");\n    const publicPath = `${privatePath}.pub`;\n    const stored = await readStoredKey(privatePath, publicPath);\n    if (stored) return stored;\n    await mkdir(directory, { recursive: true, mode: 0o700 });\n    return fileLock.withFileLock([\"lakebox-ssh-key\", privatePath], async () => {\n      const rechecked = await readStoredKey(privatePath, publicPath);\n      if (rechecked) return rechecked;\n\n      const generated = utils.generateKeyPairSync(\"ed25519\");\n      const privateKey = generated.private;\n      const publicKey = generated.public;\n      const suffix = `${process.pid}-${randomBytes(8).toString(\"hex\")}`;\n      const stagedPrivate = `${privatePath}.${suffix}`;\n      const stagedPublic = `${publicPath}.${suffix}`;\n      try {\n        await writeFile(stagedPrivate, privateKey, { mode: 0o600 });\n        await writeFile(stagedPublic, `${publicKey.trim()}\\n`, { mode: 0o600 });\n        await rename(stagedPrivate, privatePath);\n        await rename(stagedPublic, publicPath);\n        await Promise.all([chmod(privatePath, 0o600), chmod(publicPath, 0o600)]);\n        const created = await readStoredKey(privatePath, publicPath);\n        if (!created) throw new Error(\"SSH key files were not published atomically\");\n        return created;\n      } finally {\n        await Promise.all([rm(stagedPrivate, { force: true }), rm(stagedPublic, { force: true })]);\n      }\n    });\n  }\n\n  private hostFingerprintPath(scope: string, owner: string, host: string, port: number): string {\n    return join(this.directory(scope, owner), `host-${digest(`${host}\\0${port}`)}.sha256`);\n  }\n\n  private directory(scope: string, owner: string): string {\n    return join(this.root, digest(`${scope}\\0${owner}`));\n  }\n}\n\nasync function readStoredKey(\n  privatePath: string,\n  publicPath: string,\n): Promise<StoredKey | undefined> {\n  try {\n    const [privateKey, publicKey] = await Promise.all([\n      readFile(privatePath, \"utf8\"),\n      readFile(publicPath, \"utf8\"),\n    ]);\n    return {\n      privateKey,\n      privateKeyPath: privatePath,\n      publicKey,\n      keyHash: publicKeyHash(publicKey),\n    };\n  } catch {\n    return undefined;\n  }\n}\n\nfunction publicKeyHash(publicKey: string): string {\n  const normalized = publicKey.trim().split(/\\s+/).slice(0, 2).join(\" \");\n  return createHash(\"sha256\").update(normalized).digest().subarray(0, 16).toString(\"hex\");\n}\n\nfunction digest(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\").slice(0, 32);\n}\n\nfunction sshKeyAlgorithm(key: Buffer): string {\n  if (key.length < 5) throw new Error(\"SSH gateway returned an invalid host key\");\n  const length = key.readUInt32BE(0);\n  const end = 4 + length;\n  if (length === 0 || end > key.length) throw new Error(\"SSH gateway returned an invalid host key\");\n  const algorithm = key.subarray(4, end).toString(\"ascii\");\n  if (/\\s/.test(algorithm)) throw new Error(\"SSH gateway returned an invalid host key algorithm\");\n  return algorithm;\n}\n"]}

package/lib/src/lifecycle.d.ts

@@ -0,0 +1,18 @@
+import type { LakeboxStatus } from "@dbx-tools/shared-lakebox";
+import type { LakeboxClient, LakeboxEntry } from "./rest.ts";
+/** Maps an upstream Lakebox status to the shared lifecycle state. */
+export declare function normalizeLakeboxStatus(value: string): Exclude<LakeboxStatus, "missing">;
+/** Parses an upstream duration such as `600s` into seconds. */
+export declare function lakeboxIdleTimeoutSeconds(value: string | undefined): number | undefined;
+/**
+ * Starts a Lakebox when needed and waits until it is running.
+ *
+ * @throws When the Lakebox does not reach running within five minutes.
+ */
+export declare function ensureLakeboxRunning(api: LakeboxClient, current: LakeboxEntry, signal?: AbortSignal): Promise<LakeboxEntry>;
+/**
+ * Stops a Lakebox when needed and waits until it is stopped.
+ *
+ * @throws When the Lakebox does not reach stopped within five minutes.
+ */
+export declare function ensureLakeboxStopped(api: LakeboxClient, current: LakeboxEntry, signal?: AbortSignal): Promise<LakeboxEntry>;

package/lib/src/lifecycle.js

@@ -0,0 +1,75 @@
+import { asyncUtils } from "@dbx-tools/shared-core";
+const POLL_INTERVAL_MS = 1_000;
+const LIFECYCLE_TIMEOUT_MS = 300_000;
+/** Maps an upstream Lakebox status to the shared lifecycle state. */
+export function normalizeLakeboxStatus(value) {
+    switch (value.trim().toLowerCase()) {
+        case "starting":
+        case "provisioning":
+        case "pending":
+            return "starting";
+        case "running":
+            return "running";
+        case "stopping":
+            return "stopping";
+        case "stopped":
+            return "stopped";
+        case "failed":
+        case "error":
+            return "error";
+        default:
+            return "unknown";
+    }
+}
+/** Parses an upstream duration such as `600s` into seconds. */
+export function lakeboxIdleTimeoutSeconds(value) {
+    if (!value?.endsWith("s"))
+        return undefined;
+    const seconds = Number(value.slice(0, -1));
+    return Number.isFinite(seconds) && seconds > 0 ? seconds : undefined;
+}
+/**
+ * Starts a Lakebox when needed and waits until it is running.
+ *
+ * @throws When the Lakebox does not reach running within five minutes.
+ */
+export async function ensureLakeboxRunning(api, current, signal) {
+    let entry = current;
+    const status = normalizeLakeboxStatus(entry.status);
+    if (status === "running")
+        return entry;
+    if (status === "starting")
+        return waitForLakeboxStatus(api, entry, "running", signal);
+    if (status === "stopping")
+        entry = await waitForLakeboxStatus(api, entry, "stopped", signal);
+    return waitForLakeboxStatus(api, await api.start(entry.sandboxId, signal), "running", signal);
+}
+/**
+ * Stops a Lakebox when needed and waits until it is stopped.
+ *
+ * @throws When the Lakebox does not reach stopped within five minutes.
+ */
+export async function ensureLakeboxStopped(api, current, signal) {
+    let entry = current;
+    const status = normalizeLakeboxStatus(entry.status);
+    if (status === "stopped")
+        return entry;
+    if (status === "stopping")
+        return waitForLakeboxStatus(api, entry, "stopped", signal);
+    if (status === "starting")
+        entry = await waitForLakeboxStatus(api, entry, "running", signal);
+    return waitForLakeboxStatus(api, await api.stop(entry.sandboxId, signal), "stopped", signal);
+}
+async function waitForLakeboxStatus(api, current, expected, signal) {
+    const deadline = Date.now() + LIFECYCLE_TIMEOUT_MS;
+    let entry = current;
+    while (normalizeLakeboxStatus(entry.status) !== expected) {
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out waiting for Lakebox ${entry.sandboxId} to become ${expected}`);
+        }
+        await asyncUtils.sleep(POLL_INTERVAL_MS, signal);
+        entry = await api.get(entry.sandboxId, signal);
+    }
+    return entry;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlmZWN5Y2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2xpZmVjeWNsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFJcEQsTUFBTSxnQkFBZ0IsR0FBRyxLQUFLLENBQUM7QUFDL0IsTUFBTSxvQkFBb0IsR0FBRyxPQUFPLENBQUM7QUFFckMscUVBQXFFO0FBQ3JFLE1BQU0sVUFBVSxzQkFBc0IsQ0FBQyxLQUFhO0lBQ2xELFFBQVEsS0FBSyxDQUFDLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxFQUFFLENBQUM7UUFDbkMsS0FBSyxVQUFVLENBQUM7UUFDaEIsS0FBSyxjQUFjLENBQUM7UUFDcEIsS0FBSyxTQUFTO1lBQ1osT0FBTyxVQUFVLENBQUM7UUFDcEIsS0FBSyxTQUFTO1lBQ1osT0FBTyxTQUFTLENBQUM7UUFDbkIsS0FBSyxVQUFVO1lBQ2IsT0FBTyxVQUFVLENBQUM7UUFDcEIsS0FBSyxTQUFTO1lBQ1osT0FBTyxTQUFTLENBQUM7UUFDbkIsS0FBSyxRQUFRLENBQUM7UUFDZCxLQUFLLE9BQU87WUFDVixPQUFPLE9BQU8sQ0FBQztRQUNqQjtZQUNFLE9BQU8sU0FBUyxDQUFDO0lBQ3JCLENBQUM7QUFDSCxDQUFDO0FBRUQsK0RBQStEO0FBQy9ELE1BQU0sVUFBVSx5QkFBeUIsQ0FBQyxLQUF5QjtJQUNqRSxJQUFJLENBQUMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxHQUFHLENBQUM7UUFBRSxPQUFPLFNBQVMsQ0FBQztJQUM1QyxNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQzNDLE9BQU8sTUFBTSxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsSUFBSSxPQUFPLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQztBQUN2RSxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsb0JBQW9CLENBQ3hDLEdBQWtCLEVBQ2xCLE9BQXFCLEVBQ3JCLE1BQW9CO0lBRXBCLElBQUksS0FBSyxHQUFHLE9BQU8sQ0FBQztJQUNwQixNQUFNLE1BQU0sR0FBRyxzQkFBc0IsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDcEQsSUFBSSxNQUFNLEtBQUssU0FBUztRQUFFLE9BQU8sS0FBSyxDQUFDO0lBQ3ZDLElBQUksTUFBTSxLQUFLLFVBQVU7UUFBRSxPQUFPLG9CQUFvQixDQUFDLEdBQUcsRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3RGLElBQUksTUFBTSxLQUFLLFVBQVU7UUFBRSxLQUFLLEdBQUcsTUFBTSxvQkFBb0IsQ0FBQyxHQUFHLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM3RixPQUFPLG9CQUFvQixDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsRUFBRSxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDaEcsQ0FBQztBQUVEOzs7O0dBSUc7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLG9CQUFvQixDQUN4QyxHQUFrQixFQUNsQixPQUFxQixFQUNyQixNQUFvQjtJQUVwQixJQUFJLEtBQUssR0FBRyxPQUFPLENBQUM7SUFDcEIsTUFBTSxNQUFNLEdBQUcsc0JBQXNCLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ3BELElBQUksTUFBTSxLQUFLLFNBQVM7UUFBRSxPQUFPLEtBQUssQ0FBQztJQUN2QyxJQUFJLE1BQU0sS0FBSyxVQUFVO1FBQUUsT0FBTyxvQkFBb0IsQ0FBQyxHQUFHLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUN0RixJQUFJLE1BQU0sS0FBSyxVQUFVO1FBQUUsS0FBSyxHQUFHLE1BQU0sb0JBQW9CLENBQUMsR0FBRyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDN0YsT0FBTyxvQkFBb0IsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLEVBQUUsTUFBTSxDQUFDLEVBQUUsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0FBQy9GLENBQUM7QUFFRCxLQUFLLFVBQVUsb0JBQW9CLENBQ2pDLEdBQWtCLEVBQ2xCLE9BQXFCLEVBQ3JCLFFBQStCLEVBQy9CLE1BQW9CO0lBRXBCLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxvQkFBb0IsQ0FBQztJQUNuRCxJQUFJLEtBQUssR0FBRyxPQUFPLENBQUM7SUFDcEIsT0FBTyxzQkFBc0IsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDekQsSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLElBQUksUUFBUSxFQUFFLENBQUM7WUFDM0IsTUFBTSxJQUFJLEtBQUssQ0FBQyxpQ0FBaUMsS0FBSyxDQUFDLFNBQVMsY0FBYyxRQUFRLEVBQUUsQ0FBQyxDQUFDO1FBQzVGLENBQUM7UUFDRCxNQUFNLFVBQVUsQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDakQsS0FBSyxHQUFHLE1BQU0sR0FBRyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFDRCxPQUFPLEtBQUssQ0FBQztBQUNmLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBhc3luY1V0aWxzIH0gZnJvbSBcIkBkYngtdG9vbHMvc2hhcmVkLWNvcmVcIjtcbmltcG9ydCB0eXBlIHsgTGFrZWJveFN0YXR1cyB9IGZyb20gXCJAZGJ4LXRvb2xzL3NoYXJlZC1sYWtlYm94XCI7XG5pbXBvcnQgdHlwZSB7IExha2Vib3hDbGllbnQsIExha2Vib3hFbnRyeSB9IGZyb20gXCIuL3Jlc3QudHNcIjtcblxuY29uc3QgUE9MTF9JTlRFUlZBTF9NUyA9IDFfMDAwO1xuY29uc3QgTElGRUNZQ0xFX1RJTUVPVVRfTVMgPSAzMDBfMDAwO1xuXG4vKiogTWFwcyBhbiB1cHN0cmVhbSBMYWtlYm94IHN0YXR1cyB0byB0aGUgc2hhcmVkIGxpZmVjeWNsZSBzdGF0ZS4gKi9cbmV4cG9ydCBmdW5jdGlvbiBub3JtYWxpemVMYWtlYm94U3RhdHVzKHZhbHVlOiBzdHJpbmcpOiBFeGNsdWRlPExha2Vib3hTdGF0dXMsIFwibWlzc2luZ1wiPiB7XG4gIHN3aXRjaCAodmFsdWUudHJpbSgpLnRvTG93ZXJDYXNlKCkpIHtcbiAgICBjYXNlIFwic3RhcnRpbmdcIjpcbiAgICBjYXNlIFwicHJvdmlzaW9uaW5nXCI6XG4gICAgY2FzZSBcInBlbmRpbmdcIjpcbiAgICAgIHJldHVybiBcInN0YXJ0aW5nXCI7XG4gICAgY2FzZSBcInJ1bm5pbmdcIjpcbiAgICAgIHJldHVybiBcInJ1bm5pbmdcIjtcbiAgICBjYXNlIFwic3RvcHBpbmdcIjpcbiAgICAgIHJldHVybiBcInN0b3BwaW5nXCI7XG4gICAgY2FzZSBcInN0b3BwZWRcIjpcbiAgICAgIHJldHVybiBcInN0b3BwZWRcIjtcbiAgICBjYXNlIFwiZmFpbGVkXCI6XG4gICAgY2FzZSBcImVycm9yXCI6XG4gICAgICByZXR1cm4gXCJlcnJvclwiO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gXCJ1bmtub3duXCI7XG4gIH1cbn1cblxuLyoqIFBhcnNlcyBhbiB1cHN0cmVhbSBkdXJhdGlvbiBzdWNoIGFzIGA2MDBzYCBpbnRvIHNlY29uZHMuICovXG5leHBvcnQgZnVuY3Rpb24gbGFrZWJveElkbGVUaW1lb3V0U2Vjb25kcyh2YWx1ZTogc3RyaW5nIHwgdW5kZWZpbmVkKTogbnVtYmVyIHwgdW5kZWZpbmVkIHtcbiAgaWYgKCF2YWx1ZT8uZW5kc1dpdGgoXCJzXCIpKSByZXR1cm4gdW5kZWZpbmVkO1xuICBjb25zdCBzZWNvbmRzID0gTnVtYmVyKHZhbHVlLnNsaWNlKDAsIC0xKSk7XG4gIHJldHVybiBOdW1iZXIuaXNGaW5pdGUoc2Vjb25kcykgJiYgc2Vjb25kcyA+IDAgPyBzZWNvbmRzIDogdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIFN0YXJ0cyBhIExha2Vib3ggd2hlbiBuZWVkZWQgYW5kIHdhaXRzIHVudGlsIGl0IGlzIHJ1bm5pbmcuXG4gKlxuICogQHRocm93cyBXaGVuIHRoZSBMYWtlYm94IGRvZXMgbm90IHJlYWNoIHJ1bm5pbmcgd2l0aGluIGZpdmUgbWludXRlcy5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGVuc3VyZUxha2Vib3hSdW5uaW5nKFxuICBhcGk6IExha2Vib3hDbGllbnQsXG4gIGN1cnJlbnQ6IExha2Vib3hFbnRyeSxcbiAgc2lnbmFsPzogQWJvcnRTaWduYWwsXG4pOiBQcm9taXNlPExha2Vib3hFbnRyeT4ge1xuICBsZXQgZW50cnkgPSBjdXJyZW50O1xuICBjb25zdCBzdGF0dXMgPSBub3JtYWxpemVMYWtlYm94U3RhdHVzKGVudHJ5LnN0YXR1cyk7XG4gIGlmIChzdGF0dXMgPT09IFwicnVubmluZ1wiKSByZXR1cm4gZW50cnk7XG4gIGlmIChzdGF0dXMgPT09IFwic3RhcnRpbmdcIikgcmV0dXJuIHdhaXRGb3JMYWtlYm94U3RhdHVzKGFwaSwgZW50cnksIFwicnVubmluZ1wiLCBzaWduYWwpO1xuICBpZiAoc3RhdHVzID09PSBcInN0b3BwaW5nXCIpIGVudHJ5ID0gYXdhaXQgd2FpdEZvckxha2Vib3hTdGF0dXMoYXBpLCBlbnRyeSwgXCJzdG9wcGVkXCIsIHNpZ25hbCk7XG4gIHJldHVybiB3YWl0Rm9yTGFrZWJveFN0YXR1cyhhcGksIGF3YWl0IGFwaS5zdGFydChlbnRyeS5zYW5kYm94SWQsIHNpZ25hbCksIFwicnVubmluZ1wiLCBzaWduYWwpO1xufVxuXG4vKipcbiAqIFN0b3BzIGEgTGFrZWJveCB3aGVuIG5lZWRlZCBhbmQgd2FpdHMgdW50aWwgaXQgaXMgc3RvcHBlZC5cbiAqXG4gKiBAdGhyb3dzIFdoZW4gdGhlIExha2Vib3ggZG9lcyBub3QgcmVhY2ggc3RvcHBlZCB3aXRoaW4gZml2ZSBtaW51dGVzLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZW5zdXJlTGFrZWJveFN0b3BwZWQoXG4gIGFwaTogTGFrZWJveENsaWVudCxcbiAgY3VycmVudDogTGFrZWJveEVudHJ5LFxuICBzaWduYWw/OiBBYm9ydFNpZ25hbCxcbik6IFByb21pc2U8TGFrZWJveEVudHJ5PiB7XG4gIGxldCBlbnRyeSA9IGN1cnJlbnQ7XG4gIGNvbnN0IHN0YXR1cyA9IG5vcm1hbGl6ZUxha2Vib3hTdGF0dXMoZW50cnkuc3RhdHVzKTtcbiAgaWYgKHN0YXR1cyA9PT0gXCJzdG9wcGVkXCIpIHJldHVybiBlbnRyeTtcbiAgaWYgKHN0YXR1cyA9PT0gXCJzdG9wcGluZ1wiKSByZXR1cm4gd2FpdEZvckxha2Vib3hTdGF0dXMoYXBpLCBlbnRyeSwgXCJzdG9wcGVkXCIsIHNpZ25hbCk7XG4gIGlmIChzdGF0dXMgPT09IFwic3RhcnRpbmdcIikgZW50cnkgPSBhd2FpdCB3YWl0Rm9yTGFrZWJveFN0YXR1cyhhcGksIGVudHJ5LCBcInJ1bm5pbmdcIiwgc2lnbmFsKTtcbiAgcmV0dXJuIHdhaXRGb3JMYWtlYm94U3RhdHVzKGFwaSwgYXdhaXQgYXBpLnN0b3AoZW50cnkuc2FuZGJveElkLCBzaWduYWwpLCBcInN0b3BwZWRcIiwgc2lnbmFsKTtcbn1cblxuYXN5bmMgZnVuY3Rpb24gd2FpdEZvckxha2Vib3hTdGF0dXMoXG4gIGFwaTogTGFrZWJveENsaWVudCxcbiAgY3VycmVudDogTGFrZWJveEVudHJ5LFxuICBleHBlY3RlZDogXCJydW5uaW5nXCIgfCBcInN0b3BwZWRcIixcbiAgc2lnbmFsPzogQWJvcnRTaWduYWwsXG4pOiBQcm9taXNlPExha2Vib3hFbnRyeT4ge1xuICBjb25zdCBkZWFkbGluZSA9IERhdGUubm93KCkgKyBMSUZFQ1lDTEVfVElNRU9VVF9NUztcbiAgbGV0IGVudHJ5ID0gY3VycmVudDtcbiAgd2hpbGUgKG5vcm1hbGl6ZUxha2Vib3hTdGF0dXMoZW50cnkuc3RhdHVzKSAhPT0gZXhwZWN0ZWQpIHtcbiAgICBpZiAoRGF0ZS5ub3coKSA+PSBkZWFkbGluZSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKGBUaW1lZCBvdXQgd2FpdGluZyBmb3IgTGFrZWJveCAke2VudHJ5LnNhbmRib3hJZH0gdG8gYmVjb21lICR7ZXhwZWN0ZWR9YCk7XG4gICAgfVxuICAgIGF3YWl0IGFzeW5jVXRpbHMuc2xlZXAoUE9MTF9JTlRFUlZBTF9NUywgc2lnbmFsKTtcbiAgICBlbnRyeSA9IGF3YWl0IGFwaS5nZXQoZW50cnkuc2FuZGJveElkLCBzaWduYWwpO1xuICB9XG4gIHJldHVybiBlbnRyeTtcbn1cbiJdfQ==