@dbx-tools/cli 0.9.154 → 0.9.157

package/src/brand/run.ts

@@ -8,16 +8,16 @@ import { mkdtemp } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import type { BrandResearch } from "@dbx-tools/appkit-generator";
-import { generateBrandPackage } from "@dbx-tools/appkit-generator/generate";
+import { generateBrandPackage } from "@dbx-tools/appkit-generator";
 import {
   runWebAssetPageFetch,
   runWebFetch,
   runWebImageFetch,
-} from "@dbx-tools/appkit-web-search/fetch";
-import { createWebSearchRuntime } from "@dbx-tools/appkit-web-search/runtime";
-import { runWebSearch } from "@dbx-tools/appkit-web-search/search";
-import { createWorkspaceClient } from "@dbx-tools/databricks/workspace-client";
-import { object } from "@dbx-tools/shared-core";
+  createWebSearchRuntime,
+  runWebSearch,
+} from "@dbx-tools/appkit-web-search";
+import { createWorkspaceClient } from "@dbx-tools/databricks";
+import { isRecord } from "@dbx-tools/shared-core";
 import type { BrandGenerationProgressEvent } from "@dbx-tools/shared-generator";
 
 import { writeBrandPackage, type WrittenBrandPackage } from "./export.ts";
@@ -64,7 +64,7 @@ export async function exportBrandFromPrompt(
             },
             signal,
             async (event) => {
-              if (!object.isRecord(event)) return;
+              if (!isRecord(event)) return;
               const status = typeof event.status === "string" ? event.status : undefined;
               const eventMessage =
                 typeof event.message === "string" ? event.message.trim() : undefined;

package/src/brand/showcase.ts

@@ -4,7 +4,7 @@
  * @module
  */
 
-import { stringUtils } from "@dbx-tools/shared-core";
+import { escapeHtml, dedent } from "@dbx-tools/shared-core";
 import type { BrandPackage } from "@dbx-tools/shared-generator";
 
 function safeAsset(value: string | undefined): string | undefined {
@@ -22,13 +22,13 @@ function safeFontFamily(value: string): string {
 }
 
 function listItems(values: readonly string[]): string {
-  return values.map((value) => `<li>${stringUtils.escapeHtml(value)}</li>`).join("");
+  return values.map((value) => `<li>${escapeHtml(value)}</li>`).join("");
 }
 
 /** Render one responsive brand presentation with desktop and mobile mockups. */
 export function renderBrandShowcase(brandPackage: BrandPackage): string {
   const { brand, visualReferences } = brandPackage;
-  const html = stringUtils.escapeHtml;
+  const html = escapeHtml;
   const logo = safeAsset(brand.assets.logo.light) ?? safeAsset(brand.assets.icon.light);
   const icon = safeAsset(brand.assets.icon.light);
   const website = safeWebsite(brand.links.website);
@@ -75,7 +75,7 @@ export function renderBrandShowcase(brandPackage: BrandPackage): string {
   const headline = brand.tagline ?? brand.name;
 
   // prettier-ignore
-  return stringUtils.dedent(
+  return dedent(
     // ============================================================================
     /*html*/`
     <!doctype html>

package/src/bun.ts

@@ -22,8 +22,8 @@
  */
 import { existsSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
-import { exec, projectUtils } from "@dbx-tools/core";
-import { functionUtils, log } from "@dbx-tools/shared-core";
+import { spawnSync, npmRegistry } from "@dbx-tools/core";
+import { log, memoize } from "@dbx-tools/shared-core";
 import { needsInstall } from "./root.ts";
 
 const logger = log.logger("dbx-tools:bun");
@@ -43,8 +43,8 @@ const REGISTRY_SUBCOMMANDS = new Set(["add", "install", "i", "update", "up"]);
  * container may export it without any `.npmrc` for lookup. Memoized: resolution
  * shells out.
  */
-const registryOverride = functionUtils.memoize((): string | undefined =>
-  projectUtils.npmRegistry(null, { overrideOnly: true, envVars: true })?.toString(),
+const registryOverride = memoize((): string | undefined =>
+  npmRegistry(null, { overrideOnly: true, envVars: true })?.toString(),
 );
 
 /** `--registry <url>` for a bun invocation, or `[]` when the subcommand doesn't resolve. */
@@ -98,7 +98,7 @@ function resolveBunArgvImpl(): string[] {
 }
 
 /** Memoized `[command, ...prefix]` argv prefix to run bun. */
-export const resolveBunArgv = functionUtils.memoize(resolveBunArgvImpl);
+export const resolveBunArgv = memoize(resolveBunArgvImpl);
 
 /** Run bun with inherited stdio from `cwd`, forcing the resolved registry. */
 export function runBun(args: string[], cwd: string): void {
@@ -107,7 +107,7 @@ export function runBun(args: string[], cwd: string): void {
   if (registryArgs.length > 0) {
     logger.info(`running bun with registry: ${registryArgs[1]}`);
   }
-  exec.spawnSync(command, [...prefix, ...args, ...registryArgs], {
+  spawnSync(command, [...prefix, ...args, ...registryArgs], {
     cwd,
     check: true,
     env: childEnv(),

package/src/genie-code/cli.ts

@@ -5,9 +5,9 @@
  */
 
 import { addArgs, parseArgs } from "@dbx-tools/cli-args";
+import { GenieCodeOptionsSchema, type GenieCodeOptions } from "@dbx-tools/shared-genie-code";
 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. */
@@ -15,7 +15,7 @@ export interface GenieCodeCliDependencies {
   run(input: {
     cwd: string;
     genieArgs: readonly string[];
-    options: GenieCodeCliOptions;
+    options: GenieCodeOptions;
   }): Promise<void>;
 }
 
@@ -40,13 +40,13 @@ export function buildProgram(
       .passThroughOptions()
       .allowExcessArguments()
       .showHelpAfterError(),
-    GenieCodeCliOptionsSchema,
+    GenieCodeOptionsSchema,
   );
   program.action(async (genieArgs: string[]) => {
     await dependencies.run({
       cwd: process.cwd(),
       genieArgs,
-      options: parseArgs(program, GenieCodeCliOptionsSchema),
+      options: parseArgs(program, GenieCodeOptionsSchema),
     });
   });
   return program;

package/src/genie-code/config.ts

@@ -8,8 +8,8 @@ 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 { withFileLock } from "@dbx-tools/core";
+import { isRecord } from "@dbx-tools/shared-core";
 import {
   GenieCodeBaseConfigSchema,
   GenieCodeConfigSchema,
@@ -17,8 +17,8 @@ import {
   type GenieCodeBaseConfig,
   type GenieCodeConfig,
   type GenieCodeProviderOverlay,
-} from "@dbx-tools/shared-genie-code/config";
-import { genieCodeHomeName } from "@dbx-tools/shared-genie-code/options";
+} from "@dbx-tools/shared-genie-code";
+import { genieCodeHomeName } from "@dbx-tools/shared-genie-code";
 import { parse, stringify } from "smol-toml";
 
 /** Provider identifier written to the base and invocation overlay configurations. */
@@ -65,7 +65,7 @@ export function genieCodeBaseConfig(
 ): GenieCodeBaseConfig {
   const projects = Object.fromEntries(
     Object.entries(existingProjects).filter(
-      ([, value]) => object.isRecord(value) && value.trust_level === "trusted",
+      ([, value]) => isRecord(value) && value.trust_level === "trusted",
     ),
   );
   return GenieCodeBaseConfigSchema.parse({
@@ -118,7 +118,7 @@ export function genieCodeConfig(options: WriteGenieCodeConfigOptions): GenieCode
 async function existingProjects(path: string): Promise<Record<string, unknown>> {
   try {
     const value = parse(await readFile(path, "utf8"));
-    return object.isRecord(value.projects) ? value.projects : {};
+    return isRecord(value.projects) ? value.projects : {};
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") return {};
     throw error;

package/src/genie-code/install.ts

@@ -6,8 +6,8 @@
 
 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";
+import { type BinContext, ensure } from "@dbx-tools/core";
+import { GENIE_CODE_VERSION } from "@dbx-tools/shared-genie-code";
 
 interface GenieCodeAsset {
   target: string;
@@ -63,9 +63,7 @@ export function genieCodeAsset(
 }
 
 /** Install and return the shared Genie Code package entrypoint. */
-export async function installGenieCode(
-  options: InstallGenieCodeOptions = {},
-): Promise<bin.BinContext> {
+export async function installGenieCode(options: InstallGenieCodeOptions = {}): Promise<BinContext> {
   const platform = options.platform ?? process.platform;
   const asset = genieCodeAsset(platform, options.architecture ?? process.arch);
   const executable = platform === "win32" ? "genie.exe" : "genie";
@@ -78,7 +76,7 @@ export async function installGenieCode(
     "releases",
     `${GENIE_CODE_VERSION}-${asset.target}`,
   );
-  const destination: bin.BinContext = {
+  const destination: BinContext = {
     root,
     binDir: join(root, dirname(entrypoint)),
     path: join(root, entrypoint),
@@ -86,7 +84,7 @@ export async function installGenieCode(
   const url =
     `https://github.com/databricks/genie-code-cli/releases/download/v${GENIE_CODE_VERSION}/` +
     `genie-package-${asset.target}.tar.gz`;
-  return bin.ensure(
+  return ensure(
     "genie",
     { url, sha256: asset.sha256 },
     {

package/src/genie-code/runner.ts

@@ -4,18 +4,21 @@
  * @module
  */
 
-import { exec } from "@dbx-tools/core";
-import { asyncUtils, log } from "@dbx-tools/shared-core";
-import { GenieCodeRunnerOptionsSchema } from "@dbx-tools/shared-genie-code/options";
+import { configUtils, spawn } from "@dbx-tools/core";
+import { log, poll } from "@dbx-tools/shared-core";
+import { GenieCodeRunnerOptionsSchema } from "@dbx-tools/shared-genie-code";
 
-/** Private environment field carrying serialized runner options. */
-const RUNNER_OPTIONS_ENV = "DBX_TOOLS_GENIE_RUNNER_OPTIONS";
+/** Logical configuration key carrying serialized runner options. */
+export const RUNNER_OPTIONS_KEY = "GENIE_RUNNER_OPTIONS";
 const logger = log.logger("genie-code:runner");
 
 /** Parse the serialized runner boundary from its private environment field. */
 export function genieCodeRunnerOptions(environment: NodeJS.ProcessEnv = process.env) {
-  const serialized = environment[RUNNER_OPTIONS_ENV];
-  if (!serialized) throw new Error(`${RUNNER_OPTIONS_ENV} is required`);
+  const serialized = configUtils.resolveValue(RUNNER_OPTIONS_KEY, {
+    data: environment,
+    sources: "config",
+  });
+  if (!serialized) throw new Error(`${configUtils.name(RUNNER_OPTIONS_KEY)} is required`);
   return GenieCodeRunnerOptionsSchema.parse(JSON.parse(serialized));
 }
 
@@ -25,7 +28,7 @@ export async function waitForGenieCodeGateway(
   bearerToken: string,
   timeoutMs: number,
 ): Promise<void> {
-  for await (const ready of asyncUtils.poll(
+  for await (const ready of poll(
     async ({ signal }) => {
       try {
         const response = await fetch(healthUrl, {
@@ -65,7 +68,7 @@ export async function runGenieCodeChild(
     executable: options.executable,
     home: options.home,
   });
-  const child = exec.spawn(options.executable, [...options.arguments], {
+  const child = spawn(options.executable, [...options.arguments], {
     cwd: process.cwd(),
     env: {
       ...environment,
@@ -80,5 +83,3 @@ export async function runGenieCodeChild(
   const result = await child;
   if (result.exitCode !== 0) process.exitCode = result.exitCode;
 }
-
-export { RUNNER_OPTIONS_ENV };

package/src/genie-code/runtime.ts

@@ -7,24 +7,24 @@
 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 { DatabricksModelRegistry, codexModelSlug } from "@dbx-tools/appkit-model-gateway";
 import * as auth from "@dbx-tools/auth";
-import { resolveServicePackageBin } from "@dbx-tools/cli-service/definition";
-import type { BinContext } from "@dbx-tools/core/bin";
-import { workspaceClient } from "@dbx-tools/databricks";
+import { resolveServicePackageBin } from "@dbx-tools/cli-service";
+import { configUtils, type BinContext } from "@dbx-tools/core";
+import { createWorkspaceClient } from "@dbx-tools/databricks";
 import { log } from "@dbx-tools/shared-core";
 import {
   resolveGenieCodeOptions,
   type GenieCodeOptions,
   type GenieCodeRunnerOptions,
-} from "@dbx-tools/shared-genie-code/options";
-import type { ModelClass } from "@dbx-tools/shared-model/contracts";
+} from "@dbx-tools/shared-genie-code";
+import type { ModelClass } from "@dbx-tools/shared-model";
 import concurrently from "concurrently";
 import getPort from "get-port";
 
 import { writeGenieCodeConfig, type GenieCodeHome } from "./config.ts";
 import { installGenieCode } from "./install.ts";
-import { RUNNER_OPTIONS_ENV } from "./runner.ts";
+import { RUNNER_OPTIONS_KEY } from "./runner.ts";
 
 const logger = log.logger("genie-code");
 
@@ -61,7 +61,7 @@ async function resolveCodexModel(
   profile: string,
   modelClass?: ModelClass,
 ): Promise<string> {
-  const client = await workspaceClient.createWorkspaceClient({ profile });
+  const client = await createWorkspaceClient({ profile });
   const target = await new DatabricksModelRegistry({ client }).resolve(model, {
     requiresTools: true,
     ...(modelClass ? { modelClass } : {}),
@@ -72,7 +72,7 @@ async function resolveCodexModel(
     );
   }
   // Genie Code pins the exact system.ai service slug, which wins regardless of gateway preference.
-  return models.codexModelSlug(target, true);
+  return codexModelSlug(target, true);
 }
 
 /** Inputs accepted by managed Genie Code preparation and execution. */
@@ -205,7 +205,7 @@ export async function runGenieCode(input: RunGenieCodeOptions = {}): Promise<voi
           ...process.env,
           PATH: path,
           DATABRICKS_CONFIG_PROFILE: prepared.profile,
-          [RUNNER_OPTIONS_ENV]: JSON.stringify(runnerOptions),
+          [configUtils.name(RUNNER_OPTIONS_KEY)]: JSON.stringify(runnerOptions),
         },
       },
     ],

package/src/graphiti/cli.ts

@@ -12,16 +12,20 @@ import { join } from "node:path";
 
 import { runtime as graphitiRuntime } from "@dbx-tools/appkit-memory/graphiti";
 import { addArgs, parseArgs, serializeArgs } from "@dbx-tools/cli-args";
-import { buildServiceCommand, type CliServiceCliDependencies } from "@dbx-tools/cli-service/cli";
-import { defineService, type CliServiceDefinition } from "@dbx-tools/cli-service/definition";
-import { serviceTrayIcon } from "@dbx-tools/cli-service/icon";
-import { Command } from "commander";
-
+import {
+  buildServiceCommand,
+  type CliServiceCliDependencies,
+  defineService,
+  type CliServiceDefinition,
+} from "@dbx-tools/cli-service";
+import { serviceTrayIcon } from "@dbx-tools/cli-service";
 import {
   GraphitiCliOptionsSchema,
   GraphitiOptionsSchema,
   type GraphitiOptions,
-} from "./options.ts";
+} from "@dbx-tools/shared-graphiti";
+import { Command } from "commander";
+
 import { PACKAGE_VERSION } from "../../index.ts";
 
 const DEFAULT_SERVICE_DIRECTORY = join(homedir(), ".dbx-tools", "services", "graphiti");
@@ -74,18 +78,18 @@ export function buildProgram(
       .version(PACKAGE_VERSION, "-v, --version"),
     GraphitiCliOptionsSchema,
   ).action(async () => {
-    await dependencies.run(graphitiOptions(program));
+    await dependencies.run(parseGraphitiOptions(program));
   });
 
   program.addCommand(
     buildServiceCommand(
-      () => graphitiServiceDefinition(graphitiOptions(program)),
+      () => graphitiServiceDefinition(parseGraphitiOptions(program)),
       dependencies.service,
     ),
   );
   return program;
 }
 
-function graphitiOptions(command: Command): GraphitiOptions {
+function parseGraphitiOptions(command: Command): GraphitiOptions {
   return GraphitiOptionsSchema.parse(parseArgs(command, GraphitiCliOptionsSchema));
 }

package/src/lakebase-proxy/cli.ts

@@ -1,9 +1,13 @@
 /** Commander entry point for the pure Node Lakebase proxy. */
 
 import { addArgs, parseArgs, serializeArgs } from "@dbx-tools/cli-args";
-import { buildServiceCommand, type CliServiceCliDependencies } from "@dbx-tools/cli-service/cli";
-import { defineService, type CliServiceDefinition } from "@dbx-tools/cli-service/definition";
-import { serviceTrayIcon } from "@dbx-tools/cli-service/icon";
+import {
+  buildServiceCommand,
+  type CliServiceCliDependencies,
+  defineService,
+  type CliServiceDefinition,
+} from "@dbx-tools/cli-service";
+import { serviceTrayIcon } from "@dbx-tools/cli-service";
 import { connectionUrl } from "@dbx-tools/lakebase";
 import { Command } from "commander";
 

package/src/lakebase-proxy/options.ts

@@ -4,24 +4,29 @@
  * @module
  */
 
-import { options } from "@dbx-tools/shared-core";
+import {
+  PostgresConfigOptionsSchema,
+  listenAddressSchema,
+  DatabricksOptionsSchema,
+  LakebaseOptionsSchema,
+} from "@dbx-tools/shared-core";
 import { z } from "zod";
 
 const text = (description: string) => z.string().trim().min(1).optional().describe(description);
 
 export const LakebaseProxyOptionsSchema = z
   .object({
-    ...options.PostgresConfigOptionsSchema.shape,
-    listen: options
-      .listenAddressSchema({ port: 5432, loopback: true })
-      .describe("Loopback listener address."),
+    ...PostgresConfigOptionsSchema.shape,
+    listen: listenAddressSchema({ port: 5432, loopback: true }).describe(
+      "Loopback listener address.",
+    ),
     startupTimeoutSeconds: z.coerce
       .number<number>()
       .int()
       .nonnegative()
       .default(30)
       .describe("Startup timeout in seconds."),
-    profile: options.DatabricksOptionsSchema.shape.profile.describe("Exact Databricks profile."),
+    profile: DatabricksOptionsSchema.shape.profile.describe("Exact Databricks profile."),
   })
   .strict()
   .describe("Lakebase proxy listener and service options.");
@@ -29,8 +34,8 @@ export const LakebaseProxyOptionsSchema = z
 export const LakebaseProxyUrlOptionsSchema = z
   .object({
     target: text("Lakebase project, resource path, host, or URL."),
-    lakebaseEndpoint: options.LakebaseOptionsSchema.shape.lakebaseEndpoint,
-    listen: options.listenAddressSchema({ port: 5432 }).describe("Local proxy address."),
+    lakebaseEndpoint: LakebaseOptionsSchema.shape.lakebaseEndpoint,
+    listen: listenAddressSchema({ port: 5432 }).describe("Local proxy address."),
   })
   .strict()
   .refine(

package/src/lakebase-proxy/proxy.ts

@@ -4,7 +4,7 @@ import { createServer, type Server, type Socket } from "node:net";
 import type { Duplex } from "node:stream";
 import { LakebaseClient, requireAddress } from "@dbx-tools/lakebase";
 import { postgresConnectionOptions } from "@dbx-tools/postgres";
-import { errorUtils, log, stringUtils } from "@dbx-tools/shared-core";
+import { log, toError, trimToUndefined } from "@dbx-tools/shared-core";
 import { Client } from "pg";
 
 import { CancellationRegistry } from "./cancellation.ts";
@@ -113,20 +113,20 @@ export class LakebaseProxy {
       try {
         target = requireAddress(targetText);
       } catch (error) {
-        throw new ProxyFailure(message(error), "3D000", { cause: errorUtils.toError(error) });
+        throw new ProxyFailure(message(error), "3D000", { cause: toError(error) });
       }
-      const startupUser = stringUtils.trimToUndefined(startup.parameters.user);
+      const startupUser = trimToUndefined(startup.parameters.user);
       let resolved;
       try {
         resolved = await this.client.resolve(target, startupUser);
       } catch (error) {
-        throw new ProxyFailure(message(error), "3D000", { cause: errorUtils.toError(error) });
+        throw new ProxyFailure(message(error), "3D000", { cause: toError(error) });
       }
       let password;
       try {
         password = await this.client.generateDatabaseCredential(resolved.endpoint, startupUser);
       } catch (error) {
-        throw new ProxyFailure(message(error), "28000", { cause: errorUtils.toError(error) });
+        throw new ProxyFailure(message(error), "28000", { cause: toError(error) });
       }
       let connected;
       try {
@@ -136,7 +136,7 @@ export class LakebaseProxy {
           postgresConnectionOptions(startup.parameters, this.options.postgresRole),
         );
       } catch (error) {
-        throw new ProxyFailure(message(error), "08001", { cause: errorUtils.toError(error) });
+        throw new ProxyFailure(message(error), "08001", { cause: toError(error) });
       }
       upstream = connected.socket;
       cancellation = this.cancellations.register({
@@ -168,7 +168,7 @@ export class LakebaseProxy {
           ? error
           : error instanceof PostgresProtocolError
             ? new ProxyFailure(error.message, "08P01", { cause: error })
-            : new ProxyFailure(message(error), "08001", { cause: errorUtils.toError(error) });
+            : new ProxyFailure(message(error), "08001", { cause: toError(error) });
       logger.warn("Lakebase connection failed", {
         durationMs: Date.now() - started,
         error: failure,

package/src/model-gateway/cli.ts

@@ -5,14 +5,18 @@
  */
 
 import { addArgs, parseArgs, serializeArgs } from "@dbx-tools/cli-args";
-import { buildServiceCommand, type CliServiceCliDependencies } from "@dbx-tools/cli-service/cli";
-import { defineService, type CliServiceDefinition } from "@dbx-tools/cli-service/definition";
+import {
+  buildServiceCommand,
+  type CliServiceCliDependencies,
+  defineService,
+  type CliServiceDefinition,
+} from "@dbx-tools/cli-service";
 import {
   ModelGatewayCliOptionsSchema,
   resolveModelGatewayCliOptions,
   type ModelGatewayCliOptions,
   type ModelGatewayOptions,
-} from "@dbx-tools/shared-model-gateway/options";
+} from "@dbx-tools/shared-model-gateway";
 import { Command } from "commander";
 
 import { startModelGateway } from "./server.ts";

package/src/model-gateway/server.ts

@@ -6,14 +6,18 @@
 
 import { createHash, timingSafeEqual } from "node:crypto";
 import { createApp, server } from "@databricks/appkit";
-import { ModelGateway } from "@dbx-tools/appkit-model-gateway";
-import { sendHealth, sendInference, sendModels } from "@dbx-tools/appkit-model-gateway/routes";
-import { workspaceClient } from "@dbx-tools/databricks";
+import {
+  ModelGateway,
+  sendHealth,
+  sendInference,
+  sendModels,
+} from "@dbx-tools/appkit-model-gateway";
+import { createWorkspaceClient } from "@dbx-tools/databricks";
 import {
   resolveModelGatewayOptions,
   type ModelGatewayOptions,
   type ResolvedModelGatewayOptions,
-} from "@dbx-tools/shared-model-gateway/options";
+} from "@dbx-tools/shared-model-gateway";
 import type express from "express";
 
 type AppKitServerOptions = NonNullable<Parameters<typeof server>[0]>;
@@ -65,7 +69,7 @@ export async function startModelGateway(options: ModelGatewayOptions = {}): Prom
     ...(resolved.modelClass ? { modelClass: resolved.modelClass } : {}),
     preferSystemModels: resolved.preferSystemModels,
   });
-  const client = await workspaceClient.createWorkspaceClient({
+  const client = await createWorkspaceClient({
     ...(resolved.profile ? { profile: resolved.profile } : {}),
   });
   await createApp({

package/src/root.ts

@@ -6,7 +6,7 @@
 import { existsSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { projectUtils } from "@dbx-tools/core";
-import { functionUtils } from "@dbx-tools/shared-core";
+import { memoize } from "@dbx-tools/shared-core";
 
 /**
  * Walk upward from `startDir` for `.projenrc.ts`. If none is found, try git
@@ -52,7 +52,7 @@ export function needsToolchain(root: string): boolean {
 }
 
 /** Async, memoized root lookup from the process cwd at first use. */
-export const workspaceRoot = functionUtils.memoize(() => findWorkspaceRoot());
+export const workspaceRoot = memoize(() => findWorkspaceRoot());
 
 /** Short label for log output (`basename` of the resolved root). */
 export function rootLabel(root: string): string {

package/src/tunnel/app.ts

@@ -16,11 +16,11 @@
  */
 
 import { lakebase, type WorkspaceClient } from "@databricks/appkit";
-import { appkit } from "@dbx-tools/appkit";
-import { authStorage } from "@dbx-tools/auth-gate";
+import { createApp } from "@dbx-tools/appkit";
+import { shouldUseLakebase } from "@dbx-tools/auth-gate";
 import { email } from "@dbx-tools/email";
 import { postgresConnectionOptions } from "@dbx-tools/postgres";
-import { object } from "@dbx-tools/shared-core";
+import { isRecord } from "@dbx-tools/shared-core";
 import { authGate, type AuthGateApi, type AuthGateConfig } from "@dbx-tools/tunnel";
 
 /** Boot the gate app and return the handlers the proxy authenticates against. */
@@ -30,12 +30,10 @@ export async function startGateApp(
 ): Promise<AuthGateApi> {
   // No `server()` plugin: nothing here listens. `plugins` order matters - `email`
   // registers its transport before `authGate` looks for a sibling to send with.
-  const plugins = await appkit.createApp({
+  const plugins = await createApp({
     client,
     plugins: [
-      ...(authStorage.shouldUseLakebase(config)
-        ? [lakebase({ pool: postgresConnectionOptions({}) })]
-        : []),
+      ...(shouldUseLakebase(config) ? [lakebase({ pool: postgresConnectionOptions({}) })] : []),
       ...(config.sendCode ? [] : [email()]),
       authGate(config),
     ],
@@ -47,7 +45,7 @@ export async function startGateApp(
 
 function isAuthGateApi(value: unknown): value is AuthGateApi {
   return (
-    object.isRecord(value) &&
+    isRecord(value) &&
     typeof value.basePath === "string" &&
     typeof value.passkeysEnabled === "boolean" &&
     typeof value.isProtectedHost === "function" &&