@dbx-tools/cli 0.9.37 → 0.9.40

package/README.md

@@ -1,137 +1,181 @@
 # @dbx-tools/cli
 
-The `dbx` CLI for workspace lifecycle, AppKit env, Databricks OAuth, and a
-gated public tunnel.
-
-Available commands:
-
-| Command              | What it does                                                             |
-| -------------------- | ------------------------------------------------------------------------ |
-| `dbx dev`            | Bootstrap or repair a dbx-tools workspace, then forward to projen.       |
-| `dbx appkit env`     | Print the environment an AppKit app resolves, as eval-able shell output. |
-| `dbx auth`           | Generate U2M or M2M OAuth tokens with secure credential storage.         |
-| `dbx tunnel`         | Front any command with a public portr tunnel and an email-OTP gate.      |
-| `dbx lakebase-proxy` | Run the loopback PostgreSQL proxy for Databricks Lakebase.               |
-
-Key features:
-
-- Bootstrap path that scaffolds bun/projen into an empty or partially-set-up
-  folder, including the initial install and synth.
-- Toolchain repair for a cloned repo whose generated files and `node_modules`
-  are gitignored.
-- Transparent forwarding to projen for any task once the workspace is ready.
-- Custom-registry forcing that survives bun's own resolution rules, applied only
-  when the effective registry is not npmjs.
-- Importable CLI/root/bun helpers for tests and thin wrapper commands.
-
-Every feature group lives in its own package:
-[`@dbx-tools/cli-appkit-env`](../appkit-env),
-[`@dbx-tools/cli-auth`](../auth), and
-[`@dbx-tools/cli-tunnel`](../tunnel). Each package is imported LAZILY, only once
-its name is matched, so `dbx dev` never pays to load AppKit, OAuth, SMTP, or
-X.509 code. Run
-`dbx <group> --help` for a group's own flags; each forwards `--help` to the child
-program rather than answering it at the root.
-
-The Lakebase proxy command runs the pure Node implementation.
+Use one CLI to authenticate with Databricks, connect local PostgreSQL tools to
+Lakebase, serve Databricks models to coding agents, run graph memory, and share
+applications through a gated public URL.
 
-## Bootstrap A Workspace
+## Install And Connect
 
 ```sh
-dbx dev sync
+bun add --global @dbx-tools/cli
+dbx auth login --profile MY-PROFILE
+dbx auth status --profile MY-PROFILE
 ```
 
-In an empty folder this creates the minimum bun/projen structure needed for
-`@dbx-tools/projen`, installs the toolchain, and runs the first synth. In a
-freshly cloned repo it seeds the missing toolchain and synthesizes. This is the
-case projen cannot handle on its own, because there are no tasks to run yet.
+`dbx-tools` is an alias for `dbx`. Choose a configured Databricks profile for
+workspace commands; the examples use `MY-PROFILE` as a placeholder.
+
+## Serve Models To Local Tools
+
+```sh
+dbx model-gateway --profile MY-PROFILE --port 4000
+```
 
