@dbx-tools/cli 0.9.58 → 0.9.61

package/lib/src/auth/cli.js

@@ -0,0 +1,129 @@
+/**
+ * `dbx auth` Commander program for Databricks OAuth.
+ *
+ * The command delegates profile resolution and token lifecycle to
+ * `@dbx-tools/auth`.
+ *
+ * @module
+ */
+import * as databricks from "@dbx-tools/auth";
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { Command, CommanderError } from "commander";
+import { AuthCliOptionsSchema, databricksAuthOptions, TokenCommandOptionsSchema, } from "./options.js";
+const DEFAULT_DEPENDENCIES = {
+    createAuthClient: databricks.client.createAuthClient,
+    writeJson: (value) => {
+        process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+    },
+    writeText: (value) => {
+        process.stdout.write(`${value}\n`);
+    },
+};
+/** Open the selected authentication client. */
+async function openAuth(options, dependencies) {
+    return {
+        auth: await dependencies.createAuthClient(databricksAuthOptions(options)),
+        close: async () => { },
+    };
+}
+/** Execute an auth action and close resources owned by the command. */
+async function withAuth(options, dependencies, action) {
+    const context = await openAuth(options, dependencies);
+    try {
+        await action(context);
+    }
+    finally {
+        await context.close();
+    }
+}
+/** Shape a generated token record for stable CLI JSON output. */
+function tokenJson(token) {
+    return {
+        access_token: token.accessToken,
+        token_type: token.tokenType,
+        ...(token.expiry ? { expiry: token.expiry } : {}),
+        ...(token.scopes.length ? { scopes: token.scopes } : {}),
+    };
+}
+/** Select the serializable identity fields from an authentication client. */
+function clientInfo(auth) {
+    return {
+        ...(auth.profile ? { profile: auth.profile } : {}),
+        host: auth.host,
+        ...(auth.accountId ? { accountId: auth.accountId } : {}),
+        ...(auth.workspaceId ? { workspaceId: auth.workspaceId } : {}),
+        target: auth.target,
+        authType: auth.authType,
+        principal: auth.principal,
+    };
+}
+/** Build the `dbx auth` Commander program without parsing arguments. */
+export function buildProgram(name = "dbx auth", overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const program = addArgs(new Command()
+        .name(name)
+        .description("Authenticate to Databricks with user or machine OAuth")
+        .showHelpAfterError(), AuthCliOptionsSchema);
+    const options = () => parseArgs(program, AuthCliOptionsSchema);
+    program
+        .command("login")
+        .description("Force browser login and return an access token")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            dependencies.writeJson(tokenJson(await auth.token({ login: true })));
+        });
+    });
+    const tokenCommand = addArgs(program.command("token").description("Return a valid access token, logging in when needed"), TokenCommandOptionsSchema);
+    tokenCommand.action(async () => {
+        const tokenOptions = parseArgs(tokenCommand, TokenCommandOptionsSchema);
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            const token = await auth.token({
+                ...(tokenOptions.login ? {} : { login: false }),
+                ...(tokenOptions.forceRefresh ? { refresh: true } : {}),
+            });
+            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")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            dependencies.writeText(auth.profile ?? "ambient");
+        });
+    });
+    program
+        .command("logout")
+        .description("Delete the stored credential for the selected profile")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            await auth.logout();
+        });
+    });
+    program
+        .command("status")
+        .description("Show the resolved authentication client configuration")
+        .action(async () => {
+        await withAuth(options(), dependencies, async ({ auth }) => {
+            dependencies.writeJson(clientInfo(auth));
+        });
+    });
+    return program;
+}
+/** Parse `argv` and run the selected auth operation. */
+export async function runCli(argv) {
+    await buildProgram().parseAsync(argv);
+}
+export { CommanderError };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../../src/auth/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `dbx auth` Commander program for Databricks OAuth.\n *\n * The command delegates profile resolution and token lifecycle to\n * `@dbx-tools/auth`.\n *\n * @module\n */\n\nimport * as databricks from \"@dbx-tools/auth\";\nimport { addArgs, parseArgs } from \"@dbx-tools/cli-args\";\nimport type { DatabricksAuthClientInfo } from \"@dbx-tools/shared-auth/client\";\nimport { Command, CommanderError } from \"commander\";\n\nimport {\n  AuthCliOptionsSchema,\n  databricksAuthOptions,\n  TokenCommandOptionsSchema,\n  type AuthCliOptions,\n} from \"./options.ts\";\n\ninterface AuthContext {\n  auth: databricks.AuthClient;\n  close(): Promise<void>;\n}\n\ninterface AuthCliDependencies {\n  createAuthClient: typeof databricks.client.createAuthClient;\n  writeJson(value: unknown): void;\n  writeText(value: string): void;\n}\n\nconst DEFAULT_DEPENDENCIES: AuthCliDependencies = {\n  createAuthClient: databricks.client.createAuthClient,\n  writeJson: (value) => {\n    process.stdout.write(`${JSON.stringify(value, null, 2)}\\n`);\n  },\n  writeText: (value) => {\n    process.stdout.write(`${value}\\n`);\n  },\n};\n\n/** Open the selected authentication client. */\nasync function openAuth(\n  options: AuthCliOptions,\n  dependencies: AuthCliDependencies,\n): Promise<AuthContext> {\n  return {\n    auth: await dependencies.createAuthClient(databricksAuthOptions(options)),\n    close: async () => {},\n  };\n}\n\n/** Execute an auth action and close resources owned by the command. */\nasync function withAuth(\n  options: AuthCliOptions,\n  dependencies: AuthCliDependencies,\n  action: (context: AuthContext) => Promise<void>,\n): Promise<void> {\n  const context = await openAuth(options, dependencies);\n  try {\n    await action(context);\n  } finally {\n    await context.close();\n  }\n}\n\n/** Shape a generated token record for stable CLI JSON output. */\nfunction tokenJson(token: databricks.AccessToken): Record<string, unknown> {\n  return {\n    access_token: token.accessToken,\n    token_type: token.tokenType,\n    ...(token.expiry ? { expiry: token.expiry } : {}),\n    ...(token.scopes.length ? { scopes: token.scopes } : {}),\n  };\n}\n\n/** Select the serializable identity fields from an authentication client. */\nfunction clientInfo(auth: databricks.AuthClient): DatabricksAuthClientInfo {\n  return {\n    ...(auth.profile ? { profile: auth.profile } : {}),\n    host: auth.host,\n    ...(auth.accountId ? { accountId: auth.accountId } : {}),\n    ...(auth.workspaceId ? { workspaceId: auth.workspaceId } : {}),\n    target: auth.target,\n    authType: auth.authType,\n    principal: auth.principal,\n  };\n}\n\n/** Build the `dbx auth` Commander program without parsing arguments. */\nexport function buildProgram(\n  name = \"dbx auth\",\n  overrides: Partial<AuthCliDependencies> = {},\n): Command {\n  const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };\n  const program = addArgs(\n    new Command()\n      .name(name)\n      .description(\"Authenticate to Databricks with user or machine OAuth\")\n      .showHelpAfterError(),\n    AuthCliOptionsSchema,\n  );\n  const options = (): AuthCliOptions => parseArgs(program, AuthCliOptionsSchema);\n\n  program\n    .command(\"login\")\n    .description(\"Force browser login and return an access token\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeJson(tokenJson(await auth.token({ login: true })));\n      });\n    });\n\n  const tokenCommand = addArgs(\n    program.command(\"token\").description(\"Return a valid access token, logging in when needed\"),\n    TokenCommandOptionsSchema,\n  );\n  tokenCommand.action(async () => {\n    const tokenOptions = parseArgs(tokenCommand, TokenCommandOptionsSchema);\n    await withAuth(options(), dependencies, async ({ auth }) => {\n      const token = await auth.token({\n        ...(tokenOptions.login ? {} : { login: false }),\n        ...(tokenOptions.forceRefresh ? { refresh: true } : {}),\n      });\n      if (tokenOptions.format === \"text\") dependencies.writeText(token.accessToken);\n      else dependencies.writeJson(tokenJson(token));\n    });\n  });\n\n  program\n    .command(\"headers\")\n    .description(\"Return current Databricks authentication headers\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeJson(await auth.headers());\n      });\n    });\n\n  program\n    .command(\"profile\")\n    .description(\"Print the configured or automatically detected profile\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeText(auth.profile ?? \"ambient\");\n      });\n    });\n\n  program\n    .command(\"logout\")\n    .description(\"Delete the stored credential for the selected profile\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        await auth.logout();\n      });\n    });\n\n  program\n    .command(\"status\")\n    .description(\"Show the resolved authentication client configuration\")\n    .action(async () => {\n      await withAuth(options(), dependencies, async ({ auth }) => {\n        dependencies.writeJson(clientInfo(auth));\n      });\n    });\n\n  return program;\n}\n\n/** Parse `argv` and run the selected auth operation. */\nexport async function runCli(argv: string[]): Promise<void> {\n  await buildProgram().parseAsync(argv);\n}\n\nexport { CommanderError };\n"]}

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

