@dbx-tools/cli 0.9.58 → 0.9.60

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;
+}

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 { PACKAGE_VERSION } from "../../index.js";
+import { startModelGateway } from "./server.js";
+const DEFAULT_DEPENDENCIES = {
+    start: startModelGateway,
+};
+/** Build the tray-only model-gateway service definition. */
+export function modelGatewayServiceDefinition(options = {}) {
+    const { runtimeInfo: _, ...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,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

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

@@ -0,0 +1,13 @@
+/**
+ * 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";
+type AppKitServerOptions = NonNullable<Parameters<typeof server>[0]>;
+/** Resolve AppKit server settings for the loopback model gateway. */
+export declare function modelGatewayServerOptions(options?: ModelGatewayOptions): AppKitServerOptions;
+/** 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,53 @@
+/**
+ * Foreground model-gateway server owned by the CLI package.
+ *
+ * @module
+ */
+import { createApp, server } from "@databricks/appkit";
+import { modelGateway } from "@dbx-tools/appkit-model-gateway/plugin";
+import { sendHealth } 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,
+    };
+}
+/** Start the foreground model gateway and keep its AppKit server active. */
+export async function startModelGateway(options = {}) {
+    const resolved = resolveModelGatewayOptions(options);
+    const client = await workspaceClient.createWorkspaceClient({
+        ...(resolved.profile ? { profile: resolved.profile } : {}),
+    });
+    await createApp({
+        client,
+        plugins: [modelGateway(), server(appKitServerOptions(resolved))],
+        onPluginsReady(appkit) {
+            appkit.server.extend((application) => {
+                application.get("/api/healthz", (_request, response) => {
+                    sendHealth(response);
+                });
+                application.get("/v1/models", (request, response) => {
+                    void appkit.modelGateway.models(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 appkit.modelGateway.inference(protocol, request, response);
+                    });
+                }
+            });
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21vZGVsLWdhdGV3YXkvc2VydmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUN0RSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDcEUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFDTCwwQkFBMEIsR0FHM0IsTUFBTSx5Q0FBeUMsQ0FBQztBQUlqRCxxRUFBcUU7QUFDckUsTUFBTSxVQUFVLHlCQUF5QixDQUFDLFVBQStCLEVBQUU7SUFDekUsT0FBTyxtQkFBbUIsQ0FBQywwQkFBMEIsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO0FBQ2xFLENBQUM7QUFFRCxTQUFTLG1CQUFtQixDQUFDLE9BQW9DO0lBQy9ELE9BQU87UUFDTCxTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVM7UUFDNUIsSUFBSSxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsSUFBSTtRQUN6QixJQUFJLEVBQUUsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJO0tBQzFCLENBQUM7QUFDSixDQUFDO0FBRUQsNEVBQTRFO0FBQzVFLE1BQU0sQ0FBQyxLQUFLLFVBQVUsaUJBQWlCLENBQUMsVUFBK0IsRUFBRTtJQUN2RSxNQUFNLFFBQVEsR0FBRywwQkFBMEIsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNyRCxNQUFNLE1BQU0sR0FBRyxNQUFNLGVBQWUsQ0FBQyxxQkFBcUIsQ0FBQztRQUN6RCxHQUFHLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxPQUFPLEVBQUUsUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7S0FDM0QsQ0FBQyxDQUFDO0lBQ0gsTUFBTSxTQUFTLENBQUM7UUFDZCxNQUFNO1FBQ04sT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLEVBQUUsTUFBTSxDQUFDLG1CQUFtQixDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFDaEUsY0FBYyxDQUFDLE1BQU07WUFDbkIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRTtnQkFDbkMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxjQUFjLEVBQUUsQ0FBQyxRQUFRLEVBQUUsUUFBUSxFQUFFLEVBQUU7b0JBQ3JELFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDdkIsQ0FBQyxDQUFDLENBQUM7Z0JBQ0gsV0FBVyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLEVBQUU7b0JBQ2xELEtBQUssTUFBTSxDQUFDLFlBQVksQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO2dCQUNyRCxDQUFDLENBQUMsQ0FBQztnQkFDSCxLQUFLLE1BQU0sQ0FBQyxJQUFJLEVBQUUsUUFBUSxDQUFDLElBQUk7b0JBQzdCLENBQUMsc0JBQXNCLEVBQUUsYUFBYSxDQUFDO29CQUN2QyxDQUFDLGVBQWUsRUFBRSxrQkFBa0IsQ0FBQztvQkFDckMsQ0FBQyxjQUFjLEVBQUUsb0JBQW9CLENBQUM7b0JBQ3RDLENBQUMsZ0JBQWdCLEVBQUUsbUJBQW1CLENBQUM7aUJBQy9CLEVBQUUsQ0FBQztvQkFDWCxXQUFXLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLE9BQU8sRUFBRSxRQUFRLEVBQUUsRUFBRTt3QkFDM0MsS0FBSyxNQUFNLENBQUMsWUFBWSxDQUFDLFNBQVMsQ0FBQyxRQUFRLEVBQUUsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO29CQUNsRSxDQUFDLENBQUMsQ0FBQztnQkFDTCxDQUFDO1lBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO0tBQ0YsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRm9yZWdyb3VuZCBtb2RlbC1nYXRld2F5IHNlcnZlciBvd25lZCBieSB0aGUgQ0xJIHBhY2thZ2UuXG4gKlxuICogQG1vZHVsZVxuICovXG5cbmltcG9ydCB7IGNyZWF0ZUFwcCwgc2VydmVyIH0gZnJvbSBcIkBkYXRhYnJpY2tzL2FwcGtpdFwiO1xuaW1wb3J0IHsgbW9kZWxHYXRld2F5IH0gZnJvbSBcIkBkYngtdG9vbHMvYXBwa2l0LW1vZGVsLWdhdGV3YXkvcGx1Z2luXCI7XG5pbXBvcnQgeyBzZW5kSGVhbHRoIH0gZnJvbSBcIkBkYngtdG9vbHMvYXBwa2l0LW1vZGVsLWdhdGV3YXkvcm91dGVzXCI7XG5pbXBvcnQgeyB3b3Jrc3BhY2VDbGllbnQgfSBmcm9tIFwiQGRieC10b29scy9kYXRhYnJpY2tzXCI7XG5pbXBvcnQge1xuICByZXNvbHZlTW9kZWxHYXRld2F5T3B0aW9ucyxcbiAgdHlwZSBNb2RlbEdhdGV3YXlPcHRpb25zLFxuICB0eXBlIFJlc29sdmVkTW9kZWxHYXRld2F5T3B0aW9ucyxcbn0gZnJvbSBcIkBkYngtdG9vbHMvc2hhcmVkLW1vZGVsLWdhdGV3YXkvb3B0aW9uc1wiO1xuXG50eXBlIEFwcEtpdFNlcnZlck9wdGlvbnMgPSBOb25OdWxsYWJsZTxQYXJhbWV0ZXJzPHR5cGVvZiBzZXJ2ZXI+WzBdPjtcblxuLyoqIFJlc29sdmUgQXBwS2l0IHNlcnZlciBzZXR0aW5ncyBmb3IgdGhlIGxvb3BiYWNrIG1vZGVsIGdhdGV3YXkuICovXG5leHBvcnQgZnVuY3Rpb24gbW9kZWxHYXRld2F5U2VydmVyT3B0aW9ucyhvcHRpb25zOiBNb2RlbEdhdGV3YXlPcHRpb25zID0ge30pOiBBcHBLaXRTZXJ2ZXJPcHRpb25zIHtcbiAgcmV0dXJuIGFwcEtpdFNlcnZlck9wdGlvbnMocmVzb2x2ZU1vZGVsR2F0ZXdheU9wdGlvbnMob3B0aW9ucykpO1xufVxuXG5mdW5jdGlvbiBhcHBLaXRTZXJ2ZXJPcHRpb25zKG9wdGlvbnM6IFJlc29sdmVkTW9kZWxHYXRld2F5T3B0aW9ucyk6IEFwcEtpdFNlcnZlck9wdGlvbnMge1xuICByZXR1cm4ge1xuICAgIGJvZHlMaW1pdDogb3B0aW9ucy5ib2R5TGltaXQsXG4gICAgaG9zdDogb3B0aW9ucy5saXN0ZW4uaG9zdCxcbiAgICBwb3J0OiBvcHRpb25zLmxpc3Rlbi5wb3J0LFxuICB9O1xufVxuXG4vKiogU3RhcnQgdGhlIGZvcmVncm91bmQgbW9kZWwgZ2F0ZXdheSBhbmQga2VlcCBpdHMgQXBwS2l0IHNlcnZlciBhY3RpdmUuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc3RhcnRNb2RlbEdhdGV3YXkob3B0aW9uczogTW9kZWxHYXRld2F5T3B0aW9ucyA9IHt9KTogUHJvbWlzZTx2b2lkPiB7XG4gIGNvbnN0IHJlc29sdmVkID0gcmVzb2x2ZU1vZGVsR2F0ZXdheU9wdGlvbnMob3B0aW9ucyk7XG4gIGNvbnN0IGNsaWVudCA9IGF3YWl0IHdvcmtzcGFjZUNsaWVudC5jcmVhdGVXb3Jrc3BhY2VDbGllbnQoe1xuICAgIC4uLihyZXNvbHZlZC5wcm9maWxlID8geyBwcm9maWxlOiByZXNvbHZlZC5wcm9maWxlIH0gOiB7fSksXG4gIH0pO1xuICBhd2FpdCBjcmVhdGVBcHAoe1xuICAgIGNsaWVudCxcbiAgICBwbHVnaW5zOiBbbW9kZWxHYXRld2F5KCksIHNlcnZlcihhcHBLaXRTZXJ2ZXJPcHRpb25zKHJlc29sdmVkKSldLFxuICAgIG9uUGx1Z2luc1JlYWR5KGFwcGtpdCkge1xuICAgICAgYXBwa2l0LnNlcnZlci5leHRlbmQoKGFwcGxpY2F0aW9uKSA9PiB7XG4gICAgICAgIGFwcGxpY2F0aW9uLmdldChcIi9hcGkvaGVhbHRoelwiLCAoX3JlcXVlc3QsIHJlc3BvbnNlKSA9PiB7XG4gICAgICAgICAgc2VuZEhlYWx0aChyZXNwb25zZSk7XG4gICAgICAgIH0pO1xuICAgICAgICBhcHBsaWNhdGlvbi5nZXQoXCIvdjEvbW9kZWxzXCIsIChyZXF1ZXN0LCByZXNwb25zZSkgPT4ge1xuICAgICAgICAgIHZvaWQgYXBwa2l0Lm1vZGVsR2F0ZXdheS5tb2RlbHMocmVxdWVzdCwgcmVzcG9uc2UpO1xuICAgICAgICB9KTtcbiAgICAgICAgZm9yIChjb25zdCBbcGF0aCwgcHJvdG9jb2xdIG9mIFtcbiAgICAgICAgICBbXCIvdjEvY2hhdC9jb21wbGV0aW9uc1wiLCBcIm9wZW5haS1jaGF0XCJdLFxuICAgICAgICAgIFtcIi92MS9yZXNwb25zZXNcIiwgXCJvcGVuYWktcmVzcG9uc2VzXCJdLFxuICAgICAgICAgIFtcIi92MS9tZXNzYWdlc1wiLCBcImFudGhyb3BpYy1tZXNzYWdlc1wiXSxcbiAgICAgICAgICBbXCIvdjEvZW1iZWRkaW5nc1wiLCBcIm9wZW5haS1lbWJlZGRpbmdzXCJdLFxuICAgICAgICBdIGFzIGNvbnN0KSB7XG4gICAgICAgICAgYXBwbGljYXRpb24ucG9zdChwYXRoLCAocmVxdWVzdCwgcmVzcG9uc2UpID0+IHtcbiAgICAgICAgICAgIHZvaWQgYXBwa2l0Lm1vZGVsR2F0ZXdheS5pbmZlcmVuY2UocHJvdG9jb2wsIHJlcXVlc3QsIHJlc3BvbnNlKTtcbiAgICAgICAgICB9KTtcbiAgICAgICAgfVxuICAgICAgfSk7XG4gICAgfSxcbiAgfSk7XG59XG4iXX0=