@dbx-tools/projen 0.9.153 → 0.9.157

package/src/tags.ts

@@ -13,6 +13,7 @@
  * across the subtree; the root applies built-in tag mixins during construction and
  * callers add their own afterward.
  */
+import { relative } from "node:path";
 import type { IMixin as ConstructsMixin } from "constructs";
 import { DependencyType, javascript } from "projen";
 import { BunBuildFile, BunDevServerFile, BunfigFile } from "./bun-app.ts";
@@ -23,7 +24,7 @@ import {
   applyCompilerOptions,
   applyExports,
   applyIncludes,
-  srcModuleExports,
+  srcFolderExports,
 } from "./project-js.ts";
 import * as projectPredicate from "./project-predicate.ts";
 
@@ -83,11 +84,13 @@ export const PACKAGE_TAG_MIXINS = {
     applyCompilerOptions(p, {
       target: "ES2022",
       lib: [...DOM_LIB],
+      noEmit: true,
+      rootDir: relative(p.outdir, p.root.outdir).replaceAll("\\", "/") || ".",
     });
-    // UI libraries are subpath-only. Their React entrypoint, optional stylesheet,
-    // and any other public source modules are discovered from the source tree.
+    // UI libraries expose their package barrel, folder barrels, and public CSS.
     applyExports(p, {
-      ...srcModuleExports(p),
+      ".": "./index.ts",
+      ...srcFolderExports(p),
       "./package.json": "./package.json",
     });
   }),