@@ -0,0 +1,45 @@
+/**
+ * Databricks auth command-line option schemas and runtime projection.
+ *
+ * @module
+ */
+import { type DatabricksAuthOptions } from "@dbx-tools/auth/config";
+import { z } from "zod";
+export declare const AuthCliOptionsSchema: z.ZodObject<{
+    profile: z.ZodOptional<z.ZodString>;
+    host: z.ZodOptional<z.ZodString>;
+    accountId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    configFile: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    authType: z.ZodOptional<z.ZodEnum<{
+        "databricks-cli": "databricks-cli";
+        "oauth-m2m": "oauth-m2m";
+        pat: "pat";
+        app_obo: "app_obo";
+        app_sp: "app_sp";
+    }>>;
+    scopes: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    target: z.ZodOptional<z.ZodEnum<{
+        workspace: "workspace";
+        account: "account";
+        unified: "unified";
+    }>>;
+    lockTimeoutMs: z.ZodDefault<z.ZodCoercedNumber<number>>;
+    loginTimeoutMs: z.ZodDefault<z.ZodCoercedNumber<number>>;
+    refreshBufferMs: z.ZodDefault<z.ZodCoercedNumber<number>>;
+    preferUserToMachine: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const TokenCommandOptionsSchema: z.ZodObject<{
+    forceRefresh: z.ZodDefault<z.ZodBoolean>;
+    login: z.ZodDefault<z.ZodBoolean>;
+    format: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        text: "text";
+    }>>;
+}, z.core.$strict>;
+export type AuthCliOptions = z.output<typeof AuthCliOptionsSchema>;
+export type TokenCommandOptions = z.output<typeof TokenCommandOptionsSchema>;
+/** Convert flat CLI fields into the Node auth package's nested options. */
+export declare function databricksAuthOptions(options: AuthCliOptions): DatabricksAuthOptions;

