@dbx-tools/cli 0.9.60 → 0.9.61

package/lib/src/genie-code/runtime.js

@@ -0,0 +1,162 @@
+/**
+ * Supervise Genie Code and its authenticated local model gateway.
+ *
+ * @module
+ */
+import { randomBytes } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { delimiter, dirname } from "node:path";
+import { DatabricksModelRegistry, models } from "@dbx-tools/appkit-model-gateway";
+import * as auth from "@dbx-tools/auth";
+import { resolveServicePackageBin } from "@dbx-tools/cli-service/definition";
+import { workspaceClient } from "@dbx-tools/databricks";
+import { log } from "@dbx-tools/shared-core";
+import { resolveGenieCodeOptions, } from "@dbx-tools/shared-genie-code/options";
+import concurrently from "concurrently";
+import getPort from "get-port";
+import { writeGenieCodeConfig } from "./config.js";
+import { installGenieCode } from "./install.js";
+import { RUNNER_OPTIONS_ENV } from "./runner.js";
+const logger = log.logger("genie-code");
+const DEFAULT_DEPENDENCIES = {
+    createAuthClient: auth.client.createAuthClient,
+    install: installGenieCode,
+    port: ({ host, port }) => getPort({ host, ...(port ? { port } : {}) }),
+    resolveBin: resolveServicePackageBin,
+    resolveCodexModel,
+    supervise: concurrently,
+    token: () => randomBytes(32).toString("base64url"),
+    writeConfig: writeGenieCodeConfig,
+};
+/** Resolve a Genie `--model` value to the Codex catalogue slug the gateway publishes. */
+async function resolveCodexModel(model, profile) {
+    const client = await workspaceClient.createWorkspaceClient({ profile });
+    const target = await new DatabricksModelRegistry({ client }).resolve(model, {
+        requiresTools: true,
+    });
+    if (!target)
+        throw new Error(`Genie Code model not found: ${model}`);
+    return models.codexModelSlug(target);
+}
+/** Resolve auth, installation, listener, and configuration before spawning children. */
+export async function prepareGenieCodeRuntime(input = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };
+    const options = resolveGenieCodeOptions(input.options);
+    logger.info("resolving Databricks authentication", {
+        requestedProfile: options.profile,
+    });
+    const authClient = await dependencies.createAuthClient(options.profile ? { profile: options.profile } : {});
+    const profile = authClient.profile;
+    if (!profile) {
+        throw new Error("Genie Code requires a configured Databricks profile");
+    }
+    logger.info("preparing Genie Code runtime", {
+        profile,
+        model: options.model,
+    });
+    const installation = await dependencies.install();
+    const host = options.gatewayListen.host;
+    const requestedPort = options.gatewayListen.port;
+    const gatewayPort = await dependencies.port({
+        host,
+        ...(requestedPort > 0 ? { port: requestedPort } : {}),
+    });
+    if (requestedPort > 0 && gatewayPort !== requestedPort) {
+        throw new Error(`Genie Code gateway port ${requestedPort} is already in use`);
+    }
+    const model = await dependencies.resolveCodexModel(options.model, profile);
+    logger.info("resolved Genie Code model", { requested: options.model, model });
+    const urlHost = host.includes(":") ? `[${host}]` : host;
+    const gatewayBaseUrl = `http://${urlHost}:${gatewayPort}/v1`;
+    const gatewayHealthUrl = `http://${urlHost}:${gatewayPort}/api/healthz`;
+    const gatewayListen = `tcp://${urlHost}:${gatewayPort}`;
+    const bearerToken = dependencies.token();
+    const home = await dependencies.writeConfig({
+        bearerToken,
+        gatewayBaseUrl,
+        model,
+        profile,
+        projectDirectory: input.cwd ?? process.cwd(),
+    });
+    return {
+        bearerToken,
+        gatewayBaseUrl,
+        gatewayHealthUrl,
+        gatewayListen,
+        gatewayPort,
+        home,
+        installation,
+        model,
+        profile,
+    };
+}
+function shellExecutable(path) {
+    if (process.platform === "win32")
+        return `"${path.replaceAll('"', '""')}"`;
+    return `'${path.replaceAll("'", "'\\''")}'`;
+}
+function childPath(...paths) {
+    return [...new Set([...paths.map(dirname), process.env.PATH].filter(Boolean))].join(delimiter);
+}
+/** Run Genie Code and the model gateway until either process exits. */
+export async function runGenieCode(input = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };
+    const prepared = await prepareGenieCodeRuntime({
+        ...input,
+        dependencies,
+    });
+    const gatewayBin = dependencies.resolveBin(import.meta.url, "dbx-model-gateway");
+    const runnerBin = dependencies.resolveBin(import.meta.url, "dbx-genie");
+    const path = childPath(gatewayBin, runnerBin);
+    const runnerOptions = {
+        executable: prepared.installation.path,
+        arguments: ["-p", prepared.home.overlayName, ...(input.genieArgs ?? [])],
+        home: prepared.home.home,
+        gatewayHealthUrl: prepared.gatewayHealthUrl,
+        bearerToken: prepared.bearerToken,
+        startupTimeoutMs: 60_000,
+    };
+    const { result } = dependencies.supervise([
+        {
+            command: shellExecutable(gatewayBin),
+            name: "gateway",
+            env: {
+                ...process.env,
+                PATH: path,
+                LISTEN: prepared.gatewayListen,
+                DATABRICKS_CONFIG_PROFILE: prepared.profile,
+                DBX_TOOLS_MODEL_GATEWAY_BEARER_TOKEN: prepared.bearerToken,
+            },
+        },
+        {
+            command: shellExecutable(runnerBin),
+            name: "genie",
+            env: {
+                ...process.env,
+                PATH: path,
+                DATABRICKS_CONFIG_PROFILE: prepared.profile,
+                [RUNNER_OPTIONS_ENV]: JSON.stringify(runnerOptions),
+            },
+        },
+    ], {
+        cwd: input.cwd ?? process.cwd(),
+        raw: true,
+        killOthersOn: ["failure", "success"],
+        killSignal: "SIGTERM",
+        killTimeout: 17_000,
+        successCondition: "command-genie",
+    });
+    logger.info("started Genie Code and model gateway", {
+        profile: prepared.profile,
+        model: prepared.model,
+        gateway: prepared.gatewayBaseUrl,
+        home: prepared.home.home,
+    });
+    try {
+        await result;
+    }
+    finally {
+        await rm(prepared.home.overlayPath, { force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/genie-code/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Supervise Genie Code and its authenticated local model gateway.\n *\n * @module\n */\n\nimport { randomBytes } from \"node:crypto\";\nimport { rm } from \"node:fs/promises\";\nimport { delimiter, dirname } from \"node:path\";\nimport { DatabricksModelRegistry, models } from \"@dbx-tools/appkit-model-gateway\";\nimport * as auth from \"@dbx-tools/auth\";\nimport { resolveServicePackageBin } from \"@dbx-tools/cli-service/definition\";\nimport type { BinContext } from \"@dbx-tools/core/bin\";\nimport { workspaceClient } from \"@dbx-tools/databricks\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  resolveGenieCodeOptions,\n  type GenieCodeOptions,\n  type GenieCodeRunnerOptions,\n} from \"@dbx-tools/shared-genie-code/options\";\nimport concurrently from \"concurrently\";\nimport getPort from \"get-port\";\n\nimport { writeGenieCodeConfig, type GenieCodeHome } from \"./config.ts\";\nimport { installGenieCode } from \"./install.ts\";\nimport { RUNNER_OPTIONS_ENV } from \"./runner.ts\";\n\nconst logger = log.logger(\"genie-code\");\n\n/** Injectable owners used to prepare and supervise managed Genie Code. */\nexport interface GenieCodeRuntimeDependencies {\n  createAuthClient: typeof auth.client.createAuthClient;\n  install: typeof installGenieCode;\n  port(options: { host: string; port?: number }): Promise<number>;\n  resolveBin(packageReference: string, binName: string): string;\n  resolveCodexModel(model: string, profile: string): Promise<string>;\n  supervise: typeof concurrently;\n  token(): string;\n  writeConfig: typeof writeGenieCodeConfig;\n}\n\nconst DEFAULT_DEPENDENCIES: GenieCodeRuntimeDependencies = {\n  createAuthClient: auth.client.createAuthClient,\n  install: installGenieCode,\n  port: ({ host, port }) => getPort({ host, ...(port ? { port } : {}) }),\n  resolveBin: resolveServicePackageBin,\n  resolveCodexModel,\n  supervise: concurrently,\n  token: () => randomBytes(32).toString(\"base64url\"),\n  writeConfig: writeGenieCodeConfig,\n};\n\n/** Resolve a Genie `--model` value to the Codex catalogue slug the gateway publishes. */\nasync function resolveCodexModel(model: string, profile: string): Promise<string> {\n  const client = await workspaceClient.createWorkspaceClient({ profile });\n  const target = await new DatabricksModelRegistry({ client }).resolve(model, {\n    requiresTools: true,\n  });\n  if (!target) throw new Error(`Genie Code model not found: ${model}`);\n  return models.codexModelSlug(target);\n}\n\n/** Inputs accepted by managed Genie Code preparation and execution. */\nexport interface RunGenieCodeOptions {\n  cwd?: string;\n  dependencies?: Partial<GenieCodeRuntimeDependencies>;\n  genieArgs?: readonly string[];\n  options?: GenieCodeOptions;\n}\n\n/** Resolved installation, auth, listener, and home for one invocation. */\nexport interface PreparedGenieCodeRuntime {\n  bearerToken: string;\n  gatewayBaseUrl: string;\n  gatewayHealthUrl: string;\n  gatewayListen: string;\n  gatewayPort: number;\n  home: GenieCodeHome;\n  installation: BinContext;\n  model: string;\n  profile: string;\n}\n\n/** Resolve auth, installation, listener, and configuration before spawning children. */\nexport async function prepareGenieCodeRuntime(\n  input: RunGenieCodeOptions = {},\n): Promise<PreparedGenieCodeRuntime> {\n  const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };\n  const options = resolveGenieCodeOptions(input.options);\n  logger.info(\"resolving Databricks authentication\", {\n    requestedProfile: options.profile,\n  });\n  const authClient = await dependencies.createAuthClient(\n    options.profile ? { profile: options.profile } : {},\n  );\n  const profile = authClient.profile;\n  if (!profile) {\n    throw new Error(\"Genie Code requires a configured Databricks profile\");\n  }\n  logger.info(\"preparing Genie Code runtime\", {\n    profile,\n    model: options.model,\n  });\n  const installation = await dependencies.install();\n  const host = options.gatewayListen.host;\n  const requestedPort = options.gatewayListen.port;\n  const gatewayPort = await dependencies.port({\n    host,\n    ...(requestedPort > 0 ? { port: requestedPort } : {}),\n  });\n  if (requestedPort > 0 && gatewayPort !== requestedPort) {\n    throw new Error(`Genie Code gateway port ${requestedPort} is already in use`);\n  }\n  const model = await dependencies.resolveCodexModel(options.model, profile);\n  logger.info(\"resolved Genie Code model\", { requested: options.model, model });\n  const urlHost = host.includes(\":\") ? `[${host}]` : host;\n  const gatewayBaseUrl = `http://${urlHost}:${gatewayPort}/v1`;\n  const gatewayHealthUrl = `http://${urlHost}:${gatewayPort}/api/healthz`;\n  const gatewayListen = `tcp://${urlHost}:${gatewayPort}`;\n  const bearerToken = dependencies.token();\n  const home = await dependencies.writeConfig({\n    bearerToken,\n    gatewayBaseUrl,\n    model,\n    profile,\n    projectDirectory: input.cwd ?? process.cwd(),\n  });\n  return {\n    bearerToken,\n    gatewayBaseUrl,\n    gatewayHealthUrl,\n    gatewayListen,\n    gatewayPort,\n    home,\n    installation,\n    model,\n    profile,\n  };\n}\n\nfunction shellExecutable(path: string): string {\n  if (process.platform === \"win32\") return `\"${path.replaceAll('\"', '\"\"')}\"`;\n  return `'${path.replaceAll(\"'\", \"'\\\\''\")}'`;\n}\n\nfunction childPath(...paths: string[]): string {\n  return [...new Set([...paths.map(dirname), process.env.PATH].filter(Boolean))].join(delimiter);\n}\n\n/** Run Genie Code and the model gateway until either process exits. */\nexport async function runGenieCode(input: RunGenieCodeOptions = {}): Promise<void> {\n  const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };\n  const prepared = await prepareGenieCodeRuntime({\n    ...input,\n    dependencies,\n  });\n  const gatewayBin = dependencies.resolveBin(import.meta.url, \"dbx-model-gateway\");\n  const runnerBin = dependencies.resolveBin(import.meta.url, \"dbx-genie\");\n  const path = childPath(gatewayBin, runnerBin);\n  const runnerOptions: GenieCodeRunnerOptions = {\n    executable: prepared.installation.path,\n    arguments: [\"-p\", prepared.home.overlayName, ...(input.genieArgs ?? [])],\n    home: prepared.home.home,\n    gatewayHealthUrl: prepared.gatewayHealthUrl,\n    bearerToken: prepared.bearerToken,\n    startupTimeoutMs: 60_000,\n  };\n  const { result } = dependencies.supervise(\n    [\n      {\n        command: shellExecutable(gatewayBin),\n        name: \"gateway\",\n        env: {\n          ...process.env,\n          PATH: path,\n          LISTEN: prepared.gatewayListen,\n          DATABRICKS_CONFIG_PROFILE: prepared.profile,\n          DBX_TOOLS_MODEL_GATEWAY_BEARER_TOKEN: prepared.bearerToken,\n        },\n      },\n      {\n        command: shellExecutable(runnerBin),\n        name: \"genie\",\n        env: {\n          ...process.env,\n          PATH: path,\n          DATABRICKS_CONFIG_PROFILE: prepared.profile,\n          [RUNNER_OPTIONS_ENV]: JSON.stringify(runnerOptions),\n        },\n      },\n    ],\n    {\n      cwd: input.cwd ?? process.cwd(),\n      raw: true,\n      killOthersOn: [\"failure\", \"success\"],\n      killSignal: \"SIGTERM\",\n      killTimeout: 17_000,\n      successCondition: \"command-genie\",\n    },\n  );\n  logger.info(\"started Genie Code and model gateway\", {\n    profile: prepared.profile,\n    model: prepared.model,\n    gateway: prepared.gatewayBaseUrl,\n    home: prepared.home.home,\n  });\n  try {\n    await result;\n  } finally {\n    await rm(prepared.home.overlayPath, { force: true });\n  }\n}\n"]}

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

@@ -8,14 +8,14 @@ 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";
+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: _, ...resolved } = resolveModelGatewayCliOptions(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",
@@ -60,4 +60,4 @@ function modelGatewayOptions(command) {
 function urlHost(host) {
     return host.includes(":") ? `[${host}]` : host;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -5,9 +5,12 @@
  */
 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

@@ -3,9 +3,10 @@
  *
  * @module
  */
+import { createHash, timingSafeEqual } from "node:crypto";
 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 { 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. */
@@ -19,22 +20,51 @@ function appKitServerOptions(options) {
         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: [modelGateway(), server(appKitServerOptions(resolved))],
+        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 appkit.modelGateway.models(request, response);
+                    void sendModels(gateway, request, response);
                 });
                 for (const [path, protocol] of [
                     ["/v1/chat/completions", "openai-chat"],
@@ -43,11 +73,11 @@ export async function startModelGateway(options = {}) {
                     ["/v1/embeddings", "openai-embeddings"],
                 ]) {
                     application.post(path, (request, response) => {
-                        void appkit.modelGateway.inference(protocol, request, response);
+                        void sendInference(gateway, protocol, request, response);
                     });
                 }
             });
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../src/appkit/cli.ts","../src/appkit/env-export.ts","../src/auth/cli.ts","../src/auth/options.ts","../src/graphiti/cli.ts","../src/graphiti/options.ts","../src/lakebase-proxy/cancellation.ts","../src/lakebase-proxy/cli.ts","../src/lakebase-proxy/options.ts","../src/lakebase-proxy/protocol.ts","../src/lakebase-proxy/proxy.ts","../src/model-gateway/cli.ts","../src/model-gateway/server.ts","../src/tunnel/app.ts","../src/tunnel/cli.ts","../src/tunnel/options.ts","../src/tunnel/proxy.ts","../index.ts","../bin/dbx-graphiti.ts","../bin/dbx-lakebase-proxy.ts","../bin/dbx-model-gateway.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}
+{"root":["../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../src/appkit/cli.ts","../src/appkit/env-export.ts","../src/auth/cli.ts","../src/auth/options.ts","../src/genie-code/cli.ts","../src/genie-code/config.ts","../src/genie-code/install.ts","../src/genie-code/options.ts","../src/genie-code/runner.ts","../src/genie-code/runtime.ts","../src/graphiti/cli.ts","../src/graphiti/options.ts","../src/lakebase-proxy/cancellation.ts","../src/lakebase-proxy/cli.ts","../src/lakebase-proxy/options.ts","../src/lakebase-proxy/protocol.ts","../src/lakebase-proxy/proxy.ts","../src/model-gateway/cli.ts","../src/model-gateway/server.ts","../src/tunnel/app.ts","../src/tunnel/cli.ts","../src/tunnel/options.ts","../src/tunnel/proxy.ts","../index.ts","../bin/dbx-genie.ts","../bin/dbx-graphiti.ts","../bin/dbx-lakebase-proxy.ts","../bin/dbx-model-gateway.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}

package/package.json

@@ -8,6 +8,7 @@
   },
   "bin": {
     "dbx": "./lib/bin/dbx-tools.js",
+    "dbx-genie": "./lib/bin/dbx-genie.js",
     "dbx-graphiti": "./lib/bin/dbx-graphiti.js",
     "dbx-lakebase-proxy": "./lib/bin/dbx-lakebase-proxy.js",
     "dbx-model-gateway": "./lib/bin/dbx-model-gateway.js",
@@ -33,26 +34,30 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@databricks/appkit": "0.81.0",
-    "@dbx-tools/appkit": "^0.9.60",
-    "@dbx-tools/appkit-model-gateway": "^0.9.60",
-    "@dbx-tools/auth": "^0.9.60",
-    "@dbx-tools/auth-gate": "^0.9.60",
-    "@dbx-tools/cli-args": "^0.9.60",
-    "@dbx-tools/cli-service": "^0.9.60",
-    "@dbx-tools/core": "^0.9.60",
-    "@dbx-tools/databricks": "^0.9.60",
-    "@dbx-tools/email": "^0.9.60",
-    "@dbx-tools/graphiti": "^0.9.60",
-    "@dbx-tools/lakebase": "^0.9.60",
-    "@dbx-tools/postgres": "^0.9.60",
-    "@dbx-tools/shared-auth": "^0.9.60",
-    "@dbx-tools/shared-core": "^0.9.60",
-    "@dbx-tools/shared-email": "^0.9.60",
-    "@dbx-tools/shared-model-gateway": "^0.9.60",
-    "@dbx-tools/tunnel": "^0.9.60",
+    "@dbx-tools/appkit": "^0.9.61",
+    "@dbx-tools/appkit-model-gateway": "^0.9.61",
+    "@dbx-tools/auth": "^0.9.61",
+    "@dbx-tools/auth-gate": "^0.9.61",
+    "@dbx-tools/cli-args": "^0.9.61",
+    "@dbx-tools/cli-service": "^0.9.61",
+    "@dbx-tools/core": "^0.9.61",
+    "@dbx-tools/databricks": "^0.9.61",
+    "@dbx-tools/email": "^0.9.61",
+    "@dbx-tools/graphiti": "^0.9.61",
+    "@dbx-tools/lakebase": "^0.9.61",
+    "@dbx-tools/postgres": "^0.9.61",
+    "@dbx-tools/shared-auth": "^0.9.61",
+    "@dbx-tools/shared-core": "^0.9.61",
+    "@dbx-tools/shared-email": "^0.9.61",
+    "@dbx-tools/shared-genie-code": "^0.9.61",
+    "@dbx-tools/shared-model-gateway": "^0.9.61",
+    "@dbx-tools/tunnel": "^0.9.61",
     "commander": "^15.0.0",
+    "concurrently": "^10.0.3",
+    "get-port": "^7.1.0",
     "http-proxy-3": "^1.23.1",
     "pg": "^8.22.0",
+    "smol-toml": "1.8.0",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -63,6 +68,7 @@
     "types": "./lib/index.d.ts",
     "bin": {
       "dbx": "./lib/bin/dbx-tools.js",
+      "dbx-genie": "./lib/bin/dbx-genie.js",
       "dbx-graphiti": "./lib/bin/dbx-graphiti.js",
       "dbx-lakebase-proxy": "./lib/bin/dbx-lakebase-proxy.js",
       "dbx-model-gateway": "./lib/bin/dbx-model-gateway.js",
@@ -113,6 +119,14 @@
         "types": "./lib/src/graphiti/options.d.ts",
         "default": "./lib/src/graphiti/options.js"
       },
+      "./genie": {
+        "types": "./lib/src/genie-code/cli.d.ts",
+        "default": "./lib/src/genie-code/cli.js"
+      },
+      "./genie/options": {
+        "types": "./lib/src/genie-code/options.d.ts",
+        "default": "./lib/src/genie-code/options.js"
+      },
       "./lakebase-proxy": {
         "types": "./lib/src/lakebase-proxy/cli.d.ts",
         "default": "./lib/src/lakebase-proxy/cli.js"
@@ -140,7 +154,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.60",
+  "version": "0.9.61",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [
@@ -193,6 +207,14 @@
       "types": "./lib/src/graphiti/options.d.ts",
       "default": "./lib/src/graphiti/options.js"
     },
+    "./genie": {
+      "types": "./lib/src/genie-code/cli.d.ts",
+      "default": "./lib/src/genie-code/cli.js"
+    },
+    "./genie/options": {
+      "types": "./lib/src/genie-code/options.d.ts",
+      "default": "./lib/src/genie-code/options.js"
+    },
     "./lakebase-proxy": {
       "types": "./lib/src/lakebase-proxy/cli.d.ts",
       "default": "./lib/src/lakebase-proxy/cli.js"

package/src/auth/cli.ts

@@ -123,10 +123,20 @@ export function buildProgram(
         ...(tokenOptions.login ? {} : { login: false }),
         ...(tokenOptions.forceRefresh ? { refresh: true } : {}),
       });
-      dependencies.writeJson(tokenJson(token));
+      if (tokenOptions.format === "text") dependencies.writeText(token.accessToken);
+      else dependencies.writeJson(tokenJson(token));
     });
   });
 
