@dbx-tools/cli 0.6.186 → 0.6.188

package/README.md

@@ -5,12 +5,14 @@ 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.      |
+| 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 model-proxy`    | Run the multi-protocol Databricks Model Serving proxy.                   |
+| `dbx lakebase-proxy` | Run the loopback PostgreSQL proxy for Databricks Lakebase.               |
 
 Key features:
 
@@ -32,6 +34,13 @@ 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.
 
+Rust commands are generated from the workspace's release metadata. The first
+invocation downloads the exact GitHub release asset matching `PACKAGE_VERSION`
+and the operating system, then installs it as
+`~/.dbx-tools/bin/<binary>_<major>_<minor>_<patch>`. Later invocations reuse
+that versioned executable. Root help never downloads a binary, and all command
+arguments are forwarded directly to the Rust CLI.
+
 ## Bootstrap A Workspace
 
 ```sh

package/index.ts

@@ -3,10 +3,12 @@
 // 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.6.186";
+export const PACKAGE_VERSION = "0.6.188";
 export * as bootstrap from "./src/bootstrap.ts";
 export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";
 export * as root from "./src/root.ts";
+export * as rustBinary from "./src/rust-binary.ts";
 export { resolveBunArgv } from "./src/bun.ts";
 export { workspaceRoot } from "./src/root.ts";
+export type { RustReleaseBinaryAsset, RustReleaseBinaryCommand, RustReleaseBinaryOptions } from "./src/rust-binary.ts";

package/lib/index.d.ts

@@ -1,8 +1,10 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/cli";
-export declare const PACKAGE_VERSION = "0.6.186";
+export declare const PACKAGE_VERSION = "0.6.188";
 export * as bootstrap from "./src/bootstrap.ts";
 export * as bun from "./src/bun.ts";
 export * as cli from "./src/cli.ts";
 export * as root from "./src/root.ts";
+export * as rustBinary from "./src/rust-binary.ts";
 export { resolveBunArgv } from "./src/bun.ts";
 export { workspaceRoot } from "./src/root.ts";
+export type { RustReleaseBinaryAsset, RustReleaseBinaryCommand, RustReleaseBinaryOptions } from "./src/rust-binary.ts";

package/lib/index.js

@@ -2,11 +2,12 @@
 // 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.6.186";
+export const PACKAGE_VERSION = "0.6.188";
 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 * as rustBinary from "./src/rust-binary.js";
 export { resolveBunArgv } from "./src/bun.js";
 export { workspaceRoot } from "./src/root.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxnQkFBZ0IsQ0FBQztBQUNuRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxTQUFTLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUM5QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9jbGlcIjtcbmV4cG9ydCBjb25zdCBQQUNLQUdFX1ZFUlNJT04gPSBcIjAuNi4xODZcIjtcbmV4cG9ydCAqIGFzIGJvb3RzdHJhcCBmcm9tIFwiLi9zcmMvYm9vdHN0cmFwLnRzXCI7XG5leHBvcnQgKiBhcyBidW4gZnJvbSBcIi4vc3JjL2J1bi50c1wiO1xuZXhwb3J0ICogYXMgY2xpIGZyb20gXCIuL3NyYy9jbGkudHNcIjtcbmV4cG9ydCAqIGFzIHJvb3QgZnJvbSBcIi4vc3JjL3Jvb3QudHNcIjtcbmV4cG9ydCB7IHJlc29sdmVCdW5Bcmd2IH0gZnJvbSBcIi4vc3JjL2J1bi50c1wiO1xuZXhwb3J0IHsgd29ya3NwYWNlUm9vdCB9IGZyb20gXCIuL3NyYy9yb290LnRzXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxnQkFBZ0IsQ0FBQztBQUNuRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxTQUFTLE1BQU0sb0JBQW9CLENBQUM7QUFDaEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxlQUFlLENBQUM7QUFDdEMsT0FBTyxLQUFLLFVBQVUsTUFBTSxzQkFBc0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzlDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHRU5FUkFURUQgYnkgcHJvamVuIHdhdGNoIC0gRE8gTk9UIEVESVQuXG4vLyBSZWdlbmVyYXRlZCBmcm9tIHRoZSBleHBvcnRpbmcgbW9kdWxlcyBpbiAuL3NyYy5cbi8vIEhhbmQgZWRpdHMgYXJlIG92ZXJ3cml0dGVuIG9uIHRoZSBuZXh0IHdhdGNoOyB0aGlzIGZpbGUgaXMgcmVhZC1vbmx5LlxuXG5leHBvcnQgY29uc3QgUEFDS0FHRV9JREVOVElGSUVSID0gXCJAZGJ4LXRvb2xzL2NsaVwiO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9IFwiMC42LjE4OFwiO1xuZXhwb3J0ICogYXMgYm9vdHN0cmFwIGZyb20gXCIuL3NyYy9ib290c3RyYXAudHNcIjtcbmV4cG9ydCAqIGFzIGJ1biBmcm9tIFwiLi9zcmMvYnVuLnRzXCI7XG5leHBvcnQgKiBhcyBjbGkgZnJvbSBcIi4vc3JjL2NsaS50c1wiO1xuZXhwb3J0ICogYXMgcm9vdCBmcm9tIFwiLi9zcmMvcm9vdC50c1wiO1xuZXhwb3J0ICogYXMgcnVzdEJpbmFyeSBmcm9tIFwiLi9zcmMvcnVzdC1iaW5hcnkudHNcIjtcbmV4cG9ydCB7IHJlc29sdmVCdW5Bcmd2IH0gZnJvbSBcIi4vc3JjL2J1bi50c1wiO1xuZXhwb3J0IHsgd29ya3NwYWNlUm9vdCB9IGZyb20gXCIuL3NyYy9yb290LnRzXCI7XG5leHBvcnQgdHlwZSB7IFJ1c3RSZWxlYXNlQmluYXJ5QXNzZXQsIFJ1c3RSZWxlYXNlQmluYXJ5Q29tbWFuZCwgUnVzdFJlbGVhc2VCaW5hcnlPcHRpb25zIH0gZnJvbSBcIi4vc3JjL3J1c3QtYmluYXJ5LnRzXCI7XG4iXX0=

