@dbx-tools/cli 0.9.58 → 0.9.61

package/src/auth/cli.ts

@@ -0,0 +1,175 @@
+/**
+ * `dbx auth` Commander program for Databricks OAuth.
+ *
+ * The command delegates profile resolution and token lifecycle to
+ * `@dbx-tools/auth`.
+ *
+ * @module
+ */
+
+import * as databricks from "@dbx-tools/auth";
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import type { DatabricksAuthClientInfo } from "@dbx-tools/shared-auth/client";
+import { Command, CommanderError } from "commander";
+
+import {
+  AuthCliOptionsSchema,
+  databricksAuthOptions,
+  TokenCommandOptionsSchema,
+  type AuthCliOptions,
+} from "./options.ts";
+
+interface AuthContext {
+  auth: databricks.AuthClient;
+  close(): Promise<void>;
+}
+
+interface AuthCliDependencies {
+  createAuthClient: typeof databricks.client.createAuthClient;
+  writeJson(value: unknown): void;
+  writeText(value: string): void;
+}
+
+const DEFAULT_DEPENDENCIES: AuthCliDependencies = {
+  createAuthClient: databricks.client.createAuthClient,
+  writeJson: (value) => {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+  },
+  writeText: (value) => {
+    process.stdout.write(`${value}\n`);
+  },
+};
+
+/** Open the selected authentication client. */
+async function openAuth(
+  options: AuthCliOptions,
+  dependencies: AuthCliDependencies,
+): Promise<AuthContext> {
+  return {
+    auth: await dependencies.createAuthClient(databricksAuthOptions(options)),
+    close: async () => {},
+  };
+}
+
+/** Execute an auth action and close resources owned by the command. */
+async function withAuth(
+  options: AuthCliOptions,
+  dependencies: AuthCliDependencies,
+  action: (context: AuthContext) => Promise<void>,
+): Promise<void> {
+  const context = await openAuth(options, dependencies);
+  try {
+    await action(context);
+  } finally {
+    await context.close();
+  }
+}
+
+/** Shape a generated token record for stable CLI JSON output. */
+function tokenJson(token: databricks.AccessToken): Record<string, unknown> {
+  return {
+    access_token: token.accessToken,
+    token_type: token.tokenType,
+    ...(token.expiry ? { expiry: token.expiry } : {}),
+    ...(token.scopes.length ? { scopes: token.scopes } : {}),
+  };
+}
+
+/** Select the serializable identity fields from an authentication client. */
+function clientInfo(auth: databricks.AuthClient): DatabricksAuthClientInfo {
+  return {
+    ...(auth.profile ? { profile: auth.profile } : {}),
+    host: auth.host,
+    ...(auth.accountId ? { accountId: auth.accountId } : {}),
+    ...(auth.workspaceId ? { workspaceId: auth.workspaceId } : {}),
+    target: auth.target,
+    authType: auth.authType,
+    principal: auth.principal,
+  };
+}
+
+/** Build the `dbx auth` Commander program without parsing arguments. */
+export function buildProgram(
+  name = "dbx auth",
+  overrides: Partial<AuthCliDependencies> = {},
+): Command {
+  const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+  const program = addArgs(
+    new Command()
+      .name(name)
+      .description("Authenticate to Databricks with user or machine OAuth")
+      .showHelpAfterError(),
+    AuthCliOptionsSchema,
+  );
+  const options = (): AuthCliOptions => parseArgs(program, AuthCliOptionsSchema);
+
+  program
+    .command("login")
+    .description("Force browser login and return an access token")
+    .action(async () => {
+      await withAuth(options(), dependencies, async ({ auth }) => {
+        dependencies.writeJson(tokenJson(await auth.token({ login: true })));
+      });
+    });
+
+  const tokenCommand = addArgs(
+    program.command("token").description("Return a valid access token, logging in when needed"),
+    TokenCommandOptionsSchema,
+  );
+  tokenCommand.action(async () => {
+    const tokenOptions = parseArgs(tokenCommand, TokenCommandOptionsSchema);
+    await withAuth(options(), dependencies, async ({ auth }) => {
+      const token = await auth.token({
+        ...(tokenOptions.login ? {} : { login: false }),
+        ...(tokenOptions.forceRefresh ? { refresh: true } : {}),
+      });
+      if (tokenOptions.format === "text") dependencies.writeText(token.accessToken);
+      else dependencies.writeJson(tokenJson(token));
+    });
+  });
+
+  program
+    .command("headers")
+    .description("Return current Databricks authentication headers")
+    .action(async () => {
+      await withAuth(options(), dependencies, async ({ auth }) => {
+        dependencies.writeJson(await auth.headers());
+      });
+    });
+
+  program
+    .command("profile")
+    .description("Print the configured or automatically detected profile")
+    .action(async () => {
+      await withAuth(options(), dependencies, async ({ auth }) => {
+        dependencies.writeText(auth.profile ?? "ambient");
+      });
+    });
+
+  program
+    .command("logout")
+    .description("Delete the stored credential for the selected profile")
+    .action(async () => {
+      await withAuth(options(), dependencies, async ({ auth }) => {
+        await auth.logout();
+      });
+    });
+
+  program
+    .command("status")
+    .description("Show the resolved authentication client configuration")
+    .action(async () => {
+      await withAuth(options(), dependencies, async ({ auth }) => {
+        dependencies.writeJson(clientInfo(auth));
+      });
+    });
+
+  return program;
+}
+
+/** Parse `argv` and run the selected auth operation. */
+export async function runCli(argv: string[]): Promise<void> {
+  await buildProgram().parseAsync(argv);
+}
+
+export { CommanderError };