@@ -149,13 +152,11 @@ export const PACKAGE_TAG_MIXINS = {
     // A CLI compiles code OUTSIDE `src/` - its root `index.ts` barrel and the
     // `bin/` entries - which the src-only tag default doesn't reach.
     applyCompilerOptions(p, NODE_COMPILER_OPTIONS);
-    applyIncludes(p, "index.ts", "bin/**/*.ts");
-    // A CLI's standard surface: the `.` root entry, a `./<module>` subpath per
-    // top-level `src` module, and `./package.json`. Derived rather than declared
-    // so no CLI has to hand-list its own modules.
+    applyIncludes(p, "index*.ts", "bin/**/*.ts");
+    // A CLI's standard surface: the root barrel, folder barrels, and package metadata.
     applyExports(p, {
       ".": "./index.ts",
-      ...srcModuleExports(p),
+      ...srcFolderExports(p),
       "./package.json": "./package.json",
     });
     // A CLI is the one shape whose entry point lives outside `src`, so its

package/src/watch.ts

@@ -16,8 +16,8 @@
  * is thin glue.
  */
 import { isAbsolute, resolve } from "node:path";
-import { watch as pathWatch } from "@dbx-tools/path";
-import { asyncUtils, errorUtils, log } from "@dbx-tools/shared-core";
+import { watchFiles } from "@dbx-tools/path";
+import { log, sleep, toError } from "@dbx-tools/shared-core";
 import { isGeneratedFile, recordedRoots, repoRoot } from "./packages.ts";
 import { withWorkspaceMutationLock } from "./workspace-lock.ts";
 
@@ -49,9 +49,7 @@ const CLOSE_GRACE_MS = 2_000;
 const FATAL_WATCH_ERROR_CODES = new Set(["EMFILE", "ENFILE", "ENOSPC"]);
 
 /** node-path's built-in ignore-group toggles (`{ dot, temp, test, lock, defaults }`). */
-export type IgnoreGroupOptions = NonNullable<
-  Parameters<typeof pathWatch.watchFiles>[1]
->["ignoreOptions"];
+export type IgnoreGroupOptions = NonNullable<Parameters<typeof watchFiles>[1]>["ignoreOptions"];
 
 /** The package roots (absolute), where every watchable source file lives. */
 export function watchRoots(): string[] {
@@ -119,7 +117,7 @@ export async function watchLoop(
         });
       }
     } catch (err) {
-      logger.error(`${tag} cycle failed`, { error: errorUtils.toError(err) });
+      logger.error(`${tag} cycle failed`, { error: toError(err) });
     } finally {
       running = false;
       if (rerun) {
@@ -129,7 +127,7 @@ export async function watchLoop(
     }
   }
 
-  const watcher = await pathWatch.watchFiles(paths, {
+  const watcher = await watchFiles(paths, {
     cwd: repoRoot,
     ignoreInitial: true,
     ignore: (path) => ignoredPath(path),
@@ -146,7 +144,7 @@ export async function watchLoop(
     if (closing) return;
     closing = true;
     clearTimeout(timer);
-    await Promise.race([watcher.close().catch(() => {}), asyncUtils.sleep(CLOSE_GRACE_MS)]);
+    await Promise.race([watcher.close().catch(() => {}), sleep(CLOSE_GRACE_MS)]);
     process.exit(code);
   }
 
@@ -156,7 +154,7 @@ export async function watchLoop(
     timer = setTimeout(() => void flush(), DEBOUNCE_MS);
   });
   watcher.on("error", (err) => {
-    logger.error(`${tag} watcher error`, { error: errorUtils.toError(err) });
+    logger.error(`${tag} watcher error`, { error: toError(err) });
     const code = (err as NodeJS.ErrnoException | undefined)?.code;
     if (code === undefined || !FATAL_WATCH_ERROR_CODES.has(code)) return;
     logger.error(`${tag}: ${code} leaves the watcher blind - exiting so it is restarted`);

package/src/workspace-lock.ts

@@ -1,6 +1,6 @@
 /** Cross-process coordination for generated workspace mutations. */
 import { resolve } from "node:path";
-import * as fileLock from "@dbx-tools/core/file-lock";
+import { withFileLock } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
 
 const MUTATION_LOCK_SCOPE = "dbx-tools-workspace-mutation";
@@ -36,7 +36,7 @@ export async function withWorkspaceMutationLock<T>(
   }
   let waitLogTimer: ReturnType<typeof setInterval> | undefined;
   try {
-    return await fileLock.withFileLock(
+    return await withFileLock(
       [MUTATION_LOCK_SCOPE, repository],
       async () => {
         if (check && !(await check())) {

package/src/workspace-manifest.ts

@@ -17,7 +17,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
+import { spawnSync } from "@dbx-tools/core";
 
 const DEPENDENCY_FIELDS = [
   "dependencies",
@@ -102,7 +102,7 @@ export async function withStagedWorkspaceManifests<T>(
 ): Promise<T> {
   const stage = mkdtempSync(join(tmpdir(), "dbx-tools-app-deploy-"));
   try {
-    const listed = exec.spawnSync(
+    const listed = spawnSync(
       "git",
       ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
       {

package/tasks/appkit-deploy.ts

@@ -1,11 +1,11 @@
 #!/usr/bin/env -S bun
 /** Deploy an AppKit workspace through npm-compatible temporary manifests. */
-import { existsSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { profile } from "@dbx-tools/auth";
+import { cpSync, existsSync, rmSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { resolveProfile } from "@dbx-tools/auth";
 import { serializeArgs } from "@dbx-tools/cli-args";
-import * as exec from "@dbx-tools/core/exec";
-import { errorUtils, log } from "@dbx-tools/shared-core";
+import { spawn, spawnSync } from "@dbx-tools/core";
+import { log, toError } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
 import { withStagedWorkspaceManifests } from "../src/workspace-manifest.ts";
@@ -33,6 +33,13 @@ export const AppKitDeployContextOptionsSchema = z.object({
 });
 
 export const AppKitDeployOptionsSchema = AppKitDeployContextOptionsSchema.extend({
+  directory: z
+    .string()
+    .trim()
+    .min(1)
+    .default(".")
+    .describe("Application directory relative to the workspace root")
+    .meta({ env: [] }),
   autoApprove: z
     .boolean()
     .default(false)
@@ -81,6 +88,17 @@ export async function deployApp(
 ): Promise<void> {
   const root = dependencies.root ?? process.cwd();
   const options = await resolveDeployOptions(args, dependencies);
+  const application = resolve(root, options.directory);
+  const applicationPath = relative(root, application);
+  if (!applicationPath || applicationPath.startsWith("..") || isAbsolute(applicationPath)) {
+    if (options.directory !== ".") {
+      throw new Error("Application directory must be inside the workspace root");
+    }
+  }
+  const clientDist = join(application, "client", "dist");
+  if (!existsSync(clientDist)) {
+    throw new Error(`Built client is missing: ${clientDist}`);
+  }
   const context = AppKitDeployContextOptionsSchema.parse({
     target: options.target,
     profile: options.profile,
@@ -99,7 +117,7 @@ export async function deployApp(
     (dependencies.run
       ? undefined
       : (validateArgs: readonly string[], cwd: string) =>
-          exec.spawn(
+          spawn(
             "databricks",
             ["bundle", "validate", ...serializeArgs({ strict: true }), ...validateArgs],
             {
@@ -111,7 +129,7 @@ export async function deployApp(
             },
           ));
   if (validate) {
-    const validation = await validate(contextArgs, root);
+    const validation = await validate(contextArgs, application);
     if (validation.exitCode !== 0) {
       throw new Error(`databricks bundle validate exited with code ${validation.exitCode}`);
     }
@@ -119,7 +137,7 @@ export async function deployApp(
   const run =
     dependencies.run ??
     ((deployArgs: readonly string[], cwd: string) =>
-      exec.spawn("databricks", ["apps", "deploy", ...deployArgs], {
+      spawn("databricks", ["apps", "deploy", ...deployArgs], {
         cwd,
         env: dependencies.environment ?? process.env,
         stdin: "inherit",
@@ -127,10 +145,12 @@ export async function deployApp(
         stderr: "inherit",
       }));
   await withStagedWorkspaceManifests(root, async (stage) => {
-    await reconcileStagedBundleState(stage, contextArgs, options.target, dependencies);
-    const result = await run(deployArgs, stage);
+    const stagedApplication = resolve(stage, options.directory);
+    cpSync(clientDist, join(stagedApplication, "client", "dist"), { recursive: true });
+    await reconcileStagedBundleState(stagedApplication, contextArgs, options.target, dependencies);
+    const result = await run(deployArgs, stagedApplication);
     if (result.exitCode !== 0) {
-      await printAppLogs(contextArgs, stage, dependencies);
+      await printAppLogs(contextArgs, stagedApplication, dependencies);
       throw new Error(`databricks apps deploy exited with code ${result.exitCode}`);
     }
   });
@@ -148,7 +168,7 @@ async function reconcileStagedBundleState(
       ? undefined
       : (args: readonly string[], cwd: string) =>
           Promise.resolve(
-            exec.spawnSync(
+            spawnSync(
               "databricks",
               ["bundle", "plan", ...serializeArgs({ quiet: true }), ...args],
               {
@@ -186,7 +206,7 @@ async function printAppLogs(
   const showLogs =
     dependencies.logs ??
     ((args: readonly string[], logsCwd: string) =>
-      exec.spawn("databricks", ["apps", "logs", ...serializeArgs({ tailLines: 200 }), ...args], {
+      spawn("databricks", ["apps", "logs", ...serializeArgs({ tailLines: 200 }), ...args], {
         cwd: logsCwd,
         env: dependencies.environment ?? process.env,
         stdin: "ignore",
@@ -200,7 +220,7 @@ async function printAppLogs(
     }
   } catch (error) {
     logger.warn("Could not read Databricks App logs", {
-      message: errorUtils.toError(error).message,
+      error: toError(error),
     });
   }
 }
@@ -229,7 +249,7 @@ async function resolveDeployOptions(
     configuredProfile ??
     (hasEnvironmentAuth
       ? undefined
-      : (dependencies.resolveProfile ?? (() => profile.resolveProfile()?.name))());
+      : (dependencies.resolveProfile ?? (() => resolveProfile()?.name))());
   if (!hasEnvironmentAuth && !resolvedProfile) {
     throw new Error(
       "Select a Databricks profile with --profile or configure Databricks environment credentials",

package/tasks/barrels.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 /** Generate package barrels once or keep affected barrels current in watch mode. */
 import { sep } from "node:path";
-import { log, object, stringUtils } from "@dbx-tools/shared-core";
+import { log, type Sequence, sequence, pluralize } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
 import { TaskDirectoriesOptionSchema, TaskWatchOptionSchema } from "./options.ts";
@@ -19,10 +19,9 @@ function ownerPackageDir(
   return packages.find(({ dir }) => abs === dir || abs.startsWith(dir + sep))?.dir;
 }
 
-function changedBarrelTargets(changed: readonly string[]): object.Sequence<string> {
+function changedBarrelTargets(changed: readonly string[]): Sequence<string> {
   const packages = recordedPackages();
-  return object
-    .sequence(changed)
+  return sequence(changed)
     .map((path) => ownerPackageDir(path, packages))
     .nonNull()
     .distinct();
@@ -31,7 +30,7 @@ function changedBarrelTargets(changed: readonly string[]): object.Sequence<strin
 function warnUnownedChanges(changed: readonly string[]): void {
   if (changed.length) {
     logger.warn(
-      `no recorded package owns ${stringUtils.pluralize(changed.length, "change")}; ` +
+      `no recorded package owns ${pluralize(changed.length, "change")}; ` +
         "run `bun run default` (or touch .projenrc.ts) to pick up a new package folder",
     );
   }
@@ -62,7 +61,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
       watchRoots(),
       (changed) => {
         const n = generateBarrels({ dirs: [...changedBarrelTargets(changed)] });
-        if (n) logger.success(`rebuilt ${stringUtils.pluralize(n, "barrel")}`);
+        if (n) logger.success(`rebuilt ${pluralize(n, "barrel")}`);
       },
       {
         check: (changed) => {
@@ -80,9 +79,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   } else {
     const dirs = values.dir;
     const n = generateBarrels(dirs.length ? { dirs } : undefined);
-    logger.success(
-      n === 0 ? "barrels already up to date" : `updated ${stringUtils.pluralize(n, "barrel")}`,
-    );
+    logger.success(n === 0 ? "barrels already up to date" : `updated ${pluralize(n, "barrel")}`);
   }
 }
 

package/tasks/bump.ts

@@ -4,7 +4,7 @@
  * generated version surface. This task has no git, registry, or publication
  * side effects; release preparation owns those operations.
  */
-import * as projectUtils from "@dbx-tools/core/project-utils";
+import { projectUtils } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions, taskRoot } from "./cli.ts";

package/tasks/clean.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 /** Interactively remove generated files and installed dependency directories. */
 import { relative } from "node:path";
-import { log, stringUtils } from "@dbx-tools/shared-core";
+import { log, pluralize } from "@dbx-tools/shared-core";
 import { z } from "zod";
 import { runTaskMain, taskCommand, taskOptions } from "./cli.ts";
 import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
@@ -43,7 +43,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   if (yes) {
     const n = removePaths(targets);
     logger.success(
-      `removed ${stringUtils.pluralize(n, "path")} (${files.length} generated + ${nodeModules.length} node_modules) - ${regenHint(nodeModules.length > 0)}`,
+      `removed ${pluralize(n, "path")} (${files.length} generated + ${nodeModules.length} node_modules) - ${regenHint(nodeModules.length > 0)}`,
     );
     process.exit(0);
   }
@@ -83,7 +83,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
 
   const removedNodeModules = picked.some((p) => nodeModules.includes(p));
   const n = removePaths(picked);
-  clack.outro(`removed ${stringUtils.pluralize(n, "path")} - ${regenHint(removedNodeModules)}`);
+  clack.outro(`removed ${pluralize(n, "path")} - ${regenHint(removedNodeModules)}`);
 }
 
 await runTaskMain(import.meta, main);

package/tasks/cli.ts

@@ -2,8 +2,8 @@
 import { basename, extname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { addArgs, parseArgs, type CliArgsOptions } from "@dbx-tools/cli-args";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { stringUtils } from "@dbx-tools/shared-core";
+import { projectUtils } from "@dbx-tools/core";
+import { tokenize } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { z } from "zod";
 
@@ -15,7 +15,7 @@ export function taskName(moduleUrl: string): string {
 
 /** Config resolution shared by task schemas. */
 export function taskCliArgsOptions(moduleUrl: string): CliArgsOptions {
-  const prefix = [...stringUtils.tokenize(taskName(moduleUrl))].join("_").toUpperCase();
+  const prefix = [...tokenize(taskName(moduleUrl))].join("_").toUpperCase();
   return {
     cwd: process.cwd(),
     prefix: `PROJEN_${prefix}`,

package/tasks/compile-workspace.ts

@@ -3,8 +3,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { availableParallelism } from "node:os";
 import { join, resolve } from "node:path";
-import * as exec from "@dbx-tools/core/exec";
-import { errorUtils, log } from "@dbx-tools/shared-core";
+import { type ExecResult, spawn } from "@dbx-tools/core";
+import { log, toError } from "@dbx-tools/shared-core";
 import type { TaskSpec, TasksManifest } from "projen";
 import { runTaskMain } from "./cli.ts";
 
@@ -80,7 +80,7 @@ const emoji = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
 export async function main(): Promise<void> {
   const root = process.cwd();
   const plan = compilePlan(root);
-  const jobs: Array<{ name: string; result: Promise<exec.ExecResult> }> = [];
+  const jobs: Array<{ name: string; result: Promise<ExecResult> }> = [];
   if (plan.typescriptConfigs.length > 0) {
     const batchCount = Math.min(4, availableParallelism(), plan.typescriptConfigs.length);
     const batches = Array.from({ length: batchCount }, () => [] as string[]);
@@ -91,7 +91,7 @@ export async function main(): Promise<void> {
     for (const [index, batch] of batches.entries()) {
       jobs.push({
         name: `TypeScript batch ${index + 1}`,
-        result: exec.spawn("bunx", ["tsc", "--build", ...batch], {
+        result: spawn("bunx", ["tsc", "--build", ...batch], {
           cwd: root,
           stdin: "ignore",
           stdout: "inherit",
@@ -111,7 +111,7 @@ export async function main(): Promise<void> {
   for (const [index, result] of results.entries()) {
     if (result.status === "rejected") {
       logger.error(`${jobs[index]!.name} compile failed`, {
-        error: errorUtils.toError(result.reason),
+        error: toError(result.reason),
       });
       failed = true;
     } else if (result.value.exitCode !== 0) {
@@ -125,10 +125,10 @@ export async function main(): Promise<void> {
 async function compileCustomPackage(pkg: {
   readonly name: string;
   readonly directory: string;
-}): Promise<exec.ExecResult> {
-  let result: exec.ExecResult | undefined;
+}): Promise<ExecResult> {
+  let result: ExecResult | undefined;
   for (const task of ["pre-compile", "compile", "post-compile"]) {
-    result = await exec.spawn("bun", ["run", task], {
+    result = await spawn("bun", ["run", task], {
       cwd: pkg.directory,
       stdin: "ignore",
       stdout: (line) => logger.info(`${pkg.name}: ${line.replace(emoji, "")}`),

package/tasks/dev-watch.ts

@@ -2,9 +2,9 @@
 /** Restart a development command after relevant workspace changes settle. */
 import { isAbsolute, relative, resolve } from "node:path";
 import { serializeArgs } from "@dbx-tools/cli-args";
-import * as exec from "@dbx-tools/core/exec";
-import { watch as pathWatch } from "@dbx-tools/path";
-import { asyncUtils, errorUtils, log } from "@dbx-tools/shared-core";
+import { spawn, type ChildProcessResult } from "@dbx-tools/core";
+import { watchFiles } from "@dbx-tools/path";
+import { log, sleep, toError } from "@dbx-tools/shared-core";
 import { CommanderError } from "commander";
 import { z } from "zod";
 import { parsedTaskOptions, runTaskMain, taskCommand, taskPositionals } from "./cli.ts";
@@ -232,7 +232,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   if (options.watchDisable) {
     logger.info(`watch disabled; running ${commandLabel}`);
     const [command, ...commandArgs] = options.command;
-    const { exitCode } = await exec.spawn(command!, commandArgs, {
+    const { exitCode } = await spawn(command!, commandArgs, {
       cwd,
       stdin: "inherit",
       stdout: "inherit",
@@ -250,13 +250,13 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
     options.watchInclude,
     options.watchExclude,
   );
-  let child: exec.ChildProcessResult | undefined;
+  let child: ChildProcessResult | undefined;
   let timer: ReturnType<typeof setTimeout> | undefined;
   let restartReason: string | undefined;
   let restarting = false;
   let stopping = false;
 
-  const watcher = await pathWatch.watchFiles([...watchPaths], {
+  const watcher = await watchFiles([...watchPaths], {
     cwd: root,
     ignore: watchIgnore.length > 0 ? [...watchIgnore] : undefined,
     ignoreInitial: true,
@@ -276,7 +276,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
       });
     } catch (err) {
       logger.error("failed to stop command process tree", {
-        error: errorUtils.toError(err),
+        error: toError(err),
       });
     }
   }
@@ -284,7 +284,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   function startChild(reason: string): void {
     logger.info(`${reason}; starting ${commandLabel}`);
     const [command, ...commandArgs] = options.command;
-    const current = exec.spawn(command!, commandArgs, {
+    const current = spawn(command!, commandArgs, {
       cwd,
       stdin: "ignore",
       stdout: "inherit",
@@ -304,7 +304,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
       .catch((err) => {
         if (child !== current || stopping) return;
         child = undefined;
-        logger.error("command failed", { error: errorUtils.toError(err) });
+        logger.error("command failed", { error: toError(err) });
       });
   }
 
@@ -337,7 +337,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
   }
 
   watcher.on("all", scheduleRestart);
-  watcher.on("error", (err) => logger.error("watcher error", { error: errorUtils.toError(err) }));
+  watcher.on("error", (err) => logger.error("watcher error", { error: toError(err) }));
   watcher.on("ready", () => {
     const count = watchPaths.length;
     const source = options.watchInclude.length > 0 ? "include glob" : "workspace directory";
@@ -380,7 +380,7 @@ export async function main(args: string[] = process.argv.slice(2)): Promise<void
     restoreStdin();
     await Promise.race([
       Promise.allSettled([watcher.close(), stopChild()]),
-      asyncUtils.sleep(SHUTDOWN_TIMEOUT_MS),
+      sleep(SHUTDOWN_TIMEOUT_MS),
     ]);
     process.exit(exitCode);
   }

package/tasks/local-publish.ts

@@ -1,9 +1,9 @@
 /** Build and publish the current workspace to configured loopback registries. */
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import type { ChildProcessResult } from "@dbx-tools/core/exec";
-import * as projectUtils from "@dbx-tools/core/project-utils";
-import { log, net } from "@dbx-tools/shared-core";
+import type { ChildProcessResult } from "@dbx-tools/core";
+import { npmRegistry } from "@dbx-tools/core";
+import { log, isLoopbackHost } from "@dbx-tools/shared-core";
 import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
 import { spawnTaskCommand } from "../src/_task-command.ts";
 
@@ -22,8 +22,8 @@ export function resolveLocalRegistry(value: string): string | undefined {
   const trimmed = value.trim();
   if (!trimmed || trimmed.toLowerCase() === "false") return undefined;
   if (trimmed.toLowerCase() === "auto") {
-    const registry = projectUtils.npmRegistry();
-    return registry && net.isLoopbackHost(registry) ? registry.href : undefined;
+    const registry = npmRegistry();
+    return registry && isLoopbackHost(registry) ? registry.href : undefined;
   }
   return trimmed;
 }
@@ -69,7 +69,7 @@ export async function publishLocalRelease(
 
   if (
     options.localPypi.toLowerCase() === "auto" &&
-    activeIndexes.some((index) => net.isLoopbackHost(index)) &&
+    activeIndexes.some((index) => isLoopbackHost(index)) &&
     !localPypi
   ) {
     logger.info(