package/lib/src/_rust-release-binaries.d.ts

@@ -0,0 +1,49 @@
+export declare const RUST_RELEASE_BINARY_COMMANDS: readonly [{
+    readonly command: "lakebase-proxy";
+    readonly description: "Loopback PostgreSQL proxy for Databricks Lakebase";
+    readonly binaryName: "dbx-lakebase-proxy";
+    readonly repository: "https://github.com/reggie-db/dbx-tools";
+    readonly assets: readonly [{
+        readonly os: "linux";
+        readonly cpu: "x64";
+        readonly name: "dbx-lakebase-proxy-linux-x64-gnu.tar.gz";
+    }, {
+        readonly os: "linux";
+        readonly cpu: "arm64";
+        readonly name: "dbx-lakebase-proxy-linux-arm64-gnu.tar.gz";
+    }, {
+        readonly os: "darwin";
+        readonly cpu: "x64";
+        readonly name: "dbx-lakebase-proxy-darwin-x64.tar.gz";
+    }, {
+        readonly os: "darwin";
+        readonly cpu: "arm64";
+        readonly name: "dbx-lakebase-proxy-darwin-arm64.tar.gz";
+    }];
+}, {
+    readonly command: "model-proxy";
+    readonly description: "Multi-protocol Databricks model proxy";
+    readonly binaryName: "dbx-model-proxy";
+    readonly repository: "https://github.com/reggie-db/dbx-tools";
+    readonly assets: readonly [{
+        readonly os: "linux";
+        readonly cpu: "x64";
+        readonly name: "dbx-model-proxy-linux-x64-gnu.tar.gz";
+    }, {
+        readonly os: "linux";
+        readonly cpu: "arm64";
+        readonly name: "dbx-model-proxy-linux-arm64-gnu.tar.gz";
+    }, {
+        readonly os: "darwin";
+        readonly cpu: "x64";
+        readonly name: "dbx-model-proxy-darwin-x64.tar.gz";
+    }, {
+        readonly os: "darwin";
+        readonly cpu: "arm64";
+        readonly name: "dbx-model-proxy-darwin-arm64.tar.gz";
+    }, {
+        readonly os: "win32";
+        readonly cpu: "x64";
+        readonly name: "dbx-model-proxy-win32-x64-msvc.zip";
+    }];
+}];

package/lib/src/_rust-release-binaries.js

