@runa-ai/runa-cli 0.7.3 → 0.9.0

package/dist/{build-HQMSVN6N.js → build-P2A6345N.js}

@@ -2,9 +2,9 @@
 import { createRequire } from 'module';
 import './chunk-QDF7QXBL.js';
 import { getSnapshotStateName, isSnapshotComplete } from './chunk-XVNDDHAF.js';
-import { guards, manifestActor, supabaseStartActor, envCheckActor, depsInstallActor, detectTurbo, detectManifestTask, detectDatabase, checkSupabaseStatus } from './chunk-VSH3IXDQ.js';
+import { guards, manifestActor, supabaseStartActor, envCheckActor, depsInstallActor, detectTurbo, detectManifestTask, detectDatabase, checkSupabaseStatus } from './chunk-MAFJAA2P.js';
 import { findRepoRoot } from './chunk-3WDV32GA.js';
-import { runLogged } from './chunk-6FAU4IGR.js';
+import { runLogged } from './chunk-ELXXQIGW.js';
 import { createMachineStateChangeLogger } from './chunk-5FT3F36G.js';
 import './chunk-II7VYQEM.js';
 import './chunk-QSEF4T3Y.js';

package/dist/{check-PCSQPYDM.js → check-4TZHNOZU.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-export { checkCommand, runCheckCommand } from './chunk-2QX7T24B.js';
-import './chunk-WPMR7RQ4.js';
-import './chunk-DRSUEMAK.js';
+export { checkCommand, runCheckCommand } from './chunk-QKGL6Q2S.js';
+import './chunk-IWVXI5O4.js';
+import './chunk-B7C7CLW2.js';
 import './chunk-KE6QJBZG.js';
 import './chunk-WJXC4MVY.js';
 import './chunk-HKUWEGUX.js';
-import './chunk-JMJP4A47.js';
+import './chunk-GT5DMS5R.js';
 import './chunk-VRXHCR5K.js';
 
 createRequire(import.meta.url);

package/dist/{chunk-DRSUEMAK.js → chunk-B7C7CLW2.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
-import { existsSync, realpathSync } from 'fs';
+import { realpathSync } from 'fs';
 import { resolve, sep, isAbsolute, relative, normalize } from 'path';
 
 createRequire(import.meta.url);
@@ -10,10 +10,7 @@ createRequire(import.meta.url);
 init_esm_shims();
 function safeRealpath(targetPath) {
   try {
-    if (existsSync(targetPath)) {
-      return realpathSync(targetPath);
-    }
-    return targetPath;
+    return realpathSync(targetPath);
   } catch {
     return targetPath;
   }

package/dist/{chunk-B3POLMII.js → chunk-BQ336L5T.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { isPathContained } from './chunk-DRSUEMAK.js';
+import { isPathContained } from './chunk-B7C7CLW2.js';
 import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import { init_esm_shims, __dirname as __dirname$1 } from './chunk-VRXHCR5K.js';
 import * as fs2 from 'fs';

package/dist/{chunk-6FAU4IGR.js → chunk-ELXXQIGW.js}

@@ -44,7 +44,10 @@ async function ensureRunaTmpDir(cwd) {
   return dir;
 }
 function runLogged(params) {
-  console.log(`\u25B6 ${params.label}: ${params.command} ${redactArgsForLog(params.args).join(" ")}`);
+  process.stderr.write(
+    `\u25B6 ${params.label}: ${params.command} ${redactArgsForLog(params.args).join(" ")}
+`
+  );
   const proc = execa(params.command, params.args, {
     cwd: params.cwd,
     env: { DOTENVX_QUIET: "1", ...params.env },

package/dist/{chunk-FWMGC5FP.js → chunk-EXR4J2JT.js}

@@ -1,14 +1,294 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { init_esm_shims, __require } from './chunk-VRXHCR5K.js';
-import { existsSync, createWriteStream } from 'fs';
-import path from 'path';
-import { loadRunaConfig, CLIError } from '@runa-ai/runa';
-import { writeFile, readFile } from 'fs/promises';
+import { detectEnvironment } from './chunk-GT5DMS5R.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { appendFile, writeFile, readFile } from 'fs/promises';
+import { CLIError, formatDuration, loadRunaConfig } from '@runa-ai/runa';
 import { z } from 'zod';
+import { existsSync, createWriteStream, readFileSync, readdirSync } from 'fs';
+import path from 'path';
 
 createRequire(import.meta.url);
 
+// src/commands/ci/utils/github.ts
+init_esm_shims();
+async function appendGithubStepSummary(markdown) {
+  const file = process.env.GITHUB_STEP_SUMMARY;
+  if (!file) return;
+  await appendFile(file, `${markdown.trimEnd()}
+
+`, "utf-8");
+}
+function addGithubMask(value) {
+  if (!value) return;
+  console.log(`::add-mask::${value}`);
+}
+z.object({
+  action: z.string().optional(),
+  pull_request: z.object({
+    number: z.number().int()
+  })
+}).passthrough();
+
+// src/commands/ci/commands/ci-prod-utils.ts
+init_esm_shims();
+function requireEnv(name) {
+  const v = process.env[name];
+  if (v && v.trim().length > 0) return v.trim();
+  throw new CLIError(
+    `Missing required environment variable: ${name}`,
+    "CI_INPUT_MISSING",
+    [`Set ${name} in GitHub Actions secrets/env`, "If unsure, run: runa check"],
+    void 0,
+    10
+  );
+}
+function resolveRepoKind() {
+  const env = detectEnvironment(process.cwd());
+  const result = env === "runa-repo" ? "monorepo" : env === "pj-repo" ? "pj-repo" : "unknown";
+  if (process.env.RUNA_DEBUG === "true") {
+    console.error("[DEBUG:resolveRepoKind]", {
+      cwd: process.cwd(),
+      detectedEnv: env,
+      result
+    });
+  }
+  return result;
+}
+function createInitialSummary(params) {
+  return {
+    version: "1.0",
+    mode: params.mode,
+    command: "ci prod-apply",
+    status: "failure",
+    startedAt: params.startedAt.toISOString(),
+    endedAt: params.startedAt.toISOString(),
+    durationMs: 0,
+    repoKind: resolveRepoKind(),
+    detected: {},
+    diagnostics: {},
+    steps: {},
+    layers: {},
+    errors: []
+  };
+}
+function requireCiAutoApprove(params) {
+  if (params.mode !== "github-actions") return;
+  if (params.autoApprove === true) return;
+  throw new CLIError(
+    "Missing required flag: --auto-approve (required in CI mode)",
+    "CI_AUTO_APPROVE_REQUIRED",
+    ["Re-run with: runa ci prod-apply --auto-approve", "Keep CI non-interactive and deterministic"],
+    void 0,
+    10
+  );
+}
+function resolveProdApplyInputs() {
+  const productionDatabaseUrlAdmin = requireEnv("GH_DATABASE_URL_ADMIN");
+  const productionDatabaseUrl = requireEnv("GH_DATABASE_URL");
+  addGithubMask(productionDatabaseUrlAdmin);
+  addGithubMask(productionDatabaseUrl);
+  return {
+    productionDatabaseUrlAdmin,
+    productionDatabaseUrl,
+    githubSha: process.env.GITHUB_SHA ?? "unknown",
+    githubActor: process.env.GITHUB_ACTOR ?? "unknown",
+    githubRepository: process.env.GITHUB_REPOSITORY ?? "unknown"
+  };
+}
+function classifyCiProdApplyError(error) {
+  if (error instanceof CLIError) {
+    return {
+      code: error.code ?? "CI_ERROR",
+      message: error.message,
+      retryable: false
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.startsWith("artifact_retry_requires_replan:")) {
+    return {
+      code: "artifact_retry_requires_replan",
+      message,
+      retryable: false
+    };
+  }
+  if (/timed out|timeout/i.test(message)) {
+    return {
+      code: "PHASE_TIMEOUT",
+      message,
+      retryable: true
+    };
+  }
+  return {
+    code: "CI_ERROR",
+    message,
+    retryable: false
+  };
+}
+function setSummaryErrorFromUnknown(summary, error) {
+  const classified = classifyCiProdApplyError(error);
+  summary.errors.push({
+    code: classified.code,
+    message: classified.message,
+    step: "ci prod-apply",
+    details: error instanceof CLIError && error.cause instanceof Error ? error.cause.message : void 0
+  });
+}
+function buildCiProdApplyStepSummaryMarkdown(params) {
+  const { summary } = params;
+  const lines = [];
+  const statusEmoji = summary.status === "success" ? "\u2705" : "\u274C";
+  const duration = formatDuration(summary.durationMs);
+  lines.push(
+    `## ${statusEmoji} Production Deploy ${summary.status === "success" ? "Completed" : "Failed"}`
+  );
+  lines.push("");
+  lines.push(`**Duration**: ${duration}`);
+  lines.push("");
+  if (summary.dbOutcome) {
+    lines.push(`**Exit mode**: \`${summary.dbOutcome.exitMode}\``);
+    const failedPhase = summary.dbOutcome.phases.find(
+      (phase) => phase.status === "failed" || phase.status === "timeout"
+    );
+    if (failedPhase) {
+      lines.push(`**Failed phase**: \`${failedPhase.id}\``);
+    }
+    if (summary.dbOutcome.summary.warnings > 0) {
+      lines.push(`**Warnings**: ${summary.dbOutcome.summary.warnings}`);
+    }
+    lines.push("");
+  }
+  const planSource = typeof summary.detected.dbPlanSource === "string" ? summary.detected.dbPlanSource : null;
+  const planReuseReason = typeof summary.detected.dbPlanReuseReason === "string" ? summary.detected.dbPlanReuseReason : null;
+  const planReuseMessage = typeof summary.detected.dbPlanReuseMessage === "string" ? summary.detected.dbPlanReuseMessage : null;
+  const planHasChanges = typeof summary.detected.dbPlanHasChanges === "boolean" ? summary.detected.dbPlanHasChanges : void 0;
+  if (planSource) {
+    lines.push(`**Plan source**: \`${planSource}\``);
+    if (planReuseReason) {
+      lines.push(
+        `**Plan reuse fallback**: \`${planReuseReason}\`${planReuseMessage ? ` \u2014 ${planReuseMessage}` : ""}`
+      );
+    }
+    if (planHasChanges === false) {
+      lines.push("**Plan result**: `no_changes`");
+    }
+    lines.push("");
+  }
+  if (summary.errors.length > 0) {
+    lines.push("### \u274C Errors");
+    lines.push("");
+    for (const e of summary.errors) {
+      lines.push(`- **${e.code}**: ${e.message}`);
+    }
+    lines.push("");
+  }
+  lines.push("<details>");
+  lines.push("<summary>\u{1F4CB} Technical Details</summary>");
+  lines.push("");
+  lines.push(`- Command: \`${summary.command}\``);
+  lines.push(`- Mode: \`${summary.mode}\``);
+  lines.push(`- Summary: \`${params.summaryPath}\``);
+  if (summary.dbOutcome) {
+    lines.push(`- DB exit mode: \`${summary.dbOutcome.exitMode}\``);
+  }
+  lines.push("");
+  lines.push("</details>");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/ci/commands/ci-resolvers.ts
+init_esm_shims();
+
+// src/commands/ci/utils/config-readers.ts
+init_esm_shims();
+function readNested(value, keyPath, guard) {
+  let current = value;
+  for (const key of keyPath) {
+    if (typeof current !== "object" || current === null) return null;
+    if (!(key in current)) return null;
+    current = current[key];
+  }
+  return guard(current) ? current : null;
+}
+var isBoolean = (v) => typeof v === "boolean";
+var isString = (v) => typeof v === "string";
+function readNestedBoolean(params) {
+  return readNested(params.value, params.keyPath, isBoolean);
+}
+function readNestedString(params) {
+  return readNested(params.value, params.keyPath, isString);
+}
+
+// src/commands/ci/commands/ci-resolvers.ts
+function resolveMode(modeRaw) {
+  if (modeRaw === "github-actions" || modeRaw === "local") return modeRaw;
+  return process.env.GITHUB_ACTIONS === "true" ? "github-actions" : "local";
+}
+function resolveCiPrProfile(params) {
+  const raw = readNestedString({ value: params.config, keyPath: ["ci", "pr", "profile"] });
+  if (raw === "runa-strict" || raw === "pj-stable") return raw;
+  if (params.repoKind === "pj-repo") return "pj-stable";
+  return "runa-strict";
+}
+function debugLogPolicy(label, policy) {
+  if (process.env.RUNA_DEBUG === "true") {
+    console.error(`[DEBUG:resolveCiPrPolicy] \u2192 ${label}:`, policy);
+  }
+}
+var DEFAULT_POLICIES = {
+  monorepo: {
+    allowLocalFallback: false,
+    source: "default"
+  },
+  "pj-repo": {
+    allowLocalFallback: true,
+    source: "default"
+  },
+  "pj-stable-profile": {
+    allowLocalFallback: true,
+    source: "config"
+  },
+  unknown: {
+    allowLocalFallback: false,
+    source: "default"
+  }
+};
+function resolveCiPrPolicy(params) {
+  const allowLocalFallback = readNestedBoolean({
+    value: params.config,
+    keyPath: ["ci", "pr", "allowLocalFallback"]
+  });
+  if (process.env.RUNA_DEBUG === "true") {
+    console.error("[DEBUG:resolveCiPrPolicy] Inputs:", {
+      repoKind: params.repoKind,
+      hasConfig: params.config !== null && params.config !== void 0,
+      configValues: { allowLocalFallback }
+    });
+  }
+  if (typeof allowLocalFallback === "boolean") {
+    const policy2 = {
+      allowLocalFallback,
+      source: "config"
+    };
+    debugLogPolicy("config override", policy2);
+    return policy2;
+  }
+  const profile = resolveCiPrProfile({ repoKind: params.repoKind, config: params.config });
+  if (profile === "pj-stable") {
+    const policy2 = DEFAULT_POLICIES["pj-stable-profile"];
+    debugLogPolicy("pj-stable profile", policy2);
+    return policy2;
+  }
+  const policy = DEFAULT_POLICIES[params.repoKind] ?? DEFAULT_POLICIES.unknown;
+  debugLogPolicy(`${params.repoKind} default`, policy);
+  return policy;
+}
+function parseIntOr(value, fallback) {
+  const n = Number.parseInt(String(value ?? ""), 10);
+  return Number.isNaN(n) ? fallback : n;
+}
+
 // src/commands/ci/machine/actors/setup/pr-common.ts
 init_esm_shims();
 function resolvePrContext(input) {
@@ -22,12 +302,8 @@ function resolvePrContext(input) {
     headBranch: input.githubHeadRef ?? null
   };
 }
-function resolvePolicy(_config, _repoKind) {
-  return {
-    allowLocalFallback: true,
-    allowPartialPhases: false,
-    source: "default"
-  };
+function resolvePolicy(config, repoKind) {
+  return resolveCiPrPolicy({ config, repoKind });
 }
 function detectRepoKind(repoRoot) {
   const hasApps = existsSync(path.join(repoRoot, "apps"));
@@ -70,7 +346,6 @@ function hasPackageJson(dir) {
 }
 function readAppsSubdirectoryNames(appsDir) {
   try {
-    const { readdirSync } = __require("fs");
     const entries = readdirSync(appsDir, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   } catch {
@@ -114,7 +389,6 @@ function readPortFromScripts(appDir) {
   const pkgPath = path.join(appDir, "package.json");
   if (!existsSync(pkgPath)) return 3e3;
   try {
-    const { readFileSync } = __require("fs");
     const raw = readFileSync(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     const scripts = parsed.scripts;
@@ -176,7 +450,6 @@ function createErrorOutput(repoRoot, error, extraFields) {
     prContext: { prNumber: null, action: null, sha: null, baseBranch: null, headBranch: null },
     policy: {
       allowLocalFallback: true,
-      allowPartialPhases: false,
       source: "default"
     },
     app: null,
@@ -201,7 +474,7 @@ async function executePrSetupBase(input, ensureTmpDir) {
     githubBaseRef: input.githubBaseRef,
     githubHeadRef: input.githubHeadRef
   });
-  const policy = resolvePolicy(input.config);
+  const policy = resolvePolicy(input.config, repoKind);
   const configResult = loadRunaConfig(repoRoot);
   const appConfigOverride = configResult?.config?.app?.directory ? {
     directory: configResult.config.app.directory
@@ -458,4 +731,4 @@ async function waitForAppReady(params) {
   });
 }
 
-export { createErrorOutput, detectApp, executePrSetupBase, startAppBackground, waitForAppReady, writeEnvLocal };
+export { addGithubMask, appendGithubStepSummary, buildCiProdApplyStepSummaryMarkdown, classifyCiProdApplyError, createErrorOutput, createInitialSummary, detectApp, executePrSetupBase, parseIntOr, requireCiAutoApprove, resolveMode, resolveProdApplyInputs, setSummaryErrorFromUnknown, startAppBackground, waitForAppReady, writeEnvLocal };

package/dist/{chunk-AO554K3G.js → chunk-GKBE7EIE.js}

@@ -6,7 +6,7 @@ createRequire(import.meta.url);
 
 // src/version.ts
 init_esm_shims();
-var CLI_VERSION = "0.7.3";
+var CLI_VERSION = "0.9.0";
 var HAS_ADMIN_COMMAND = false;
 
 export { CLI_VERSION, HAS_ADMIN_COMMAND };

package/dist/{chunk-JMJP4A47.js → chunk-GT5DMS5R.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'module';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { existsSync, readFileSync, realpathSync } from 'fs';
-import { join, isAbsolute, normalize, resolve, relative } from 'path';
+import { join, resolve, dirname, isAbsolute, normalize, relative } from 'path';
 import { findWorkspaceRoot as findWorkspaceRoot$1 } from '@runa-ai/runa';
 
 createRequire(import.meta.url);
@@ -200,5 +200,23 @@ function detectEnvironment(from = process.cwd()) {
   }
   return "unknown";
 }
+function findRunaConfig(from = process.cwd()) {
+  let current = resolve(from);
+  while (true) {
+    const configPath = join(current, "runa.config.ts");
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+    if (existsSync(join(current, ".git"))) {
+      return null;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
 
-export { detectEnvironment, findPackage, findWorkspaceRoot };
+export { detectEnvironment, findPackage, findRunaConfig, findWorkspaceRoot };

package/dist/{chunk-3JO6YP3T.js → chunk-IEKYTCYA.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { isPathContained } from './chunk-DRSUEMAK.js';
+import { isPathContained } from './chunk-B7C7CLW2.js';
 import { secureGh, securePnpm } from './chunk-RZLYEO4U.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import fs from 'fs';

package/dist/{chunk-WPMR7RQ4.js → chunk-IWVXI5O4.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { validateEnvSuffix, isPathContained, MAX_DIRECTORY_TRAVERSAL_DEPTH } from './chunk-DRSUEMAK.js';
-import { findWorkspaceRoot } from './chunk-JMJP4A47.js';
+import { validateEnvSuffix, isPathContained, MAX_DIRECTORY_TRAVERSAL_DEPTH } from './chunk-B7C7CLW2.js';
+import { findWorkspaceRoot } from './chunk-GT5DMS5R.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';

package/dist/chunk-KUH3G522.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from 'fs';
+import path from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/env-local-bridge.ts
+init_esm_shims();
+var DEFAULT_API_PORT = 54321;
+var DEFAULT_DB_PORT = 54322;
+var RUNA_ENV_LOCAL_MARKER = "# RUNA_AUTO_GENERATED \u2014 do not edit (created by `runa db start`)";
+function envLocalPath(projectRoot) {
+  return path.join(projectRoot, ".env.local");
+}
+function isNonDefaultPorts(config) {
+  return config.api !== DEFAULT_API_PORT || config.db !== DEFAULT_DB_PORT;
+}
+function buildEnvLocalContent(config) {
+  const dbUrl = `postgresql://postgres:postgres@${config.host}:${config.db}/postgres`;
+  return [
+    RUNA_ENV_LOCAL_MARKER,
+    `# Supabase is running on non-default ports (default: api=${DEFAULT_API_PORT}, db=${DEFAULT_DB_PORT}).`,
+    "# This file overrides .env.development so that `pnpm dev` uses correct ports.",
+    "# Removed automatically by `runa db stop`. Safe to delete manually.",
+    `DATABASE_URL=${dbUrl}`,
+    `DATABASE_URL_LISTENER=${dbUrl}`,
+    `DATABASE_URL_ADMIN=${dbUrl}`,
+    `DATABASE_URL_SERVICE=${dbUrl}`,
+    `NEXT_PUBLIC_SUPABASE_URL=http://${config.host}:${config.api}`,
+    ""
+  ].join("\n");
+}
+function isRunaManagedEnvLocal(projectRoot) {
+  const filePath = envLocalPath(projectRoot);
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return content.startsWith(RUNA_ENV_LOCAL_MARKER);
+  } catch {
+    return false;
+  }
+}
+function writeEnvLocalBridge(projectRoot, config) {
+  const filePath = envLocalPath(projectRoot);
+  const fileExists = existsSync(filePath);
+  if (isNonDefaultPorts(config)) {
+    if (fileExists && !isRunaManagedEnvLocal(projectRoot)) {
+      return { written: false, reason: "user-managed" };
+    }
+    writeFileSync(filePath, buildEnvLocalContent(config), "utf-8");
+    return { written: true, ports: { api: config.api, db: config.db } };
+  }
+  if (fileExists && isRunaManagedEnvLocal(projectRoot)) {
+    unlinkSync(filePath);
+    return { written: false, reason: "stale-removed" };
+  }
+  return { written: false, reason: "default-ports" };
+}
+function removeEnvLocalBridge(projectRoot) {
+  const filePath = envLocalPath(projectRoot);
+  if (!existsSync(filePath)) {
+    return { removed: false, reason: "not-found" };
+  }
+  if (!isRunaManagedEnvLocal(projectRoot)) {
+    return { removed: false, reason: "user-managed" };
+  }
+  unlinkSync(filePath);
+  return { removed: true };
+}
+
+export { removeEnvLocalBridge, writeEnvLocalBridge };

package/dist/{chunk-VSH3IXDQ.js → chunk-MAFJAA2P.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { runLogged } from './chunk-6FAU4IGR.js';
+import { runLogged } from './chunk-ELXXQIGW.js';
 import { init_constants, detectSupabasePorts } from './chunk-QSEF4T3Y.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { execSync, spawnSync } from 'child_process';

package/dist/{chunk-CCKG5R4Y.js → chunk-MILCC3B6.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { getDatabasePackagePath } from './chunk-5NKWR4FF.js';
+import { getDatabasePackagePath } from './chunk-OERS32LW.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { existsSync } from 'fs';
 import { join } from 'path';

package/dist/{chunk-5NKWR4FF.js → chunk-OERS32LW.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { findPackage, findWorkspaceRoot } from './chunk-JMJP4A47.js';
+import { findPackage, findWorkspaceRoot } from './chunk-GT5DMS5R.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { existsSync, readFileSync } from 'fs';
 import path, { join } from 'path';

package/dist/{chunk-2QX7T24B.js → chunk-QKGL6Q2S.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { loadEnvFiles } from './chunk-WPMR7RQ4.js';
+import { loadEnvFiles } from './chunk-IWVXI5O4.js';
 import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';