@dbx-tools/cli 0.9.58 → 0.9.61

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

@@ -0,0 +1,111 @@
+/**
+ * Generate one persistent Genie Code home per exact profile-model pairing.
+ *
+ * @module
+ */
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { withFileLock } from "@dbx-tools/core/file-lock";
+import { object } from "@dbx-tools/shared-core";
+import { GenieCodeBaseConfigSchema, GenieCodeConfigSchema, GenieCodeProviderOverlaySchema, } from "@dbx-tools/shared-genie-code/config";
+import { genieCodePairingName } from "@dbx-tools/shared-genie-code/options";
+import { parse, stringify } from "smol-toml";
+/** Provider identifier written to the base and invocation overlay configurations. */
+export const GENIE_CODE_GATEWAY_PROVIDER = "dbx_tools_model_gateway";
+/** Derive the stable home for one exact profile-model pair. */
+export function genieCodeHome(profile, model, homeDirectory = homedir()) {
+    const digest = createHash("sha256")
+        .update(JSON.stringify([profile, model]))
+        .digest("hex")
+        .slice(0, 12);
+    const name = genieCodePairingName({ profile, model, digest });
+    const home = join(homeDirectory, ".dbx-tools", "genie", "profiles", name);
+    return { name, home, configPath: join(home, "config.toml") };
+}
+/** Render the persistent profile-model configuration. */
+export function genieCodeBaseConfig(options, existingProjects = {}) {
+    const projects = Object.fromEntries(Object.entries(existingProjects).filter(([, value]) => object.isRecord(value) && value.trust_level === "trusted"));
+    return GenieCodeBaseConfigSchema.parse({
+        model_provider: GENIE_CODE_GATEWAY_PROVIDER,
+        model: options.model,
+        databricks_profile: options.profile,
+        projects: {
+            ...projects,
+            [resolve(options.projectDirectory)]: {
+                trust_level: "trusted",
+            },
+        },
+        tui: {
+            model_availability_nux: {
+                [options.model]: 1,
+            },
+        },
+    });
+}
+/** Render the invocation-specific guarded provider configuration. */
+export function genieCodeProviderOverlay(options) {
+    return GenieCodeProviderOverlaySchema.parse({
+        model_providers: {
+            [GENIE_CODE_GATEWAY_PROVIDER]: {
+                name: "dbx-tools model gateway",
+                base_url: options.gatewayBaseUrl,
+                wire_api: "responses",
+                requires_openai_auth: false,
+                supports_websockets: false,
+                http_headers: {
+                    Authorization: `Bearer ${options.bearerToken}`,
+                    Originator: "codex",
+                },
+            },
+        },
+    });
+}
+/** Render the merged configuration used by validation and tests. */
+export function genieCodeConfig(options) {
+    return GenieCodeConfigSchema.parse({
+        ...genieCodeBaseConfig(options),
+        ...genieCodeProviderOverlay(options),
+    });
+}
+async function existingProjects(path) {
+    try {
+        const value = parse(await readFile(path, "utf8"));
+        return object.isRecord(value.projects) ? value.projects : {};
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+async function writePrivateToml(path, value) {
+    const staged = join(dirname(path), `.${randomUUID()}.toml`);
+    try {
+        await writeFile(staged, stringify(value), { mode: 0o600 });
+        await chmod(staged, 0o600);
+        await rename(staged, path);
+    }
+    finally {
+        await rm(staged, { force: true });
+    }
+}
+/** Update the persistent base config and write one private invocation overlay. */
+export async function writeGenieCodeConfig(options) {
+    const base = genieCodeHome(options.profile, options.model, options.homeDirectory);
+    const overlayName = `dbx-${randomUUID().replaceAll("-", "")}`;
+    const destination = {
+        ...base,
+        overlayName,
+        overlayPath: join(base.home, `${overlayName}.config.toml`),
+    };
+    await mkdir(destination.home, { recursive: true });
+    await withFileLock(["genie-code-config", destination.configPath], async () => {
+        const projects = await existingProjects(destination.configPath);
+        await writePrivateToml(destination.configPath, genieCodeBaseConfig(options, projects));
+    });
+    await writePrivateToml(destination.overlayPath, genieCodeProviderOverlay(options));
+    return destination;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/genie-code/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Generate one persistent Genie Code home per exact profile-model pairing.\n *\n * @module\n */\n\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { chmod, mkdir, readFile, rename, rm, writeFile } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { dirname, join, resolve } from \"node:path\";\nimport { withFileLock } from \"@dbx-tools/core/file-lock\";\nimport { object } from \"@dbx-tools/shared-core\";\nimport {\n  GenieCodeBaseConfigSchema,\n  GenieCodeConfigSchema,\n  GenieCodeProviderOverlaySchema,\n  type GenieCodeBaseConfig,\n  type GenieCodeConfig,\n  type GenieCodeProviderOverlay,\n} from \"@dbx-tools/shared-genie-code/config\";\nimport { genieCodePairingName } from \"@dbx-tools/shared-genie-code/options\";\nimport { parse, stringify } from \"smol-toml\";\n\n/** Provider identifier written to the base and invocation overlay configurations. */\nexport const GENIE_CODE_GATEWAY_PROVIDER = \"dbx_tools_model_gateway\";\n\n/** Inputs used to update a persistent home and create one invocation overlay. */\nexport interface WriteGenieCodeConfigOptions {\n  bearerToken: string;\n  gatewayBaseUrl: string;\n  homeDirectory?: string;\n  model: string;\n  profile: string;\n  projectDirectory: string;\n}\n\n/** Stable persistent home for one exact profile-model pairing. */\nexport interface GenieCodePairingHome {\n  configPath: string;\n  home: string;\n  name: string;\n}\n\n/** Persistent pairing home and invocation-specific provider overlay. */\nexport interface GenieCodeHome extends GenieCodePairingHome {\n  overlayName: string;\n  overlayPath: string;\n}\n\n/** Derive the stable home for one exact profile-model pair. */\nexport function genieCodeHome(\n  profile: string,\n  model: string,\n  homeDirectory: string = homedir(),\n): GenieCodePairingHome {\n  const digest = createHash(\"sha256\")\n    .update(JSON.stringify([profile, model]))\n    .digest(\"hex\")\n    .slice(0, 12);\n  const name = genieCodePairingName({ profile, model, digest });\n  const home = join(homeDirectory, \".dbx-tools\", \"genie\", \"profiles\", name);\n  return { name, home, configPath: join(home, \"config.toml\") };\n}\n\n/** Render the persistent profile-model configuration. */\nexport function genieCodeBaseConfig(\n  options: WriteGenieCodeConfigOptions,\n  existingProjects: Readonly<Record<string, unknown>> = {},\n): GenieCodeBaseConfig {\n  const projects = Object.fromEntries(\n    Object.entries(existingProjects).filter(\n      ([, value]) => object.isRecord(value) && value.trust_level === \"trusted\",\n    ),\n  );\n  return GenieCodeBaseConfigSchema.parse({\n    model_provider: GENIE_CODE_GATEWAY_PROVIDER,\n    model: options.model,\n    databricks_profile: options.profile,\n    projects: {\n      ...projects,\n      [resolve(options.projectDirectory)]: {\n        trust_level: \"trusted\",\n      },\n    },\n    tui: {\n      model_availability_nux: {\n        [options.model]: 1,\n      },\n    },\n  });\n}\n\n/** Render the invocation-specific guarded provider configuration. */\nexport function genieCodeProviderOverlay(\n  options: WriteGenieCodeConfigOptions,\n): GenieCodeProviderOverlay {\n  return GenieCodeProviderOverlaySchema.parse({\n    model_providers: {\n      [GENIE_CODE_GATEWAY_PROVIDER]: {\n        name: \"dbx-tools model gateway\",\n        base_url: options.gatewayBaseUrl,\n        wire_api: \"responses\",\n        requires_openai_auth: false,\n        supports_websockets: false,\n        http_headers: {\n          Authorization: `Bearer ${options.bearerToken}`,\n          Originator: \"codex\",\n        },\n      },\n    },\n  });\n}\n\n/** Render the merged configuration used by validation and tests. */\nexport function genieCodeConfig(options: WriteGenieCodeConfigOptions): GenieCodeConfig {\n  return GenieCodeConfigSchema.parse({\n    ...genieCodeBaseConfig(options),\n    ...genieCodeProviderOverlay(options),\n  });\n}\n\nasync function existingProjects(path: string): Promise<Record<string, unknown>> {\n  try {\n    const value = parse(await readFile(path, \"utf8\"));\n    return object.isRecord(value.projects) ? value.projects : {};\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && error.code === \"ENOENT\") return {};\n    throw error;\n  }\n}\n\nasync function writePrivateToml(path: string, value: unknown): Promise<void> {\n  const staged = join(dirname(path), `.${randomUUID()}.toml`);\n  try {\n    await writeFile(staged, stringify(value), { mode: 0o600 });\n    await chmod(staged, 0o600);\n    await rename(staged, path);\n  } finally {\n    await rm(staged, { force: true });\n  }\n}\n\n/** Update the persistent base config and write one private invocation overlay. */\nexport async function writeGenieCodeConfig(\n  options: WriteGenieCodeConfigOptions,\n): Promise<GenieCodeHome> {\n  const base = genieCodeHome(options.profile, options.model, options.homeDirectory);\n  const overlayName = `dbx-${randomUUID().replaceAll(\"-\", \"\")}`;\n  const destination = {\n    ...base,\n    overlayName,\n    overlayPath: join(base.home, `${overlayName}.config.toml`),\n  };\n  await mkdir(destination.home, { recursive: true });\n  await withFileLock([\"genie-code-config\", destination.configPath], async () => {\n    const projects = await existingProjects(destination.configPath);\n    await writePrivateToml(destination.configPath, genieCodeBaseConfig(options, projects));\n  });\n  await writePrivateToml(destination.overlayPath, genieCodeProviderOverlay(options));\n  return destination;\n}\n"]}

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

@@ -0,0 +1,21 @@
+/**
+ * Install the pinned multi-file Genie Code runtime under dbx-tools ownership.
+ *
+ * @module
+ */
+import { bin } from "@dbx-tools/core";
+interface GenieCodeAsset {
+    target: string;
+    sha256: string;
+}
+/** Host overrides used by installation tests and embedded callers. */
+export interface InstallGenieCodeOptions {
+    homeDirectory?: string;
+    platform?: NodeJS.Platform;
+    architecture?: NodeJS.Architecture;
+}
+/** Resolve the pinned release asset for one supported host. */
+export declare function genieCodeAsset(platform?: NodeJS.Platform, architecture?: NodeJS.Architecture): GenieCodeAsset;
+/** Install and return the shared Genie Code package entrypoint. */
+export declare function installGenieCode(options?: InstallGenieCodeOptions): Promise<bin.BinContext>;
+export {};

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,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

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

@@ -0,0 +1,48 @@
+/**
+ * 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 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, profile: string): 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,162 @@
+/**
+ * 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) {
+    const client = await workspaceClient.createWorkspaceClient({ profile });
+    const target = await new DatabricksModelRegistry({ client }).resolve(model, {
+        requiresTools: true,
+    });
+    if (!target)
+        throw new Error(`Genie Code model not found: ${model}`);
+    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,
+    });
+    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);
+    logger.info("resolved Genie Code model", { requested: options.model, 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 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(model: string, profile: string): 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(model: string, profile: string): Promise<string> {\n  const client = await workspaceClient.createWorkspaceClient({ profile });\n  const target = await new DatabricksModelRegistry({ client }).resolve(model, {\n    requiresTools: true,\n  });\n  if (!target) throw new Error(`Genie Code model not found: ${model}`);\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  });\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);\n  logger.info(\"resolved Genie Code model\", { requested: options.model, model });\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"]}