package/src/auth/options.ts

@@ -0,0 +1,83 @@
+/**
+ * Databricks auth command-line option schemas and runtime projection.
+ *
+ * @module
+ */
+
+import {
+  AuthOptionsSchema,
+  DatabricksAuthOptionsSchema,
+  type DatabricksAuthOptions,
+} from "@dbx-tools/auth/config";
+import { stringUtils } from "@dbx-tools/shared-core";
+import { z } from "zod";
+
+export const AuthCliOptionsSchema = z
+  .object({
+    profile: DatabricksAuthOptionsSchema.shape.profile,
+    host: DatabricksAuthOptionsSchema.shape.host,
+    accountId: DatabricksAuthOptionsSchema.shape.accountId,
+    workspaceId: DatabricksAuthOptionsSchema.shape.workspaceId,
+    configFile: DatabricksAuthOptionsSchema.shape.configFile,
+    clientId: DatabricksAuthOptionsSchema.shape.clientId,
+    groupId: DatabricksAuthOptionsSchema.shape.groupId,
+    authType: DatabricksAuthOptionsSchema.shape.authType,
+    scopes: z
+      .preprocess(
+        (value) =>
+          Array.isArray(value)
+            ? value.flatMap((entry) => stringUtils.parseList(String(entry)))
+            : value,
+        z.array(z.string().trim().min(1)),
+      )
+      .default([])
+      .describe("OAuth scopes."),
+    target: DatabricksAuthOptionsSchema.shape.target,
+    lockTimeoutMs: AuthOptionsSchema.shape.lockTimeoutMs,
+    loginTimeoutMs: AuthOptionsSchema.shape.loginTimeoutMs,
+    refreshBufferMs: AuthOptionsSchema.shape.refreshBufferMs,
+    preferUserToMachine: z
+      .boolean()
+      .default(true)
+      .describe("Prefer a matching user profile over selected machine credentials."),
+  })
+  .strict()
+  .describe("Options shared by every Databricks auth command.");
+
+export const TokenCommandOptionsSchema = z
+  .object({
+    forceRefresh: z.boolean().default(false).describe("Refresh the token before returning it."),
+    login: z.boolean().default(true).describe("Log in when credentials are missing or invalid."),
+    format: z
+      .enum(["json", "text"])
+      .default("json")
+      .describe("Output structured token metadata or only the access token."),
+  })
+  .strict()
+  .describe("Options for returning a Databricks access token.");
+
+export type AuthCliOptions = z.output<typeof AuthCliOptionsSchema>;
+
+export type TokenCommandOptions = z.output<typeof TokenCommandOptionsSchema>;
+
+/** Convert flat CLI fields into the Node auth package's nested options. */
+export function databricksAuthOptions(options: AuthCliOptions): DatabricksAuthOptions {
+  return {
+    profile: options.profile,
+    host: options.host,
+    accountId: options.accountId,
+    workspaceId: options.workspaceId,
+    configFile: options.configFile,
+    clientId: options.clientId,
+    groupId: options.groupId,
+    authType: options.authType,
+    scopes: options.scopes.length > 0 ? options.scopes : undefined,
+    target: options.target,
+    auth: {
+      lockTimeoutMs: options.lockTimeoutMs,
+      loginTimeoutMs: options.loginTimeoutMs,
+      refreshBufferMs: options.refreshBufferMs,
+    },
+    preferUserToMachine: options.preferUserToMachine,
+  };
+}

