@dbx-tools/cli 0.6.75 → 0.6.77

package/README.md

@@ -1,16 +1,20 @@
 # @dbx-tools/cli
 
-Bootstrap CLI for the dbx-tools projen workspace engine.
+The single `dbx` CLI: workspace lifecycle, Model Serving proxy, and AppKit env.
 
-Run the `dbx-tools` command (aliased `dbxt`) to turn a folder that has no
-`.projenrc.ts` or toolchain yet into a working dbx-tools workspace. Once that
-workspace exists, everything else is a projen task you run with
-`bun run <task>` - the CLI only forwards to projen from that point on. Import
-the package modules when custom tooling needs the same root detection, bun
-delegation, or CLI program behavior.
+This package installs one command, `dbx` (aliased `dbx-tools`), with three
+groups:
+
+| Command           | What it does                                                             |
+| ----------------- | ------------------------------------------------------------------------ |
+| `dbx dev`         | Bootstrap or repair a dbx-tools workspace, then forward to projen.       |
+| `dbx model-proxy` | Local OpenAI-compatible proxy in front of Databricks Model Serving.      |
+| `dbx appkit env`  | Print the environment an AppKit app resolves, as eval-able shell output. |
 
 Key features:
 
+- One installed command for every dbx-tools CLI surface, so there is a single
+  thing to install and a single `--help` to discover.
 - 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`
@@ -20,10 +24,17 @@ Key features:
   when the effective registry is not npmjs.
 - Importable CLI/root/bun helpers for tests and thin wrapper commands.
 
+`model-proxy` and `appkit` live in
+[`@dbx-tools/cli-model-proxy`](../model-proxy) and
+[`@dbx-tools/cli-appkit-env`](../appkit-env) and are imported LAZILY, only once
+their name is matched - so `dbx dev` never pays to load the Databricks SDK or
+AppKit. Run `dbx <group> --help` for a group's own flags; each forwards `--help`
+to the child program rather than answering it at the root.
+
 ## Bootstrap A Workspace
 
 ```sh
-dbx-tools sync
+dbx dev sync
 ```
 
 In an empty folder this creates the minimum bun/projen structure needed for
@@ -31,7 +42,7 @@ In an empty folder this creates the minimum bun/projen structure needed for
 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.
 
-The three cases the bin dispatches on, in order:
+The three cases `dbx dev` dispatches on, in order:
 
 | Workspace state                           | What happens                                                                                                                                          |
 | ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -39,6 +50,11 @@ The three cases the bin dispatches on, in order:
 | `.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.                                                                   |
 
+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.
+
 ## After Bootstrap, Use The Projen Tasks
 
 The engine registers its commands as projen tasks on the workspace root, so run
@@ -52,25 +68,37 @@ bun run openapi          # generate the openapi packages from tsoa controllers
 bun run clean            # remove generated (read-only) files; -y to skip the picker
 ```
 
-`dbx-tools <task>` still works and forwards to the same projen task, but the
+`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.
 
+## Proxy Model Serving And Resolve AppKit Env
+
+```sh
+dbx model-proxy --profile my-workspace --port 4000
+eval "$(dbx appkit env --quiet)"
+```
+
+See [`@dbx-tools/cli-model-proxy`](../model-proxy) and
+[`@dbx-tools/cli-appkit-env`](../appkit-env) for the full flag surface, auth
+resolution, and output formats.
+
 ## Use The CLI Internals
 
 ```ts
 import { cli, root, bun } from "@dbx-tools/cli";
 
-await cli.runCli(["sync"]);
+await cli.prepareAndRunProjen(["sync"]);
 const workspaceRoot = await root.findWorkspaceRoot();
 bun.runProjen(["barrels"], workspaceRoot);
 ```
 
 Importing internals is mainly useful for tests or wrapper scripts; most users
-should run the `dbx-tools` bin.
+should run the `dbx` bin.
 
 ## Modules
 
