@dbx-tools/cli 0.9.54 → 0.9.60

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

@@ -0,0 +1,41 @@
+/**
+ * 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>;
+}, 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,64 @@
+/**
+ * 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."),
+})
+    .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

@@ -84,12 +84,18 @@ 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, "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("./graphiti/cli.js")).buildProgram("graphiti"));
     return program;
 }
 /**
@@ -104,4 +110,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 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(\"./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    \"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(\"./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/graphiti/cli.d.ts

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

package/lib/src/graphiti/cli.js

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

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

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

package/lib/src/graphiti/options.js

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

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

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

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

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

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

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

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

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

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

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

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

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