package/src/cli.ts

@@ -59,8 +59,9 @@ export async function prepareAndRunProjen(projenArgs: string[], startDir?: strin
 /**
  * Mount `name` as a command that captures every following token verbatim and
  * hands it to the program `load()` resolves. `helpOption(false)` is what lets
- * `--help` through to the child instead of being answered here, and the child
- * program owns its own flags, so this wrapper never has to restate them.
+ * `--help` through to the child instead of being answered here, and
+ * `passThroughOptions()` keeps unknown flags in that token list so the child
+ * program owns them.
  */
 function addForwardedCommand(
   program: Command,
@@ -73,6 +74,7 @@ function addForwardedCommand(
     .description(description)
     .argument("[args...]", `arguments forwarded to ${name}`)
     .allowUnknownOption()
+    .passThroughOptions()
     .allowExcessArguments()
     .helpOption(false)
     .action(async (args: string[]) => {
@@ -88,6 +90,7 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     .description(
       "Databricks developer tools: workspace lifecycle, AppKit env, auth, tunnels, and local proxies",
     )
+    .enablePositionalOptions()
     .showHelpAfterError()
     .helpOption("-h, --help", `Show ${name} help`);
 
@@ -106,47 +109,71 @@ export function buildProgram(name: string = PROGRAM_NAMES[0]): Command {
     program,
     "appkit",
     "AppKit helpers (env: print the environment an AppKit app resolves)",
-    async () => (await import("@dbx-tools/cli-appkit-env/cli")).buildProgram,
+    async () => (await import("./appkit/cli.ts")).buildProgram,
   );
 
   addForwardedCommand(
     program,
     "auth",
     "Authenticate to Databricks and manage OAuth tokens",
-    async () => (await import("@dbx-tools/cli-auth/cli")).buildProgram,
+    async () => (await import("./auth/cli.ts")).buildProgram,
   );
 
   addForwardedCommand(
     program,
     "tunnel",
     "Run a public portr tunnel with an email-OTP gate",
-    async () => (await import("@dbx-tools/cli-tunnel/cli")).buildProgram,
+    async () => (await import("./tunnel/cli.ts")).buildProgram,
   );
 
   addForwardedCommand(
     program,
     "lakebase-proxy",
     "Run the Node Databricks Lakebase PostgreSQL proxy",
-    async () => (await import("@dbx-tools/cli-lakebase-proxy/cli")).buildProgram,
+    async () => (await import("./lakebase-proxy/cli.ts")).buildProgram,
   );
 
   addForwardedCommand(
     program,
     "model-gateway",
     "Run the foreground AppKit Databricks model gateway",
-    async () => (await import("@dbx-tools/cli-model-gateway/cli")).buildProgram,
+    async () => (await import("./model-gateway/cli.ts")).buildProgram,
+  );
+
+  addForwardedCommand(
+    program,
+    "genie",
+    "Run managed Genie Code through a local Databricks model gateway",
+    async () => (await import("./genie-code/cli.ts")).buildProgram,
   );
 
   addForwardedCommand(
     program,
     "graphiti",
     "Run Graphiti or manage its current-user desktop service",
-    async () => (await import("@dbx-tools/cli-graphiti/cli")).buildProgram,
+    async () => (await import("./graphiti/cli.ts")).buildProgram,
   );
 
   return program;
 }
 
+/** Build the complete command tree used for generated documentation. */
+export async function buildDocumentationProgram(name: string = PROGRAM_NAMES[0]): Promise<Command> {
+  const program = buildProgram(name);
+  (program.commands as Command[]).splice(
+    1,
+    program.commands.length - 1,
+    (await import("./appkit/cli.ts")).buildProgram("appkit"),
+    (await import("./auth/cli.ts")).buildProgram("auth"),
+    (await import("./tunnel/cli.ts")).buildProgram("tunnel"),
+    (await import("./lakebase-proxy/cli.ts")).buildProgram("lakebase-proxy"),
+    (await import("./model-gateway/cli.ts")).buildProgram("model-gateway"),
+    (await import("./genie-code/cli.ts")).buildProgram("genie"),
+    (await import("./graphiti/cli.ts")).buildProgram("graphiti"),
+  );
+  return program;
+}
+
 /**
  * Program name for help output: whichever bin the user actually typed, so
  * `dbx-tools --help` doesn't document itself as `dbx`. Falls back to `dbx`.

package/src/genie-code/cli.ts

@@ -0,0 +1,58 @@
+/**
+ * Managed `dbx genie` command.
+ *
+ * @module
+ */
+
+import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { Command } from "commander";
+
+import { GenieCodeCliOptionsSchema, type GenieCodeCliOptions } from "./options.ts";
+import { runGenieCode } from "./runtime.ts";
+
+/** Injectable managed Genie execution boundary for parser tests and embedding. */
+export interface GenieCodeCliDependencies {
+  run(input: {
+    cwd: string;
+    genieArgs: readonly string[];
+    options: GenieCodeCliOptions;
+  }): Promise<void>;
+}
+
+const DEFAULT_DEPENDENCIES: GenieCodeCliDependencies = {
+  run: runGenieCode,
+};
+
+/** Build the managed Genie Code command without executing it. */
+export function buildProgram(
+  name = "dbx genie",
+  dependencies: GenieCodeCliDependencies = DEFAULT_DEPENDENCIES,
+): Command {
+  const program = addArgs(
+    new Command()
+      .name(name)
+      .description("Run Genie Code through an authenticated local Databricks model gateway")
+      .argument(
+        "[genieArgs...]",
+        "arguments and unknown flags forwarded to Genie Code; wrapper options may be separated with --",
+      )
+      .allowUnknownOption()
+      .passThroughOptions()
+      .allowExcessArguments()
+      .showHelpAfterError(),
+    GenieCodeCliOptionsSchema,
+  );
+  program.action(async (genieArgs: string[]) => {
+    await dependencies.run({
+      cwd: process.cwd(),
+      genieArgs,
+      options: parseArgs(program, GenieCodeCliOptionsSchema),
+    });
+  });
+  return program;
+}
+
+/** Parse argv and run managed Genie Code. */
+export async function runCli(argv: string[]): Promise<void> {
+  await buildProgram().parseAsync(argv);
+}

package/src/genie-code/config.ts

@@ -0,0 +1,161 @@
+/**
+ * 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,
+  type GenieCodeBaseConfig,
+  type GenieCodeConfig,
+  type GenieCodeProviderOverlay,
+} 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";
+
+/** Inputs used to update a persistent home and create one invocation overlay. */
+export interface WriteGenieCodeConfigOptions {
+  bearerToken: string;
+  gatewayBaseUrl: string;
+  homeDirectory?: string;
+  model: string;
+  profile: string;
+  projectDirectory: string;
+}
+
+/** Stable persistent home for one exact profile-model pairing. */
+export interface GenieCodePairingHome {
+  configPath: string;
+  home: string;
+  name: string;
+}
+
+/** Persistent pairing home and invocation-specific provider overlay. */
+export interface GenieCodeHome extends GenieCodePairingHome {
+  overlayName: string;
+  overlayPath: string;
+}
+
+/** Derive the stable home for one exact profile-model pair. */
+export function genieCodeHome(
+  profile: string,
+  model: string,
+  homeDirectory: string = homedir(),
+): GenieCodePairingHome {
+  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: WriteGenieCodeConfigOptions,
+  existingProjects: Readonly<Record<string, unknown>> = {},
+): GenieCodeBaseConfig {
+  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: WriteGenieCodeConfigOptions,
+): GenieCodeProviderOverlay {
+  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: WriteGenieCodeConfigOptions): GenieCodeConfig {
+  return GenieCodeConfigSchema.parse({
+    ...genieCodeBaseConfig(options),
+    ...genieCodeProviderOverlay(options),
+  });
+}
+
+async function existingProjects(path: string): Promise<Record<string, unknown>> {
+  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: string, value: unknown): Promise<void> {
+  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: WriteGenieCodeConfigOptions,
+): Promise<GenieCodeHome> {
+  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;
+}

package/src/genie-code/install.ts

@@ -0,0 +1,103 @@
+/**
+ * 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";
+
+interface GenieCodeAsset {
+  target: string;
+  sha256: string;
+}
+
+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",
+  },
+} as const satisfies Record<string, GenieCodeAsset>;
+
+/** 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 function genieCodeAsset(
+  platform: NodeJS.Platform = process.platform,
+  architecture: NodeJS.Architecture = process.arch,
+): GenieCodeAsset {
+  const asset = GENIE_CODE_ASSETS[`${platform}:${architecture}` as keyof typeof GENIE_CODE_ASSETS];
+  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: InstallGenieCodeOptions = {},
+): Promise<bin.BinContext> {
+  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: bin.BinContext = {
+    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"],
+      },
+    },
+  );
+}