@dbx-tools/cli 0.9.58 → 0.9.61

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

@@ -0,0 +1,18 @@
+import { type CliServiceCliDependencies } from "@dbx-tools/cli-service/cli";
+import { type CliServiceDefinition } from "@dbx-tools/cli-service/definition";
+import { type GraphitiRuntimeOptions } from "@dbx-tools/graphiti/runtime";
+import { Command } from "commander";
+import { type GraphitiOptions } from "./options.ts";
+/** Injectable runtime and service lifecycle boundaries for CLI callers. */
+export interface GraphitiCliDependencies {
+    /** Run the Graphiti stack through the Node runtime owner. */
+    run(options: GraphitiRuntimeOptions): Promise<void>;
+    /** Shared service command dependencies for tests and embedding. */
+    readonly service?: CliServiceCliDependencies;
+}
+/** Runtime options persisted when installing the Graphiti desktop service. */
+export type GraphitiServiceOptions = GraphitiOptions;
+/** Define a Graphiti service without duplicating installation or lifecycle policy. */
+export declare function graphitiServiceDefinition(options?: GraphitiServiceOptions): CliServiceDefinition;
+/** Build foreground execution and shared desktop-service commands. */
+export declare function buildProgram(name?: string, dependencies?: GraphitiCliDependencies): Command;

package/lib/src/graphiti/cli.js