-- `cli` - Commander entrypoint and `runCli()`.
+- `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.

package/lib/src/bootstrap.d.ts

@@ -1,12 +1,11 @@
 /**
  * Upgrade an established workspace whose installed engine predates this CLI.
  *
- * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a
- * workspace created months ago kept resolving its original engine no matter how
- * current the CLI invoking it was, and failed inside the OLD engine's code
- * (`sync --watch` dying on a `concurrently` that engine never declared). The two
- * are released in lockstep, so this CLI's version is exactly the engine it
- * expects.
+ * Bootstrapping pins the engine once, so without this a workspace created months ago
+ * would keep resolving its original engine no matter how current the CLI invoking it
+ * is, and would fail inside THAT engine's code (`sync --watch` dying on a
+ * `concurrently` it never declared). The two are released in lockstep, so this CLI's
+ * version is exactly the engine it expects.
  *
  * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so
  * an older CLI cannot downgrade a workspace.

package/lib/src/bootstrap.js

@@ -66,12 +66,11 @@ function installedEngineVersion(root) {
 /**
  * Upgrade an established workspace whose installed engine predates this CLI.
  *
- * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a
- * workspace created months ago kept resolving its original engine no matter how
- * current the CLI invoking it was, and failed inside the OLD engine's code
- * (`sync --watch` dying on a `concurrently` that engine never declared). The two
- * are released in lockstep, so this CLI's version is exactly the engine it
- * expects.
+ * Bootstrapping pins the engine once, so without this a workspace created months ago
+ * would keep resolving its original engine no matter how current the CLI invoking it
+ * is, and would fail inside THAT engine's code (`sync --watch` dying on a
+ * `concurrently` it never declared). The two are released in lockstep, so this CLI's
+ * version is exactly the engine it expects.
  *
  * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so
  * an older CLI cannot downgrade a workspace.
@@ -211,4 +210,4 @@ export function runInitialSynth(root) {
         check: true,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap a brand-new folder into a working dbx-tools workspace before projen runs.\n *\n * @module\n */\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { json, log } from \"@dbx-tools/shared-core\";\nimport { childEnv, resolveBunArgv, runBun } from \"./bun.ts\";\nimport { rootLabel } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:bootstrap\");\n\n/** Published package name used for Node's self-reference manifest resolution. */\nconst CLI_PACKAGE = \"@dbx-tools/cli\";\n\n/** Fallback when this CLI's own version isn't a real release (an in-repo `0.0.0`). */\nconst FALLBACK_PROJEN_SPECIFIER = \"@dbx-tools/projen@latest\";\n\n/**\n * Install the engine at THIS CLI's own version. The two are released together by\n * the root `bump`, so the matching engine always exists on the registry.\n *\n * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on\n * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. An explicit\n * range pinned to this CLI's own version admits only the matching engine, so the\n * CLI and the engine it drives never drift across a release (they are cut\n * together by the root `bump`).\n */\nfunction defaultProjenSpecifier(): string {\n  const version = ownVersion();\n  return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;\n}\n\n/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */\nfunction ownVersion(): string | undefined {\n  try {\n    // Resolve through the package's exported `./package.json`, which works from\n    // both source (`src/bootstrap.ts`) and published output\n    // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest\n    // in source but two levels away after compilation and silently fell back to\n    // `@latest` in every installed CLI.\n    const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);\n    const version = json.parseRecord(readFileSync(manifestPath, \"utf8\"))?.version;\n    return typeof version === \"string\" && version !== \"0.0.0\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */\nfunction compareVersions(a: string, b: string): number {\n  const parts = (v: string) => v.split(\".\").map((p) => Number.parseInt(p, 10) || 0);\n  const [x, y] = [parts(a), parts(b)];\n  return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];\n}\n\n/** Version of the engine currently installed at `root`, if any. */\nfunction installedEngineVersion(root: string): string | undefined {\n  try {\n    const manifest = join(root, \"node_modules\", \"@dbx-tools\", \"projen\", \"package.json\");\n    const version = json.parseRecord(readFileSync(manifest, \"utf8\"))?.version;\n    return typeof version === \"string\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Upgrade an established workspace whose installed engine predates this CLI.\n *\n * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a\n * workspace created months ago kept resolving its original engine no matter how\n * current the CLI invoking it was, and failed inside the OLD engine's code\n * (`sync --watch` dying on a `concurrently` that engine never declared). The two\n * are released in lockstep, so this CLI's version is exactly the engine it\n * expects.\n *\n * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so\n * an older CLI cannot downgrade a workspace.\n */\nexport function ensureEngineCurrent(root: string): void {\n  const expected = ownVersion();\n  if (!expected) return;\n  const installed = installedEngineVersion(root);\n  if (installed && compareVersions(installed, expected) >= 0) return;\n  runBun([\"add\", \"-D\", defaultProjenSpecifier()], root);\n}\n\n// Reach the class through its module NAMESPACE. Current engines also hoist it\n// flat, but every engine ever published exports the namespace, and this template\n// is resolved against `@latest` - a flat import dies on an older one with\n// \"does not provide an export named 'DBXToolsNodeProject'\".\nconst PROJENRC_TEMPLATE = `import { project as projectApi } from \"@dbx-tools/projen\";\n\nconst project = new projectApi.DBXToolsNodeProject();\nproject.synth();\n`;\n\n/**\n * Turn a folder into a functioning dbx-tools workspace: `bun init`, seed the\n * `package.json` workspace fields (bun reads `workspaces`/`trustedDependencies`\n * from the manifest), add `projen`/`typescript` + the engine package, write a\n * minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then install.\n * Does not run barrels - run `bun run barrels` or a full projen synth post-install\n * to generate package barrels.\n *\n * Every step is idempotent and self-guarded, so this is safe to run against a\n * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed\n * `package.json`) but is missing the installed toolchain - e.g. a freshly copied\n * project whose generated files (including manifests) are gitignored. In that\n * case `bun init` and the `.projenrc.ts` scaffold are skipped, but the engine +\n * projen are (re)installed so the subsequent synth can regenerate everything.\n * See {@link seedToolchain}.\n */\nexport function bootstrapWorkspace(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);\n\n  seedToolchain(root, projenSpecifier);\n\n  const projenrc = join(root, \".projenrc.ts\");\n  if (!existsSync(projenrc)) {\n    writeFileSync(projenrc, PROJENRC_TEMPLATE);\n  }\n\n  runInitialSynth(root);\n\n  runBun([\"install\"], root);\n  outro(\"Workspace ready - re-run dbx-tools or add packages under packages/\");\n}\n\n/**\n * Install the toolchain a synth needs (`projen`, `typescript`, and the dbx-tools\n * engine), seeding a `package.json` first when absent. bun reads its workspace\n * config (`workspaces`/`trustedDependencies`) from the manifest, so there is no\n * separate workspace file to seed - the engine writes `pnpm-workspace.yaml` at\n * synth for the Databricks Apps platform. Idempotent: run it whenever the engine\n * is missing, so a copied project with a `.projenrc.ts` but no\n * `node_modules`/manifest can be brought up to a synth-ready state.\n */\nexport function seedToolchain(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  const manifestPath = join(root, \"package.json\");\n  if (!existsSync(manifestPath)) {\n    runBun([\"init\", \"-y\"], root);\n    normalizeSeedManifest(manifestPath);\n  }\n\n  seedRegistry(root);\n\n  const kernelArch = exec.spawnSync(\"uname\", [\"-m\"], {\n    stdin: \"ignore\",\n    stdout: \"capture\",\n    stderr: \"ignore\",\n  }).stdout;\n  logger.info(\"seeding toolchain\", {\n    node: process.version,\n    bun: process.versions.bun,\n    platform: process.platform,\n    arch: process.arch,\n    kernelArch: kernelArch || \"unknown\",\n    engine: projenSpecifier,\n  });\n  runBun([\"add\", \"-D\", \"projen\", \"typescript@^5.9.3\", \"@types/bun\", projenSpecifier], root);\n}\n\n/**\n * Pin a non-default registry into the new root's `.npmrc`.\n *\n * The CLI already forces `--registry` onto the bun invocations it makes itself,\n * but a bootstrapped workspace outlives this process: every later `bun install`\n * the developer (or projen's post-synth step) runs is on its own. bun ignores\n * `npm_config_registry` from the environment, so without a file on disk those\n * runs revert to `https://registry.npmjs.org/` - which is a hard failure where\n * the custom registry was the only reachable one.\n *\n * Only writes for an actual override, never creates a file just to name npmjs,\n * and never overwrites an existing `.npmrc` (the developer's own wins).\n */\nfunction seedRegistry(root: string): void {\n  const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();\n  if (!registry) return;\n  const npmrc = join(root, \".npmrc\");\n  if (existsSync(npmrc)) return;\n  writeFileSync(npmrc, `registry=${registry}\\n`);\n}\n\n/**\n * Make what `bun init` produced safe to synth against: force `type: \"module\"`\n * (bun runs `.projenrc.ts` fine either way, but projen's ESM sources and the\n * emitted config assume module type) and drop any `packageManager`/`devEngines`\n * field that would pin a different manager. projen regenerates the whole manifest\n * at synth, so this only has to hold the seed together long enough to get there.\n */\nfunction normalizeSeedManifest(manifestPath: string): void {\n  try {\n    const manifest = json.parseRecord(readFileSync(manifestPath, \"utf8\"));\n    if (!manifest) return;\n    delete manifest.devEngines;\n    delete manifest.packageManager;\n    manifest.type = \"module\";\n    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\\n`);\n  } catch {\n    // A malformed/absent manifest here just means the later `bun add` recreates it.\n  }\n}\n\n/**\n * Run the initial synth by executing `.projenrc.ts` directly with bun (with\n * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a\n * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once\n * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.\n */\nexport function runInitialSynth(root: string): void {\n  const [command, ...prefix] = resolveBunArgv();\n  // bun runs the `.ts` directly. The registry reaches anything nested through\n  // `childEnv` and the seeded `.npmrc`.\n  exec.spawnSync(command, [...prefix, \".projenrc.ts\"], {\n    cwd: root,\n    env: childEnv({ PROJEN_DISABLE_POST: \"true\" }),\n    check: true,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bootstrap.js","sourceRoot":"","sources":["../../src/bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap a brand-new folder into a working dbx-tools workspace before projen runs.\n *\n * @module\n */\nimport { existsSync, readFileSync, writeFileSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { join } from \"node:path\";\nimport { intro, outro } from \"@clack/prompts\";\nimport { exec, project } from \"@dbx-tools/core\";\nimport { json, log } from \"@dbx-tools/shared-core\";\nimport { childEnv, resolveBunArgv, runBun } from \"./bun.ts\";\nimport { rootLabel } from \"./root.ts\";\n\nconst logger = log.logger(\"dbx-tools:bootstrap\");\n\n/** Published package name used for Node's self-reference manifest resolution. */\nconst CLI_PACKAGE = \"@dbx-tools/cli\";\n\n/** Fallback when this CLI's own version isn't a real release (an in-repo `0.0.0`). */\nconst FALLBACK_PROJEN_SPECIFIER = \"@dbx-tools/projen@latest\";\n\n/**\n * Install the engine at THIS CLI's own version. The two are released together by\n * the root `bump`, so the matching engine always exists on the registry.\n *\n * Not `@latest`, and not a bare `@dbx-tools/projen`. A bare specifier can land on\n * a stray `0.0.0`, whose `^0.0.0` caret then reaches no real release. An explicit\n * range pinned to this CLI's own version admits only the matching engine, so the\n * CLI and the engine it drives never drift across a release (they are cut\n * together by the root `bump`).\n */\nfunction defaultProjenSpecifier(): string {\n  const version = ownVersion();\n  return version ? `@dbx-tools/projen@^${version}` : FALLBACK_PROJEN_SPECIFIER;\n}\n\n/** This CLI's own released version, or `undefined` for an in-repo `0.0.0` build. */\nfunction ownVersion(): string | undefined {\n  try {\n    // Resolve through the package's exported `./package.json`, which works from\n    // both source (`src/bootstrap.ts`) and published output\n    // (`lib/src/bootstrap.js`). A relative URL is one level from the manifest\n    // in source but two levels away after compilation and silently fell back to\n    // `@latest` in every installed CLI.\n    const manifestPath = createRequire(import.meta.url).resolve(`${CLI_PACKAGE}/package.json`);\n    const version = json.parseRecord(readFileSync(manifestPath, \"utf8\"))?.version;\n    return typeof version === \"string\" && version !== \"0.0.0\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Compare `x.y.z` triples; returns <0, 0, or >0. Missing parts count as 0. */\nfunction compareVersions(a: string, b: string): number {\n  const parts = (v: string) => v.split(\".\").map((p) => Number.parseInt(p, 10) || 0);\n  const [x, y] = [parts(a), parts(b)];\n  return x[0] - y[0] || x[1] - y[1] || x[2] - y[2];\n}\n\n/** Version of the engine currently installed at `root`, if any. */\nfunction installedEngineVersion(root: string): string | undefined {\n  try {\n    const manifest = join(root, \"node_modules\", \"@dbx-tools\", \"projen\", \"package.json\");\n    const version = json.parseRecord(readFileSync(manifest, \"utf8\"))?.version;\n    return typeof version === \"string\" ? version : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Upgrade an established workspace whose installed engine predates this CLI.\n *\n * Bootstrapping pins the engine once, so without this a workspace created months ago\n * would keep resolving its original engine no matter how current the CLI invoking it\n * is, and would fail inside THAT engine's code (`sync --watch` dying on a\n * `concurrently` it never declared). The two are released in lockstep, so this CLI's\n * version is exactly the engine it expects.\n *\n * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so\n * an older CLI cannot downgrade a workspace.\n */\nexport function ensureEngineCurrent(root: string): void {\n  const expected = ownVersion();\n  if (!expected) return;\n  const installed = installedEngineVersion(root);\n  if (installed && compareVersions(installed, expected) >= 0) return;\n  runBun([\"add\", \"-D\", defaultProjenSpecifier()], root);\n}\n\n// Reach the class through its module NAMESPACE. Current engines also hoist it\n// flat, but every engine ever published exports the namespace, and this template\n// is resolved against `@latest` - a flat import dies on an older one with\n// \"does not provide an export named 'DBXToolsNodeProject'\".\nconst PROJENRC_TEMPLATE = `import { project as projectApi } from \"@dbx-tools/projen\";\n\nconst project = new projectApi.DBXToolsNodeProject();\nproject.synth();\n`;\n\n/**\n * Turn a folder into a functioning dbx-tools workspace: `bun init`, seed the\n * `package.json` workspace fields (bun reads `workspaces`/`trustedDependencies`\n * from the manifest), add `projen`/`typescript` + the engine package, write a\n * minimal `.projenrc.ts`, synth once (with `PROJEN_DISABLE_POST`), then install.\n * Does not run barrels - run `bun run barrels` or a full projen synth post-install\n * to generate package barrels.\n *\n * Every step is idempotent and self-guarded, so this is safe to run against a\n * folder that ALREADY has a hand-authored `.projenrc.ts` (and even a committed\n * `package.json`) but is missing the installed toolchain - e.g. a freshly copied\n * project whose generated files (including manifests) are gitignored. In that\n * case `bun init` and the `.projenrc.ts` scaffold are skipped, but the engine +\n * projen are (re)installed so the subsequent synth can regenerate everything.\n * See {@link seedToolchain}.\n */\nexport function bootstrapWorkspace(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  intro(`Bootstrapping dbx-tools workspace in ${rootLabel(root)}`);\n\n  seedToolchain(root, projenSpecifier);\n\n  const projenrc = join(root, \".projenrc.ts\");\n  if (!existsSync(projenrc)) {\n    writeFileSync(projenrc, PROJENRC_TEMPLATE);\n  }\n\n  runInitialSynth(root);\n\n  runBun([\"install\"], root);\n  outro(\"Workspace ready - re-run dbx-tools or add packages under packages/\");\n}\n\n/**\n * Install the toolchain a synth needs (`projen`, `typescript`, and the dbx-tools\n * engine), seeding a `package.json` first when absent. bun reads its workspace\n * config (`workspaces`/`trustedDependencies`) from the manifest, so there is no\n * separate workspace file to seed - the engine writes `pnpm-workspace.yaml` at\n * synth for the Databricks Apps platform. Idempotent: run it whenever the engine\n * is missing, so a copied project with a `.projenrc.ts` but no\n * `node_modules`/manifest can be brought up to a synth-ready state.\n */\nexport function seedToolchain(\n  root: string,\n  projenSpecifier: string = defaultProjenSpecifier(),\n): void {\n  const manifestPath = join(root, \"package.json\");\n  if (!existsSync(manifestPath)) {\n    runBun([\"init\", \"-y\"], root);\n    normalizeSeedManifest(manifestPath);\n  }\n\n  seedRegistry(root);\n\n  const kernelArch = exec.spawnSync(\"uname\", [\"-m\"], {\n    stdin: \"ignore\",\n    stdout: \"capture\",\n    stderr: \"ignore\",\n  }).stdout;\n  logger.info(\"seeding toolchain\", {\n    node: process.version,\n    bun: process.versions.bun,\n    platform: process.platform,\n    arch: process.arch,\n    kernelArch: kernelArch || \"unknown\",\n    engine: projenSpecifier,\n  });\n  runBun([\"add\", \"-D\", \"projen\", \"typescript@^5.9.3\", \"@types/bun\", projenSpecifier], root);\n}\n\n/**\n * Pin a non-default registry into the new root's `.npmrc`.\n *\n * The CLI already forces `--registry` onto the bun invocations it makes itself,\n * but a bootstrapped workspace outlives this process: every later `bun install`\n * the developer (or projen's post-synth step) runs is on its own. bun ignores\n * `npm_config_registry` from the environment, so without a file on disk those\n * runs revert to `https://registry.npmjs.org/` - which is a hard failure where\n * the custom registry was the only reachable one.\n *\n * Only writes for an actual override, never creates a file just to name npmjs,\n * and never overwrites an existing `.npmrc` (the developer's own wins).\n */\nfunction seedRegistry(root: string): void {\n  const registry = project.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString();\n  if (!registry) return;\n  const npmrc = join(root, \".npmrc\");\n  if (existsSync(npmrc)) return;\n  writeFileSync(npmrc, `registry=${registry}\\n`);\n}\n\n/**\n * Make what `bun init` produced safe to synth against: force `type: \"module\"`\n * (bun runs `.projenrc.ts` fine either way, but projen's ESM sources and the\n * emitted config assume module type) and drop any `packageManager`/`devEngines`\n * field that would pin a different manager. projen regenerates the whole manifest\n * at synth, so this only has to hold the seed together long enough to get there.\n */\nfunction normalizeSeedManifest(manifestPath: string): void {\n  try {\n    const manifest = json.parseRecord(readFileSync(manifestPath, \"utf8\"));\n    if (!manifest) return;\n    delete manifest.devEngines;\n    delete manifest.packageManager;\n    manifest.type = \"module\";\n    writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\\n`);\n  } catch {\n    // A malformed/absent manifest here just means the later `bun add` recreates it.\n  }\n}\n\n/**\n * Run the initial synth by executing `.projenrc.ts` directly with bun (with\n * `PROJEN_DISABLE_POST` set), NOT `projen <task>`. Use right after seeding a\n * fresh workspace: the projen TASKS (`sync`, `barrels`, ...) only exist once\n * `.projenrc.ts` has run once, so `projen sync` can't be the bootstrapping step.\n */\nexport function runInitialSynth(root: string): void {\n  const [command, ...prefix] = resolveBunArgv();\n  // bun runs the `.ts` directly. The registry reaches anything nested through\n  // `childEnv` and the seeded `.npmrc`.\n  exec.spawnSync(command, [...prefix, \".projenrc.ts\"], {\n    cwd: root,\n    env: childEnv({ PROJEN_DISABLE_POST: \"true\" }),\n    check: true,\n  });\n}\n"]}