@@ -0,0 +1,66 @@
+// GENERATED by projen - DO NOT EDIT.
+// Rust release package options are the source of truth.
+export const RUST_RELEASE_BINARY_COMMANDS = [
+    {
+        "command": "lakebase-proxy",
+        "description": "Loopback PostgreSQL proxy for Databricks Lakebase",
+        "binaryName": "dbx-lakebase-proxy",
+        "repository": "https://github.com/reggie-db/dbx-tools",
+        "assets": [
+            {
+                "os": "linux",
+                "cpu": "x64",
+                "name": "dbx-lakebase-proxy-linux-x64-gnu.tar.gz"
+            },
+            {
+                "os": "linux",
+                "cpu": "arm64",
+                "name": "dbx-lakebase-proxy-linux-arm64-gnu.tar.gz"
+            },
+            {
+                "os": "darwin",
+                "cpu": "x64",
+                "name": "dbx-lakebase-proxy-darwin-x64.tar.gz"
+            },
+            {
+                "os": "darwin",
+                "cpu": "arm64",
+                "name": "dbx-lakebase-proxy-darwin-arm64.tar.gz"
+            }
+        ]
+    },
+    {
+        "command": "model-proxy",
+        "description": "Multi-protocol Databricks model proxy",
+        "binaryName": "dbx-model-proxy",
+        "repository": "https://github.com/reggie-db/dbx-tools",
+        "assets": [
+            {
+                "os": "linux",
+                "cpu": "x64",
+                "name": "dbx-model-proxy-linux-x64-gnu.tar.gz"
+            },
+            {
+                "os": "linux",
+                "cpu": "arm64",
+                "name": "dbx-model-proxy-linux-arm64-gnu.tar.gz"
+            },
+            {
+                "os": "darwin",
+                "cpu": "x64",
+                "name": "dbx-model-proxy-darwin-x64.tar.gz"
+            },
+            {
+                "os": "darwin",
+                "cpu": "arm64",
+                "name": "dbx-model-proxy-darwin-arm64.tar.gz"
+            },
+            {
+                "os": "win32",
+                "cpu": "x64",
+                "name": "dbx-model-proxy-win32-x64-msvc.zip"
+            }
+        ]
+    }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/cli.js

@@ -16,6 +16,7 @@ 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";
+import { runRustReleaseBinary, rustReleaseBinaryCommands, } from "./rust-binary.js";
 /** Commands the bin exposes, and the names help is rendered under. */
 const PROGRAM_NAMES = ["dbx", "dbx-tools"];
 /**
@@ -67,11 +68,23 @@ function addForwardedCommand(program, name, description, load) {
         await buildProgram(`${program.name()} ${name}`).parseAsync(args, { from: "user" });
     });
 }
+function addRustReleaseCommand(program, command) {
+    program
+        .command(command.command)
+        .description(command.description)
+        .argument("[args...]", `arguments forwarded to ${command.binaryName}`)
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .helpOption(false)
+        .action(async (args) => {
+        process.exitCode = await runRustReleaseBinary(command, args);
+    });
+}
 /** 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, AppKit env, auth, and tunnel")
+        .description("Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and native proxies")
         .showHelpAfterError()
         .helpOption("-h, --help", `Show ${name} help`);
     program
@@ -87,6 +100,9 @@ export function buildProgram(name = PROGRAM_NAMES[0]) {
     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);
+    for (const command of rustReleaseBinaryCommands()) {
+        addRustReleaseCommand(program, command);
+    }
     return program;
 }
 /**
@@ -101,4 +117,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(\"Databricks developer tools: workspace lifecycle, AppKit env, auth, and tunnel\")\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  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\";\nimport {\n  runRustReleaseBinary,\n  rustReleaseBinaryCommands,\n  type RustReleaseBinaryCommand,\n} from \"./rust-binary.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\nfunction addRustReleaseCommand(program: Command, command: RustReleaseBinaryCommand): void {\n  program\n    .command(command.command)\n    .description(command.description)\n    .argument(\"[args...]\", `arguments forwarded to ${command.binaryName}`)\n    .allowUnknownOption()\n    .allowExcessArguments()\n    .helpOption(false)\n    .action(async (args: string[]) => {\n      process.exitCode = await runRustReleaseBinary(command, args);\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 native 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  for (const command of rustReleaseBinaryCommands()) {\n    addRustReleaseCommand(program, command);\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/lib/src/rust-binary.d.ts

@@ -0,0 +1,34 @@
+import { bin } from "@dbx-tools/core";
+/** One release archive available to the current Node runtime. */
+export interface RustReleaseBinaryAsset {
+    readonly os: string;
+    readonly cpu: string;
+    readonly name: string;
+}
+/** Generated registration for one `dbx` Rust command. */
+export interface RustReleaseBinaryCommand {
+    readonly command: string;
+    readonly description: string;
+    readonly binaryName: string;
+    readonly repository: string;
+    readonly assets: readonly RustReleaseBinaryAsset[];
+}
+/** Overrides used by tests and callers that install under a custom home. */
+export interface RustReleaseBinaryOptions {
+    readonly homeDir?: string;
+    readonly platform?: NodeJS.Platform;
+    readonly arch?: string;
+    readonly version?: string;
+}
+/** Return every Rust command registered by the synthesized workspace. */
+export declare function rustReleaseBinaryCommands(): readonly RustReleaseBinaryCommand[];
+/** Resolve one registered Rust command by its `dbx` subcommand. */
+export declare function rustReleaseBinaryCommand(command: string): RustReleaseBinaryCommand;
+/** Select the archive for an OS and CPU pair. */
+export declare function rustReleaseBinaryAsset(command: RustReleaseBinaryCommand, platform: NodeJS.Platform, arch: string): RustReleaseBinaryAsset;
+/** Build the GitHub release URL for a generated archive entry. */
+export declare function rustReleaseBinaryUrl(command: RustReleaseBinaryCommand, asset: RustReleaseBinaryAsset, version: string): string;
+/** Install the release binary matching this CLI version and host platform. */
+export declare function ensureRustReleaseBinary(command: RustReleaseBinaryCommand, options?: RustReleaseBinaryOptions): Promise<bin.BinContext>;
+/** Install and run a Rust command with inherited terminal I/O. */
+export declare function runRustReleaseBinary(command: RustReleaseBinaryCommand, args: readonly string[], options?: RustReleaseBinaryOptions): Promise<number>;

package/lib/src/rust-binary.js

@@ -0,0 +1,103 @@
+/**
+ * Lazy installation and transparent execution of Rust release binaries.
+ *
+ * @module
+ */
+import { spawn } from "node:child_process";
+import { constants as osConstants, homedir } from "node:os";
+import { join } from "node:path";
+import { bin } from "@dbx-tools/core";
+import { RUST_RELEASE_BINARY_COMMANDS } from "./_rust-release-binaries.js";
+/** Return every Rust command registered by the synthesized workspace. */
+export function rustReleaseBinaryCommands() {
+    return RUST_RELEASE_BINARY_COMMANDS;
+}
+/** Resolve one registered Rust command by its `dbx` subcommand. */
+export function rustReleaseBinaryCommand(command) {
+    const resolved = RUST_RELEASE_BINARY_COMMANDS.find((candidate) => candidate.command === command);
+    if (!resolved)
+        throw new Error(`Unknown Rust release command: ${command}`);
+    return resolved;
+}
+function repositoryName(repository) {
+    const parsed = new URL(repository.replace(/^git\+/, ""));
+    const name = parsed.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+    if (parsed.hostname !== "github.com" || name.split("/").length !== 2) {
+        throw new Error(`Rust release repository must be a GitHub owner/repository: ${repository}`);
+    }
+    return name;
+}
+async function packageVersion() {
+    return (await import("../index.js")).PACKAGE_VERSION;
+}
+function versionedBinaryName(binaryName, version, platform) {
+    const suffix = version.replace(/[^0-9A-Za-z]+/g, "_");
+    const extension = platform === "win32" ? ".exe" : "";
+    return `${binaryName}_${suffix}${extension}`;
+}
+/** Select the archive for an OS and CPU pair. */
+export function rustReleaseBinaryAsset(command, platform, arch) {
+    const asset = command.assets.find((candidate) => candidate.os === platform && candidate.cpu === arch);
+    if (!asset) {
+        throw new Error(`${command.command} has no release binary for ${platform}/${arch}`);
+    }
+    return asset;
+}
+/** Build the GitHub release URL for a generated archive entry. */
+export function rustReleaseBinaryUrl(command, asset, version) {
+    return `https://github.com/${repositoryName(command.repository)}/releases/download/v${version}/${asset.name}`;
+}
+/** Install the release binary matching this CLI version and host platform. */
+export async function ensureRustReleaseBinary(command, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const version = options.version ?? (await packageVersion());
+    const asset = rustReleaseBinaryAsset(command, platform, arch);
+    const root = join(options.homeDir ?? homedir(), ".dbx-tools");
+    const binDir = join(root, "bin");
+    const destination = {
+        root,
+        binDir,
+        path: join(binDir, versionedBinaryName(command.binaryName, version, platform)),
+    };
+    return bin.ensure(command.binaryName, () => rustReleaseBinaryUrl(command, asset, version), {
+        autoUnpackage: true,
+        destination,
+        minVersion: version,
+        versionParser: (output) => {
+            const installed = bin.parseVersion(output);
+            return installed === version ? installed : undefined;
+        },
+    });
+}
+function signalExitCode(signal) {
+    return 128 + (osConstants.signals[signal] ?? 0);
+}
+/** Install and run a Rust command with inherited terminal I/O. */
+export async function runRustReleaseBinary(command, args, options = {}) {
+    const installed = await ensureRustReleaseBinary(command, options);
+    const child = spawn(installed.path, args, { stdio: "inherit" });
+    const signals = ["SIGINT", "SIGTERM", "SIGHUP"];
+    const handlers = new Map();
+    for (const signal of signals) {
+        const handler = () => {
+            if (!child.killed)
+                child.kill(signal);
+        };
+        handlers.set(signal, handler);
+        process.on(signal, handler);
+    }
+    try {
+        return await new Promise((resolve, reject) => {
+            child.once("error", reject);
+            child.once("close", (code, signal) => {
+                resolve(signal ? signalExitCode(signal) : (code ?? 1));
+            });
+        });
+    }
+    finally {
+        for (const [signal, handler] of handlers)
+            process.off(signal, handler);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rust-binary.js","sourceRoot":"","sources":["../../src/rust-binary.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lazy installation and transparent execution of Rust release binaries.\n *\n * @module\n */\nimport { spawn } from \"node:child_process\";\nimport { constants as osConstants, homedir } from \"node:os\";\nimport { join } from \"node:path\";\n\nimport { bin } from \"@dbx-tools/core\";\nimport { RUST_RELEASE_BINARY_COMMANDS } from \"./_rust-release-binaries.ts\";\n\n/** One release archive available to the current Node runtime. */\nexport interface RustReleaseBinaryAsset {\n  readonly os: string;\n  readonly cpu: string;\n  readonly name: string;\n}\n\n/** Generated registration for one `dbx` Rust command. */\nexport interface RustReleaseBinaryCommand {\n  readonly command: string;\n  readonly description: string;\n  readonly binaryName: string;\n  readonly repository: string;\n  readonly assets: readonly RustReleaseBinaryAsset[];\n}\n\n/** Overrides used by tests and callers that install under a custom home. */\nexport interface RustReleaseBinaryOptions {\n  readonly homeDir?: string;\n  readonly platform?: NodeJS.Platform;\n  readonly arch?: string;\n  readonly version?: string;\n}\n\n/** Return every Rust command registered by the synthesized workspace. */\nexport function rustReleaseBinaryCommands(): readonly RustReleaseBinaryCommand[] {\n  return RUST_RELEASE_BINARY_COMMANDS;\n}\n\n/** Resolve one registered Rust command by its `dbx` subcommand. */\nexport function rustReleaseBinaryCommand(command: string): RustReleaseBinaryCommand {\n  const resolved = RUST_RELEASE_BINARY_COMMANDS.find((candidate) => candidate.command === command);\n  if (!resolved) throw new Error(`Unknown Rust release command: ${command}`);\n  return resolved;\n}\n\nfunction repositoryName(repository: string): string {\n  const parsed = new URL(repository.replace(/^git\\+/, \"\"));\n  const name = parsed.pathname.replace(/^\\/+|\\/+$/g, \"\").replace(/\\.git$/, \"\");\n  if (parsed.hostname !== \"github.com\" || name.split(\"/\").length !== 2) {\n    throw new Error(`Rust release repository must be a GitHub owner/repository: ${repository}`);\n  }\n  return name;\n}\n\nasync function packageVersion(): Promise<string> {\n  return (await import(\"../index.ts\")).PACKAGE_VERSION;\n}\n\nfunction versionedBinaryName(\n  binaryName: string,\n  version: string,\n  platform: NodeJS.Platform,\n): string {\n  const suffix = version.replace(/[^0-9A-Za-z]+/g, \"_\");\n  const extension = platform === \"win32\" ? \".exe\" : \"\";\n  return `${binaryName}_${suffix}${extension}`;\n}\n\n/** Select the archive for an OS and CPU pair. */\nexport function rustReleaseBinaryAsset(\n  command: RustReleaseBinaryCommand,\n  platform: NodeJS.Platform,\n  arch: string,\n): RustReleaseBinaryAsset {\n  const asset = command.assets.find(\n    (candidate) => candidate.os === platform && candidate.cpu === arch,\n  );\n  if (!asset) {\n    throw new Error(`${command.command} has no release binary for ${platform}/${arch}`);\n  }\n  return asset;\n}\n\n/** Build the GitHub release URL for a generated archive entry. */\nexport function rustReleaseBinaryUrl(\n  command: RustReleaseBinaryCommand,\n  asset: RustReleaseBinaryAsset,\n  version: string,\n): string {\n  return `https://github.com/${repositoryName(command.repository)}/releases/download/v${version}/${asset.name}`;\n}\n\n/** Install the release binary matching this CLI version and host platform. */\nexport async function ensureRustReleaseBinary(\n  command: RustReleaseBinaryCommand,\n  options: RustReleaseBinaryOptions = {},\n): Promise<bin.BinContext> {\n  const platform = options.platform ?? process.platform;\n  const arch = options.arch ?? process.arch;\n  const version = options.version ?? (await packageVersion());\n  const asset = rustReleaseBinaryAsset(command, platform, arch);\n  const root = join(options.homeDir ?? homedir(), \".dbx-tools\");\n  const binDir = join(root, \"bin\");\n  const destination: bin.BinContext = {\n    root,\n    binDir,\n    path: join(binDir, versionedBinaryName(command.binaryName, version, platform)),\n  };\n  return bin.ensure(command.binaryName, () => rustReleaseBinaryUrl(command, asset, version), {\n    autoUnpackage: true,\n    destination,\n    minVersion: version,\n    versionParser: (output) => {\n      const installed = bin.parseVersion(output);\n      return installed === version ? installed : undefined;\n    },\n  });\n}\n\nfunction signalExitCode(signal: NodeJS.Signals): number {\n  return 128 + (osConstants.signals[signal] ?? 0);\n}\n\n/** Install and run a Rust command with inherited terminal I/O. */\nexport async function runRustReleaseBinary(\n  command: RustReleaseBinaryCommand,\n  args: readonly string[],\n  options: RustReleaseBinaryOptions = {},\n): Promise<number> {\n  const installed = await ensureRustReleaseBinary(command, options);\n  const child = spawn(installed.path, args, { stdio: \"inherit\" });\n  const signals = [\"SIGINT\", \"SIGTERM\", \"SIGHUP\"] as const;\n  const handlers = new Map<NodeJS.Signals, () => void>();\n  for (const signal of signals) {\n    const handler = () => {\n      if (!child.killed) child.kill(signal);\n    };\n    handlers.set(signal, handler);\n    process.on(signal, handler);\n  }\n  try {\n    return await new Promise<number>((resolve, reject) => {\n      child.once(\"error\", reject);\n      child.once(\"close\", (code, signal) => {\n        resolve(signal ? signalExitCode(signal) : (code ?? 1));\n      });\n    });\n  } finally {\n    for (const [signal, handler] of handlers) process.off(signal, handler);\n  }\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../index.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}
+{"root":["../src/_rust-release-binaries.ts","../src/bootstrap.ts","../src/bun.ts","../src/cli.ts","../src/root.ts","../src/rust-binary.ts","../index.ts","../bin/dbx-tools.ts"],"version":"5.9.3"}

package/package.json

@@ -28,11 +28,11 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/cli-appkit-env": "0.6.186",
-    "@dbx-tools/cli-auth": "0.6.186",
-    "@dbx-tools/cli-tunnel": "0.6.186",
-    "@dbx-tools/core": "0.6.186",
-    "@dbx-tools/shared-core": "0.6.186",
+    "@dbx-tools/cli-appkit-env": "0.6.188",
+    "@dbx-tools/cli-auth": "0.6.188",
+    "@dbx-tools/cli-tunnel": "0.6.188",
+    "@dbx-tools/core": "0.6.188",
+    "@dbx-tools/shared-core": "0.6.188",
     "commander": "^15.0.0"
   },
   "main": "./lib/index.js",
@@ -66,10 +66,14 @@
         "types": "./lib/src/root.d.ts",
         "default": "./lib/src/root.js"
       },
+      "./rust-binary": {
+        "types": "./lib/src/rust-binary.d.ts",
+        "default": "./lib/src/rust-binary.js"
+      },
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.186",
+  "version": "0.6.188",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
@@ -93,6 +97,10 @@
       "types": "./lib/src/root.d.ts",
       "default": "./lib/src/root.js"
     },