@@ -0,0 +1,43 @@
+/**
+ * Commander-owned Graphiti CLI and shared current-user service definition.
+ *
+ * This module owns every user-facing Graphiti command. The shared Graphiti Zod
+ * schema owns its options, environment names, defaults, and validation. The
+ * Node Graphiti package owns runtime and Python interaction.
+ *
+ * @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 { runGraphiti } from "@dbx-tools/graphiti/runtime";
+import { Command } from "commander";
+import { PACKAGE_VERSION } from "../../index.js";
+import { GraphitiCliOptionsSchema, GraphitiOptionsSchema, } from "./options.js";
+/** Define a Graphiti service without duplicating installation or lifecycle policy. */
+export function graphitiServiceDefinition(options = {}) {
+    return defineService(import.meta.url, {
+        id: "dbx-tools.cli-graphiti",
+        name: "dbx graphiti",
+        pythonPackage: { name: "dbx-tools-graphiti" },
+        command: {
+            binName: "dbx-graphiti",
+            arguments: serializeArgs(GraphitiOptionsSchema.parse(options)),
+        },
+    });
+}
+/** Build foreground execution and shared desktop-service commands. */
+export function buildProgram(name = "dbx graphiti", dependencies = { run: runGraphiti }) {
+    const program = addArgs(new Command()
+        .name(name)
+        .description("Run Graphiti or manage its current-user desktop service")
+        .version(PACKAGE_VERSION, "-v, --version"), GraphitiCliOptionsSchema).action(async () => {
+        await dependencies.run(graphitiOptions(program));
+    });
+    program.addCommand(buildServiceCommand(() => graphitiServiceDefinition(graphitiOptions(program)), dependencies.service));
+    return program;
+}
+function graphitiOptions(command) {
+    return GraphitiOptionsSchema.parse(parseArgs(command, GraphitiCliOptionsSchema));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/graphiti/options.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Graphiti CLI option surface.
+ *
+ * The Node Graphiti runtime owns the complete shared option contract. This
+ * module re-exports that surface without creating parallel CLI policy.
+ *
+ * @module
+ */
+export { GRAPHITI_DEFAULTS, GraphitiCliOptionsSchema, GraphitiOptionsSchema, ResolvedGraphitiOptionsSchema, graphitiOptionOverrides, graphitiOptionsEnvironment, graphitiOptionsFromEnvironment, resolveGraphitiOptions, } from "@dbx-tools/graphiti/options";
+export type { GraphitiOptions, ResolvedGraphitiOptions } from "@dbx-tools/graphiti/options";

package/lib/src/graphiti/options.js

@@ -0,0 +1,10 @@
+/**
+ * Graphiti CLI option surface.
+ *
+ * The Node Graphiti runtime owns the complete shared option contract. This
+ * module re-exports that surface without creating parallel CLI policy.
+ *
+ * @module
+ */
+export { GRAPHITI_DEFAULTS, GraphitiCliOptionsSchema, GraphitiOptionsSchema, ResolvedGraphitiOptionsSchema, graphitiOptionOverrides, graphitiOptionsEnvironment, graphitiOptionsFromEnvironment, resolveGraphitiOptions, } from "@dbx-tools/graphiti/options";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ncmFwaGl0aS9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7O0dBT0c7QUFFSCxPQUFPLEVBQ0wsaUJBQWlCLEVBQ2pCLHdCQUF3QixFQUN4QixxQkFBcUIsRUFDckIsNkJBQTZCLEVBQzdCLHVCQUF1QixFQUN2QiwwQkFBMEIsRUFDMUIsOEJBQThCLEVBQzlCLHNCQUFzQixHQUN2QixNQUFNLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHcmFwaGl0aSBDTEkgb3B0aW9uIHN1cmZhY2UuXG4gKlxuICogVGhlIE5vZGUgR3JhcGhpdGkgcnVudGltZSBvd25zIHRoZSBjb21wbGV0ZSBzaGFyZWQgb3B0aW9uIGNvbnRyYWN0LiBUaGlzXG4gKiBtb2R1bGUgcmUtZXhwb3J0cyB0aGF0IHN1cmZhY2Ugd2l0aG91dCBjcmVhdGluZyBwYXJhbGxlbCBDTEkgcG9saWN5LlxuICpcbiAqIEBtb2R1bGVcbiAqL1xuXG5leHBvcnQge1xuICBHUkFQSElUSV9ERUZBVUxUUyxcbiAgR3JhcGhpdGlDbGlPcHRpb25zU2NoZW1hLFxuICBHcmFwaGl0aU9wdGlvbnNTY2hlbWEsXG4gIFJlc29sdmVkR3JhcGhpdGlPcHRpb25zU2NoZW1hLFxuICBncmFwaGl0aU9wdGlvbk92ZXJyaWRlcyxcbiAgZ3JhcGhpdGlPcHRpb25zRW52aXJvbm1lbnQsXG4gIGdyYXBoaXRpT3B0aW9uc0Zyb21FbnZpcm9ubWVudCxcbiAgcmVzb2x2ZUdyYXBoaXRpT3B0aW9ucyxcbn0gZnJvbSBcIkBkYngtdG9vbHMvZ3JhcGhpdGkvb3B0aW9uc1wiO1xuZXhwb3J0IHR5cGUgeyBHcmFwaGl0aU9wdGlvbnMsIFJlc29sdmVkR3JhcGhpdGlPcHRpb25zIH0gZnJvbSBcIkBkYngtdG9vbHMvZ3JhcGhpdGkvb3B0aW9uc1wiO1xuIl19

package/lib/src/lakebase-proxy/cancellation.d.ts

@@ -0,0 +1,22 @@
+/** PostgreSQL cancellation key translation and TLS forwarding. */
+import { type CancelMessage } from "./protocol.ts";
+/** Upstream PostgreSQL backend key used to forward a cancellation request. */
+export interface CancellationTarget {
+    host: string;
+    port: number;
+    processId: number;
+    secretKey: number;
+}
+/** Sends one PostgreSQL cancellation request to its upstream backend. */
+export type CancellationForwarder = (target: CancellationTarget) => Promise<void>;
+/** Maps synthetic local backend keys onto real upstream cancellation targets. */
+export declare class CancellationRegistry {
+    private readonly forwarder;
+    private readonly targets;
+    constructor(forwarder?: CancellationForwarder);
+    register(target: CancellationTarget): CancelMessage;
+    remove(message: CancelMessage): void;
+    forward(message: CancelMessage): Promise<boolean>;
+}
+/** Forward a PostgreSQL cancellation request over a verified TLS connection. */
+export declare function forwardCancellation(target: CancellationTarget): Promise<void>;

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

@@ -0,0 +1,100 @@
+/** PostgreSQL cancellation key translation and TLS forwarding. */
+import { randomBytes } from "node:crypto";
+import { createConnection, isIP } from "node:net";
+import { connect as connectTls } from "node:tls";
+import { cancelRequest, sslRequest } from "./protocol.js";
+let nextProcessId = 10_000;
+/** Maps synthetic local backend keys onto real upstream cancellation targets. */
+export class CancellationRegistry {
+    forwarder;
+    targets = new Map();
+    constructor(forwarder = forwardCancellation) {
+        this.forwarder = forwarder;
+    }
+    register(target) {
+        const processId = nextProcessId++;
+        const secretKey = randomBytes(4).readInt32BE(0);
+        this.targets.set(key(processId, secretKey), target);
+        return { kind: "cancel", processId, secretKey };
+    }
+    remove(message) {
+        this.targets.delete(key(message.processId, message.secretKey));
+    }
+    async forward(message) {
+        const target = this.targets.get(key(message.processId, message.secretKey));
+        if (!target)
+            return false;
+        await this.forwarder(target);
+        return true;
+    }
+}
+/** Forward a PostgreSQL cancellation request over a verified TLS connection. */
+export async function forwardCancellation(target) {
+    const socket = createConnection({ host: target.host, port: target.port });
+    await event(socket, "connect");
+    socket.write(sslRequest());
+    const response = await readByte(socket);
+    if (response !== "S".charCodeAt(0)) {
+        socket.destroy();
+        throw new Error("Lakebase upstream refused TLS for cancellation");
+    }
+    const tls = connectTls({
+        socket,
+        rejectUnauthorized: true,
+        ...(isIP(target.host) === 0 ? { servername: target.host } : {}),
+    });
+    await event(tls, "secureConnect");
+    await writeAndClose(tls, cancelRequest(target.processId, target.secretKey));
+}
+function key(processId, secretKey) {
+    return `${processId}:${secretKey}`;
+}
+function event(socket, name) {
+    return new Promise((resolve, reject) => {
+        const onEvent = () => finish();
+        const onError = (error) => finish(error);
+        const finish = (error) => {
+            socket.off(name, onEvent);
+            socket.off("error", onError);
+            if (error)
+                reject(error);
+            else
+                resolve();
+        };
+        socket.once(name, onEvent);
+        socket.once("error", onError);
+    });
+}
+function readByte(socket) {
+    return new Promise((resolve, reject) => {
+        const onData = (chunk) => {
+            finish();
+            if (chunk.length > 1)
+                socket.unshift(chunk.subarray(1));
+            resolve(chunk[0]);
+        };
+        const onError = (error) => {
+            finish();
+            reject(error);
+        };
+        const onEnd = () => {
+            finish();
+            reject(new Error("Lakebase upstream closed during TLS negotiation"));
+        };
+        const finish = () => {
+            socket.off("data", onData);
+            socket.off("error", onError);
+            socket.off("end", onEnd);
+        };
+        socket.once("data", onData);
+        socket.once("error", onError);
+        socket.once("end", onEnd);
+    });
+}
+function writeAndClose(socket, packet) {
+    return new Promise((resolve, reject) => {
+        socket.end(packet, () => resolve());
+        socket.once("error", reject);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancellation.js","sourceRoot":"","sources":["../../../src/lakebase-proxy/cancellation.ts"],"names":[],"mappings":"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","sourcesContent":["/** PostgreSQL cancellation key translation and TLS forwarding. */\n\nimport { randomBytes } from \"node:crypto\";\nimport { createConnection, isIP, type Socket } from \"node:net\";\nimport { connect as connectTls, type TLSSocket } from \"node:tls\";\n\nimport { cancelRequest, sslRequest, type CancelMessage } from \"./protocol.ts\";\n\n/** Upstream PostgreSQL backend key used to forward a cancellation request. */\nexport interface CancellationTarget {\n  host: string;\n  port: number;\n  processId: number;\n  secretKey: number;\n}\n\n/** Sends one PostgreSQL cancellation request to its upstream backend. */\nexport type CancellationForwarder = (target: CancellationTarget) => Promise<void>;\n\nlet nextProcessId = 10_000;\n\n/** Maps synthetic local backend keys onto real upstream cancellation targets. */\nexport class CancellationRegistry {\n  private readonly targets = new Map<string, CancellationTarget>();\n\n  constructor(private readonly forwarder: CancellationForwarder = forwardCancellation) {}\n\n  register(target: CancellationTarget): CancelMessage {\n    const processId = nextProcessId++;\n    const secretKey = randomBytes(4).readInt32BE(0);\n    this.targets.set(key(processId, secretKey), target);\n    return { kind: \"cancel\", processId, secretKey };\n  }\n\n  remove(message: CancelMessage): void {\n    this.targets.delete(key(message.processId, message.secretKey));\n  }\n\n  async forward(message: CancelMessage): Promise<boolean> {\n    const target = this.targets.get(key(message.processId, message.secretKey));\n    if (!target) return false;\n    await this.forwarder(target);\n    return true;\n  }\n}\n\n/** Forward a PostgreSQL cancellation request over a verified TLS connection. */\nexport async function forwardCancellation(target: CancellationTarget): Promise<void> {\n  const socket = createConnection({ host: target.host, port: target.port });\n  await event(socket, \"connect\");\n  socket.write(sslRequest());\n  const response = await readByte(socket);\n  if (response !== \"S\".charCodeAt(0)) {\n    socket.destroy();\n    throw new Error(\"Lakebase upstream refused TLS for cancellation\");\n  }\n  const tls = connectTls({\n    socket,\n    rejectUnauthorized: true,\n    ...(isIP(target.host) === 0 ? { servername: target.host } : {}),\n  });\n  await event(tls, \"secureConnect\");\n  await writeAndClose(tls, cancelRequest(target.processId, target.secretKey));\n}\n\nfunction key(processId: number, secretKey: number): string {\n  return `${processId}:${secretKey}`;\n}\n\nfunction event(socket: Socket | TLSSocket, name: \"connect\" | \"secureConnect\"): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const onEvent = () => finish();\n    const onError = (error: Error) => finish(error);\n    const finish = (error?: Error) => {\n      socket.off(name, onEvent);\n      socket.off(\"error\", onError);\n      if (error) reject(error);\n      else resolve();\n    };\n    socket.once(name, onEvent);\n    socket.once(\"error\", onError);\n  });\n}\n\nfunction readByte(socket: Socket): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const onData = (chunk: Buffer) => {\n      finish();\n      if (chunk.length > 1) socket.unshift(chunk.subarray(1));\n      resolve(chunk[0]!);\n    };\n    const onError = (error: Error) => {\n      finish();\n      reject(error);\n    };\n    const onEnd = () => {\n      finish();\n      reject(new Error(\"Lakebase upstream closed during TLS negotiation\"));\n    };\n    const finish = () => {\n      socket.off(\"data\", onData);\n      socket.off(\"error\", onError);\n      socket.off(\"end\", onEnd);\n    };\n    socket.once(\"data\", onData);\n    socket.once(\"error\", onError);\n    socket.once(\"end\", onEnd);\n  });\n}\n\nfunction writeAndClose(socket: TLSSocket, packet: Buffer): Promise<void> {\n  return new Promise((resolve, reject) => {\n    socket.end(packet, () => resolve());\n    socket.once(\"error\", reject);\n  });\n}\n"]}

package/lib/src/lakebase-proxy/cli.d.ts

@@ -0,0 +1,13 @@
+/** Commander entry point for the pure Node Lakebase proxy. */
+import { type CliServiceCliDependencies } from "@dbx-tools/cli-service/cli";
+import { type CliServiceDefinition } from "@dbx-tools/cli-service/definition";
+import { Command } from "commander";
+import { type LakebaseProxyOptions } from "./options.ts";
+/** Injectable service boundary for Lakebase proxy CLI composition and tests. */
+export interface LakebaseProxyCliDependencies {
+    readonly service?: CliServiceCliDependencies;
+}
+/** Build the tray-only Lakebase proxy service definition. */
+export declare function lakebaseProxyServiceDefinition(options?: LakebaseProxyOptions): CliServiceDefinition;
+/** Build the Lakebase proxy command-line program. */
+export declare function buildProgram(name?: string, dependencies?: LakebaseProxyCliDependencies): Command;

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

@@ -0,0 +1,54 @@
+/** Commander entry point for the pure Node Lakebase proxy. */
+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 { connectionUrl } from "@dbx-tools/lakebase";
+import { Command } from "commander";
+import { PACKAGE_VERSION } from "../../index.js";
+import { LakebaseProxyOptionsSchema, LakebaseProxyUrlOptionsSchema, resolveLakebaseProxyOptions, } from "./options.js";
+import { LakebaseProxy } from "./proxy.js";
+/** Build the tray-only Lakebase proxy service definition. */
+export function lakebaseProxyServiceDefinition(options = {}) {
+    const resolved = resolveLakebaseProxyOptions(options);
+    return defineService(import.meta.url, {
+        id: "dbx-tools.cli-lakebase-proxy",
+        name: "dbx lakebase proxy",
+        command: {
+            binName: "dbx-lakebase-proxy",
+            arguments: serializeArgs(resolved),
+        },
+    });
+}
+/** Build the Lakebase proxy command-line program. */
+export function buildProgram(name = "dbx lakebase-proxy", dependencies = {}) {
+    const program = addArgs(new Command(name)
+        .description("Run a loopback PostgreSQL proxy for Databricks Lakebase")
+        .version(PACKAGE_VERSION)
+        .enablePositionalOptions(), LakebaseProxyOptionsSchema).action(async () => {
+        const proxy = new LakebaseProxy(parseArgs(program, LakebaseProxyOptionsSchema));
+        await proxy.listen();
+        await waitForShutdown();
+        await proxy.close();
+    });
+    const urlCommand = addArgs(program.command("url").description("Format a local PostgreSQL URL for a Lakebase target"), LakebaseProxyUrlOptionsSchema).action(() => {
+        const options = parseArgs(urlCommand, LakebaseProxyUrlOptionsSchema);
+        const target = options.target ?? options.lakebaseEndpoint;
+        process.stdout.write(`${connectionUrl(target, options.listen.host, options.listen.port)}\n`);
+    });
+    let installCommand;
+    const serviceCommand = buildServiceCommand(() => {
+        return lakebaseProxyServiceDefinition(parseArgs(installCommand, LakebaseProxyOptionsSchema));
+    }, dependencies.service);
+    installCommand = serviceCommand.commands.find((command) => command.name() === "install");
+    addArgs(installCommand, LakebaseProxyOptionsSchema);
+    program.addCommand(serviceCommand);
+    return program;
+}
+function waitForShutdown() {
+    return new Promise((resolve) => {
+        const shutdown = () => resolve();
+        process.once("SIGINT", shutdown);
+        process.once("SIGTERM", shutdown);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/lakebase-proxy/options.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lakebase proxy listener, service, and URL command options.
+ *
+ * @module
+ */
+import { options } from "@dbx-tools/shared-core";
+import { z } from "zod";
+export declare const LakebaseProxyOptionsSchema: z.ZodObject<{
+    listen: z.ZodDefault<z.ZodType<options.TcpListenAddress, unknown, z.core.$ZodTypeInternals<options.TcpListenAddress, unknown>>>;
+    startupTimeoutSeconds: z.ZodDefault<z.ZodCoercedNumber<number>>;
+    profile: z.ZodOptional<z.ZodString>;
+    postgresRole: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const LakebaseProxyUrlOptionsSchema: z.ZodObject<{
+    target: z.ZodOptional<z.ZodString>;
+    lakebaseEndpoint: z.ZodOptional<z.ZodString>;
+    listen: z.ZodDefault<z.ZodType<options.TcpListenAddress, unknown, z.core.$ZodTypeInternals<options.TcpListenAddress, unknown>>>;
+}, z.core.$strict>;
+export type LakebaseProxyOptions = z.input<typeof LakebaseProxyOptionsSchema>;
+export type ResolvedLakebaseProxyOptions = z.output<typeof LakebaseProxyOptionsSchema>;
+export type LakebaseProxyUrlOptions = z.output<typeof LakebaseProxyUrlOptionsSchema>;
+/** Validate and default Lakebase proxy listener options. */
+export declare function resolveLakebaseProxyOptions(options?: LakebaseProxyOptions): ResolvedLakebaseProxyOptions;

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

@@ -0,0 +1,41 @@
+/**
+ * Lakebase proxy listener, service, and URL command options.
+ *
+ * @module
+ */
+import { options } from "@dbx-tools/shared-core";
+import { z } from "zod";
+const text = (description) => z.string().trim().min(1).optional().describe(description);
+export const LakebaseProxyOptionsSchema = z
+    .object({
+    ...options.PostgresOptionsSchema.shape,
+    listen: options
+        .listenAddressSchema({ port: 5432, loopback: true })
+        .describe("Loopback listener address."),
+    startupTimeoutSeconds: z.coerce
+        .number()
+        .int()
+        .nonnegative()
+        .default(30)
+        .describe("Startup timeout in seconds."),
+    profile: options.DatabricksOptionsSchema.shape.profile.describe("Exact Databricks profile."),
+})
+    .strict()
+    .describe("Lakebase proxy listener and service options.");
+export const LakebaseProxyUrlOptionsSchema = z
+    .object({
+    target: text("Lakebase project, resource path, host, or URL."),
+    lakebaseEndpoint: options.LakebaseOptionsSchema.shape.lakebaseEndpoint,
+    listen: options.listenAddressSchema({ port: 5432 }).describe("Local proxy address."),
+})
+    .strict()
+    .refine((configured) => configured.target !== undefined || configured.lakebaseEndpoint !== undefined, {
+    message: "URL requires target or endpoint.",
+    path: ["target"],
+})
+    .describe("Options for formatting a local Lakebase PostgreSQL URL.");
+/** Validate and default Lakebase proxy listener options. */
+export function resolveLakebaseProxyOptions(options = {}) {
+    return LakebaseProxyOptionsSchema.parse(options);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/lakebase-proxy/protocol.d.ts

@@ -0,0 +1,37 @@
+/** Minimal PostgreSQL startup protocol helpers for the loopback proxy. */
+import type { Socket } from "node:net";
+/** PostgreSQL SSLRequest protocol code. */
+export declare const SSL_REQUEST = 80877103;
+/** PostgreSQL CancelRequest protocol code. */
+export declare const CANCEL_REQUEST = 80877102;
+/** PostgreSQL protocol version 3 code. */
+export declare const PROTOCOL_3 = 196608;
+/** Parsed PostgreSQL startup packet. */
+export interface StartupMessage {
+    kind: "startup";
+    protocol: number;
+    parameters: Record<string, string>;
+}
+/** Parsed PostgreSQL cancellation packet. */
+export interface CancelMessage {
+    kind: "cancel";
+    processId: number;
+    secretKey: number;
+}
+/** First supported packet received from a PostgreSQL client. */
+export type InitialMessage = StartupMessage | CancelMessage;
+/** Error caused by an invalid or unsupported PostgreSQL startup packet. */
+export declare class PostgresProtocolError extends Error {
+}
+/** Read and classify the first PostgreSQL frontend message from a socket. */
+export declare function readInitialMessage(socket: Socket, timeoutMs: number): Promise<InitialMessage>;
+/** Build a PostgreSQL SSL negotiation request packet. */
+export declare function sslRequest(): Buffer;
+/** Build a PostgreSQL cancellation request packet. */
+export declare function cancelRequest(processId: number, secretKey: number): Buffer;
+/** Build the backend messages that complete PostgreSQL startup. */
+export declare function startupComplete(parameters: ReadonlyMap<string, string>, processId: number, secretKey: number, transactionStatus?: string): Buffer;
+/** Replace client startup identity with the resolved upstream identity. */
+export declare function upstreamStartupParameters(parameters: Record<string, string>, user: string, database: string): Record<string, string>;
+/** Build a fatal PostgreSQL error response. */
+export declare function fatalError(message: string, sqlstate?: string): Buffer;

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

@@ -0,0 +1,124 @@
+/** Minimal PostgreSQL startup protocol helpers for the loopback proxy. */
+/** PostgreSQL SSLRequest protocol code. */
+export const SSL_REQUEST = 80_877_103;
+/** PostgreSQL CancelRequest protocol code. */
+export const CANCEL_REQUEST = 80_877_102;
+/** PostgreSQL protocol version 3 code. */
+export const PROTOCOL_3 = 196_608;
+/** Error caused by an invalid or unsupported PostgreSQL startup packet. */
+export class PostgresProtocolError extends Error {
+}
+/** Read and classify the first PostgreSQL frontend message from a socket. */
+export async function readInitialMessage(socket, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const packet = await readPacket(socket, deadline);
+        const code = packet.readInt32BE(4);
+        if (code === SSL_REQUEST) {
+            socket.write("N");
+            continue;
+        }
+        if (code === CANCEL_REQUEST) {
+            if (packet.length !== 16)
+                throw new PostgresProtocolError("Invalid CancelRequest packet");
+            return {
+                kind: "cancel",
+                processId: packet.readInt32BE(8),
+                secretKey: packet.readInt32BE(12),
+            };
+        }
+        if (code !== PROTOCOL_3) {
+            throw new PostgresProtocolError(`Unsupported PostgreSQL protocol version ${code}`);
+        }
+        return { kind: "startup", protocol: code, parameters: parseParameters(packet.subarray(8)) };
+    }
+}
+/** Build a PostgreSQL SSL negotiation request packet. */
+export function sslRequest() {
+    return requestPacket(SSL_REQUEST);
+}
+/** Build a PostgreSQL cancellation request packet. */
+export function cancelRequest(processId, secretKey) {
+    return requestPacket(CANCEL_REQUEST, processId, secretKey);
+}
+/** Build the backend messages that complete PostgreSQL startup. */
+export function startupComplete(parameters, processId, secretKey, transactionStatus = "I") {
+    return Buffer.concat([
+        backendMessage("R", int32(0)),
+        ...[...parameters].map(([name, value]) => backendMessage("S", Buffer.from(`${name}\0${value}\0`))),
+        backendMessage("K", Buffer.concat([int32(processId), int32(secretKey)])),
+        backendMessage("Z", Buffer.from(transactionStatus.slice(0, 1) || "I")),
+    ]);
+}
+/** Replace client startup identity with the resolved upstream identity. */
+export function upstreamStartupParameters(parameters, user, database) {
+    return { ...parameters, user, database };
+}
+/** Build a fatal PostgreSQL error response. */
+export function fatalError(message, sqlstate = "08001") {
+    return backendMessage("E", Buffer.concat([Buffer.from(`SFATAL\0C${sqlstate}\0M${message}\0`), Buffer.from([0])]));
+}
+function requestPacket(code, processId, secretKey) {
+    const values = [code];
+    if (processId !== undefined && secretKey !== undefined)
+        values.push(processId, secretKey);
+    return Buffer.concat([int32(4 + values.length * 4), ...values.map(int32)]);
+}
+function backendMessage(code, body) {
+    return Buffer.concat([Buffer.from(code), int32(body.length + 4), body]);
+}
+function int32(value) {
+    const buffer = Buffer.allocUnsafe(4);
+    buffer.writeInt32BE(value);
+    return buffer;
+}
+async function readPacket(socket, deadline) {
+    let buffer = Buffer.alloc(0);
+    while (buffer.length < 4)
+        buffer = Buffer.concat([buffer, await readChunk(socket, deadline)]);
+    const length = buffer.readInt32BE(0);
+    if (length < 8 || length > 1024 * 1024) {
+        throw new PostgresProtocolError("Invalid PostgreSQL startup packet");
+    }
+    while (buffer.length < length) {
+        buffer = Buffer.concat([buffer, await readChunk(socket, deadline)]);
+    }
+    const remainder = buffer.subarray(length);
+    if (remainder.length)
+        socket.unshift(remainder);
+    return buffer.subarray(0, length);
+}
+function readChunk(socket, deadline) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+        return Promise.reject(new PostgresProtocolError("PostgreSQL startup timed out"));
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => finish(new PostgresProtocolError("PostgreSQL startup timed out")), remaining);
+        const onData = (chunk) => finish(undefined, chunk);
+        const onError = (error) => finish(error);
+        const onEnd = () => finish(new PostgresProtocolError("PostgreSQL client closed during startup"));
+        const finish = (error, chunk) => {
+            clearTimeout(timer);
+            socket.off("data", onData);
+            socket.off("error", onError);
+            socket.off("end", onEnd);
+            if (error)
+                reject(error);
+            else
+                resolve(chunk);
+        };
+        socket.once("data", onData);
+        socket.once("error", onError);
+        socket.once("end", onEnd);
+    });
+}
+function parseParameters(body) {
+    const values = body.toString("utf8").split("\0");
+    const parameters = {};
+    for (let index = 0; index + 1 < values.length && values[index]; index += 2) {
+        parameters[values[index]] = values[index + 1] ?? "";
+    }
+    return parameters;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/lakebase-proxy/protocol.ts"],"names":[],"mappings":"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","sourcesContent":["/** Minimal PostgreSQL startup protocol helpers for the loopback proxy. */\n\nimport type { Socket } from \"node:net\";\n\n/** PostgreSQL SSLRequest protocol code. */\nexport const SSL_REQUEST = 80_877_103;\n/** PostgreSQL CancelRequest protocol code. */\nexport const CANCEL_REQUEST = 80_877_102;\n/** PostgreSQL protocol version 3 code. */\nexport const PROTOCOL_3 = 196_608;\n\n/** Parsed PostgreSQL startup packet. */\nexport interface StartupMessage {\n  kind: \"startup\";\n  protocol: number;\n  parameters: Record<string, string>;\n}\n\n/** Parsed PostgreSQL cancellation packet. */\nexport interface CancelMessage {\n  kind: \"cancel\";\n  processId: number;\n  secretKey: number;\n}\n\n/** First supported packet received from a PostgreSQL client. */\nexport type InitialMessage = StartupMessage | CancelMessage;\n\n/** Error caused by an invalid or unsupported PostgreSQL startup packet. */\nexport class PostgresProtocolError extends Error {}\n\n/** Read and classify the first PostgreSQL frontend message from a socket. */\nexport async function readInitialMessage(\n  socket: Socket,\n  timeoutMs: number,\n): Promise<InitialMessage> {\n  const deadline = Date.now() + timeoutMs;\n  for (;;) {\n    const packet = await readPacket(socket, deadline);\n    const code = packet.readInt32BE(4);\n    if (code === SSL_REQUEST) {\n      socket.write(\"N\");\n      continue;\n    }\n    if (code === CANCEL_REQUEST) {\n      if (packet.length !== 16) throw new PostgresProtocolError(\"Invalid CancelRequest packet\");\n      return {\n        kind: \"cancel\",\n        processId: packet.readInt32BE(8),\n        secretKey: packet.readInt32BE(12),\n      };\n    }\n    if (code !== PROTOCOL_3) {\n      throw new PostgresProtocolError(`Unsupported PostgreSQL protocol version ${code}`);\n    }\n    return { kind: \"startup\", protocol: code, parameters: parseParameters(packet.subarray(8)) };\n  }\n}\n\n/** Build a PostgreSQL SSL negotiation request packet. */\nexport function sslRequest(): Buffer {\n  return requestPacket(SSL_REQUEST);\n}\n\n/** Build a PostgreSQL cancellation request packet. */\nexport function cancelRequest(processId: number, secretKey: number): Buffer {\n  return requestPacket(CANCEL_REQUEST, processId, secretKey);\n}\n\n/** Build the backend messages that complete PostgreSQL startup. */\nexport function startupComplete(\n  parameters: ReadonlyMap<string, string>,\n  processId: number,\n  secretKey: number,\n  transactionStatus = \"I\",\n): Buffer {\n  return Buffer.concat([\n    backendMessage(\"R\", int32(0)),\n    ...[...parameters].map(([name, value]) =>\n      backendMessage(\"S\", Buffer.from(`${name}\\0${value}\\0`)),\n    ),\n    backendMessage(\"K\", Buffer.concat([int32(processId), int32(secretKey)])),\n    backendMessage(\"Z\", Buffer.from(transactionStatus.slice(0, 1) || \"I\")),\n  ]);\n}\n\n/** Replace client startup identity with the resolved upstream identity. */\nexport function upstreamStartupParameters(\n  parameters: Record<string, string>,\n  user: string,\n  database: string,\n): Record<string, string> {\n  return { ...parameters, user, database };\n}\n\n/** Build a fatal PostgreSQL error response. */\nexport function fatalError(message: string, sqlstate = \"08001\"): Buffer {\n  return backendMessage(\n    \"E\",\n    Buffer.concat([Buffer.from(`SFATAL\\0C${sqlstate}\\0M${message}\\0`), Buffer.from([0])]),\n  );\n}\n\nfunction requestPacket(code: number, processId?: number, secretKey?: number): Buffer {\n  const values = [code];\n  if (processId !== undefined && secretKey !== undefined) values.push(processId, secretKey);\n  return Buffer.concat([int32(4 + values.length * 4), ...values.map(int32)]);\n}\n\nfunction backendMessage(code: string, body: Buffer): Buffer {\n  return Buffer.concat([Buffer.from(code), int32(body.length + 4), body]);\n}\n\nfunction int32(value: number): Buffer {\n  const buffer = Buffer.allocUnsafe(4);\n  buffer.writeInt32BE(value);\n  return buffer;\n}\n\nasync function readPacket(socket: Socket, deadline: number): Promise<Buffer> {\n  let buffer = Buffer.alloc(0);\n  while (buffer.length < 4) buffer = Buffer.concat([buffer, await readChunk(socket, deadline)]);\n  const length = buffer.readInt32BE(0);\n  if (length < 8 || length > 1024 * 1024) {\n    throw new PostgresProtocolError(\"Invalid PostgreSQL startup packet\");\n  }\n  while (buffer.length < length) {\n    buffer = Buffer.concat([buffer, await readChunk(socket, deadline)]);\n  }\n  const remainder = buffer.subarray(length);\n  if (remainder.length) socket.unshift(remainder);\n  return buffer.subarray(0, length);\n}\n\nfunction readChunk(socket: Socket, deadline: number): Promise<Buffer> {\n  const remaining = deadline - Date.now();\n  if (remaining <= 0) {\n    return Promise.reject(new PostgresProtocolError(\"PostgreSQL startup timed out\"));\n  }\n  return new Promise((resolve, reject) => {\n    const timer = setTimeout(\n      () => finish(new PostgresProtocolError(\"PostgreSQL startup timed out\")),\n      remaining,\n    );\n    const onData = (chunk: Buffer) => finish(undefined, chunk);\n    const onError = (error: Error) => finish(error);\n    const onEnd = () =>\n      finish(new PostgresProtocolError(\"PostgreSQL client closed during startup\"));\n    const finish = (error?: Error, chunk?: Buffer) => {\n      clearTimeout(timer);\n      socket.off(\"data\", onData);\n      socket.off(\"error\", onError);\n      socket.off(\"end\", onEnd);\n      if (error) reject(error);\n      else resolve(chunk!);\n    };\n    socket.once(\"data\", onData);\n    socket.once(\"error\", onError);\n    socket.once(\"end\", onEnd);\n  });\n}\n\nfunction parseParameters(body: Buffer): Record<string, string> {\n  const values = body.toString(\"utf8\").split(\"\\0\");\n  const parameters: Record<string, string> = {};\n  for (let index = 0; index + 1 < values.length && values[index]; index += 2) {\n    parameters[values[index]!] = values[index + 1] ?? \"\";\n  }\n  return parameters;\n}\n"]}

package/lib/src/lakebase-proxy/proxy.d.ts

@@ -0,0 +1,22 @@
+/** Pure Node PostgreSQL wire proxy for Databricks Lakebase. */
+import { type LakebaseProxyOptions } from "./options.ts";
+/** Loopback PostgreSQL wire proxy backed by Databricks Lakebase credentials. */
+export declare class LakebaseProxy {
+    private readonly client;
+    private readonly options;
+    private readonly cancellations;
+    private server?;
+    private statsTimer?;
+    private opened;
+    private closed;
+    private failed;
+    private active;
+    constructor(options?: LakebaseProxyOptions);
+    listen(): Promise<{
+        host: string;
+        port: number;
+    }>;
+    close(): Promise<void>;
+    private handle;
+    private reportStats;
+}