+  program
+    .command("headers")
+    .description("Return current Databricks authentication headers")
+    .action(async () => {
+      await withAuth(options(), dependencies, async ({ auth }) => {
+        dependencies.writeJson(await auth.headers());
+      });
+    });
+
   program
     .command("profile")
     .description("Print the configured or automatically detected profile")

package/src/auth/options.ts

@@ -48,6 +48,10 @@ export const TokenCommandOptionsSchema = z
   .object({
     forceRefresh: z.boolean().default(false).describe("Refresh the token before returning it."),
     login: z.boolean().default(true).describe("Log in when credentials are missing or invalid."),
+    format: z
+      .enum(["json", "text"])
+      .default("json")
+      .describe("Output structured token metadata or only the access token."),
   })
   .strict()
   .describe("Options for returning a Databricks access token.");

package/src/cli.ts

@@ -59,8 +59,9 @@ export async function prepareAndRunProjen(projenArgs: string[], startDir?: strin
 /**
  * Mount `name` as a command that captures every following token verbatim and
  * hands it to the program `load()` resolves. `helpOption(false)` is what lets
- * `--help` through to the child instead of being answered here, and the child
- * program owns its own flags, so this wrapper never has to restate them.
+ * `--help` through to the child instead of being answered here, and
+ * `passThroughOptions()` keeps unknown flags in that token list so the child
+ * program owns them.
  */
 function addForwardedCommand(
   program: Command,
@@ -73,6 +74,7 @@ function addForwardedCommand(
     .description(description)
     .argument("[args...]", `arguments forwarded to ${name}`)
     .allowUnknownOption()
+    .passThroughOptions()
     .allowExcessArguments()
     .helpOption(false)
     .action(async (args: string[]) => {
@@ -88,6 +90,7 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     .description(
       "Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies",
     )
+    .enablePositionalOptions()
     .showHelpAfterError()
     .helpOption("-h, --help", `Show ${name} help`);
 
@@ -137,6 +140,13 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     async () => (await import("./model-gateway/cli.ts")).buildProgram,
   );
 
+  addForwardedCommand(
+    program,
+    "genie",
+    "Run managed Genie Code through a local Databricks model gateway",
+    async () => (await import("./genie-code/cli.ts")).buildProgram,
+  );
+
   addForwardedCommand(
     program,
     "graphiti",
@@ -158,6 +168,7 @@ export async function buildDocumentationProgram(name: string = PROGRAM_NAMES[0])
     (await import("./tunnel/cli.ts")).buildProgram("tunnel"),
     (await import("./lakebase-proxy/cli.ts")).buildProgram("lakebase-proxy"),
     (await import("./model-gateway/cli.ts")).buildProgram("model-gateway"),
+    (await import("./genie-code/cli.ts")).buildProgram("genie"),
     (await import("./graphiti/cli.ts")).buildProgram("graphiti"),
   );
   return program;

package/src/genie-code/cli.ts

@@ -0,0 +1,58 @@
+/**
+ * Managed `dbx genie` command.
+ *
+ * @module
+ */
+
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { Command } from "commander";
+
+import { GenieCodeCliOptionsSchema, type GenieCodeCliOptions } from "./options.ts";
+import { runGenieCode } from "./runtime.ts";
+
+/** Injectable managed Genie execution boundary for parser tests and embedding. */
+export interface GenieCodeCliDependencies {
+  run(input: {
+    cwd: string;
+    genieArgs: readonly string[];
+    options: GenieCodeCliOptions;
+  }): Promise<void>;
+}
+
+const DEFAULT_DEPENDENCIES: GenieCodeCliDependencies = {
+  run: runGenieCode,
+};
+
+/** Build the managed Genie Code command without executing it. */
+export function buildProgram(
+  name = "dbx genie",
+  dependencies: GenieCodeCliDependencies = DEFAULT_DEPENDENCIES,
+): Command {
+  const program = addArgs(
+    new Command()
+      .name(name)
+      .description("Run Genie Code through an authenticated local Databricks model gateway")
+      .argument(
+        "[genieArgs...]",
+        "arguments and unknown flags forwarded to Genie Code; wrapper options may be separated with --",
+      )
+      .allowUnknownOption()
+      .passThroughOptions()
+      .allowExcessArguments()
+      .showHelpAfterError(),
+    GenieCodeCliOptionsSchema,
+  );
+  program.action(async (genieArgs: string[]) => {
+    await dependencies.run({
+      cwd: process.cwd(),
+      genieArgs,
+      options: parseArgs(program, GenieCodeCliOptionsSchema),
+    });
+  });
+  return program;
+}
+
+/** Parse argv and run managed Genie Code. */
+export async function runCli(argv: string[]): Promise<void> {
+  await buildProgram().parseAsync(argv);
+}