-The three cases `dbx dev` dispatches on, in order:
+Point an OpenAI-compatible client at `http://127.0.0.1:4000/v1`. See
+[model gateway](../model-gateway#command-reference) for all options and desktop
+service commands.
 
-| Workspace state                           | What happens                                                                                                                                          |
-| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
-| No `.projenrc.ts`                         | Full bootstrap: scaffold, install, initial synth.                                                                                                     |
-| `.projenrc.ts` but no installed toolchain | Seed the toolchain, run the initial synth, then install. Task args are not forwarded, because the tasks they name do not exist until the first synth. |
-| Established workspace                     | Ensure deps, bring the engine up to this CLI's version, forward the args to projen.                                                                   |
+## Connect To Lakebase
 
-Everything after `dev` is forwarded verbatim, flags included - `dbx dev sync
---watch` runs the `sync` task with `--watch`. `dev` is an explicit subcommand
-rather than the bare root action so a projen task name can never collide with a
-sibling command group.
+```sh
+dbx lakebase-proxy --profile MY-PROFILE --port 5432
+```
 
-## After Bootstrap, Use The Projen Tasks
+Connect your PostgreSQL client to the loopback listener. See
+[Lakebase proxy](../lakebase-proxy#command-reference) for target selection,
+connection URLs, and service commands.
 
-The engine registers its commands as projen tasks on the workspace root, so run
-them directly instead of going through this CLI:
+## Add Memory Or Share An App
 
 ```sh
-bun run sync             # one-shot full synth
-bun run sync -- --watch  # projenrc + barrels + openapi watchers
-bun run barrels          # rebuild every package-root index.ts barrel
-bun run openapi          # generate the openapi packages from tsoa controllers
-bun run clean            # remove generated (read-only) files; -y to skip the picker
+dbx graphiti --profile MY-PROFILE
+dbx tunnel --allow example.com -- bun src/server.ts
 ```
 
-`dbx dev <task>` still works and forwards to the same projen task, but the
-`bun run` form is the documented one for an established workspace.
+[Graphiti](../graphiti#command-reference) provides graph memory for agents.
+[Tunnel](../tunnel#command-reference) adds a public URL with passwordless access
+to an existing process. Each guide includes setup requirements and a generated
+command reference.
 
-## Resolve AppKit Env
+## Export AppKit Configuration
 
 ```sh
 eval "$(dbx appkit env --quiet)"
 ```
 
-See [`@dbx-tools/cli-appkit-env`](../appkit-env) for output formats and
-configuration behavior.
+Use the resolved AppKit environment before starting another process. See
+[AppKit environment](../appkit-env#command-reference) for JSON and Windows
+output, and [authentication](../auth#command-reference) for token commands.
 
-## Authenticate With Databricks User OAuth
+## Bootstrap A Workspace
 
 ```sh
-dbx auth login --profile my-workspace
-dbx auth token --profile my-workspace
-dbx auth status --profile my-workspace
+dbx dev sync
 ```
 
-The auth command uses `@dbx-tools/auth` for preferred U2M browser OAuth, M2M
-client credentials, refresh, locking, and file or memory
-storage. See [`@dbx-tools/cli-auth`](../auth) for the complete command and
-option surface.
+In an empty folder, this creates and initializes a Bun/Projen workspace. In a
+cloned workspace, it installs missing tooling before running the requested task.
+Arguments after `dev` are forwarded to Projen.
 
-## Put A Gated Public URL In Front Of A Command
+Once the workspace is initialized, use its tasks directly:
 
 ```sh
-dbx tunnel status --allow databricks.com
-dbx tunnel --allow databricks.com -- bun src/server.ts
+bun run sync
+bun run sync -- --watch
+bun run barrels
+bun run openapi
+```
+
+See [`@dbx-tools/projen`](../../../../projen) for workspace configuration and
+generation. The command reference below lists the top-level groups; each linked
+package guide documents that group's complete options and subcommands.
+
+<!-- cli-reference:start -->
+
+## Command Reference
+
+### `dbx`
+
+```text
+Usage: dbx [command]
+
+Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies
+
+Commands:
+  dev [projenArgs...]       Bootstrap or repair a dbx-tools workspace, then forward to projen
+  appkit [args...]          AppKit helpers (env: print the environment an AppKit app resolves)
+  auth [args...]            Authenticate to Databricks and manage OAuth tokens
+  tunnel [args...]          Run a public portr tunnel with an email-OTP gate
+  lakebase-proxy [args...]  Run the Node Databricks Lakebase PostgreSQL proxy
+  model-gateway [args...]   Run the foreground AppKit Databricks model gateway
+  graphiti [args...]        Run Graphiti or manage its current-user desktop service
+```
+
+### `dbx dev`
+
+```text
+Usage: dbx dev [projenArgs...]
+
+Bootstrap or repair a dbx-tools workspace, then forward to projen
+
+Arguments:
+  projenArgs  projen task and arguments (e.g. sync --watch)
 ```
 
-`dbx tunnel` claims the public port, moves the wrapped command to a private
-loopback port, and reverse-proxies between them so an email one-time-code gate
-sits in front of traffic the command never has to know about. The command does
-not have to be a Node server - anything that honors `PORT` /
-`DATABRICKS_APP_PORT` works. An AppKit app should prefer the in-process plugin
-path instead; see [`@dbx-tools/cli-tunnel`](../tunnel) for that comparison, the
-full flag table, and the request flow.
+### `dbx appkit`
 
-## Use The CLI Internals
+```text
+Usage: dbx appkit [args...]
 
-```ts
-import { cli, root, bun } from "@dbx-tools/cli";
+AppKit helpers (env: print the environment an AppKit app resolves)
 
-await cli.prepareAndRunProjen(["sync"]);
-const workspaceRoot = await root.findWorkspaceRoot();
-bun.runProjen(["barrels"], workspaceRoot);
+Arguments:
+  args  arguments forwarded to appkit
 ```
 
-Importing internals is mainly useful for tests or wrapper scripts; most users
-should run the `dbx` bin.
+### `dbx auth`
 
-## Modules
+```text
+Usage: dbx auth [args...]
 
-- `cli` - the root commander program (`buildProgram()`, `runCli()`) and the
-  `dev` implementation `prepareAndRunProjen()`.
-- `bootstrap` - empty-workspace bootstrap, toolchain seeding, and the initial synth.
-- `root` - workspace-root detection and bootstrap/install checks.
-- `bun` - bun discovery, workspace install, registry forcing, and projen delegation.
+Authenticate to Databricks and manage OAuth tokens
+
+Arguments:
+  args  arguments forwarded to auth
+```
+
+### `dbx tunnel`
+
+```text
+Usage: dbx tunnel [args...]
+
+Run a public portr tunnel with an email-OTP gate
+
+Arguments:
+  args  arguments forwarded to tunnel
+```
+
+### `dbx lakebase-proxy`
+
+```text
+Usage: dbx lakebase-proxy [args...]
+
+Run the Node Databricks Lakebase PostgreSQL proxy
+
+Arguments:
+  args  arguments forwarded to lakebase-proxy
+```
+
+### `dbx model-gateway`
+
+```text
+Usage: dbx model-gateway [args...]
+
+Run the foreground AppKit Databricks model gateway
+
+Arguments:
+  args  arguments forwarded to model-gateway
+```
+
+### `dbx graphiti`
+
+```text
+Usage: dbx graphiti [args...]
+
+Run Graphiti or manage its current-user desktop service
+
+Arguments:
+  args  arguments forwarded to graphiti
+```
 
-The reusable project classes and generators live in
-[`@dbx-tools/projen`](../../../../projen).
+<!-- cli-reference:end -->

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export const PACKAGE_VERSION = "0.9.37";
+export const PACKAGE_VERSION = "0.9.40";
 export * as bootstrap from "./src/bootstrap.ts";
 export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export declare const PACKAGE_VERSION = "0.9.37";
+export declare const PACKAGE_VERSION = "0.9.40";
 export * as bootstrap from "./src/bootstrap.ts";
 export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";

package/lib/index.js

@@ -2,11 +2,11 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export const PACKAGE_VERSION = "0.9.37";
+export const PACKAGE_VERSION = "0.9.40";
 export * as bootstrap from "./src/bootstrap.js";
 export * as bun from "./src/bun.js";
 export * as cli from "./src/cli.js";
 export * as root from "./src/root.js";
 export { resolveBunArgv } from "./src/bun.js";
 export { workspaceRoot } from "./src/root.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxnQkFBZ0IsQ0FBQztBQUNuRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUM5QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9jbGlcIjtcbmV4cG9ydCBjb25zdCBQQUNLQUdFX1ZFUlNJT04gPSBcIjAuOS4zN1wiO1xuZXhwb3J0ICogYXMgYm9vdHN0cmFwIGZyb20gXCIuL3NyYy9ib290c3RyYXAudHNcIjtcbmV4cG9ydCAqIGFzIGJ1biBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgKiBhcyBjbGkgZnJvbSBcIi4vc3JjL2NsaS50c1wiO1xuZXhwb3J0ICogYXMgcm9vdCBmcm9tIFwiLi9zcmMvcm9vdC50c1wiO1xuZXhwb3J0IHsgcmVzb2x2ZUJ1bkFyZ3YgfSBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgeyB3b3Jrc3BhY2VSb290IH0gZnJvbSBcIi4vc3JjL3Jvb3QudHNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxnQkFBZ0IsQ0FBQztBQUNuRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxTQUFTLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUM5QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9jbGlcIjtcbmV4cG9ydCBjb25zdCBQQUNLQUdFX1ZFUlNJT04gPSBcIjAuOS40MFwiO1xuZXhwb3J0ICogYXMgYm9vdHN0cmFwIGZyb20gXCIuL3NyYy9ib290c3RyYXAudHNcIjtcbmV4cG9ydCAqIGFzIGJ1biBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgKiBhcyBjbGkgZnJvbSBcIi4vc3JjL2NsaS50c1wiO1xuZXhwb3J0ICogYXMgcm9vdCBmcm9tIFwiLi9zcmMvcm9vdC50c1wiO1xuZXhwb3J0IHsgcmVzb2x2ZUJ1bkFyZ3YgfSBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgeyB3b3Jrc3BhY2VSb290IH0gZnJvbSBcIi4vc3JjL3Jvb3QudHNcIjtcbiJdfQ==

package/lib/src/cli.js

@@ -89,6 +89,7 @@ export function buildProgram(name = PROGRAM_NAMES[0]) {
     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);
     return program;
 }
 /**
@@ -103,4 +104,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  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":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAE9E,sEAAsE;AACtE,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,WAAW,CAAU,CAAC;AAEpD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,UAAoB,EAAE,QAAiB;IAC/E,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAC/C,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,kBAAkB,CAAC,IAAI,CAAC,CAAC;QACzB,OAAO;IACT,CAAC;IACD,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;QACzB,aAAa,CAAC,IAAI,CAAC,CAAC;QACpB,eAAe,CAAC,IAAI,CAAC,CAAC;QACtB,MAAM,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,CAAC;QAC1B,OAAO;IACT,CAAC;IACD,oBAAoB,CAAC,IAAI,CAAC,CAAC;IAC3B,mBAAmB,CAAC,IAAI,CAAC,CAAC;IAC1B,SAAS,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAC1B,OAAgB,EAChB,IAAY,EACZ,WAAmB,EACnB,IAA8C;IAE9C,OAAO;SACJ,OAAO,CAAC,IAAI,CAAC;SACb,WAAW,CAAC,WAAW,CAAC;SACxB,QAAQ,CAAC,WAAW,EAAE,0BAA0B,IAAI,EAAE,CAAC;SACvD,kBAAkB,EAAE;SACpB,oBAAoB,EAAE;SACtB,UAAU,CAAC,KAAK,CAAC;SACjB,MAAM,CAAC,KAAK,EAAE,IAAc,EAAE,EAAE;QAC/B,MAAM,YAAY,GAAG,MAAM,IAAI,EAAE,CAAC;QAClC,MAAM,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IACrF,CAAC,CAAC,CAAC;AACP,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,YAAY,CAAC,OAAe,aAAa,CAAC,CAAC,CAAC;IAC1D,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE;SAC1B,IAAI,CAAC,IAAI,CAAC;SACV,WAAW,CACV,+FAA+F,CAChG;SACA,kBAAkB,EAAE;SACpB,UAAU,CAAC,YAAY,EAAE,QAAQ,IAAI,OAAO,CAAC,CAAC;IAEjD,OAAO;SACJ,OAAO,CAAC,KAAK,CAAC;SACd,WAAW,CAAC,mEAAmE,CAAC;SAChF,QAAQ,CAAC,iBAAiB,EAAE,+CAA+C,CAAC;SAC5E,kBAAkB,EAAE;SACpB,oBAAoB,EAAE;SACtB,UAAU,CAAC,KAAK,CAAC;SACjB,MAAM,CAAC,KAAK,EAAE,UAAoB,EAAE,EAAE;QACrC,MAAM,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEL,mBAAmB,CACjB,OAAO,EACP,QAAQ,EACR,oEAAoE,EACpE,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,+BAA+B,CAAC,CAAC,CAAC,YAAY,CACzE,CAAC;IAEF,mBAAmB,CACjB,OAAO,EACP,MAAM,EACN,oDAAoD,EACpD,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,yBAAyB,CAAC,CAAC,CAAC,YAAY,CACnE,CAAC;IAEF,mBAAmB,CACjB,OAAO,EACP,QAAQ,EACR,kDAAkD,EAClD,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,2BAA2B,CAAC,CAAC,CAAC,YAAY,CACrE,CAAC;IAEF,mBAAmB,CACjB,OAAO,EACP,gBAAgB,EAChB,mDAAmD,EACnD,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,mCAAmC,CAAC,CAAC,CAAC,YAAY,CAC7E,CAAC;IAEF,mBAAmB,CACjB,OAAO,EACP,eAAe,EACf,oDAAoD,EACpD,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,kCAAkC,CAAC,CAAC,CAAC,YAAY,CAC5E,CAAC;IAEF,mBAAmB,CACjB,OAAO,EACP,UAAU,EACV,yDAAyD,EACzD,KAAK,IAAI,EAAE,CAAC,CAAC,MAAM,MAAM,CAAC,6BAA6B,CAAC,CAAC,CAAC,YAAY,CACvE,CAAC;IAEF,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,SAAS,WAAW,CAAC,IAAc;IACjC,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,mBAAmB,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IACzF,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,KAAK,OAAO,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;AACtF,CAAC;AAED,oEAAoE;AACpE,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,IAAc;IACzC,MAAM,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC","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"]}

package/package.json

@@ -28,13 +28,14 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/cli-appkit-env": "^0.9.37",
-    "@dbx-tools/cli-auth": "^0.9.37",
-    "@dbx-tools/cli-lakebase-proxy": "^0.9.37",
-    "@dbx-tools/cli-model-gateway": "^0.9.37",
-    "@dbx-tools/cli-tunnel": "^0.9.37",
-    "@dbx-tools/core": "^0.9.37",
-    "@dbx-tools/shared-core": "^0.9.37",
+    "@dbx-tools/cli-appkit-env": "^0.9.40",
+    "@dbx-tools/cli-auth": "^0.9.40",
+    "@dbx-tools/cli-graphiti": "^0.9.40",
+    "@dbx-tools/cli-lakebase-proxy": "^0.9.40",
+    "@dbx-tools/cli-model-gateway": "^0.9.40",
+    "@dbx-tools/cli-tunnel": "^0.9.40",
+    "@dbx-tools/core": "^0.9.40",
+    "@dbx-tools/shared-core": "^0.9.40",
     "commander": "^15.0.0"
   },
   "main": "./lib/index.js",
@@ -71,7 +72,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.37",
+  "version": "0.9.40",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [

package/src/cli.ts

@@ -137,6 +137,13 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     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,
+  );
+
   return program;
 }