@dbx-tools/cli 0.9.58 → 0.9.61

package/lib/src/lakebase-proxy/proxy.js

@@ -0,0 +1,200 @@
+/** Pure Node PostgreSQL wire proxy for Databricks Lakebase. */
+import { createServer } from "node:net";
+import { LakebaseClient, requireAddress } from "@dbx-tools/lakebase";
+import { postgresConnectionOptions } from "@dbx-tools/postgres";
+import { log, stringUtils } from "@dbx-tools/shared-core";
+import { Client } from "pg";
+import { CancellationRegistry } from "./cancellation.js";
+import { resolveLakebaseProxyOptions, } from "./options.js";
+import { fatalError, PostgresProtocolError, readInitialMessage, startupComplete, upstreamStartupParameters, } from "./protocol.js";
+const logger = log.logger("lakebase-proxy");
+/** Loopback PostgreSQL wire proxy backed by Databricks Lakebase credentials. */
+export class LakebaseProxy {
+    client;
+    options;
+    cancellations = new CancellationRegistry();
+    server;
+    statsTimer;
+    opened = 0;
+    closed = 0;
+    failed = 0;
+    active = 0;
+    constructor(options = {}) {
+        this.options = resolveLakebaseProxyOptions(options);
+        this.client = new LakebaseClient({ profile: this.options.profile });
+    }
+    async listen() {
+        if (this.server)
+            throw new Error("Lakebase proxy is already listening");
+        const host = this.options.listen.host;
+        const server = createServer((socket) => void this.handle(socket));
+        this.server = server;
+        this.statsTimer = setInterval(() => this.reportStats(), 60_000);
+        this.statsTimer.unref();
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(this.options.listen.port, host, () => {
+                server.off("error", reject);
+                resolve();
+            });
+        });
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            throw new Error("Lakebase listener has no address");
+        }
+        logger.info("Lakebase proxy listening", { host: address.address, port: address.port });
+        return { host: address.address, port: address.port };
+    }
+    async close() {
+        const server = this.server;
+        this.server = undefined;
+        if (this.statsTimer)
+            clearInterval(this.statsTimer);
+        this.statsTimer = undefined;
+        if (!server)
+            return;
+        await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    }
+    async handle(local) {
+        const started = Date.now();
+        let upstream;
+        let cancellation;
+        this.opened += 1;
+        this.active += 1;
+        try {
+            local.setNoDelay(true);
+            const initial = await readInitialMessage(local, this.options.startupTimeoutSeconds * 1000);
+            if (initial.kind === "cancel") {
+                await this.cancellations.forward(initial);
+                local.end();
+                return;
+            }
+            const startup = initial;
+            const targetText = startup.parameters.database;
+            if (!targetText)
+                throw new ProxyFailure("startup database is required", "3D000");
+            let target;
+            try {
+                target = requireAddress(targetText);
+            }
+            catch (error) {
+                throw new ProxyFailure(message(error), "3D000");
+            }
+            const startupUser = stringUtils.trimToUndefined(startup.parameters.user);
+            let resolved;
+            try {
+                resolved = await this.client.resolve(target, startupUser);
+            }
+            catch (error) {
+                throw new ProxyFailure(message(error), "3D000");
+            }
+            let password;
+            try {
+                password = await this.client.generateDatabaseCredential(resolved.endpoint, startupUser);
+            }
+            catch (error) {
+                throw new ProxyFailure(message(error), "28000");
+            }
+            let connected;
+            try {
+                connected = await connectUpstream(resolved, password, postgresConnectionOptions(startup.parameters, this.options.postgresRole));
+            }
+            catch (error) {
+                throw new ProxyFailure(message(error), "08001");
+            }
+            upstream = connected.socket;
+            cancellation = this.cancellations.register({
+                host: resolved.host,
+                port: resolved.port,
+                processId: connected.processId,
+                secretKey: connected.secretKey,
+            });
+            local.write(startupComplete(connected.parameters, cancellation.processId, cancellation.secretKey, connected.transactionStatus));
+            local.pipe(upstream).pipe(local);
+            await Promise.race([closed(local), closed(upstream)]);
+            logger.debug("Lakebase connection closed", {
+                durationMs: Date.now() - started,
+                project: resolved.project,
+                branch: resolved.branch,
+                endpoint: resolved.endpoint,
+            });
+        }
+        catch (error) {
+            this.failed += 1;
+            const failure = error instanceof ProxyFailure
+                ? error
+                : error instanceof PostgresProtocolError
+                    ? new ProxyFailure(error.message, "08P01")
+                    : new ProxyFailure(message(error));
+            logger.warn("Lakebase connection failed", {
+                durationMs: Date.now() - started,
+                error: failure.message,
+            });
+            if (!local.destroyed)
+                local.end(fatalError(failure.message, failure.sqlstate));
+        }
+        finally {
+            if (cancellation)
+                this.cancellations.remove(cancellation);
+            upstream?.destroy();
+            local.destroy();
+            this.closed += 1;
+            this.active -= 1;
+        }
+    }
+    reportStats() {
+        logger.info("Lakebase proxy connections", {
+            opened: this.opened,
+            closed: this.closed,
+            failed: this.failed,
+            active: this.active,
+        });
+    }
+}
+async function connectUpstream(resolved, password, startup) {
+    const client = new Client({
+        host: resolved.host,
+        port: resolved.port,
+        database: resolved.database,
+        user: resolved.user,
+        password,
+        ssl: { rejectUnauthorized: true, servername: resolved.host },
+        application_name: startup.application_name,
+        connectionTimeoutMillis: 30_000,
+    });
+    const parameters = new Map();
+    client.getStartupConf = () => upstreamStartupParameters(startup, resolved.user, resolved.database);
+    client.on("error", (error) => {
+        logger.debug("Lakebase upstream client closed", { error: error.message });
+    });
+    client.connection.on("parameterStatus", (message) => {
+        parameters.set(message.parameterName, message.parameterValue);
+    });
+    await client.connect();
+    const socket = client.connection.stream;
+    socket.removeAllListeners("data");
+    return {
+        socket,
+        parameters,
+        processId: client.processID,
+        secretKey: client.secretKey,
+        transactionStatus: client._txStatus ?? "I",
+    };
+}
+function closed(socket) {
+    return new Promise((resolve, reject) => {
+        socket.once("close", () => resolve());
+        socket.once("error", reject);
+    });
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class ProxyFailure extends Error {
+    sqlstate;
+    constructor(message, sqlstate = "08001") {
+        super(message);
+        this.sqlstate = sqlstate;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../../src/lakebase-proxy/proxy.ts"],"names":[],"mappings":"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","sourcesContent":["/** Pure Node PostgreSQL wire proxy for Databricks Lakebase. */\n\nimport { createServer, type Server, type Socket } from \"node:net\";\nimport type { Duplex } from \"node:stream\";\nimport { LakebaseClient, requireAddress } from \"@dbx-tools/lakebase\";\nimport { postgresConnectionOptions } from \"@dbx-tools/postgres\";\nimport { log, stringUtils } from \"@dbx-tools/shared-core\";\nimport { Client } from \"pg\";\n\nimport { CancellationRegistry } from \"./cancellation.ts\";\nimport {\n  resolveLakebaseProxyOptions,\n  type LakebaseProxyOptions,\n  type ResolvedLakebaseProxyOptions,\n} from \"./options.ts\";\nimport {\n  fatalError,\n  PostgresProtocolError,\n  readInitialMessage,\n  startupComplete,\n  upstreamStartupParameters,\n  type CancelMessage,\n} from \"./protocol.ts\";\n\nconst logger = log.logger(\"lakebase-proxy\");\n\ninterface PgConnectionInternals {\n  stream: Duplex;\n  on(event: \"parameterStatus\", listener: (message: ParameterStatus) => void): void;\n}\n\ntype PgClientInternals = Client & {\n  connection: Client[\"connection\"] & PgConnectionInternals;\n  processID: number;\n  secretKey: number;\n  _txStatus?: string;\n  getStartupConf(): Record<string, string>;\n};\n\ninterface ParameterStatus {\n  parameterName: string;\n  parameterValue: string;\n}\n\n/** Loopback PostgreSQL wire proxy backed by Databricks Lakebase credentials. */\nexport class LakebaseProxy {\n  private readonly client: LakebaseClient;\n  private readonly options: ResolvedLakebaseProxyOptions;\n  private readonly cancellations = new CancellationRegistry();\n  private server?: Server;\n  private statsTimer?: ReturnType<typeof setInterval>;\n  private opened = 0;\n  private closed = 0;\n  private failed = 0;\n  private active = 0;\n\n  constructor(options: LakebaseProxyOptions = {}) {\n    this.options = resolveLakebaseProxyOptions(options);\n    this.client = new LakebaseClient({ profile: this.options.profile });\n  }\n\n  async listen(): Promise<{ host: string; port: number }> {\n    if (this.server) throw new Error(\"Lakebase proxy is already listening\");\n    const host = this.options.listen.host;\n    const server = createServer((socket) => void this.handle(socket));\n    this.server = server;\n    this.statsTimer = setInterval(() => this.reportStats(), 60_000);\n    this.statsTimer.unref();\n    await new Promise<void>((resolve, reject) => {\n      server.once(\"error\", reject);\n      server.listen(this.options.listen.port, host, () => {\n        server.off(\"error\", reject);\n        resolve();\n      });\n    });\n    const address = server.address();\n    if (!address || typeof address === \"string\") {\n      throw new Error(\"Lakebase listener has no address\");\n    }\n    logger.info(\"Lakebase proxy listening\", { host: address.address, port: address.port });\n    return { host: address.address, port: address.port };\n  }\n\n  async close(): Promise<void> {\n    const server = this.server;\n    this.server = undefined;\n    if (this.statsTimer) clearInterval(this.statsTimer);\n    this.statsTimer = undefined;\n    if (!server) return;\n    await new Promise<void>((resolve, reject) =>\n      server.close((error) => (error ? reject(error) : resolve())),\n    );\n  }\n\n  private async handle(local: Socket): Promise<void> {\n    const started = Date.now();\n    let upstream: Duplex | undefined;\n    let cancellation: CancelMessage | undefined;\n    this.opened += 1;\n    this.active += 1;\n    try {\n      local.setNoDelay(true);\n      const initial = await readInitialMessage(local, this.options.startupTimeoutSeconds * 1000);\n      if (initial.kind === \"cancel\") {\n        await this.cancellations.forward(initial);\n        local.end();\n        return;\n      }\n      const startup = initial;\n      const targetText = startup.parameters.database;\n      if (!targetText) throw new ProxyFailure(\"startup database is required\", \"3D000\");\n      let target;\n      try {\n        target = requireAddress(targetText);\n      } catch (error) {\n        throw new ProxyFailure(message(error), \"3D000\");\n      }\n      const startupUser = stringUtils.trimToUndefined(startup.parameters.user);\n      let resolved;\n      try {\n        resolved = await this.client.resolve(target, startupUser);\n      } catch (error) {\n        throw new ProxyFailure(message(error), \"3D000\");\n      }\n      let password;\n      try {\n        password = await this.client.generateDatabaseCredential(resolved.endpoint, startupUser);\n      } catch (error) {\n        throw new ProxyFailure(message(error), \"28000\");\n      }\n      let connected;\n      try {\n        connected = await connectUpstream(\n          resolved,\n          password,\n          postgresConnectionOptions(startup.parameters, this.options.postgresRole),\n        );\n      } catch (error) {\n        throw new ProxyFailure(message(error), \"08001\");\n      }\n      upstream = connected.socket;\n      cancellation = this.cancellations.register({\n        host: resolved.host,\n        port: resolved.port,\n        processId: connected.processId,\n        secretKey: connected.secretKey,\n      });\n      local.write(\n        startupComplete(\n          connected.parameters,\n          cancellation.processId,\n          cancellation.secretKey,\n          connected.transactionStatus,\n        ),\n      );\n      local.pipe(upstream).pipe(local);\n      await Promise.race([closed(local), closed(upstream)]);\n      logger.debug(\"Lakebase connection closed\", {\n        durationMs: Date.now() - started,\n        project: resolved.project,\n        branch: resolved.branch,\n        endpoint: resolved.endpoint,\n      });\n    } catch (error) {\n      this.failed += 1;\n      const failure =\n        error instanceof ProxyFailure\n          ? error\n          : error instanceof PostgresProtocolError\n            ? new ProxyFailure(error.message, \"08P01\")\n            : new ProxyFailure(message(error));\n      logger.warn(\"Lakebase connection failed\", {\n        durationMs: Date.now() - started,\n        error: failure.message,\n      });\n      if (!local.destroyed) local.end(fatalError(failure.message, failure.sqlstate));\n    } finally {\n      if (cancellation) this.cancellations.remove(cancellation);\n      upstream?.destroy();\n      local.destroy();\n      this.closed += 1;\n      this.active -= 1;\n    }\n  }\n\n  private reportStats(): void {\n    logger.info(\"Lakebase proxy connections\", {\n      opened: this.opened,\n      closed: this.closed,\n      failed: this.failed,\n      active: this.active,\n    });\n  }\n}\n\nasync function connectUpstream(\n  resolved: Awaited<ReturnType<LakebaseClient[\"resolve\"]>>,\n  password: string,\n  startup: Record<string, string>,\n): Promise<{\n  socket: Duplex;\n  parameters: Map<string, string>;\n  processId: number;\n  secretKey: number;\n  transactionStatus: string;\n}> {\n  const client = new Client({\n    host: resolved.host,\n    port: resolved.port,\n    database: resolved.database,\n    user: resolved.user,\n    password,\n    ssl: { rejectUnauthorized: true, servername: resolved.host },\n    application_name: startup.application_name,\n    connectionTimeoutMillis: 30_000,\n  }) as unknown as PgClientInternals;\n  const parameters = new Map<string, string>();\n  client.getStartupConf = () =>\n    upstreamStartupParameters(startup, resolved.user, resolved.database);\n  client.on(\"error\", (error) => {\n    logger.debug(\"Lakebase upstream client closed\", { error: error.message });\n  });\n  client.connection.on(\"parameterStatus\", (message) => {\n    parameters.set(message.parameterName, message.parameterValue);\n  });\n  await client.connect();\n  const socket = client.connection.stream;\n  socket.removeAllListeners(\"data\");\n  return {\n    socket,\n    parameters,\n    processId: client.processID,\n    secretKey: client.secretKey,\n    transactionStatus: client._txStatus ?? \"I\",\n  };\n}\n\nfunction closed(socket: Duplex): Promise<void> {\n  return new Promise((resolve, reject) => {\n    socket.once(\"close\", () => resolve());\n    socket.once(\"error\", reject);\n  });\n}\n\nfunction message(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nclass ProxyFailure extends Error {\n  constructor(\n    message: string,\n    readonly sqlstate = \"08001\",\n  ) {\n    super(message);\n  }\n}\n"]}

package/lib/src/model-gateway/cli.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Foreground `dbx model-gateway` command.
+ *
+ * @module
+ */
+import { type CliServiceCliDependencies } from "@dbx-tools/cli-service/cli";
+import { type CliServiceDefinition } from "@dbx-tools/cli-service/definition";
+import { type ModelGatewayOptions } from "@dbx-tools/shared-model-gateway/options";
+import { Command } from "commander";
+/** Injectable foreground gateway boundary for CLI tests. */
+export interface ModelGatewayCliDependencies {
+    start(options: ModelGatewayOptions): Promise<void>;
+    /** Optional service CLI boundary for tests and embedding. */
+    readonly service?: CliServiceCliDependencies;
+}
+/** Build the tray-only model-gateway service definition. */
+export declare function modelGatewayServiceDefinition(options?: ModelGatewayOptions): CliServiceDefinition;
+/** Build foreground and service model-gateway commands without starting a server. */
+export declare function buildProgram(name?: string, dependencies?: ModelGatewayCliDependencies): Command;

package/lib/src/model-gateway/cli.js

@@ -0,0 +1,63 @@
+/**
+ * Foreground `dbx model-gateway` command.
+ *
+ * @module
+ */
+import { addArgs, parseArgs, serializeArgs } from "@dbx-tools/cli-args";
+import { buildServiceCommand } from "@dbx-tools/cli-service/cli";
+import { defineService } from "@dbx-tools/cli-service/definition";
+import { ModelGatewayCliOptionsSchema, resolveModelGatewayCliOptions, } from "@dbx-tools/shared-model-gateway/options";
+import { Command } from "commander";
+import { startModelGateway } from "./server.js";
+import { PACKAGE_VERSION } from "../../index.js";
+const DEFAULT_DEPENDENCIES = {
+    start: startModelGateway,
+};
+/** Build the tray-only model-gateway service definition. */
+export function modelGatewayServiceDefinition(options = {}) {
+    const { runtimeInfo: _, bearerToken: _bearerToken, ...resolved } = resolveModelGatewayCliOptions(options);
+    const host = urlHost(resolved.listen.host);
+    return defineService(import.meta.url, {
+        id: "dbx-tools.cli-model-gateway",
+        name: "dbx model gateway",
+        command: {
+            binName: "dbx-model-gateway",
+            arguments: serializeArgs(resolved),
+        },
+        menu: [
+            {
+                type: "url",
+                label: "Models",
+                url: `http://${host}:${resolved.listen.port}/v1/models`,
+            },
+        ],
+    });
+}
+/** Build foreground and service model-gateway commands without starting a server. */
+export function buildProgram(name = "dbx model-gateway", dependencies = DEFAULT_DEPENDENCIES) {
+    const version = PACKAGE_VERSION;
+    const program = addArgs(new Command()
+        .name(name)
+        .description("Run or manage the AppKit Databricks model gateway")
+        .version(version, "-v, --version"), ModelGatewayCliOptionsSchema).action(async () => {
+        const options = modelGatewayOptions(program);
+        if (options.runtimeInfo) {
+            process.stdout.write(`${JSON.stringify({ implementation: "typescript-appkit", version })}\n`);
+            return;
+        }
+        const { runtimeInfo: _, ...serverOptions } = options;
+        await dependencies.start(serverOptions);
+    });
+    const serviceCommand = buildServiceCommand(() => {
+        return modelGatewayServiceDefinition(modelGatewayOptions(program));
+    }, dependencies.service);
+    program.addCommand(serviceCommand);
+    return program;
+}
+function modelGatewayOptions(command) {
+    return parseArgs(command, ModelGatewayCliOptionsSchema);
+}
+function urlHost(host) {
+    return host.includes(":") ? `[${host}]` : host;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsLWdhdGV3YXkvY2xpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN4RSxPQUFPLEVBQUUsbUJBQW1CLEVBQWtDLE1BQU0sNEJBQTRCLENBQUM7QUFDakcsT0FBTyxFQUFFLGFBQWEsRUFBNkIsTUFBTSxtQ0FBbUMsQ0FBQztBQUM3RixPQUFPLEVBQ0wsNEJBQTRCLEVBQzVCLDZCQUE2QixHQUc5QixNQUFNLHlDQUF5QyxDQUFDO0FBQ2pELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFcEMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ2hELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQVNqRCxNQUFNLG9CQUFvQixHQUFnQztJQUN4RCxLQUFLLEVBQUUsaUJBQWlCO0NBQ3pCLENBQUM7QUFFRiw0REFBNEQ7QUFDNUQsTUFBTSxVQUFVLDZCQUE2QixDQUMzQyxVQUErQixFQUFFO0lBRWpDLE1BQU0sRUFDSixXQUFXLEVBQUUsQ0FBQyxFQUNkLFdBQVcsRUFBRSxZQUFZLEVBQ3pCLEdBQUcsUUFBUSxFQUNaLEdBQUcsNkJBQTZCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDM0MsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDM0MsT0FBTyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUU7UUFDcEMsRUFBRSxFQUFFLDZCQUE2QjtRQUNqQyxJQUFJLEVBQUUsbUJBQW1CO1FBQ3pCLE9BQU8sRUFBRTtZQUNQLE9BQU8sRUFBRSxtQkFBbUI7WUFDNUIsU0FBUyxFQUFFLGFBQWEsQ0FBQyxRQUFRLENBQUM7U0FDbkM7UUFDRCxJQUFJLEVBQUU7WUFDSjtnQkFDRSxJQUFJLEVBQUUsS0FBSztnQkFDWCxLQUFLLEVBQUUsUUFBUTtnQkFDZixHQUFHLEVBQUUsVUFBVSxJQUFJLElBQUksUUFBUSxDQUFDLE1BQU0sQ0FBQyxJQUFJLFlBQVk7YUFDeEQ7U0FDRjtLQUNGLENBQUMsQ0FBQztBQUNMLENBQUM7QUFFRCxxRkFBcUY7QUFDckYsTUFBTSxVQUFVLFlBQVksQ0FDMUIsSUFBSSxHQUFHLG1CQUFtQixFQUMxQixlQUE0QyxvQkFBb0I7SUFFaEUsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFDO0lBQ2hDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FDckIsSUFBSSxPQUFPLEVBQUU7U0FDVixJQUFJLENBQUMsSUFBSSxDQUFDO1NBQ1YsV0FBVyxDQUFDLG1EQUFtRCxDQUFDO1NBQ2hFLE9BQU8sQ0FBQyxPQUFPLEVBQUUsZUFBZSxDQUFDLEVBQ3BDLDRCQUE0QixDQUM3QixDQUFDLE1BQU0sQ0FBQyxLQUFLLElBQUksRUFBRTtRQUNsQixNQUFNLE9BQU8sR0FBRyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUM3QyxJQUFJLE9BQU8sQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUN4QixPQUFPLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsRUFBRSxjQUFjLEVBQUUsbUJBQW1CLEVBQUUsT0FBTyxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDOUYsT0FBTztRQUNULENBQUM7UUFDRCxNQUFNLEVBQUUsV0FBVyxFQUFFLENBQUMsRUFBRSxHQUFHLGFBQWEsRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUNyRCxNQUFNLFlBQVksQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDMUMsQ0FBQyxDQUFDLENBQUM7SUFDSCxNQUFNLGNBQWMsR0FBRyxtQkFBbUIsQ0FBQyxHQUFHLEVBQUU7UUFDOUMsT0FBTyw2QkFBNkIsQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0lBQ3JFLENBQUMsRUFBRSxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDekIsT0FBTyxDQUFDLFVBQVUsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUNuQyxPQUFPLE9BQU8sQ0FBQztBQUNqQixDQUFDO0FBRUQsU0FBUyxtQkFBbUIsQ0FBQyxPQUFnQjtJQUMzQyxPQUFPLFNBQVMsQ0FBQyxPQUFPLEVBQUUsNEJBQTRCLENBQUMsQ0FBQztBQUMxRCxDQUFDO0FBRUQsU0FBUyxPQUFPLENBQUMsSUFBWTtJQUMzQixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksSUFBSSxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztBQUNqRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGb3JlZ3JvdW5kIGBkYnggbW9kZWwtZ2F0ZXdheWAgY29tbWFuZC5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cblxuaW1wb3J0IHsgYWRkQXJncywgcGFyc2VBcmdzLCBzZXJpYWxpemVBcmdzIH0gZnJvbSBcIkBkYngtdG9vbHMvY2xpLWFyZ3NcIjtcbmltcG9ydCB7IGJ1aWxkU2VydmljZUNvbW1hbmQsIHR5cGUgQ2xpU2VydmljZUNsaURlcGVuZGVuY2llcyB9IGZyb20gXCJAZGJ4LXRvb2xzL2NsaS1zZXJ2aWNlL2NsaVwiO1xuaW1wb3J0IHsgZGVmaW5lU2VydmljZSwgdHlwZSBDbGlTZXJ2aWNlRGVmaW5pdGlvbiB9IGZyb20gXCJAZGJ4LXRvb2xzL2NsaS1zZXJ2aWNlL2RlZmluaXRpb25cIjtcbmltcG9ydCB7XG4gIE1vZGVsR2F0ZXdheUNsaU9wdGlvbnNTY2hlbWEsXG4gIHJlc29sdmVNb2RlbEdhdGV3YXlDbGlPcHRpb25zLFxuICB0eXBlIE1vZGVsR2F0ZXdheUNsaU9wdGlvbnMsXG4gIHR5cGUgTW9kZWxHYXRld2F5T3B0aW9ucyxcbn0gZnJvbSBcIkBkYngtdG9vbHMvc2hhcmVkLW1vZGVsLWdhdGV3YXkvb3B0aW9uc1wiO1xuaW1wb3J0IHsgQ29tbWFuZCB9IGZyb20gXCJjb21tYW5kZXJcIjtcblxuaW1wb3J0IHsgc3RhcnRNb2RlbEdhdGV3YXkgfSBmcm9tIFwiLi9zZXJ2ZXIudHNcIjtcbmltcG9ydCB7IFBBQ0tBR0VfVkVSU0lPTiB9IGZyb20gXCIuLi8uLi9pbmRleC50c1wiO1xuXG4vKiogSW5qZWN0YWJsZSBmb3JlZ3JvdW5kIGdhdGV3YXkgYm91bmRhcnkgZm9yIENMSSB0ZXN0cy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTW9kZWxHYXRld2F5Q2xpRGVwZW5kZW5jaWVzIHtcbiAgc3RhcnQob3B0aW9uczogTW9kZWxHYXRld2F5T3B0aW9ucyk6IFByb21pc2U8dm9pZD47XG4gIC8qKiBPcHRpb25hbCBzZXJ2aWNlIENMSSBib3VuZGFyeSBmb3IgdGVzdHMgYW5kIGVtYmVkZGluZy4gKi9cbiAgcmVhZG9ubHkgc2VydmljZT86IENsaVNlcnZpY2VDbGlEZXBlbmRlbmNpZXM7XG59XG5cbmNvbnN0IERFRkFVTFRfREVQRU5ERU5DSUVTOiBNb2RlbEdhdGV3YXlDbGlEZXBlbmRlbmNpZXMgPSB7XG4gIHN0YXJ0OiBzdGFydE1vZGVsR2F0ZXdheSxcbn07XG5cbi8qKiBCdWlsZCB0aGUgdHJheS1vbmx5IG1vZGVsLWdhdGV3YXkgc2VydmljZSBkZWZpbml0aW9uLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIG1vZGVsR2F0ZXdheVNlcnZpY2VEZWZpbml0aW9uKFxuICBvcHRpb25zOiBNb2RlbEdhdGV3YXlPcHRpb25zID0ge30sXG4pOiBDbGlTZXJ2aWNlRGVmaW5pdGlvbiB7XG4gIGNvbnN0IHtcbiAgICBydW50aW1lSW5mbzogXyxcbiAgICBiZWFyZXJUb2tlbjogX2JlYXJlclRva2VuLFxuICAgIC4uLnJlc29sdmVkXG4gIH0gPSByZXNvbHZlTW9kZWxHYXRld2F5Q2xpT3B0aW9ucyhvcHRpb25zKTtcbiAgY29uc3QgaG9zdCA9IHVybEhvc3QocmVzb2x2ZWQubGlzdGVuLmhvc3QpO1xuICByZXR1cm4gZGVmaW5lU2VydmljZShpbXBvcnQubWV0YS51cmwsIHtcbiAgICBpZDogXCJkYngtdG9vbHMuY2xpLW1vZGVsLWdhdGV3YXlcIixcbiAgICBuYW1lOiBcImRieCBtb2RlbCBnYXRld2F5XCIsXG4gICAgY29tbWFuZDoge1xuICAgICAgYmluTmFtZTogXCJkYngtbW9kZWwtZ2F0ZXdheVwiLFxuICAgICAgYXJndW1lbnRzOiBzZXJpYWxpemVBcmdzKHJlc29sdmVkKSxcbiAgICB9LFxuICAgIG1lbnU6IFtcbiAgICAgIHtcbiAgICAgICAgdHlwZTogXCJ1cmxcIixcbiAgICAgICAgbGFiZWw6IFwiTW9kZWxzXCIsXG4gICAgICAgIHVybDogYGh0dHA6Ly8ke2hvc3R9OiR7cmVzb2x2ZWQubGlzdGVuLnBvcnR9L3YxL21vZGVsc2AsXG4gICAgICB9LFxuICAgIF0sXG4gIH0pO1xufVxuXG4vKiogQnVpbGQgZm9yZWdyb3VuZCBhbmQgc2VydmljZSBtb2RlbC1nYXRld2F5IGNvbW1hbmRzIHdpdGhvdXQgc3RhcnRpbmcgYSBzZXJ2ZXIuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRQcm9ncmFtKFxuICBuYW1lID0gXCJkYnggbW9kZWwtZ2F0ZXdheVwiLFxuICBkZXBlbmRlbmNpZXM6IE1vZGVsR2F0ZXdheUNsaURlcGVuZGVuY2llcyA9IERFRkFVTFRfREVQRU5ERU5DSUVTLFxuKTogQ29tbWFuZCB7XG4gIGNvbnN0IHZlcnNpb24gPSBQQUNLQUdFX1ZFUlNJT047XG4gIGNvbnN0IHByb2dyYW0gPSBhZGRBcmdzKFxuICAgIG5ldyBDb21tYW5kKClcbiAgICAgIC5uYW1lKG5hbWUpXG4gICAgICAuZGVzY3JpcHRpb24oXCJSdW4gb3IgbWFuYWdlIHRoZSBBcHBLaXQgRGF0YWJyaWNrcyBtb2RlbCBnYXRld2F5XCIpXG4gICAgICAudmVyc2lvbih2ZXJzaW9uLCBcIi12LCAtLXZlcnNpb25cIiksXG4gICAgTW9kZWxHYXRld2F5Q2xpT3B0aW9uc1NjaGVtYSxcbiAgKS5hY3Rpb24oYXN5bmMgKCkgPT4ge1xuICAgIGNvbnN0IG9wdGlvbnMgPSBtb2RlbEdhdGV3YXlPcHRpb25zKHByb2dyYW0pO1xuICAgIGlmIChvcHRpb25zLnJ1bnRpbWVJbmZvKSB7XG4gICAgICBwcm9jZXNzLnN0ZG91dC53cml0ZShgJHtKU09OLnN0cmluZ2lmeSh7IGltcGxlbWVudGF0aW9uOiBcInR5cGVzY3JpcHQtYXBwa2l0XCIsIHZlcnNpb24gfSl9XFxuYCk7XG4gICAgICByZXR1cm47XG4gICAgfVxuICAgIGNvbnN0IHsgcnVudGltZUluZm86IF8sIC4uLnNlcnZlck9wdGlvbnMgfSA9IG9wdGlvbnM7XG4gICAgYXdhaXQgZGVwZW5kZW5jaWVzLnN0YXJ0KHNlcnZlck9wdGlvbnMpO1xuICB9KTtcbiAgY29uc3Qgc2VydmljZUNvbW1hbmQgPSBidWlsZFNlcnZpY2VDb21tYW5kKCgpID0+IHtcbiAgICByZXR1cm4gbW9kZWxHYXRld2F5U2VydmljZURlZmluaXRpb24obW9kZWxHYXRld2F5T3B0aW9ucyhwcm9ncmFtKSk7XG4gIH0sIGRlcGVuZGVuY2llcy5zZXJ2aWNlKTtcbiAgcHJvZ3JhbS5hZGRDb21tYW5kKHNlcnZpY2VDb21tYW5kKTtcbiAgcmV0dXJuIHByb2dyYW07XG59XG5cbmZ1bmN0aW9uIG1vZGVsR2F0ZXdheU9wdGlvbnMoY29tbWFuZDogQ29tbWFuZCk6IE1vZGVsR2F0ZXdheUNsaU9wdGlvbnMge1xuICByZXR1cm4gcGFyc2VBcmdzKGNvbW1hbmQsIE1vZGVsR2F0ZXdheUNsaU9wdGlvbnNTY2hlbWEpO1xufVxuXG5mdW5jdGlvbiB1cmxIb3N0KGhvc3Q6IHN0cmluZyk6IHN0cmluZyB7XG4gIHJldHVybiBob3N0LmluY2x1ZGVzKFwiOlwiKSA/IGBbJHtob3N0fV1gIDogaG9zdDtcbn1cbiJdfQ==

package/lib/src/model-gateway/server.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Foreground model-gateway server owned by the CLI package.
+ *
+ * @module
+ */
+import { server } from "@databricks/appkit";
+import { type ModelGatewayOptions } from "@dbx-tools/shared-model-gateway/options";
+import type express from "express";
+type AppKitServerOptions = NonNullable<Parameters<typeof server>[0]>;
+/** Resolve AppKit server settings for the loopback model gateway. */
+export declare function modelGatewayServerOptions(options?: ModelGatewayOptions): AppKitServerOptions;
+/** Require one bearer token without retaining or logging request credentials. */
+export declare function gatewayBearerMiddleware(token: string): express.RequestHandler;
+/** Start the foreground model gateway and keep its AppKit server active. */
+export declare function startModelGateway(options?: ModelGatewayOptions): Promise<void>;
+export {};

package/lib/src/model-gateway/server.js

@@ -0,0 +1,83 @@
+/**
+ * Foreground model-gateway server owned by the CLI package.
+ *
+ * @module
+ */
+import { createHash, timingSafeEqual } from "node:crypto";
+import { createApp, server } from "@databricks/appkit";
+import { ModelGateway } from "@dbx-tools/appkit-model-gateway";
+import { sendHealth, sendInference, sendModels } from "@dbx-tools/appkit-model-gateway/routes";
+import { workspaceClient } from "@dbx-tools/databricks";
+import { resolveModelGatewayOptions, } from "@dbx-tools/shared-model-gateway/options";
+/** Resolve AppKit server settings for the loopback model gateway. */
+export function modelGatewayServerOptions(options = {}) {
+    return appKitServerOptions(resolveModelGatewayOptions(options));
+}
+function appKitServerOptions(options) {
+    return {
+        bodyLimit: options.bodyLimit,
+        host: options.listen.host,
+        port: options.listen.port,
+    };
+}
+/** Require one bearer token without retaining or logging request credentials. */
+export function gatewayBearerMiddleware(token) {
+    const expected = createHash("sha256").update(token).digest();
+    return (request, response, next) => {
+        const authorization = request.header("authorization");
+        const match = /^Bearer\s+(.+)$/i.exec(authorization ?? "");
+        const actual = createHash("sha256")
+            .update(match?.[1] ?? "")
+            .digest();
+        if (match && timingSafeEqual(actual, expected)) {
+            next();
+            return;
+        }
+        response
+            .status(401)
+            .setHeader("www-authenticate", "Bearer")
+            .json({
+            error: {
+                message: "Invalid or missing model-gateway bearer token.",
+                type: "authentication_error",
+                code: "invalid_bearer_token",
+            },
+        });
+    };
+}
+/** Start the foreground model gateway and keep its AppKit server active. */
+export async function startModelGateway(options = {}) {
+    const resolved = resolveModelGatewayOptions(options);
+    const gateway = new ModelGateway();
+    const client = await workspaceClient.createWorkspaceClient({
+        ...(resolved.profile ? { profile: resolved.profile } : {}),
+    });
+    await createApp({
+        client,
+        plugins: [server(appKitServerOptions(resolved))],
+        onPluginsReady(appkit) {
+            appkit.server.extend((application) => {
+                if (resolved.bearerToken) {
+                    application.use(gatewayBearerMiddleware(resolved.bearerToken));
+                }
+                application.get("/api/healthz", (_request, response) => {
+                    sendHealth(response);
+                });
+                application.get("/v1/models", (request, response) => {
+                    void sendModels(gateway, request, response);
+                });
+                for (const [path, protocol] of [
+                    ["/v1/chat/completions", "openai-chat"],
+                    ["/v1/responses", "openai-responses"],
+                    ["/v1/messages", "anthropic-messages"],
+                    ["/v1/embeddings", "openai-embeddings"],
+                ]) {
+                    application.post(path, (request, response) => {
+                        void sendInference(gateway, protocol, request, response);
+                    });
+                }
+            });
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server.js","sourceRoot":"","sources":["../../../src/model-gateway/server.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Foreground model-gateway server owned by the CLI package.\n *\n * @module\n */\n\nimport { createHash, timingSafeEqual } from \"node:crypto\";\nimport { createApp, server } from \"@databricks/appkit\";\nimport { ModelGateway } from \"@dbx-tools/appkit-model-gateway\";\nimport { sendHealth, sendInference, sendModels } from \"@dbx-tools/appkit-model-gateway/routes\";\nimport { workspaceClient } from \"@dbx-tools/databricks\";\nimport {\n  resolveModelGatewayOptions,\n  type ModelGatewayOptions,\n  type ResolvedModelGatewayOptions,\n} from \"@dbx-tools/shared-model-gateway/options\";\nimport type express from \"express\";\n\ntype AppKitServerOptions = NonNullable<Parameters<typeof server>[0]>;\n\n/** Resolve AppKit server settings for the loopback model gateway. */\nexport function modelGatewayServerOptions(options: ModelGatewayOptions = {}): AppKitServerOptions {\n  return appKitServerOptions(resolveModelGatewayOptions(options));\n}\n\nfunction appKitServerOptions(options: ResolvedModelGatewayOptions): AppKitServerOptions {\n  return {\n    bodyLimit: options.bodyLimit,\n    host: options.listen.host,\n    port: options.listen.port,\n  };\n}\n\n/** Require one bearer token without retaining or logging request credentials. */\nexport function gatewayBearerMiddleware(token: string): express.RequestHandler {\n  const expected = createHash(\"sha256\").update(token).digest();\n  return (request, response, next) => {\n    const authorization = request.header(\"authorization\");\n    const match = /^Bearer\\s+(.+)$/i.exec(authorization ?? \"\");\n    const actual = createHash(\"sha256\")\n      .update(match?.[1] ?? \"\")\n      .digest();\n    if (match && timingSafeEqual(actual, expected)) {\n      next();\n      return;\n    }\n    response\n      .status(401)\n      .setHeader(\"www-authenticate\", \"Bearer\")\n      .json({\n        error: {\n          message: \"Invalid or missing model-gateway bearer token.\",\n          type: \"authentication_error\",\n          code: \"invalid_bearer_token\",\n        },\n      });\n  };\n}\n\n/** Start the foreground model gateway and keep its AppKit server active. */\nexport async function startModelGateway(options: ModelGatewayOptions = {}): Promise<void> {\n  const resolved = resolveModelGatewayOptions(options);\n  const gateway = new ModelGateway();\n  const client = await workspaceClient.createWorkspaceClient({\n    ...(resolved.profile ? { profile: resolved.profile } : {}),\n  });\n  await createApp({\n    client,\n    plugins: [server(appKitServerOptions(resolved))],\n    onPluginsReady(appkit) {\n      appkit.server.extend((application) => {\n        if (resolved.bearerToken) {\n          application.use(gatewayBearerMiddleware(resolved.bearerToken));\n        }\n        application.get(\"/api/healthz\", (_request, response) => {\n          sendHealth(response);\n        });\n        application.get(\"/v1/models\", (request, response) => {\n          void sendModels(gateway, request, response);\n        });\n        for (const [path, protocol] of [\n          [\"/v1/chat/completions\", \"openai-chat\"],\n          [\"/v1/responses\", \"openai-responses\"],\n          [\"/v1/messages\", \"anthropic-messages\"],\n          [\"/v1/embeddings\", \"openai-embeddings\"],\n        ] as const) {\n          application.post(path, (request, response) => {\n            void sendInference(gateway, protocol, request, response);\n          });\n        }\n      });\n    },\n  });\n}\n"]}

package/lib/src/tunnel/app.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The GATE half of the wrapper: a server-less AppKit app whose only job is to
+ * expose the `authGate` handlers the proxy calls.
+ *
+ * The in-process plugin path (`authGate` in the app's own `plugins`) has a real
+ * HTTP server to mount routes on. A wrapper does not - the app it fronts is a
+ * separate process it must not reach into - so the gate's login routes live on
+ * the proxy instead, and this app exists purely to give the plugin the runtime it
+ * needs: a `CacheManager` for the one-time-code store and signing key, and the
+ * sibling `email` plugin's transport for delivering a code.
+ *
+ * Lazily imported by `cli.ts`, so `dbx tunnel --insecure` (and `install` /
+ * `status`) never load AppKit, the Databricks SDK, or the SMTP stack.
+ *
+ * @module
+ */
+import { type WorkspaceClient } from "@databricks/appkit";
+import { type AuthGateApi, type AuthGateConfig } from "@dbx-tools/tunnel";
+/** Boot the gate app and return the handlers the proxy authenticates against. */
+export declare function startGateApp(config: AuthGateConfig, client?: WorkspaceClient): Promise<AuthGateApi>;

package/lib/src/tunnel/app.js

@@ -0,0 +1,52 @@
+/**
+ * The GATE half of the wrapper: a server-less AppKit app whose only job is to
+ * expose the `authGate` handlers the proxy calls.
+ *
+ * The in-process plugin path (`authGate` in the app's own `plugins`) has a real
+ * HTTP server to mount routes on. A wrapper does not - the app it fronts is a
+ * separate process it must not reach into - so the gate's login routes live on
+ * the proxy instead, and this app exists purely to give the plugin the runtime it
+ * needs: a `CacheManager` for the one-time-code store and signing key, and the
+ * sibling `email` plugin's transport for delivering a code.
+ *
+ * Lazily imported by `cli.ts`, so `dbx tunnel --insecure` (and `install` /
+ * `status`) never load AppKit, the Databricks SDK, or the SMTP stack.
+ *
+ * @module
+ */
+import { lakebase } from "@databricks/appkit";
+import { appkit } from "@dbx-tools/appkit";
+import { authStorage } from "@dbx-tools/auth-gate";
+import { email } from "@dbx-tools/email";
+import { postgresConnectionOptions } from "@dbx-tools/postgres";
+import { object } from "@dbx-tools/shared-core";
+import { authGate } from "@dbx-tools/tunnel";
+/** Boot the gate app and return the handlers the proxy authenticates against. */
+export async function startGateApp(config, client) {
+    // No `server()` plugin: nothing here listens. `plugins` order matters - `email`
+    // registers its transport before `authGate` looks for a sibling to send with.
+    const plugins = await appkit.createApp({
+        client,
+        plugins: [
+            ...(authStorage.shouldUseLakebase(config)
+                ? [lakebase({ pool: postgresConnectionOptions({}) })]
+                : []),
+            ...(config.sendCode ? [] : [email()]),
+            authGate(config),
+        ],
+    });
+    const api = Reflect.get(plugins, "authGate");
+    if (!isAuthGateApi(api))
+        throw new Error("the authGate plugin exposed no api");
+    return api;
+}
+function isAuthGateApi(value) {
+    return (object.isRecord(value) &&
+        typeof value.basePath === "string" &&
+        typeof value.passkeysEnabled === "boolean" &&
+        typeof value.handler === "function" &&
+        typeof value.session === "function" &&
+        typeof value.status === "function" &&
+        typeof value.close === "function");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/tunnel/cli.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `dbx tunnel` - front a command with a public portr tunnel and passwordless gate.
+ *
+ * This is the WRAPPER path, and it exists for one case: a project that does not
+ * use `@dbx-tools/appkit`'s `createApp`, and therefore cannot register
+ * `tunnelInterceptor()` + the `authGate` plugin in-process. An AppKit app should
+ * still take the plugin path - one process, no proxy hop, no duplicated header
+ * handling.
+ *
+ * The wrapper claims the PUBLIC port (`DATABRICKS_APP_PORT`, the port the
+ * platform and portr route to), moves the wrapped app to a private one, and
+ * reverse-proxies between them so the gate sits in front of traffic it would
+ * otherwise have no way to intercept. Everything else is delegated: the gate
+ * config comes from `plugin.resolveAuthGateConfig`, the portr lifecycle from
+ * `portr.*` - both the same functions the in-process path uses.
+ *
+ * Ships no bin. `@dbx-tools/cli` mounts `buildProgram()` as `dbx tunnel` lazily,
+ * so `dbx dev` pays for none of this, and `--insecure` / `status` / `install`
+ * never load AppKit or the SMTP stack either (the gate app is behind a dynamic
+ * import).
+ *
+ * @module
+ */
+import { Command, CommanderError } from "commander";
+export { CommanderError };
+/** The `dbx tunnel` program. No side effects until parsed. */
+export declare function buildProgram(name?: string): Command;