+    "./rust-binary": {
+      "types": "./lib/src/rust-binary.d.ts",
+      "default": "./lib/src/rust-binary.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/_rust-release-binaries.ts

@@ -0,0 +1,66 @@
+// GENERATED by projen - DO NOT EDIT.
+// Rust release package options are the source of truth.
+
+export const RUST_RELEASE_BINARY_COMMANDS = [
+  {
+    "command": "lakebase-proxy",
+    "description": "Loopback PostgreSQL proxy for Databricks Lakebase",
+    "binaryName": "dbx-lakebase-proxy",
+    "repository": "https://github.com/reggie-db/dbx-tools",
+    "assets": [
+      {
+        "os": "linux",
+        "cpu": "x64",
+        "name": "dbx-lakebase-proxy-linux-x64-gnu.tar.gz"
+      },
+      {
+        "os": "linux",
+        "cpu": "arm64",
+        "name": "dbx-lakebase-proxy-linux-arm64-gnu.tar.gz"
+      },
+      {
+        "os": "darwin",
+        "cpu": "x64",
+        "name": "dbx-lakebase-proxy-darwin-x64.tar.gz"
+      },
+      {
+        "os": "darwin",
+        "cpu": "arm64",
+        "name": "dbx-lakebase-proxy-darwin-arm64.tar.gz"
+      }
+    ]
+  },
+  {
+    "command": "model-proxy",
+    "description": "Multi-protocol Databricks model proxy",
+    "binaryName": "dbx-model-proxy",
+    "repository": "https://github.com/reggie-db/dbx-tools",
+    "assets": [
+      {
+        "os": "linux",
+        "cpu": "x64",
+        "name": "dbx-model-proxy-linux-x64-gnu.tar.gz"
+      },
+      {
+        "os": "linux",
+        "cpu": "arm64",
+        "name": "dbx-model-proxy-linux-arm64-gnu.tar.gz"
+      },
+      {
+        "os": "darwin",
+        "cpu": "x64",
+        "name": "dbx-model-proxy-darwin-x64.tar.gz"
+      },
+      {
+        "os": "darwin",
+        "cpu": "arm64",
+        "name": "dbx-model-proxy-darwin-arm64.tar.gz"
+      },
+      {
+        "os": "win32",
+        "cpu": "x64",
+        "name": "dbx-model-proxy-win32-x64-msvc.zip"
+      }
+    ]
+  }
+] as const;

package/src/cli.ts

@@ -21,6 +21,11 @@ import {
 } from "./bootstrap.ts";
 import { ensureWorkspaceReady, runBun, runProjen } from "./bun.ts";
 import { findWorkspaceRoot, needsBootstrap, needsToolchain } from "./root.ts";
+import {
+  runRustReleaseBinary,
+  rustReleaseBinaryCommands,
+  type RustReleaseBinaryCommand,
+} from "./rust-binary.ts";
 
 /** Commands the bin exposes, and the names help is rendered under. */
 const PROGRAM_NAMES = ["dbx", "dbx-tools"] as const;
@@ -81,11 +86,26 @@ function addForwardedCommand(
     });
 }
 