package/lib/src/cli.d.ts

@@ -1,2 +1,20 @@
-/** Parse `argv` with commander and forward remaining args to projen. */
+import { Command } from "commander";
+/**
+ * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.
+ *
+ * Three cases, in order:
+ *   - no `.projenrc.ts` at all -> full bootstrap (scaffold + install + synth),
+ *     which already runs the initial synth; nothing more to forward.
+ *   - a `.projenrc.ts` but the engine/toolchain isn't installed (e.g. a freshly
+ *     copied project whose generated files + manifests are gitignored) -> seed
+ *     the toolchain, then run the INITIAL synth directly (the projen tasks the
+ *     args would name, like `sync`, don't exist until `.projenrc.ts` has run
+ *     once), and install. Don't forward `projenArgs` - the synth is the work.
+ *   - otherwise (established workspace) -> ensure deps, bring the engine up to
+ *     this CLI's version, then forward to projen.
+ */
+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;
+/** Parse `argv` (a `process.argv`) and run the matching command. */
 export declare function runCli(argv: string[]): Promise<void>;

package/lib/src/cli.js

@@ -1,12 +1,30 @@
 /**
- * `dbx-tools` commander entry: detect root, bootstrap or install, forward to projen.
+ * The single `dbx` (alias `dbx-tools`) commander entry.
+ *
+ * One bin, three command groups:
+ *   - `dev` - workspace lifecycle: detect the root, bootstrap or repair, then
+ *     forward whatever follows to projen. This is the passthrough, and it is an
+ *     EXPLICIT subcommand rather than the bare root action so a projen task
+ *     name can never shadow (or be shadowed by) a sibling command.
+ *   - `model-proxy` - the local OpenAI-compatible Model Serving proxy.
+ *   - `appkit` - AppKit environment helpers (`appkit env`).
+ *
+ * The two feature groups stay in their own packages (`@dbx-tools/cli-model-proxy`,
+ * `@dbx-tools/cli-appkit-env`) and are `await import()`ed only once their name is
+ * matched, so `dbx dev` never loads the Databricks SDK or AppKit. That lazy hop
+ * is also why they are mounted as ARG-FORWARDING commands instead of
+ * `addCommand()`: building a child program eagerly to register it would defeat
+ * the point. Each forwards its own `--help`, so the child prints its real help.
  *
  * @module
  */
