@dbx-tools/cli 0.9.60 → 0.9.64

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

@@ -0,0 +1,69 @@
+/**
+ * Install the pinned multi-file Genie Code runtime under dbx-tools ownership.
+ *
+ * @module
+ */
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { bin } from "@dbx-tools/core";
+import { GENIE_CODE_VERSION } from "@dbx-tools/shared-genie-code/options";
+const GENIE_CODE_ASSETS = {
+    "darwin:arm64": {
+        target: "aarch64-apple-darwin",
+        sha256: "78cc7e358c8bfc62d6da26364c762be37fc2e2a10b7e83f21a3b166f901f528e",
+    },
+    "darwin:x64": {
+        target: "x86_64-apple-darwin",
+        sha256: "2021b8b27ec3116fc015c1676b5f65c3ce11d57f1dff9c302aae135f6e4f1a5f",
+    },
+    "linux:arm64": {
+        target: "aarch64-unknown-linux-musl",
+        sha256: "dfd278c267dde43e1fe7e7d7a0da8d7a1a148cdf3d2004bd30b351645c4fe0a7",
+    },
+    "linux:x64": {
+        target: "x86_64-unknown-linux-musl",
+        sha256: "e3d9a55f6d51bdc745eda4744fb827ba1df6dacf1069518f7347a59f48c89430",
+    },
+    "win32:arm64": {
+        target: "aarch64-pc-windows-msvc",
+        sha256: "aeac95bd0148f942194270ba932245cec32e98da67292ba7b008bcab675ba7f8",
+    },
+    "win32:x64": {
+        target: "x86_64-pc-windows-msvc",
+        sha256: "c9f92c8d60273250262527bca525451501c4e8351e59927a1686c305be29a922",
+    },
+};
+/** Resolve the pinned release asset for one supported host. */
+export function genieCodeAsset(platform = process.platform, architecture = process.arch) {
+    const asset = GENIE_CODE_ASSETS[`${platform}:${architecture}`];
+    if (!asset) {
+        throw new Error(`Genie Code ${GENIE_CODE_VERSION} does not support ${platform}/${architecture}`);
+    }
+    return asset;
+}
+/** Install and return the shared Genie Code package entrypoint. */
+export async function installGenieCode(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const asset = genieCodeAsset(platform, options.architecture ?? process.arch);
+    const executable = platform === "win32" ? "genie.exe" : "genie";
+    const helper = platform === "win32" ? "genie-code-mode-host.exe" : "genie-code-mode-host";
+    const entrypoint = join("bin", executable);
+    const root = join(options.homeDirectory ?? homedir(), ".dbx-tools", "genie", "releases", `${GENIE_CODE_VERSION}-${asset.target}`);
+    const destination = {
+        root,
+        binDir: join(root, dirname(entrypoint)),
+        path: join(root, entrypoint),
+    };
+    const url = `https://github.com/databricks/genie-code-cli/releases/download/v${GENIE_CODE_VERSION}/` +
+        `genie-package-${asset.target}.tar.gz`;
+    return bin.ensure("genie", { url, sha256: asset.sha256 }, {
+        destination,
+        minVersion: "0.1.0",
+        versionParser: ({ stdout }) => stdout.trim() === `genie ${GENIE_CODE_VERSION}` ? "0.1.0" : undefined,
+        package: {
+            entrypoint,
+            requiredPaths: ["genie-package.json", join("bin", helper), "genie-path", "genie-resources"],
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,7 @@
+/**
+ * CLI projection of the shared managed Genie Code options.
+ *
+ * @module
+ */
+export { GenieCodeOptionsSchema as GenieCodeCliOptionsSchema, resolveGenieCodeOptions as resolveGenieCodeCliOptions, } from "@dbx-tools/shared-genie-code/options";
+export type { GenieCodeOptions as GenieCodeCliOptions, ResolvedGenieCodeOptions as ResolvedGenieCodeCliOptions, } from "@dbx-tools/shared-genie-code/options";

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

@@ -0,0 +1,7 @@
+/**
+ * CLI projection of the shared managed Genie Code options.
+ *
+ * @module
+ */
+export { GenieCodeOptionsSchema as GenieCodeCliOptionsSchema, resolveGenieCodeOptions as resolveGenieCodeCliOptions, } from "@dbx-tools/shared-genie-code/options";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9nZW5pZS1jb2RlL29wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILE9BQU8sRUFDTCxzQkFBc0IsSUFBSSx5QkFBeUIsRUFDbkQsdUJBQXVCLElBQUksMEJBQTBCLEdBQ3RELE1BQU0sc0NBQXNDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENMSSBwcm9qZWN0aW9uIG9mIHRoZSBzaGFyZWQgbWFuYWdlZCBHZW5pZSBDb2RlIG9wdGlvbnMuXG4gKlxuICogQG1vZHVsZVxuICovXG5cbmV4cG9ydCB7XG4gIEdlbmllQ29kZU9wdGlvbnNTY2hlbWEgYXMgR2VuaWVDb2RlQ2xpT3B0aW9uc1NjaGVtYSxcbiAgcmVzb2x2ZUdlbmllQ29kZU9wdGlvbnMgYXMgcmVzb2x2ZUdlbmllQ29kZUNsaU9wdGlvbnMsXG59IGZyb20gXCJAZGJ4LXRvb2xzL3NoYXJlZC1nZW5pZS1jb2RlL29wdGlvbnNcIjtcbmV4cG9ydCB0eXBlIHtcbiAgR2VuaWVDb2RlT3B0aW9ucyBhcyBHZW5pZUNvZGVDbGlPcHRpb25zLFxuICBSZXNvbHZlZEdlbmllQ29kZU9wdGlvbnMgYXMgUmVzb2x2ZWRHZW5pZUNvZGVDbGlPcHRpb25zLFxufSBmcm9tIFwiQGRieC10b29scy9zaGFyZWQtZ2VuaWUtY29kZS9vcHRpb25zXCI7XG4iXX0=

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

@@ -0,0 +1,21 @@
+/**
+ * Internal readiness gate and interactive Genie Code child process.
+ *
+ * @module
+ */
+/** Private environment field carrying serialized runner options. */
+declare const RUNNER_OPTIONS_ENV = "DBX_TOOLS_GENIE_RUNNER_OPTIONS";
+/** Parse the serialized runner boundary from its private environment field. */
+export declare function genieCodeRunnerOptions(environment?: NodeJS.ProcessEnv): {
+    executable: string;
+    arguments: readonly string[];
+    home: string;
+    gatewayHealthUrl: string;
+    bearerToken: string;
+    startupTimeoutMs: number;
+};
+/** Wait until the guarded model-gateway health route accepts the runner token. */
+export declare function waitForGenieCodeGateway(healthUrl: string, bearerToken: string, timeoutMs: number): Promise<void>;
+/** Run Genie Code with inherited terminal streams after its gateway is ready. */
+export declare function runGenieCodeChild(environment?: NodeJS.ProcessEnv): Promise<void>;
+export { RUNNER_OPTIONS_ENV };

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

@@ -0,0 +1,90 @@
+/**
+ * Internal readiness gate and interactive Genie Code child process.
+ *
+ * @module
+ */
+import { AppKitChildProcess } from "@dbx-tools/appkit/child-process";
+import { asyncUtils, log } from "@dbx-tools/shared-core";
+import { GenieCodeRunnerOptionsSchema } from "@dbx-tools/shared-genie-code/options";
+/** Private environment field carrying serialized runner options. */
+const RUNNER_OPTIONS_ENV = "DBX_TOOLS_GENIE_RUNNER_OPTIONS";
+const logger = log.logger("genie-code:runner");
+/** Parse the serialized runner boundary from its private environment field. */
+export function genieCodeRunnerOptions(environment = process.env) {
+    const serialized = environment[RUNNER_OPTIONS_ENV];
+    if (!serialized)
+        throw new Error(`${RUNNER_OPTIONS_ENV} is required`);
+    return GenieCodeRunnerOptionsSchema.parse(JSON.parse(serialized));
+}
+/** Wait until the guarded model-gateway health route accepts the runner token. */
+export async function waitForGenieCodeGateway(healthUrl, bearerToken, timeoutMs) {
+    for await (const ready of asyncUtils.poll(async ({ signal }) => {
+        try {
+            const response = await fetch(healthUrl, {
+                headers: { authorization: `Bearer ${bearerToken}` },
+                signal,
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }, {
+        intervalMs: 200,
+        timeoutMs,
+        predicate: (ready) => !ready,
+    })) {
+        if (ready)
+            return;
+    }
+}
+/** Run Genie Code with inherited terminal streams after its gateway is ready. */
+export async function runGenieCodeChild(environment = process.env) {
+    const options = genieCodeRunnerOptions(environment);
+    logger.info("waiting for model gateway", {
+        gateway: options.gatewayHealthUrl,
+        timeoutMs: options.startupTimeoutMs,
+    });
+    await waitForGenieCodeGateway(options.gatewayHealthUrl, options.bearerToken, options.startupTimeoutMs);
+    logger.info("model gateway ready; starting Genie Code", {
+        executable: options.executable,
+        home: options.home,
+    });
+    const child = new AppKitChildProcess([
+        options.executable,
+        [...options.arguments],
+        {
+            cwd: process.cwd(),
+            env: {
+                ...environment,
+                GENIE_HOME: options.home,
+            },
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+        },
+    ], {
+        gracefulTimeoutMs: 5_000,
+        forceTimeoutMs: 1_000,
+    });
+    const running = child.start();
+    const shutdown = () => {
+        void child.shutdown();
+    };
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        process.once(signal, shutdown);
+    }
+    try {
+        const result = await running;
+        if (result.exitCode !== 0)
+            process.exitCode = result.exitCode;
+    }
+    finally {
+        for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+            process.off(signal, shutdown);
+        }
+        await child.shutdown();
+    }
+}
+export { RUNNER_OPTIONS_ENV };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVubmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2dlbmllLWNvZGUvcnVubmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNyRSxPQUFPLEVBQUUsVUFBVSxFQUFFLEdBQUcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3pELE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBRXBGLG9FQUFvRTtBQUNwRSxNQUFNLGtCQUFrQixHQUFHLGdDQUFnQyxDQUFDO0FBQzVELE1BQU0sTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFNLENBQUMsbUJBQW1CLENBQUMsQ0FBQztBQUUvQywrRUFBK0U7QUFDL0UsTUFBTSxVQUFVLHNCQUFzQixDQUFDLGNBQWlDLE9BQU8sQ0FBQyxHQUFHO0lBQ2pGLE1BQU0sVUFBVSxHQUFHLFdBQVcsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBQ25ELElBQUksQ0FBQyxVQUFVO1FBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxHQUFHLGtCQUFrQixjQUFjLENBQUMsQ0FBQztJQUN0RSxPQUFPLDRCQUE0QixDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7QUFDcEUsQ0FBQztBQUVELGtGQUFrRjtBQUNsRixNQUFNLENBQUMsS0FBSyxVQUFVLHVCQUF1QixDQUMzQyxTQUFpQixFQUNqQixXQUFtQixFQUNuQixTQUFpQjtJQUVqQixJQUFJLEtBQUssRUFBRSxNQUFNLEtBQUssSUFBSSxVQUFVLENBQUMsSUFBSSxDQUN2QyxLQUFLLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFO1FBQ25CLElBQUksQ0FBQztZQUNILE1BQU0sUUFBUSxHQUFHLE1BQU0sS0FBSyxDQUFDLFNBQVMsRUFBRTtnQkFDdEMsT0FBTyxFQUFFLEVBQUUsYUFBYSxFQUFFLFVBQVUsV0FBVyxFQUFFLEVBQUU7Z0JBQ25ELE1BQU07YUFDUCxDQUFDLENBQUM7WUFDSCxPQUFPLFFBQVEsQ0FBQyxFQUFFLENBQUM7UUFDckIsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztJQUNILENBQUMsRUFDRDtRQUNFLFVBQVUsRUFBRSxHQUFHO1FBQ2YsU0FBUztRQUNULFNBQVMsRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLO0tBQzdCLENBQ0YsRUFBRSxDQUFDO1FBQ0YsSUFBSSxLQUFLO1lBQUUsT0FBTztJQUNwQixDQUFDO0FBQ0gsQ0FBQztBQUVELGlGQUFpRjtBQUNqRixNQUFNLENBQUMsS0FBSyxVQUFVLGlCQUFpQixDQUNyQyxjQUFpQyxPQUFPLENBQUMsR0FBRztJQUU1QyxNQUFNLE9BQU8sR0FBRyxzQkFBc0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNwRCxNQUFNLENBQUMsSUFBSSxDQUFDLDJCQUEyQixFQUFFO1FBQ3ZDLE9BQU8sRUFBRSxPQUFPLENBQUMsZ0JBQWdCO1FBQ2pDLFNBQVMsRUFBRSxPQUFPLENBQUMsZ0JBQWdCO0tBQ3BDLENBQUMsQ0FBQztJQUNILE1BQU0sdUJBQXVCLENBQzNCLE9BQU8sQ0FBQyxnQkFBZ0IsRUFDeEIsT0FBTyxDQUFDLFdBQVcsRUFDbkIsT0FBTyxDQUFDLGdCQUFnQixDQUN6QixDQUFDO0lBQ0YsTUFBTSxDQUFDLElBQUksQ0FBQywwQ0FBMEMsRUFBRTtRQUN0RCxVQUFVLEVBQUUsT0FBTyxDQUFDLFVBQVU7UUFDOUIsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJO0tBQ25CLENBQUMsQ0FBQztJQUNILE1BQU0sS0FBSyxHQUFHLElBQUksa0JBQWtCLENBQ2xDO1FBQ0UsT0FBTyxDQUFDLFVBQVU7UUFDbEIsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUM7UUFDdEI7WUFDRSxHQUFHLEVBQUUsT0FBTyxDQUFDLEdBQUcsRUFBRTtZQUNsQixHQUFHLEVBQUU7Z0JBQ0gsR0FBRyxXQUFXO2dCQUNkLFVBQVUsRUFBRSxPQUFPLENBQUMsSUFBSTthQUN6QjtZQUNELEtBQUssRUFBRSxTQUFTO1lBQ2hCLE1BQU0sRUFBRSxTQUFTO1lBQ2pCLE1BQU0sRUFBRSxTQUFTO1NBQ2xCO0tBQ0YsRUFDRDtRQUNFLGlCQUFpQixFQUFFLEtBQUs7UUFDeEIsY0FBYyxFQUFFLEtBQUs7S0FDdEIsQ0FDRixDQUFDO0lBQ0YsTUFBTSxPQUFPLEdBQUcsS0FBSyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzlCLE1BQU0sUUFBUSxHQUFHLEdBQUcsRUFBRTtRQUNwQixLQUFLLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUN4QixDQUFDLENBQUM7SUFDRixLQUFLLE1BQU0sTUFBTSxJQUFJLENBQUMsUUFBUSxFQUFFLFNBQVMsRUFBRSxRQUFRLENBQVUsRUFBRSxDQUFDO1FBQzlELE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFDRCxJQUFJLENBQUM7UUFDSCxNQUFNLE1BQU0sR0FBRyxNQUFNLE9BQU8sQ0FBQztRQUM3QixJQUFJLE1BQU0sQ0FBQyxRQUFRLEtBQUssQ0FBQztZQUFFLE9BQU8sQ0FBQyxRQUFRLEdBQUcsTUFBTSxDQUFDLFFBQVEsQ0FBQztJQUNoRSxDQUFDO1lBQVMsQ0FBQztRQUNULEtBQUssTUFBTSxNQUFNLElBQUksQ0FBQyxRQUFRLEVBQUUsU0FBUyxFQUFFLFFBQVEsQ0FBVSxFQUFFLENBQUM7WUFDOUQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDaEMsQ0FBQztRQUNELE1BQU0sS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3pCLENBQUM7QUFDSCxDQUFDO0FBRUQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEludGVybmFsIHJlYWRpbmVzcyBnYXRlIGFuZCBpbnRlcmFjdGl2ZSBHZW5pZSBDb2RlIGNoaWxkIHByb2Nlc3MuXG4gKlxuICogQG1vZHVsZVxuICovXG5cbmltcG9ydCB7IEFwcEtpdENoaWxkUHJvY2VzcyB9IGZyb20gXCJAZGJ4LXRvb2xzL2FwcGtpdC9jaGlsZC1wcm9jZXNzXCI7XG5pbXBvcnQgeyBhc3luY1V0aWxzLCBsb2cgfSBmcm9tIFwiQGRieC10b29scy9zaGFyZWQtY29yZVwiO1xuaW1wb3J0IHsgR2VuaWVDb2RlUnVubmVyT3B0aW9uc1NjaGVtYSB9IGZyb20gXCJAZGJ4LXRvb2xzL3NoYXJlZC1nZW5pZS1jb2RlL29wdGlvbnNcIjtcblxuLyoqIFByaXZhdGUgZW52aXJvbm1lbnQgZmllbGQgY2Fycnlpbmcgc2VyaWFsaXplZCBydW5uZXIgb3B0aW9ucy4gKi9cbmNvbnN0IFJVTk5FUl9PUFRJT05TX0VOViA9IFwiREJYX1RPT0xTX0dFTklFX1JVTk5FUl9PUFRJT05TXCI7XG5jb25zdCBsb2dnZXIgPSBsb2cubG9nZ2VyKFwiZ2VuaWUtY29kZTpydW5uZXJcIik7XG5cbi8qKiBQYXJzZSB0aGUgc2VyaWFsaXplZCBydW5uZXIgYm91bmRhcnkgZnJvbSBpdHMgcHJpdmF0ZSBlbnZpcm9ubWVudCBmaWVsZC4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZW5pZUNvZGVSdW5uZXJPcHRpb25zKGVudmlyb25tZW50OiBOb2RlSlMuUHJvY2Vzc0VudiA9IHByb2Nlc3MuZW52KSB7XG4gIGNvbnN0IHNlcmlhbGl6ZWQgPSBlbnZpcm9ubWVudFtSVU5ORVJfT1BUSU9OU19FTlZdO1xuICBpZiAoIXNlcmlhbGl6ZWQpIHRocm93IG5ldyBFcnJvcihgJHtSVU5ORVJfT1BUSU9OU19FTlZ9IGlzIHJlcXVpcmVkYCk7XG4gIHJldHVybiBHZW5pZUNvZGVSdW5uZXJPcHRpb25zU2NoZW1hLnBhcnNlKEpTT04ucGFyc2Uoc2VyaWFsaXplZCkpO1xufVxuXG4vKiogV2FpdCB1bnRpbCB0aGUgZ3VhcmRlZCBtb2RlbC1nYXRld2F5IGhlYWx0aCByb3V0ZSBhY2NlcHRzIHRoZSBydW5uZXIgdG9rZW4uICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gd2FpdEZvckdlbmllQ29kZUdhdGV3YXkoXG4gIGhlYWx0aFVybDogc3RyaW5nLFxuICBiZWFyZXJUb2tlbjogc3RyaW5nLFxuICB0aW1lb3V0TXM6IG51bWJlcixcbik6IFByb21pc2U8dm9pZD4ge1xuICBmb3IgYXdhaXQgKGNvbnN0IHJlYWR5IG9mIGFzeW5jVXRpbHMucG9sbChcbiAgICBhc3luYyAoeyBzaWduYWwgfSkgPT4ge1xuICAgICAgdHJ5IHtcbiAgICAgICAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBmZXRjaChoZWFsdGhVcmwsIHtcbiAgICAgICAgICBoZWFkZXJzOiB7IGF1dGhvcml6YXRpb246IGBCZWFyZXIgJHtiZWFyZXJUb2tlbn1gIH0sXG4gICAgICAgICAgc2lnbmFsLFxuICAgICAgICB9KTtcbiAgICAgICAgcmV0dXJuIHJlc3BvbnNlLm9rO1xuICAgICAgfSBjYXRjaCB7XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICAgIH1cbiAgICB9LFxuICAgIHtcbiAgICAgIGludGVydmFsTXM6IDIwMCxcbiAgICAgIHRpbWVvdXRNcyxcbiAgICAgIHByZWRpY2F0ZTogKHJlYWR5KSA9PiAhcmVhZHksXG4gICAgfSxcbiAgKSkge1xuICAgIGlmIChyZWFkeSkgcmV0dXJuO1xuICB9XG59XG5cbi8qKiBSdW4gR2VuaWUgQ29kZSB3aXRoIGluaGVyaXRlZCB0ZXJtaW5hbCBzdHJlYW1zIGFmdGVyIGl0cyBnYXRld2F5IGlzIHJlYWR5LiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJ1bkdlbmllQ29kZUNoaWxkKFxuICBlbnZpcm9ubWVudDogTm9kZUpTLlByb2Nlc3NFbnYgPSBwcm9jZXNzLmVudixcbik6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBvcHRpb25zID0gZ2VuaWVDb2RlUnVubmVyT3B0aW9ucyhlbnZpcm9ubWVudCk7XG4gIGxvZ2dlci5pbmZvKFwid2FpdGluZyBmb3IgbW9kZWwgZ2F0ZXdheVwiLCB7XG4gICAgZ2F0ZXdheTogb3B0aW9ucy5nYXRld2F5SGVhbHRoVXJsLFxuICAgIHRpbWVvdXRNczogb3B0aW9ucy5zdGFydHVwVGltZW91dE1zLFxuICB9KTtcbiAgYXdhaXQgd2FpdEZvckdlbmllQ29kZUdhdGV3YXkoXG4gICAgb3B0aW9ucy5nYXRld2F5SGVhbHRoVXJsLFxuICAgIG9wdGlvbnMuYmVhcmVyVG9rZW4sXG4gICAgb3B0aW9ucy5zdGFydHVwVGltZW91dE1zLFxuICApO1xuICBsb2dnZXIuaW5mbyhcIm1vZGVsIGdhdGV3YXkgcmVhZHk7IHN0YXJ0aW5nIEdlbmllIENvZGVcIiwge1xuICAgIGV4ZWN1dGFibGU6IG9wdGlvbnMuZXhlY3V0YWJsZSxcbiAgICBob21lOiBvcHRpb25zLmhvbWUsXG4gIH0pO1xuICBjb25zdCBjaGlsZCA9IG5ldyBBcHBLaXRDaGlsZFByb2Nlc3MoXG4gICAgW1xuICAgICAgb3B0aW9ucy5leGVjdXRhYmxlLFxuICAgICAgWy4uLm9wdGlvbnMuYXJndW1lbnRzXSxcbiAgICAgIHtcbiAgICAgICAgY3dkOiBwcm9jZXNzLmN3ZCgpLFxuICAgICAgICBlbnY6IHtcbiAgICAgICAgICAuLi5lbnZpcm9ubWVudCxcbiAgICAgICAgICBHRU5JRV9IT01FOiBvcHRpb25zLmhvbWUsXG4gICAgICAgIH0sXG4gICAgICAgIHN0ZGluOiBcImluaGVyaXRcIixcbiAgICAgICAgc3Rkb3V0OiBcImluaGVyaXRcIixcbiAgICAgICAgc3RkZXJyOiBcImluaGVyaXRcIixcbiAgICAgIH0sXG4gICAgXSxcbiAgICB7XG4gICAgICBncmFjZWZ1bFRpbWVvdXRNczogNV8wMDAsXG4gICAgICBmb3JjZVRpbWVvdXRNczogMV8wMDAsXG4gICAgfSxcbiAgKTtcbiAgY29uc3QgcnVubmluZyA9IGNoaWxkLnN0YXJ0KCk7XG4gIGNvbnN0IHNodXRkb3duID0gKCkgPT4ge1xuICAgIHZvaWQgY2hpbGQuc2h1dGRvd24oKTtcbiAgfTtcbiAgZm9yIChjb25zdCBzaWduYWwgb2YgW1wiU0lHSU5UXCIsIFwiU0lHVEVSTVwiLCBcIlNJR0hVUFwiXSBhcyBjb25zdCkge1xuICAgIHByb2Nlc3Mub25jZShzaWduYWwsIHNodXRkb3duKTtcbiAgfVxuICB0cnkge1xuICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IHJ1bm5pbmc7XG4gICAgaWYgKHJlc3VsdC5leGl0Q29kZSAhPT0gMCkgcHJvY2Vzcy5leGl0Q29kZSA9IHJlc3VsdC5leGl0Q29kZTtcbiAgfSBmaW5hbGx5IHtcbiAgICBmb3IgKGNvbnN0IHNpZ25hbCBvZiBbXCJTSUdJTlRcIiwgXCJTSUdURVJNXCIsIFwiU0lHSFVQXCJdIGFzIGNvbnN0KSB7XG4gICAgICBwcm9jZXNzLm9mZihzaWduYWwsIHNodXRkb3duKTtcbiAgICB9XG4gICAgYXdhaXQgY2hpbGQuc2h1dGRvd24oKTtcbiAgfVxufVxuXG5leHBvcnQgeyBSVU5ORVJfT1BUSU9OU19FTlYgfTtcbiJdfQ==

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

@@ -0,0 +1,49 @@
+/**
+ * Supervise Genie Code and its authenticated local model gateway.
+ *
+ * @module
+ */
+import * as auth from "@dbx-tools/auth";
+import type { BinContext } from "@dbx-tools/core/bin";
+import { type GenieCodeOptions } from "@dbx-tools/shared-genie-code/options";
+import type { ModelClass } from "@dbx-tools/shared-model/contracts";
+import concurrently from "concurrently";
+import { writeGenieCodeConfig, type GenieCodeHome } from "./config.ts";
+import { installGenieCode } from "./install.ts";
+/** Injectable owners used to prepare and supervise managed Genie Code. */
+export interface GenieCodeRuntimeDependencies {
+    createAuthClient: typeof auth.client.createAuthClient;
+    install: typeof installGenieCode;
+    port(options: {
+        host: string;
+        port?: number;
+    }): Promise<number>;
+    resolveBin(packageReference: string, binName: string): string;
+    resolveCodexModel(model: string | undefined, profile: string, modelClass?: ModelClass): Promise<string>;
+    supervise: typeof concurrently;
+    token(): string;
+    writeConfig: typeof writeGenieCodeConfig;
+}
+/** Inputs accepted by managed Genie Code preparation and execution. */
+export interface RunGenieCodeOptions {
+    cwd?: string;
+    dependencies?: Partial<GenieCodeRuntimeDependencies>;
+    genieArgs?: readonly string[];
+    options?: GenieCodeOptions;
+}
+/** Resolved installation, auth, listener, and home for one invocation. */
+export interface PreparedGenieCodeRuntime {
+    bearerToken: string;
+    gatewayBaseUrl: string;
+    gatewayHealthUrl: string;
+    gatewayListen: string;
+    gatewayPort: number;
+    home: GenieCodeHome;
+    installation: BinContext;
+    model: string;
+    profile: string;
+}
+/** Resolve auth, installation, listener, and configuration before spawning children. */
+export declare function prepareGenieCodeRuntime(input?: RunGenieCodeOptions): Promise<PreparedGenieCodeRuntime>;
+/** Run Genie Code and the model gateway until either process exits. */
+export declare function runGenieCode(input?: RunGenieCodeOptions): Promise<void>;

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

@@ -0,0 +1,169 @@
+/**
+ * Supervise Genie Code and its authenticated local model gateway.
+ *
+ * @module
+ */
+import { randomBytes } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { delimiter, dirname } from "node:path";
+import { DatabricksModelRegistry, models } from "@dbx-tools/appkit-model-gateway";
+import * as auth from "@dbx-tools/auth";
+import { resolveServicePackageBin } from "@dbx-tools/cli-service/definition";
+import { workspaceClient } from "@dbx-tools/databricks";
+import { log } from "@dbx-tools/shared-core";
+import { resolveGenieCodeOptions, } from "@dbx-tools/shared-genie-code/options";
+import concurrently from "concurrently";
+import getPort from "get-port";
+import { writeGenieCodeConfig } from "./config.js";
+import { installGenieCode } from "./install.js";
+import { RUNNER_OPTIONS_ENV } from "./runner.js";
+const logger = log.logger("genie-code");
+const DEFAULT_DEPENDENCIES = {
+    createAuthClient: auth.client.createAuthClient,
+    install: installGenieCode,
+    port: ({ host, port }) => getPort({ host, ...(port ? { port } : {}) }),
+    resolveBin: resolveServicePackageBin,
+    resolveCodexModel,
+    supervise: concurrently,
+    token: () => randomBytes(32).toString("base64url"),
+    writeConfig: writeGenieCodeConfig,
+};
+/** Resolve a Genie `--model` value to the Codex catalogue slug the gateway publishes. */
+async function resolveCodexModel(model, profile, modelClass) {
+    const client = await workspaceClient.createWorkspaceClient({ profile });
+    const target = await new DatabricksModelRegistry({ client }).resolve(model, {
+        requiresTools: true,
+        ...(modelClass ? { modelClass } : {}),
+    });
+    if (!target) {
+        throw new Error(model ? `Genie Code model not found: ${model}` : "No tool-capable chat model is available");
+    }
+    return models.codexModelSlug(target);
+}
+/** Resolve auth, installation, listener, and configuration before spawning children. */
+export async function prepareGenieCodeRuntime(input = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };
+    const options = resolveGenieCodeOptions(input.options);
+    logger.info("resolving Databricks authentication", {
+        requestedProfile: options.profile,
+    });
+    const authClient = await dependencies.createAuthClient(options.profile ? { profile: options.profile } : {});
+    const profile = authClient.profile;
+    if (!profile) {
+        throw new Error("Genie Code requires a configured Databricks profile");
+    }
+    logger.info("preparing Genie Code runtime", {
+        profile,
+        model: options.model,
+        modelClass: options.modelClass,
+    });
+    const installation = await dependencies.install();
+    const host = options.gatewayListen.host;
+    const requestedPort = options.gatewayListen.port;
+    const gatewayPort = await dependencies.port({
+        host,
+        ...(requestedPort > 0 ? { port: requestedPort } : {}),
+    });
+    if (requestedPort > 0 && gatewayPort !== requestedPort) {
+        throw new Error(`Genie Code gateway port ${requestedPort} is already in use`);
+    }
+    const model = await dependencies.resolveCodexModel(options.model, profile, options.modelClass);
+    logger.info("resolved Genie Code model", {
+        requested: options.model,
+        modelClass: options.modelClass,
+        model,
+    });
+    const urlHost = host.includes(":") ? `[${host}]` : host;
+    const gatewayBaseUrl = `http://${urlHost}:${gatewayPort}/v1`;
+    const gatewayHealthUrl = `http://${urlHost}:${gatewayPort}/api/healthz`;
+    const gatewayListen = `tcp://${urlHost}:${gatewayPort}`;
+    const bearerToken = dependencies.token();
+    const home = await dependencies.writeConfig({
+        bearerToken,
+        gatewayBaseUrl,
+        model,
+        profile,
+        projectDirectory: input.cwd ?? process.cwd(),
+    });
+    return {
+        bearerToken,
+        gatewayBaseUrl,
+        gatewayHealthUrl,
+        gatewayListen,
+        gatewayPort,
+        home,
+        installation,
+        model,
+        profile,
+    };
+}
+function shellExecutable(path) {
+    if (process.platform === "win32")
+        return `"${path.replaceAll('"', '""')}"`;
+    return `'${path.replaceAll("'", "'\\''")}'`;
+}
+function childPath(...paths) {
+    return [...new Set([...paths.map(dirname), process.env.PATH].filter(Boolean))].join(delimiter);
+}
+/** Run Genie Code and the model gateway until either process exits. */
+export async function runGenieCode(input = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };
+    const prepared = await prepareGenieCodeRuntime({
+        ...input,
+        dependencies,
+    });
+    const gatewayBin = dependencies.resolveBin(import.meta.url, "dbx-model-gateway");
+    const runnerBin = dependencies.resolveBin(import.meta.url, "dbx-genie");
+    const path = childPath(gatewayBin, runnerBin);
+    const runnerOptions = {
+        executable: prepared.installation.path,
+        arguments: ["-p", prepared.home.overlayName, ...(input.genieArgs ?? [])],
+        home: prepared.home.home,
+        gatewayHealthUrl: prepared.gatewayHealthUrl,
+        bearerToken: prepared.bearerToken,
+        startupTimeoutMs: 60_000,
+    };
+    const { result } = dependencies.supervise([
+        {
+            command: shellExecutable(gatewayBin),
+            name: "gateway",
+            env: {
+                ...process.env,
+                PATH: path,
+                LISTEN: prepared.gatewayListen,
+                DATABRICKS_CONFIG_PROFILE: prepared.profile,
+                DBX_TOOLS_MODEL_GATEWAY_BEARER_TOKEN: prepared.bearerToken,
+            },
+        },
+        {
+            command: shellExecutable(runnerBin),
+            name: "genie",
+            env: {
+                ...process.env,
+                PATH: path,
+                DATABRICKS_CONFIG_PROFILE: prepared.profile,
+                [RUNNER_OPTIONS_ENV]: JSON.stringify(runnerOptions),
+            },
+        },
+    ], {
+        cwd: input.cwd ?? process.cwd(),
+        raw: true,
+        killOthersOn: ["failure", "success"],
+        killSignal: "SIGTERM",
+        killTimeout: 17_000,
+        successCondition: "command-genie",
+    });
+    logger.info("started Genie Code and model gateway", {
+        profile: prepared.profile,
+        model: prepared.model,
+        gateway: prepared.gatewayBaseUrl,
+        home: prepared.home.home,
+    });
+    try {
+        await result;
+    }
+    finally {
+        await rm(prepared.home.overlayPath, { force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/genie-code/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Supervise Genie Code and its authenticated local model gateway.\n *\n * @module\n */\n\nimport { randomBytes } from \"node:crypto\";\nimport { rm } from \"node:fs/promises\";\nimport { delimiter, dirname } from \"node:path\";\nimport { DatabricksModelRegistry, models } from \"@dbx-tools/appkit-model-gateway\";\nimport * as auth from \"@dbx-tools/auth\";\nimport { resolveServicePackageBin } from \"@dbx-tools/cli-service/definition\";\nimport type { BinContext } from \"@dbx-tools/core/bin\";\nimport { workspaceClient } from \"@dbx-tools/databricks\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  resolveGenieCodeOptions,\n  type GenieCodeOptions,\n  type GenieCodeRunnerOptions,\n} from \"@dbx-tools/shared-genie-code/options\";\nimport type { ModelClass } from \"@dbx-tools/shared-model/contracts\";\nimport concurrently from \"concurrently\";\nimport getPort from \"get-port\";\n\nimport { writeGenieCodeConfig, type GenieCodeHome } from \"./config.ts\";\nimport { installGenieCode } from \"./install.ts\";\nimport { RUNNER_OPTIONS_ENV } from \"./runner.ts\";\n\nconst logger = log.logger(\"genie-code\");\n\n/** Injectable owners used to prepare and supervise managed Genie Code. */\nexport interface GenieCodeRuntimeDependencies {\n  createAuthClient: typeof auth.client.createAuthClient;\n  install: typeof installGenieCode;\n  port(options: { host: string; port?: number }): Promise<number>;\n  resolveBin(packageReference: string, binName: string): string;\n  resolveCodexModel(\n    model: string | undefined,\n    profile: string,\n    modelClass?: ModelClass,\n  ): Promise<string>;\n  supervise: typeof concurrently;\n  token(): string;\n  writeConfig: typeof writeGenieCodeConfig;\n}\n\nconst DEFAULT_DEPENDENCIES: GenieCodeRuntimeDependencies = {\n  createAuthClient: auth.client.createAuthClient,\n  install: installGenieCode,\n  port: ({ host, port }) => getPort({ host, ...(port ? { port } : {}) }),\n  resolveBin: resolveServicePackageBin,\n  resolveCodexModel,\n  supervise: concurrently,\n  token: () => randomBytes(32).toString(\"base64url\"),\n  writeConfig: writeGenieCodeConfig,\n};\n\n/** Resolve a Genie `--model` value to the Codex catalogue slug the gateway publishes. */\nasync function resolveCodexModel(\n  model: string | undefined,\n  profile: string,\n  modelClass?: ModelClass,\n): Promise<string> {\n  const client = await workspaceClient.createWorkspaceClient({ profile });\n  const target = await new DatabricksModelRegistry({ client }).resolve(model, {\n    requiresTools: true,\n    ...(modelClass ? { modelClass } : {}),\n  });\n  if (!target) {\n    throw new Error(\n      model ? `Genie Code model not found: ${model}` : \"No tool-capable chat model is available\",\n    );\n  }\n  return models.codexModelSlug(target);\n}\n\n/** Inputs accepted by managed Genie Code preparation and execution. */\nexport interface RunGenieCodeOptions {\n  cwd?: string;\n  dependencies?: Partial<GenieCodeRuntimeDependencies>;\n  genieArgs?: readonly string[];\n  options?: GenieCodeOptions;\n}\n\n/** Resolved installation, auth, listener, and home for one invocation. */\nexport interface PreparedGenieCodeRuntime {\n  bearerToken: string;\n  gatewayBaseUrl: string;\n  gatewayHealthUrl: string;\n  gatewayListen: string;\n  gatewayPort: number;\n  home: GenieCodeHome;\n  installation: BinContext;\n  model: string;\n  profile: string;\n}\n\n/** Resolve auth, installation, listener, and configuration before spawning children. */\nexport async function prepareGenieCodeRuntime(\n  input: RunGenieCodeOptions = {},\n): Promise<PreparedGenieCodeRuntime> {\n  const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };\n  const options = resolveGenieCodeOptions(input.options);\n  logger.info(\"resolving Databricks authentication\", {\n    requestedProfile: options.profile,\n  });\n  const authClient = await dependencies.createAuthClient(\n    options.profile ? { profile: options.profile } : {},\n  );\n  const profile = authClient.profile;\n  if (!profile) {\n    throw new Error(\"Genie Code requires a configured Databricks profile\");\n  }\n  logger.info(\"preparing Genie Code runtime\", {\n    profile,\n    model: options.model,\n    modelClass: options.modelClass,\n  });\n  const installation = await dependencies.install();\n  const host = options.gatewayListen.host;\n  const requestedPort = options.gatewayListen.port;\n  const gatewayPort = await dependencies.port({\n    host,\n    ...(requestedPort > 0 ? { port: requestedPort } : {}),\n  });\n  if (requestedPort > 0 && gatewayPort !== requestedPort) {\n    throw new Error(`Genie Code gateway port ${requestedPort} is already in use`);\n  }\n  const model = await dependencies.resolveCodexModel(options.model, profile, options.modelClass);\n  logger.info(\"resolved Genie Code model\", {\n    requested: options.model,\n    modelClass: options.modelClass,\n    model,\n  });\n  const urlHost = host.includes(\":\") ? `[${host}]` : host;\n  const gatewayBaseUrl = `http://${urlHost}:${gatewayPort}/v1`;\n  const gatewayHealthUrl = `http://${urlHost}:${gatewayPort}/api/healthz`;\n  const gatewayListen = `tcp://${urlHost}:${gatewayPort}`;\n  const bearerToken = dependencies.token();\n  const home = await dependencies.writeConfig({\n    bearerToken,\n    gatewayBaseUrl,\n    model,\n    profile,\n    projectDirectory: input.cwd ?? process.cwd(),\n  });\n  return {\n    bearerToken,\n    gatewayBaseUrl,\n    gatewayHealthUrl,\n    gatewayListen,\n    gatewayPort,\n    home,\n    installation,\n    model,\n    profile,\n  };\n}\n\nfunction shellExecutable(path: string): string {\n  if (process.platform === \"win32\") return `\"${path.replaceAll('\"', '\"\"')}\"`;\n  return `'${path.replaceAll(\"'\", \"'\\\\''\")}'`;\n}\n\nfunction childPath(...paths: string[]): string {\n  return [...new Set([...paths.map(dirname), process.env.PATH].filter(Boolean))].join(delimiter);\n}\n\n/** Run Genie Code and the model gateway until either process exits. */\nexport async function runGenieCode(input: RunGenieCodeOptions = {}): Promise<void> {\n  const dependencies = { ...DEFAULT_DEPENDENCIES, ...input.dependencies };\n  const prepared = await prepareGenieCodeRuntime({\n    ...input,\n    dependencies,\n  });\n  const gatewayBin = dependencies.resolveBin(import.meta.url, \"dbx-model-gateway\");\n  const runnerBin = dependencies.resolveBin(import.meta.url, \"dbx-genie\");\n  const path = childPath(gatewayBin, runnerBin);\n  const runnerOptions: GenieCodeRunnerOptions = {\n    executable: prepared.installation.path,\n    arguments: [\"-p\", prepared.home.overlayName, ...(input.genieArgs ?? [])],\n    home: prepared.home.home,\n    gatewayHealthUrl: prepared.gatewayHealthUrl,\n    bearerToken: prepared.bearerToken,\n    startupTimeoutMs: 60_000,\n  };\n  const { result } = dependencies.supervise(\n    [\n      {\n        command: shellExecutable(gatewayBin),\n        name: \"gateway\",\n        env: {\n          ...process.env,\n          PATH: path,\n          LISTEN: prepared.gatewayListen,\n          DATABRICKS_CONFIG_PROFILE: prepared.profile,\n          DBX_TOOLS_MODEL_GATEWAY_BEARER_TOKEN: prepared.bearerToken,\n        },\n      },\n      {\n        command: shellExecutable(runnerBin),\n        name: \"genie\",\n        env: {\n          ...process.env,\n          PATH: path,\n          DATABRICKS_CONFIG_PROFILE: prepared.profile,\n          [RUNNER_OPTIONS_ENV]: JSON.stringify(runnerOptions),\n        },\n      },\n    ],\n    {\n      cwd: input.cwd ?? process.cwd(),\n      raw: true,\n      killOthersOn: [\"failure\", \"success\"],\n      killSignal: \"SIGTERM\",\n      killTimeout: 17_000,\n      successCondition: \"command-genie\",\n    },\n  );\n  logger.info(\"started Genie Code and model gateway\", {\n    profile: prepared.profile,\n    model: prepared.model,\n    gateway: prepared.gatewayBaseUrl,\n    home: prepared.home.home,\n  });\n  try {\n    await result;\n  } finally {\n    await rm(prepared.home.overlayPath, { force: true });\n  }\n}\n"]}

package/lib/src/graphiti/cli.js

@@ -12,8 +12,8 @@ import { buildServiceCommand } from "@dbx-tools/cli-service/cli";
 import { defineService } from "@dbx-tools/cli-service/definition";
 import { runGraphiti } from "@dbx-tools/graphiti/runtime";
 import { Command } from "commander";
-import { PACKAGE_VERSION } from "../../index.js";
 import { GraphitiCliOptionsSchema, GraphitiOptionsSchema, } from "./options.js";
+import { PACKAGE_VERSION } from "../../index.js";
 /** Define a Graphiti service without duplicating installation or lifecycle policy. */
 export function graphitiServiceDefinition(options = {}) {
     return defineService(import.meta.url, {
@@ -40,4 +40,4 @@ export function buildProgram(name = "dbx graphiti", dependencies = { run: runGra
 function graphitiOptions(command) {
     return GraphitiOptionsSchema.parse(parseArgs(command, GraphitiCliOptionsSchema));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -4,9 +4,9 @@ import { buildServiceCommand } from "@dbx-tools/cli-service/cli";
 import { defineService } from "@dbx-tools/cli-service/definition";
 import { connectionUrl } from "@dbx-tools/lakebase";
 import { Command } from "commander";
-import { PACKAGE_VERSION } from "../../index.js";
 import { LakebaseProxyOptionsSchema, LakebaseProxyUrlOptionsSchema, resolveLakebaseProxyOptions, } from "./options.js";
 import { LakebaseProxy } from "./proxy.js";
+import { PACKAGE_VERSION } from "../../index.js";
 /** Build the tray-only Lakebase proxy service definition. */
 export function lakebaseProxyServiceDefinition(options = {}) {
     const resolved = resolveLakebaseProxyOptions(options);
@@ -51,4 +51,4 @@ function waitForShutdown() {
         process.once("SIGTERM", shutdown);
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/model-gateway/cli.js

@@ -8,14 +8,14 @@ import { buildServiceCommand } from "@dbx-tools/cli-service/cli";
 import { defineService } from "@dbx-tools/cli-service/definition";
 import { ModelGatewayCliOptionsSchema, resolveModelGatewayCliOptions, } from "@dbx-tools/shared-model-gateway/options";
 import { Command } from "commander";
-import { PACKAGE_VERSION } from "../../index.js";
 import { startModelGateway } from "./server.js";
+import { PACKAGE_VERSION } from "../../index.js";
 const DEFAULT_DEPENDENCIES = {
     start: startModelGateway,
 };
 /** Build the tray-only model-gateway service definition. */
 export function modelGatewayServiceDefinition(options = {}) {
-    const { runtimeInfo: _, ...resolved } = resolveModelGatewayCliOptions(options);
+    const { runtimeInfo: _, bearerToken: _bearerToken, ...resolved } = resolveModelGatewayCliOptions(options);
     const host = urlHost(resolved.listen.host);
     return defineService(import.meta.url, {
         id: "dbx-tools.cli-model-gateway",
@@ -60,4 +60,4 @@ function modelGatewayOptions(command) {
 function urlHost(host) {
     return host.includes(":") ? `[${host}]` : host;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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