package/lib/src/auth/options.js

@@ -0,0 +1,68 @@
+/**
+ * Databricks auth command-line option schemas and runtime projection.
+ *
+ * @module
+ */
+import { AuthOptionsSchema, DatabricksAuthOptionsSchema, } from "@dbx-tools/auth/config";
+import { stringUtils } from "@dbx-tools/shared-core";
+import { z } from "zod";
+export const AuthCliOptionsSchema = z
+    .object({
+    profile: DatabricksAuthOptionsSchema.shape.profile,
+    host: DatabricksAuthOptionsSchema.shape.host,
+    accountId: DatabricksAuthOptionsSchema.shape.accountId,
+    workspaceId: DatabricksAuthOptionsSchema.shape.workspaceId,
+    configFile: DatabricksAuthOptionsSchema.shape.configFile,
+    clientId: DatabricksAuthOptionsSchema.shape.clientId,
+    groupId: DatabricksAuthOptionsSchema.shape.groupId,
+    authType: DatabricksAuthOptionsSchema.shape.authType,
+    scopes: z
+        .preprocess((value) => Array.isArray(value)
+        ? value.flatMap((entry) => stringUtils.parseList(String(entry)))
+        : value, z.array(z.string().trim().min(1)))
+        .default([])
+        .describe("OAuth scopes."),
+    target: DatabricksAuthOptionsSchema.shape.target,
+    lockTimeoutMs: AuthOptionsSchema.shape.lockTimeoutMs,
+    loginTimeoutMs: AuthOptionsSchema.shape.loginTimeoutMs,
+    refreshBufferMs: AuthOptionsSchema.shape.refreshBufferMs,
+    preferUserToMachine: z
+        .boolean()
+        .default(true)
+        .describe("Prefer a matching user profile over selected machine credentials."),
+})
+    .strict()
+    .describe("Options shared by every Databricks auth command.");
+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.");
+/** Convert flat CLI fields into the Node auth package's nested options. */
+export function databricksAuthOptions(options) {
+    return {
+        profile: options.profile,
+        host: options.host,
+        accountId: options.accountId,
+        workspaceId: options.workspaceId,
+        configFile: options.configFile,
+        clientId: options.clientId,
+        groupId: options.groupId,
+        authType: options.authType,
+        scopes: options.scopes.length > 0 ? options.scopes : undefined,
+        target: options.target,
+        auth: {
+            lockTimeoutMs: options.lockTimeoutMs,
+            loginTimeoutMs: options.loginTimeoutMs,
+            refreshBufferMs: options.refreshBufferMs,
+        },
+        preferUserToMachine: options.preferUserToMachine,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/cli.d.ts

@@ -16,5 +16,7 @@ import { Command } from "commander";
 export declare function prepareAndRunProjen(projenArgs: string[], startDir?: string): Promise<void>;
 /** Build the `dbx` commander program (no side effects until parsed). */
 export declare function buildProgram(name?: string): Command;
+/** Build the complete command tree used for generated documentation. */
+export declare function buildDocumentationProgram(name?: string): Promise<Command>;
 /** Parse `argv` (a `process.argv`) and run the matching command. */
 export declare function runCli(argv: string[]): Promise<void>;

package/lib/src/cli.js

@@ -51,8 +51,9 @@ export async function prepareAndRunProjen(projenArgs, startDir) {
 /**
  * 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, name, description, load) {
     program
@@ -60,6 +61,7 @@ function addForwardedCommand(program, name, description, load) {
         .description(description)
         .argument("[args...]", `arguments forwarded to ${name}`)
         .allowUnknownOption()
+        .passThroughOptions()
         .allowExcessArguments()
         .helpOption(false)
         .action(async (args) => {
@@ -72,6 +74,7 @@ export function buildProgram(name = PROGRAM_NAMES[0]) {
     const program = new Command()
         .name(name)
         .description("Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies")
+        .enablePositionalOptions()
         .showHelpAfterError()
         .helpOption("-h, --help", `Show ${name} help`);
     program
@@ -84,12 +87,19 @@ export function buildProgram(name = PROGRAM_NAMES[0]) {
         .action(async (projenArgs) => {
         await prepareAndRunProjen(projenArgs);
     });
-    addForwardedCommand(program, "appkit", "AppKit helpers (env: print the environment an AppKit app resolves)", async () => (await import("@dbx-tools/cli-appkit-env/cli")).buildProgram);
-    addForwardedCommand(program, "auth", "Authenticate to Databricks and manage OAuth tokens", async () => (await import("@dbx-tools/cli-auth/cli")).buildProgram);
-    addForwardedCommand(program, "tunnel", "Run a public portr tunnel with an email-OTP gate", async () => (await import("@dbx-tools/cli-tunnel/cli")).buildProgram);
-    addForwardedCommand(program, "lakebase-proxy", "Run the Node Databricks Lakebase PostgreSQL proxy", async () => (await import("@dbx-tools/cli-lakebase-proxy/cli")).buildProgram);
-    addForwardedCommand(program, "model-gateway", "Run the foreground AppKit Databricks model gateway", async () => (await import("@dbx-tools/cli-model-gateway/cli")).buildProgram);
-    addForwardedCommand(program, "graphiti", "Run Graphiti or manage its current-user desktop service", async () => (await import("@dbx-tools/cli-graphiti/cli")).buildProgram);
+    addForwardedCommand(program, "appkit", "AppKit helpers (env: print the environment an AppKit app resolves)", async () => (await import("./appkit/cli.js")).buildProgram);
+    addForwardedCommand(program, "auth", "Authenticate to Databricks and manage OAuth tokens", async () => (await import("./auth/cli.js")).buildProgram);
+    addForwardedCommand(program, "tunnel", "Run a public portr tunnel with an email-OTP gate", async () => (await import("./tunnel/cli.js")).buildProgram);
+    addForwardedCommand(program, "lakebase-proxy", "Run the Node Databricks Lakebase PostgreSQL proxy", async () => (await import("./lakebase-proxy/cli.js")).buildProgram);
+    addForwardedCommand(program, "model-gateway", "Run the foreground AppKit Databricks model gateway", async () => (await import("./model-gateway/cli.js")).buildProgram);
+    addForwardedCommand(program, "genie", "Run managed Genie Code through a local Databricks model gateway", async () => (await import("./genie-code/cli.js")).buildProgram);
+    addForwardedCommand(program, "graphiti", "Run Graphiti or manage its current-user desktop service", async () => (await import("./graphiti/cli.js")).buildProgram);
+    return program;
+}
+/** Build the complete command tree used for generated documentation. */
+export async function buildDocumentationProgram(name = PROGRAM_NAMES[0]) {
+    const program = buildProgram(name);
+    program.commands.splice(1, program.commands.length - 1, (await import("./appkit/cli.js")).buildProgram("appkit"), (await import("./auth/cli.js")).buildProgram("auth"), (await import("./tunnel/cli.js")).buildProgram("tunnel"), (await import("./lakebase-proxy/cli.js")).buildProgram("lakebase-proxy"), (await import("./model-gateway/cli.js")).buildProgram("model-gateway"), (await import("./genie-code/cli.js")).buildProgram("genie"), (await import("./graphiti/cli.js")).buildProgram("graphiti"));
     return program;
 }
 /**
@@ -104,4 +114,4 @@ function programName(argv) {
 export async function runCli(argv) {
     await buildProgram(programName(argv)).parseAsync(argv);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Commander entry for `dbx` and its `dbx-tools` alias.\n *\n * `dev` bootstraps or repairs a workspace and forwards to projen.\n * `appkit` provides AppKit environment helpers.\n * `auth` manages Databricks OAuth and access tokens.\n * `tunnel` runs a public portr tunnel with passwordless access gating.\n *\n * Feature commands load their sibling packages only when selected and forward\n * their complete argument list, including `--help`.\n *\n * @module\n */\nimport { basename } from \"node:path\";\nimport { Command } from \"commander\";\nimport {\n  bootstrapWorkspace,\n  ensureEngineCurrent,\n  runInitialSynth,\n  seedToolchain,\n} from \"./bootstrap.ts\";\nimport { ensureWorkspaceReady, runBun, runProjen } from \"./bun.ts\";\nimport { findWorkspaceRoot, needsBootstrap, needsToolchain } from \"./root.ts\";\n\n/** Commands the bin exposes, and the names help is rendered under. */\nconst PROGRAM_NAMES = [\"dbx\", \"dbx-tools\"] as const;\n\n/**\n * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.\n *\n * Three cases, in order:\n *   - no `.projenrc.ts` at all -> full bootstrap (scaffold + install + synth),\n *     which already runs the initial synth; nothing more to forward.\n *   - a `.projenrc.ts` but the engine/toolchain isn't installed (e.g. a freshly\n *     copied project whose generated files + manifests are gitignored) -> seed\n *     the toolchain, then run the INITIAL synth directly (the projen tasks the\n *     args would name, like `sync`, don't exist until `.projenrc.ts` has run\n *     once), and install. Don't forward `projenArgs` - the synth is the work.\n *   - otherwise (established workspace) -> ensure deps, bring the engine up to\n *     this CLI's version, then forward to projen.\n */\nexport async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Promise<void> {\n  const root = await findWorkspaceRoot(startDir);\n  if (needsBootstrap(root)) {\n    bootstrapWorkspace(root);\n    return;\n  }\n  if (needsToolchain(root)) {\n    seedToolchain(root);\n    runInitialSynth(root);\n    runBun([\"install\"], root);\n    return;\n  }\n  ensureWorkspaceReady(root);\n  ensureEngineCurrent(root);\n  runProjen(projenArgs, root);\n}\n\n/**\n * Mount `name` as a command that captures every following token verbatim and\n * hands it to the program `load()` resolves. `helpOption(false)` is what lets\n * `--help` through to the child instead of being answered here, and the child\n * program owns its own flags, so this wrapper never has to restate them.\n */\nfunction addForwardedCommand(\n  program: Command,\n  name: string,\n  description: string,\n  load: () => Promise<(name: string) => Command>,\n): void {\n  program\n    .command(name)\n    .description(description)\n    .argument(\"[args...]\", `arguments forwarded to ${name}`)\n    .allowUnknownOption()\n    .allowExcessArguments()\n    .helpOption(false)\n    .action(async (args: string[]) => {\n      const buildProgram = await load();\n      await buildProgram(`${program.name()} ${name}`).parseAsync(args, { from: \"user\" });\n    });\n}\n\n/** Build the `dbx` commander program (no side effects until parsed). */\nexport function buildProgram(name: string = PROGRAM_NAMES[0]): Command {\n  const program = new Command()\n    .name(name)\n    .description(\n      \"Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies\",\n    )\n    .showHelpAfterError()\n    .helpOption(\"-h, --help\", `Show ${name} help`);\n\n  program\n    .command(\"dev\")\n    .description(\"Bootstrap or repair a dbx-tools workspace, then forward to projen\")\n    .argument(\"[projenArgs...]\", \"projen task and arguments (e.g. sync --watch)\")\n    .allowUnknownOption()\n    .allowExcessArguments()\n    .helpOption(false)\n    .action(async (projenArgs: string[]) => {\n      await prepareAndRunProjen(projenArgs);\n    });\n\n  addForwardedCommand(\n    program,\n    \"appkit\",\n    \"AppKit helpers (env: print the environment an AppKit app resolves)\",\n    async () => (await import(\"@dbx-tools/cli-appkit-env/cli\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"auth\",\n    \"Authenticate to Databricks and manage OAuth tokens\",\n    async () => (await import(\"@dbx-tools/cli-auth/cli\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"tunnel\",\n    \"Run a public portr tunnel with an email-OTP gate\",\n    async () => (await import(\"@dbx-tools/cli-tunnel/cli\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"lakebase-proxy\",\n    \"Run the Node Databricks Lakebase PostgreSQL proxy\",\n    async () => (await import(\"@dbx-tools/cli-lakebase-proxy/cli\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"model-gateway\",\n    \"Run the foreground AppKit Databricks model gateway\",\n    async () => (await import(\"@dbx-tools/cli-model-gateway/cli\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"graphiti\",\n    \"Run Graphiti or manage its current-user desktop service\",\n    async () => (await import(\"@dbx-tools/cli-graphiti/cli\")).buildProgram,\n  );\n\n  return program;\n}\n\n/**\n * Program name for help output: whichever bin the user actually typed, so\n * `dbx-tools --help` doesn't document itself as `dbx`. Falls back to `dbx`.\n */\nfunction programName(argv: string[]): string {\n  const invoked = argv[1] ? basename(argv[1]).replace(/\\.(?:[cm]?[jt]s)$/, \"\") : undefined;\n  return PROGRAM_NAMES.find((candidate) => candidate === invoked) ?? PROGRAM_NAMES[0];\n}\n\n/** Parse `argv` (a `process.argv`) and run the matching command. */\nexport async function runCli(argv: string[]): Promise<void> {\n  await buildProgram(programName(argv)).parseAsync(argv);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Commander entry for `dbx` and its `dbx-tools` alias.\n *\n * `dev` bootstraps or repairs a workspace and forwards to projen.\n * `appkit` provides AppKit environment helpers.\n * `auth` manages Databricks OAuth and access tokens.\n * `tunnel` runs a public portr tunnel with passwordless access gating.\n *\n * Feature commands load their sibling packages only when selected and forward\n * their complete argument list, including `--help`.\n *\n * @module\n */\nimport { basename } from \"node:path\";\nimport { Command } from \"commander\";\nimport {\n  bootstrapWorkspace,\n  ensureEngineCurrent,\n  runInitialSynth,\n  seedToolchain,\n} from \"./bootstrap.ts\";\nimport { ensureWorkspaceReady, runBun, runProjen } from \"./bun.ts\";\nimport { findWorkspaceRoot, needsBootstrap, needsToolchain } from \"./root.ts\";\n\n/** Commands the bin exposes, and the names help is rendered under. */\nconst PROGRAM_NAMES = [\"dbx\", \"dbx-tools\"] as const;\n\n/**\n * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.\n *\n * Three cases, in order:\n *   - no `.projenrc.ts` at all -> full bootstrap (scaffold + install + synth),\n *     which already runs the initial synth; nothing more to forward.\n *   - a `.projenrc.ts` but the engine/toolchain isn't installed (e.g. a freshly\n *     copied project whose generated files + manifests are gitignored) -> seed\n *     the toolchain, then run the INITIAL synth directly (the projen tasks the\n *     args would name, like `sync`, don't exist until `.projenrc.ts` has run\n *     once), and install. Don't forward `projenArgs` - the synth is the work.\n *   - otherwise (established workspace) -> ensure deps, bring the engine up to\n *     this CLI's version, then forward to projen.\n */\nexport async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Promise<void> {\n  const root = await findWorkspaceRoot(startDir);\n  if (needsBootstrap(root)) {\n    bootstrapWorkspace(root);\n    return;\n  }\n  if (needsToolchain(root)) {\n    seedToolchain(root);\n    runInitialSynth(root);\n    runBun([\"install\"], root);\n    return;\n  }\n  ensureWorkspaceReady(root);\n  ensureEngineCurrent(root);\n  runProjen(projenArgs, root);\n}\n\n/**\n * Mount `name` as a command that captures every following token verbatim and\n * hands it to the program `load()` resolves. `helpOption(false)` is what lets\n * `--help` through to the child instead of being answered here, and\n * `passThroughOptions()` keeps unknown flags in that token list so the child\n * program owns them.\n */\nfunction addForwardedCommand(\n  program: Command,\n  name: string,\n  description: string,\n  load: () => Promise<(name: string) => Command>,\n): void {\n  program\n    .command(name)\n    .description(description)\n    .argument(\"[args...]\", `arguments forwarded to ${name}`)\n    .allowUnknownOption()\n    .passThroughOptions()\n    .allowExcessArguments()\n    .helpOption(false)\n    .action(async (args: string[]) => {\n      const buildProgram = await load();\n      await buildProgram(`${program.name()} ${name}`).parseAsync(args, { from: \"user\" });\n    });\n}\n\n/** Build the `dbx` commander program (no side effects until parsed). */\nexport function buildProgram(name: string = PROGRAM_NAMES[0]): Command {\n  const program = new Command()\n    .name(name)\n    .description(\n      \"Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies\",\n    )\n    .enablePositionalOptions()\n    .showHelpAfterError()\n    .helpOption(\"-h, --help\", `Show ${name} help`);\n\n  program\n    .command(\"dev\")\n    .description(\"Bootstrap or repair a dbx-tools workspace, then forward to projen\")\n    .argument(\"[projenArgs...]\", \"projen task and arguments (e.g. sync --watch)\")\n    .allowUnknownOption()\n    .allowExcessArguments()\n    .helpOption(false)\n    .action(async (projenArgs: string[]) => {\n      await prepareAndRunProjen(projenArgs);\n    });\n\n  addForwardedCommand(\n    program,\n    \"appkit\",\n    \"AppKit helpers (env: print the environment an AppKit app resolves)\",\n    async () => (await import(\"./appkit/cli.ts\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"auth\",\n    \"Authenticate to Databricks and manage OAuth tokens\",\n    async () => (await import(\"./auth/cli.ts\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"tunnel\",\n    \"Run a public portr tunnel with an email-OTP gate\",\n    async () => (await import(\"./tunnel/cli.ts\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"lakebase-proxy\",\n    \"Run the Node Databricks Lakebase PostgreSQL proxy\",\n    async () => (await import(\"./lakebase-proxy/cli.ts\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"model-gateway\",\n    \"Run the foreground AppKit Databricks model gateway\",\n    async () => (await import(\"./model-gateway/cli.ts\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"genie\",\n    \"Run managed Genie Code through a local Databricks model gateway\",\n    async () => (await import(\"./genie-code/cli.ts\")).buildProgram,\n  );\n\n  addForwardedCommand(\n    program,\n    \"graphiti\",\n    \"Run Graphiti or manage its current-user desktop service\",\n    async () => (await import(\"./graphiti/cli.ts\")).buildProgram,\n  );\n\n  return program;\n}\n\n/** Build the complete command tree used for generated documentation. */\nexport async function buildDocumentationProgram(name: string = PROGRAM_NAMES[0]): Promise<Command> {\n  const program = buildProgram(name);\n  (program.commands as Command[]).splice(\n    1,\n    program.commands.length - 1,\n    (await import(\"./appkit/cli.ts\")).buildProgram(\"appkit\"),\n    (await import(\"./auth/cli.ts\")).buildProgram(\"auth\"),\n    (await import(\"./tunnel/cli.ts\")).buildProgram(\"tunnel\"),\n    (await import(\"./lakebase-proxy/cli.ts\")).buildProgram(\"lakebase-proxy\"),\n    (await import(\"./model-gateway/cli.ts\")).buildProgram(\"model-gateway\"),\n    (await import(\"./genie-code/cli.ts\")).buildProgram(\"genie\"),\n    (await import(\"./graphiti/cli.ts\")).buildProgram(\"graphiti\"),\n  );\n  return program;\n}\n\n/**\n * Program name for help output: whichever bin the user actually typed, so\n * `dbx-tools --help` doesn't document itself as `dbx`. Falls back to `dbx`.\n */\nfunction programName(argv: string[]): string {\n  const invoked = argv[1] ? basename(argv[1]).replace(/\\.(?:[cm]?[jt]s)$/, \"\") : undefined;\n  return PROGRAM_NAMES.find((candidate) => candidate === invoked) ?? PROGRAM_NAMES[0];\n}\n\n/** Parse `argv` (a `process.argv`) and run the matching command. */\nexport async function runCli(argv: string[]): Promise<void> {\n  await buildProgram(programName(argv)).parseAsync(argv);\n}\n"]}

package/lib/src/genie-code/cli.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Managed `dbx genie` command.
+ *
+ * @module
+ */
+import { Command } from "commander";
+import { type GenieCodeCliOptions } from "./options.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>;
+}
+/** Build the managed Genie Code command without executing it. */
+export declare function buildProgram(name?: string, dependencies?: GenieCodeCliDependencies): Command;
+/** Parse argv and run managed Genie Code. */
+export declare function runCli(argv: string[]): Promise<void>;

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