+import { basename } from "node:path";
 import { Command } from "commander";
 import { bootstrapWorkspace, ensureEngineCurrent, runInitialSynth, seedToolchain, } from "./bootstrap.js";
 import { ensureWorkspaceReady, runBun, runProjen } from "./bun.js";
 import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.js";
+/** Commands the bin exposes, and the names help is rendered under. */
+const PROGRAM_NAMES = ["dbx", "dbx-tools"];
 /**
  * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.
  *
@@ -21,7 +39,7 @@ import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.js";
  *   - otherwise (established workspace) -> ensure deps, bring the engine up to
  *     this CLI's version, then forward to projen.
  */
-async function prepareAndRunProjen(projenArgs, startDir) {
+export async function prepareAndRunProjen(projenArgs, startDir) {
     const root = await findWorkspaceRoot(startDir);
     if (needsBootstrap(root)) {
         bootstrapWorkspace(root);
@@ -37,16 +55,56 @@ async function prepareAndRunProjen(projenArgs, startDir) {
     ensureEngineCurrent(root);
     runProjen(projenArgs, root);
 }
-/** Parse `argv` with commander and forward remaining args to projen. */
-export async function runCli(argv) {
-    const program = new Command()
-        .name("dbx-tools")
-        .description("Bootstrap dbx-tools workspaces and forward to projen")
+/**
+ * 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.
+ */
+function addForwardedCommand(program, name, description, load) {
+    program
+        .command(name)
+        .description(description)
+        .argument("[args...]", `arguments forwarded to ${name}`)
         .allowUnknownOption()
         .allowExcessArguments()
+        .helpOption(false)
+        .action(async (args) => {
+        const buildProgram = await load();
+        await buildProgram(`${program.name()} ${name}`).parseAsync(args, { from: "user" });
+    });
+}
+/** Build the `dbx` commander program (no side effects until parsed). */
+export function buildProgram(name = PROGRAM_NAMES[0]) {
+    const program = new Command()
+        .name(name)
+        .description("Databricks developer tools: workspace lifecycle, model proxy, AppKit env")
         .showHelpAfterError()
-        .helpOption("-h, --help", "Show dbx-tools help");
-    program.parse(argv);
-    await prepareAndRunProjen(program.args);
+        .helpOption("-h, --help", `Show ${name} help`);
+    program
+        .command("dev")
+        .description("Bootstrap or repair a dbx-tools workspace, then forward to projen")
+        .argument("[projenArgs...]", "projen task and arguments (e.g. sync --watch)")
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .helpOption(false)
+        .action(async (projenArgs) => {
+        await prepareAndRunProjen(projenArgs);
+    });
+    addForwardedCommand(program, "model-proxy", "Serve a local OpenAI-compatible proxy in front of Databricks Model Serving", async () => (await import("@dbx-tools/cli-model-proxy/cli")).buildProgram);
+    addForwardedCommand(program, "appkit", "AppKit helpers (env: print the environment an AppKit app resolves)", async () => (await import("@dbx-tools/cli-appkit-env/cli")).buildProgram);
+    return program;
+}
+/**
+ * Program name for help output: whichever bin the user actually typed, so
+ * `dbx-tools --help` doesn't document itself as `dbx`. Falls back to `dbx`.
+ */
+function programName(argv) {
+    const invoked = argv[1] ? basename(argv[1]).replace(/\.(?:[cm]?[jt]s)$/, "") : undefined;
+    return PROGRAM_NAMES.find((candidate) => candidate === invoked) ?? PROGRAM_NAMES[0];
+}
+/** Parse `argv` (a `process.argv`) and run the matching command. */
+export async function runCli(argv) {
+    await buildProgram(programName(argv)).parseAsync(argv);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The single `dbx` (alias `dbx-tools`) commander entry.\n *\n * One bin, three command groups:\n *   - `dev` - workspace lifecycle: detect the root, bootstrap or repair, then\n *     forward whatever follows to projen. This is the passthrough, and it is an\n *     EXPLICIT subcommand rather than the bare root action so a projen task\n *     name can never shadow (or be shadowed by) a sibling command.\n *   - `model-proxy` - the local OpenAI-compatible Model Serving proxy.\n *   - `appkit` - AppKit environment helpers (`appkit env`).\n *\n * The two feature groups stay in their own packages (`@dbx-tools/cli-model-proxy`,\n * `@dbx-tools/cli-appkit-env`) and are `await import()`ed only once their name is\n * matched, so `dbx dev` never loads the Databricks SDK or AppKit. That lazy hop\n * is also why they are mounted as ARG-FORWARDING commands instead of\n * `addCommand()`: building a child program eagerly to register it would defeat\n * the point. Each forwards its own `--help`, so the child prints its real 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(\"Databricks developer tools: workspace lifecycle, model proxy, AppKit env\")\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    \"model-proxy\",\n    \"Serve a local OpenAI-compatible proxy in front of Databricks Model Serving\",\n    async () => (await import(\"@dbx-tools/cli-model-proxy/cli\")).buildProgram,\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  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

@@ -6,8 +6,8 @@
     "directory": "packages/js/cli/dbx-tools"
   },
   "bin": {
-    "dbx-tools": "./lib/bin/dbx-tools.js",
-    "dbxt": "./lib/bin/dbx-tools.js"
+    "dbx": "./lib/bin/dbx-tools.js",
+    "dbx-tools": "./lib/bin/dbx-tools.js"
   },
   "scripts": {
     "build": "projen build",
@@ -28,8 +28,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.75",
-    "@dbx-tools/shared-core": "0.6.75",
+    "@dbx-tools/cli-appkit-env": "0.6.77",
+    "@dbx-tools/cli-model-proxy": "0.6.77",
+    "@dbx-tools/core": "0.6.77",
+    "@dbx-tools/shared-core": "0.6.77",
     "commander": "^15.0.0"
   },
   "main": "./lib/index.js",
@@ -39,8 +41,8 @@
     "main": "./lib/index.js",
     "types": "./lib/index.d.ts",
     "bin": {
-      "dbx-tools": "./lib/bin/dbx-tools.js",
-      "dbxt": "./lib/bin/dbx-tools.js"
+      "dbx": "./lib/bin/dbx-tools.js",
+      "dbx-tools": "./lib/bin/dbx-tools.js"
     },
     "exports": {
       ".": {
@@ -66,7 +68,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.75",
+  "version": "0.6.77",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/bootstrap.ts

@@ -72,12 +72,11 @@ function installedEngineVersion(root: string): string | undefined {
 /**
  * Upgrade an established workspace whose installed engine predates this CLI.
  *
- * Bootstrapping pins the engine once, and nothing afterwards revisits it - so a
- * workspace created months ago kept resolving its original engine no matter how
- * current the CLI invoking it was, and failed inside the OLD engine's code
- * (`sync --watch` dying on a `concurrently` that engine never declared). The two
- * are released in lockstep, so this CLI's version is exactly the engine it
- * expects.
+ * Bootstrapping pins the engine once, so without this a workspace created months ago
+ * would keep resolving its original engine no matter how current the CLI invoking it
+ * is, and would fail inside THAT engine's code (`sync --watch` dying on a
+ * `concurrently` it never declared). The two are released in lockstep, so this CLI's
+ * version is exactly the engine it expects.
  *
  * Only ever moves FORWARD: an engine at or ahead of this CLI is left alone, so
  * an older CLI cannot downgrade a workspace.

package/src/cli.ts

@@ -1,8 +1,24 @@
 /**
- * `dbx-tools` commander entry: detect root, bootstrap or install, forward to projen.
+ * The single `dbx` (alias `dbx-tools`) commander entry.
+ *
+ * One bin, three command groups:
+ *   - `dev` - workspace lifecycle: detect the root, bootstrap or repair, then
+ *     forward whatever follows to projen. This is the passthrough, and it is an
+ *     EXPLICIT subcommand rather than the bare root action so a projen task
+ *     name can never shadow (or be shadowed by) a sibling command.
+ *   - `model-proxy` - the local OpenAI-compatible Model Serving proxy.
+ *   - `appkit` - AppKit environment helpers (`appkit env`).
+ *
+ * The two feature groups stay in their own packages (`@dbx-tools/cli-model-proxy`,
+ * `@dbx-tools/cli-appkit-env`) and are `await import()`ed only once their name is
+ * matched, so `dbx dev` never loads the Databricks SDK or AppKit. That lazy hop
+ * is also why they are mounted as ARG-FORWARDING commands instead of
+ * `addCommand()`: building a child program eagerly to register it would defeat
+ * the point. Each forwards its own `--help`, so the child prints its real help.
  *
  * @module
  */
+import { basename } from "node:path";
 import { Command } from "commander";
 import {
   bootstrapWorkspace,
@@ -13,6 +29,9 @@ import {
 import { ensureWorkspaceReady, runBun, runProjen } from "./bun.ts";
 import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.ts";
 
+/** Commands the bin exposes, and the names help is rendered under. */
+const PROGRAM_NAMES = ["dbx", "dbx-tools"] as const;
+
 /**
  * Prepare the workspace at `root`, then run projen (via bun) with `projenArgs`.
  *
@@ -27,7 +46,7 @@ import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.ts";
  *   - otherwise (established workspace) -> ensure deps, bring the engine up to
  *     this CLI's version, then forward to projen.
  */
-async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Promise<void> {
+export async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Promise<void> {
   const root = await findWorkspaceRoot(startDir);
   if (needsBootstrap(root)) {
     bootstrapWorkspace(root);
@@ -44,16 +63,77 @@ async function prepareAndRunProjen(projenArgs: string[], startDir?: string): Pro
   runProjen(projenArgs, root);
 }
 
-/** Parse `argv` with commander and forward remaining args to projen. */
-export async function runCli(argv: string[]): Promise<void> {
-  const program = new Command()
-    .name("dbx-tools")
-    .description("Bootstrap dbx-tools workspaces and forward to projen")
+/**
+ * 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.
+ */
+function addForwardedCommand(
+  program: Command,
+  name: string,
+  description: string,
+  load: () => Promise<(name: string) => Command>,
+): void {
+  program
+    .command(name)
+    .description(description)
+    .argument("[args...]", `arguments forwarded to ${name}`)
     .allowUnknownOption()
     .allowExcessArguments()
+    .helpOption(false)
+    .action(async (args: string[]) => {
+      const buildProgram = await load();
+      await buildProgram(`${program.name()} ${name}`).parseAsync(args, { from: "user" });
+    });
+}
+
+/** Build the `dbx` commander program (no side effects until parsed). */
+export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
+  const program = new Command()
+    .name(name)
+    .description("Databricks developer tools: workspace lifecycle, model proxy, AppKit env")
     .showHelpAfterError()
-    .helpOption("-h, --help", "Show dbx-tools help");
+    .helpOption("-h, --help", `Show ${name} help`);
+
+  program
+    .command("dev")
+    .description("Bootstrap or repair a dbx-tools workspace, then forward to projen")
+    .argument("[projenArgs...]", "projen task and arguments (e.g. sync --watch)")
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .helpOption(false)
+    .action(async (projenArgs: string[]) => {
+      await prepareAndRunProjen(projenArgs);
+    });
+
+  addForwardedCommand(
+    program,
+    "model-proxy",
+    "Serve a local OpenAI-compatible proxy in front of Databricks Model Serving",
+    async () => (await import("@dbx-tools/cli-model-proxy/cli")).buildProgram,
+  );
+
+  addForwardedCommand(
+    program,
+    "appkit",
+    "AppKit helpers (env: print the environment an AppKit app resolves)",
+    async () => (await import("@dbx-tools/cli-appkit-env/cli")).buildProgram,
+  );
+
+  return program;
+}
 
-  program.parse(argv);
-  await prepareAndRunProjen(program.args);
+/**
+ * Program name for help output: whichever bin the user actually typed, so
+ * `dbx-tools --help` doesn't document itself as `dbx`. Falls back to `dbx`.
+ */
+function programName(argv: string[]): string {
+  const invoked = argv[1] ? basename(argv[1]).replace(/\.(?:[cm]?[jt]s)$/, "") : undefined;
+  return PROGRAM_NAMES.find((candidate) => candidate === invoked) ?? PROGRAM_NAMES[0];
+}
+
+/** Parse `argv` (a `process.argv`) and run the matching command. */
+export async function runCli(argv: string[]): Promise<void> {
+  await buildProgram(programName(argv)).parseAsync(argv);
 }