+function addRustReleaseCommand(program: Command, command: RustReleaseBinaryCommand): void {
+  program
+    .command(command.command)
+    .description(command.description)
+    .argument("[args...]", `arguments forwarded to ${command.binaryName}`)
+    .allowUnknownOption()
+    .allowExcessArguments()
+    .helpOption(false)
+    .action(async (args: string[]) => {
+      process.exitCode = await runRustReleaseBinary(command, args);
+    });
+}
+
 /** 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, AppKit env, auth, and tunnel")
+    .description(
+      "Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and native proxies",
+    )
     .showHelpAfterError()
     .helpOption("-h, --help", `Show ${name} help`);
 
@@ -121,6 +141,10 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     async () => (await import("@dbx-tools/cli-tunnel/cli")).buildProgram,
   );
 
+  for (const command of rustReleaseBinaryCommands()) {
+    addRustReleaseCommand(program, command);
+  }
+
   return program;
 }
 

package/src/rust-binary.ts

@@ -0,0 +1,154 @@
+/**
+ * Lazy installation and transparent execution of Rust release binaries.
+ *
+ * @module
+ */
+import { spawn } from "node:child_process";
+import { constants as osConstants, homedir } from "node:os";
+import { join } from "node:path";
+
+import { bin } from "@dbx-tools/core";
+import { RUST_RELEASE_BINARY_COMMANDS } from "./_rust-release-binaries.ts";
+
+/** One release archive available to the current Node runtime. */
+export interface RustReleaseBinaryAsset {
+  readonly os: string;
+  readonly cpu: string;
+  readonly name: string;
+}
+
+/** Generated registration for one `dbx` Rust command. */
+export interface RustReleaseBinaryCommand {
+  readonly command: string;
+  readonly description: string;
+  readonly binaryName: string;
+  readonly repository: string;
+  readonly assets: readonly RustReleaseBinaryAsset[];
+}
+
+/** Overrides used by tests and callers that install under a custom home. */
+export interface RustReleaseBinaryOptions {
+  readonly homeDir?: string;
+  readonly platform?: NodeJS.Platform;
+  readonly arch?: string;
+  readonly version?: string;
+}
+
+/** Return every Rust command registered by the synthesized workspace. */
+export function rustReleaseBinaryCommands(): readonly RustReleaseBinaryCommand[] {
+  return RUST_RELEASE_BINARY_COMMANDS;
+}
+
+/** Resolve one registered Rust command by its `dbx` subcommand. */
+export function rustReleaseBinaryCommand(command: string): RustReleaseBinaryCommand {
+  const resolved = RUST_RELEASE_BINARY_COMMANDS.find((candidate) => candidate.command === command);
+  if (!resolved) throw new Error(`Unknown Rust release command: ${command}`);
+  return resolved;
+}
+
+function repositoryName(repository: string): string {
+  const parsed = new URL(repository.replace(/^git\+/, ""));
+  const name = parsed.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+  if (parsed.hostname !== "github.com" || name.split("/").length !== 2) {
+    throw new Error(`Rust release repository must be a GitHub owner/repository: ${repository}`);
+  }
+  return name;
+}
+
+async function packageVersion(): Promise<string> {
+  return (await import("../index.ts")).PACKAGE_VERSION;
+}
+
+function versionedBinaryName(
+  binaryName: string,
+  version: string,
+  platform: NodeJS.Platform,
+): string {
+  const suffix = version.replace(/[^0-9A-Za-z]+/g, "_");
+  const extension = platform === "win32" ? ".exe" : "";
+  return `${binaryName}_${suffix}${extension}`;
+}
+
+/** Select the archive for an OS and CPU pair. */
+export function rustReleaseBinaryAsset(
+  command: RustReleaseBinaryCommand,
+  platform: NodeJS.Platform,
+  arch: string,
+): RustReleaseBinaryAsset {
+  const asset = command.assets.find(
+    (candidate) => candidate.os === platform && candidate.cpu === arch,
+  );
+  if (!asset) {
+    throw new Error(`${command.command} has no release binary for ${platform}/${arch}`);
+  }
+  return asset;
+}
+
+/** Build the GitHub release URL for a generated archive entry. */
+export function rustReleaseBinaryUrl(
+  command: RustReleaseBinaryCommand,
+  asset: RustReleaseBinaryAsset,
+  version: string,
+): string {
+  return `https://github.com/${repositoryName(command.repository)}/releases/download/v${version}/${asset.name}`;
+}
+
+/** Install the release binary matching this CLI version and host platform. */
+export async function ensureRustReleaseBinary(
+  command: RustReleaseBinaryCommand,
+  options: RustReleaseBinaryOptions = {},
+): Promise<bin.BinContext> {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const version = options.version ?? (await packageVersion());
+  const asset = rustReleaseBinaryAsset(command, platform, arch);
+  const root = join(options.homeDir ?? homedir(), ".dbx-tools");
+  const binDir = join(root, "bin");
+  const destination: bin.BinContext = {
+    root,
+    binDir,
+    path: join(binDir, versionedBinaryName(command.binaryName, version, platform)),
+  };
+  return bin.ensure(command.binaryName, () => rustReleaseBinaryUrl(command, asset, version), {
+    autoUnpackage: true,
+    destination,
+    minVersion: version,
+    versionParser: (output) => {
+      const installed = bin.parseVersion(output);
+      return installed === version ? installed : undefined;
+    },
+  });
+}
+
+function signalExitCode(signal: NodeJS.Signals): number {
+  return 128 + (osConstants.signals[signal] ?? 0);
+}
+
+/** Install and run a Rust command with inherited terminal I/O. */
+export async function runRustReleaseBinary(
+  command: RustReleaseBinaryCommand,
+  args: readonly string[],
+  options: RustReleaseBinaryOptions = {},
+): Promise<number> {
+  const installed = await ensureRustReleaseBinary(command, options);
+  const child = spawn(installed.path, args, { stdio: "inherit" });
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP"] as const;
+  const handlers = new Map<NodeJS.Signals, () => void>();
+  for (const signal of signals) {
+    const handler = () => {
+      if (!child.killed) child.kill(signal);
+    };
+    handlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  try {
+    return await new Promise<number>((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", (code, signal) => {
+        resolve(signal ? signalExitCode(signal) : (code ?? 1));
+      });
+    });
+  } finally {
+    for (const [signal, handler] of handlers) process.off(signal, handler);
+  }
+}