@@ -0,0 +1,36 @@
+/**
+ * Managed `dbx genie` command.
+ *
+ * @module
+ */
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { Command } from "commander";
+import { GenieCodeCliOptionsSchema } from "./options.js";
+import { runGenieCode } from "./runtime.js";
+const DEFAULT_DEPENDENCIES = {
+    run: runGenieCode,
+};
+/** Build the managed Genie Code command without executing it. */
+export function buildProgram(name = "dbx genie", dependencies = DEFAULT_DEPENDENCIES) {
+    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) => {
+        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) {
+    await buildProgram().parseAsync(argv);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/genie-code/config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generate one persistent Genie Code home per exact profile-model pairing.
+ *
+ * @module
+ */
+import { type GenieCodeBaseConfig, type GenieCodeConfig, type GenieCodeProviderOverlay } from "@dbx-tools/shared-genie-code/config";
+/** Provider identifier written to the base and invocation overlay configurations. */
+export declare const GENIE_CODE_GATEWAY_PROVIDER = "dbx_tools_model_gateway";
+/** Inputs used to update a persistent home and create one invocation overlay. */
+export interface WriteGenieCodeConfigOptions {
+    bearerToken: string;
+    gatewayBaseUrl: string;
+    homeDirectory?: string;
+    model: string;
+    profile: string;
+    projectDirectory: string;
+}
+/** Stable persistent home for one exact profile-model pairing. */
+export interface GenieCodePairingHome {
+    configPath: string;
+    home: string;
+    name: string;
+}
+/** Persistent pairing home and invocation-specific provider overlay. */
+export interface GenieCodeHome extends GenieCodePairingHome {
+    overlayName: string;
+    overlayPath: string;
+}
+/** Derive the stable home for one exact profile-model pair. */
+export declare function genieCodeHome(profile: string, model: string, homeDirectory?: string): GenieCodePairingHome;
+/** Render the persistent profile-model configuration. */
+export declare function genieCodeBaseConfig(options: WriteGenieCodeConfigOptions, existingProjects?: Readonly<Record<string, unknown>>): GenieCodeBaseConfig;
+/** Render the invocation-specific guarded provider configuration. */
+export declare function genieCodeProviderOverlay(options: WriteGenieCodeConfigOptions): GenieCodeProviderOverlay;
+/** Render the merged configuration used by validation and tests. */
+export declare function genieCodeConfig(options: WriteGenieCodeConfigOptions): GenieCodeConfig;
+/** Update the persistent base config and write one private invocation overlay. */
+export declare function writeGenieCodeConfig(options: WriteGenieCodeConfigOptions): Promise<GenieCodeHome>;