@runa-ai/runa-cli 0.5.71 → 0.6.0

package/dist/cli/index.d.ts

@@ -5,12 +5,18 @@
  * Separated from main entry point for better organization
  */
 import { Command } from 'commander';
+type RequestedCommandName = string | null;
+export interface ProgramBuildOptions {
+    requestedCommandName?: RequestedCommandName;
+    loadAllCommands?: boolean;
+}
 /**
  * Create and configure CLI program
  */
-export declare function createProgram(): Promise<Command>;
+export declare function createProgram(options?: ProgramBuildOptions): Promise<Command>;
 /**
  * Execute CLI program
  */
 export declare function executeProgram(program: Command): Promise<void>;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/requested-command.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Detect requested top-level command from raw argv.
+ *
+ * Handles global flags that consume values (e.g. `--format json`) so
+ * command detection stays accurate for lazy command registration.
+ */
+export declare function getRequestedCommandNameFromArgv(argv: string[]): string | null;
+//# sourceMappingURL=requested-command.d.ts.map

package/dist/cli-GFRZCJQR.js

@@ -0,0 +1,661 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { enableNonInteractiveMode } from './chunk-6Y3LAUGL.js';
+import { getRequestedCommandNameFromArgv } from './chunk-UWWSAPDR.js';
+import { CLI_VERSION, HAS_ADMIN_COMMAND } from './chunk-GOGRLQNP.js';
+import { emitDefaultSuccessIfNeeded } from './chunk-RRGQCUKT.js';
+import './chunk-JT5SUTWE.js';
+import { parseOutputFormat, setOutputFormat, getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError } from '@runa-ai/runa/cli-runtime';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/cli/index.ts
+init_esm_shims();
+
+// src/cli/contract-mode.ts
+init_esm_shims();
+function formatConsoleArgs(args) {
+  return args.map((a) => {
+    if (typeof a === "string") return a;
+    try {
+      return JSON.stringify(a);
+    } catch {
+      return String(a);
+    }
+  }).join(" ");
+}
+var isPatched = false;
+function enableContractModeIO() {
+  const format = getOutputFormatFromEnv();
+  if (format !== "json") return;
+  if (isPatched) return;
+  isPatched = true;
+  console.log = (...args) => {
+    process.stderr.write(`${formatConsoleArgs(args)}
+`);
+  };
+  console.info = (...args) => {
+    process.stderr.write(`${formatConsoleArgs(args)}
+`);
+  };
+  console.warn = (...args) => {
+    process.stderr.write(`${formatConsoleArgs(args)}
+`);
+  };
+  console.error = (...args) => {
+    process.stderr.write(`${formatConsoleArgs(args)}
+`);
+  };
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk, encoding, cb) => {
+    if (process.env.RUNA_JSON_EMITTING === "true") {
+      return originalStdoutWrite(chunk, encoding, cb);
+    }
+    return originalStderrWrite(chunk, encoding, cb);
+  });
+}
+
+// src/cli/early-flags.ts
+init_esm_shims();
+function parseEarlyFlags(argv) {
+  let format = getOutputFormatFromEnv();
+  let forceNonInteractive = false;
+  if (argv.includes("--json")) {
+    format = "json";
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--non-interactive") {
+      forceNonInteractive = true;
+      continue;
+    }
+    if (token === "--format") {
+      const value = argv[i + 1];
+      if (!value) {
+        throw new CLIError(
+          "Missing value for --format. Allowed: text, json",
+          "INVALID_OUTPUT_FORMAT",
+          ["Use: --format text", "Use: --format json"],
+          void 0,
+          2
+        );
+      }
+      format = parseOutputFormat(value);
+      i++;
+      continue;
+    }
+    if (token.startsWith("--format=")) {
+      const value = token.slice("--format=".length);
+      format = parseOutputFormat(value);
+    }
+  }
+  if (argv.includes("--json")) {
+    format = "json";
+  }
+  return { format, forceNonInteractive };
+}
+function applyEarlyGlobalFlags(argv) {
+  try {
+    const { format, forceNonInteractive } = parseEarlyFlags(argv);
+    setOutputFormat(format);
+    if (process.env.CI === "true" || forceNonInteractive) {
+      enableNonInteractiveMode();
+    }
+    enableContractModeIO();
+  } catch (error) {
+    if (error instanceof CLIError && error.code === "INVALID_OUTPUT_FORMAT") {
+      setOutputFormat("json");
+      enableContractModeIO();
+    }
+    throw error;
+  }
+}
+
+// src/cli/index.ts
+function normalizeRequestedCommandName(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function isRequestedCommand(requested, commands) {
+  if (!requested) return false;
+  return commands.includes(requested);
+}
+function isSessionCommand(requested) {
+  return requested?.startsWith("session:") ?? false;
+}
+function isTestCommand(requested) {
+  if (!requested) return false;
+  if (requested === "test" || requested === "manifest" || requested === "inject-test-attrs") {
+    return true;
+  }
+  return requested.startsWith("test:") || requested.startsWith("db:test:");
+}
+async function registerProjectLifecycleCommands(program, requested, loadAllCommands) {
+  if (!loadAllCommands && requested) {
+    if (requested === "init") {
+      const { initCommand: initCommand2 } = await import('./init-ELK5QCWR.js');
+      program.addCommand(initCommand2);
+      return;
+    }
+    if (requested === "prepare") {
+      const { prepareCommand: prepareCommand2 } = await import('./prepare-32DOVHTE.js');
+      program.addCommand(prepareCommand2);
+      return;
+    }
+    if (requested === "upgrade") {
+      const { upgradeCommand: upgradeCommand2 } = await import('./upgrade-3SLWVNAC.js');
+      program.addCommand(upgradeCommand2);
+      return;
+    }
+    if (requested === "validate") {
+      const { validateCommand: validateCommand2 } = await import('./validate-SM4PXPS7.js');
+      program.addCommand(validateCommand2);
+      return;
+    }
+    if (requested === "build") {
+      const { buildCommand: buildCommand2 } = await import('./build-BXUJKYHC.js');
+      program.addCommand(buildCommand2);
+      return;
+    }
+    if (requested === "dev") {
+      const { devCommand: devCommand2 } = await import('./dev-A7RW6XQV.js');
+      program.addCommand(devCommand2);
+      return;
+    }
+  }
+  const [
+    { initCommand },
+    { prepareCommand },
+    { upgradeCommand },
+    { validateCommand },
+    { buildCommand },
+    { devCommand }
+  ] = await Promise.all([
+    import('./init-ELK5QCWR.js'),
+    import('./prepare-32DOVHTE.js'),
+    import('./upgrade-3SLWVNAC.js'),
+    import('./validate-SM4PXPS7.js'),
+    import('./build-BXUJKYHC.js'),
+    import('./dev-A7RW6XQV.js')
+  ]);
+  program.addCommand(initCommand);
+  program.addCommand(prepareCommand);
+  program.addCommand(upgradeCommand);
+  program.addCommand(validateCommand);
+  program.addCommand(buildCommand);
+  program.addCommand(devCommand);
+}
+var TEST_GENERATION_COMMANDS = /* @__PURE__ */ new Set([
+  "db:test:update-golden",
+  "test:api:gen",
+  "test:component:gen",
+  "test:e2e:generate",
+  "test:e2e:scaffold",
+  "test:security:generate",
+  "test:unit:generate"
+]);
+async function registerTestCommands(program, requested, loadAllCommands) {
+  if (!loadAllCommands && requested) {
+    if (requested === "manifest") {
+      const { manifestCommand: manifestCommand2 } = await import('./manifest-2NOQ2IMK.js');
+      program.addCommand(manifestCommand2);
+      return;
+    }
+    if (requested === "inject-test-attrs") {
+      const { injectTestAttrsCommand: injectTestAttrsCommand2 } = await import('./inject-test-attrs-Y5UD5P7Q.js');
+      program.addCommand(injectTestAttrsCommand2);
+      return;
+    }
+    if (TEST_GENERATION_COMMANDS.has(requested)) {
+      const testGenModule2 = await import('./test-gen-QPWOIEHU.js');
+      const {
+        dbTestUpdateGoldenCommand: dbTestUpdateGoldenCommand2,
+        testApiGenerateCommand: testApiGenerateCommand2,
+        testComponentGenerateCommand: testComponentGenerateCommand2,
+        testE2EGenerateCommand: testE2EGenerateCommand2,
+        testE2EScaffoldCommand: testE2EScaffoldCommand2,
+        testSecurityGenerateCommand: testSecurityGenerateCommand2,
+        testUnitGenerateCommand: testUnitGenerateCommand2
+      } = testGenModule2;
+      if (requested === "db:test:update-golden") {
+        program.addCommand(dbTestUpdateGoldenCommand2);
+      }
+      if (requested === "test:api:gen") {
+        program.addCommand(testApiGenerateCommand2);
+      }
+      if (requested === "test:component:gen") {
+        program.addCommand(testComponentGenerateCommand2);
+      }
+      if (requested === "test:e2e:generate") {
+        program.addCommand(testE2EGenerateCommand2);
+      }
+      if (requested === "test:e2e:scaffold") {
+        program.addCommand(testE2EScaffoldCommand2);
+      }
+      if (requested === "test:security:generate") {
+        program.addCommand(testSecurityGenerateCommand2);
+      }
+      if (requested === "test:unit:generate") {
+        program.addCommand(testUnitGenerateCommand2);
+      }
+      return;
+    }
+    if (requested === "test" || requested.startsWith("test:")) {
+      const testModule2 = await import('./test-QYXE5UVW.js');
+      const {
+        testApiCommand: testApiCommand2,
+        testBrowserCommand: testBrowserCommand2,
+        // Legacy commands (backward compat)
+        testCommand: testCommand2,
+        testDbCommand: testDbCommand2,
+        testE2ECommand: testE2ECommand2,
+        // New naming scheme (2025-01)
+        testFastCommand: testFastCommand2,
+        testIntegrationCommand: testIntegrationCommand2,
+        // Canonical layer commands
+        testLayer0Command: testLayer0Command2,
+        testLayer1Command: testLayer1Command2,
+        testLayer2Command: testLayer2Command2,
+        testLayer3Command: testLayer3Command2,
+        testLayer4Command: testLayer4Command2,
+        // Note: Layer 5 Flow E2E was merged into Layer 1 XState Unit Tests
+        testLintCommand: testLintCommand2,
+        testLogicCommand: testLogicCommand2,
+        testOWASPGenerateCommand: testOWASPGenerateCommand2,
+        testSchemaCommand: testSchemaCommand2,
+        testServiceCommand: testServiceCommand2,
+        testStaticCommand: testStaticCommand2
+      } = testModule2;
+      const candidates = [
+        testCommand2,
+        testDbCommand2,
+        testE2ECommand2,
+        testFastCommand2,
+        testLintCommand2,
+        testLogicCommand2,
+        testSchemaCommand2,
+        testApiCommand2,
+        testBrowserCommand2,
+        testLayer0Command2,
+        testLayer1Command2,
+        testLayer2Command2,
+        testLayer3Command2,
+        testLayer4Command2,
+        testStaticCommand2,
+        testServiceCommand2,
+        testIntegrationCommand2,
+        testOWASPGenerateCommand2
+      ];
+      const requestedCommand = candidates.find((cmd) => cmd.name() === requested);
+      if (requestedCommand) {
+        program.addCommand(requestedCommand);
+      } else {
+        for (const cmd of candidates) {
+          program.addCommand(cmd);
+        }
+      }
+      return;
+    }
+  }
+  const [testModule, testGenModule, { injectTestAttrsCommand }, { manifestCommand }] = await Promise.all([
+    import('./test-QYXE5UVW.js'),
+    import('./test-gen-QPWOIEHU.js'),
+    import('./inject-test-attrs-Y5UD5P7Q.js'),
+    import('./manifest-2NOQ2IMK.js')
+  ]);
+  const {
+    testApiCommand,
+    testBrowserCommand,
+    // Legacy commands (backward compat)
+    testCommand,
+    testDbCommand,
+    testE2ECommand,
+    // New naming scheme (2025-01)
+    testFastCommand,
+    testIntegrationCommand,
+    // Canonical layer commands
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    // Note: Layer 5 Flow E2E was merged into Layer 1 XState Unit Tests
+    testLintCommand,
+    testLogicCommand,
+    testOWASPGenerateCommand,
+    testSchemaCommand,
+    testServiceCommand,
+    testStaticCommand
+  } = testModule;
+  const {
+    dbTestUpdateGoldenCommand,
+    testApiGenerateCommand,
+    testComponentGenerateCommand,
+    testE2EGenerateCommand,
+    testE2EScaffoldCommand,
+    testSecurityGenerateCommand,
+    testUnitGenerateCommand
+  } = testGenModule;
+  program.addCommand(testFastCommand);
+  program.addCommand(testDbCommand);
+  program.addCommand(testE2ECommand);
+  program.addCommand(testLintCommand);
+  program.addCommand(testLogicCommand);
+  program.addCommand(testSchemaCommand);
+  program.addCommand(testApiCommand);
+  program.addCommand(testBrowserCommand);
+  program.addCommand(testLayer0Command);
+  program.addCommand(testLayer1Command);
+  program.addCommand(testLayer2Command);
+  program.addCommand(testLayer3Command);
+  program.addCommand(testLayer4Command);
+  program.addCommand(testStaticCommand);
+  program.addCommand(testServiceCommand);
+  program.addCommand(testIntegrationCommand);
+  program.addCommand(testUnitGenerateCommand);
+  program.addCommand(testE2EGenerateCommand);
+  program.addCommand(testSecurityGenerateCommand);
+  program.addCommand(testOWASPGenerateCommand);
+  program.addCommand(testApiGenerateCommand);
+  program.addCommand(testComponentGenerateCommand);
+  program.addCommand(dbTestUpdateGoldenCommand);
+  program.addCommand(testCommand);
+  program.addCommand(testE2EScaffoldCommand);
+  program.addCommand(injectTestAttrsCommand);
+  program.addCommand(manifestCommand);
+}
+async function registerStatusCheckAndUtilityCommands(program, requested, loadAllCommands) {
+  if (!loadAllCommands && requested) {
+    if (requested === "status") {
+      const { statusCommand: statusCommand2 } = await import('./status-IJ4ZWHMX.js');
+      program.addCommand(statusCommand2);
+      return;
+    }
+    if (requested === "check") {
+      const { checkCommand: checkCommand2 } = await import('./check-6AB5NGWK.js');
+      program.addCommand(checkCommand2.name("check"));
+      return;
+    }
+    if (requested === "cache") {
+      const { cacheCommand: cacheCommand2 } = await import('./cache-H63JKFYH.js');
+      program.addCommand(cacheCommand2);
+      return;
+    }
+    if (requested === "telemetry") {
+      const { telemetryCommand: telemetryCommand2 } = await import('./telemetry-FN7V727Y.js');
+      program.addCommand(telemetryCommand2);
+      return;
+    }
+    if (requested === "link" || requested === "unlink") {
+      const { linkCommand: linkCommand2, unlinkCommand: unlinkCommand2 } = await import('./link-C43JRZWY.js');
+      program.addCommand(linkCommand2);
+      program.addCommand(unlinkCommand2);
+      return;
+    }
+  }
+  const [
+    { statusCommand },
+    { checkCommand },
+    { cacheCommand },
+    { telemetryCommand },
+    { linkCommand, unlinkCommand }
+  ] = await Promise.all([
+    import('./status-IJ4ZWHMX.js'),
+    import('./check-6AB5NGWK.js'),
+    import('./cache-H63JKFYH.js'),
+    import('./telemetry-FN7V727Y.js'),
+    import('./link-C43JRZWY.js')
+  ]);
+  program.addCommand(statusCommand);
+  program.addCommand(checkCommand.name("check"));
+  program.addCommand(cacheCommand);
+  program.addCommand(telemetryCommand);
+  program.addCommand(linkCommand);
+  program.addCommand(unlinkCommand);
+}
+async function registerCiCommand(program) {
+  const { ciCommand } = await import('./ci-V3PIG2GI.js');
+  program.addCommand(ciCommand);
+}
+async function registerDbCommand(program) {
+  const { dbCommand } = await import('./db-HR7CREX2.js');
+  program.addCommand(dbCommand);
+}
+async function registerServicesCommand(program) {
+  const { servicesCommand } = await import('./services-7VK5KZTO.js');
+  program.addCommand(servicesCommand);
+}
+async function registerEnvCommand(program) {
+  const { envCommand } = await import('./env-B47Z4747.js');
+  program.addCommand(envCommand);
+}
+async function registerHotfixCommand(program) {
+  const { hotfixCommand } = await import('./hotfix-CULKKMGS.js');
+  program.addCommand(hotfixCommand);
+}
+async function registerSdkCommand(program) {
+  const { sdkCommand } = await import('./sdk-XK6HQU7S.js');
+  program.addCommand(sdkCommand);
+}
+async function registerUiCommand(program) {
+  const { uiCommand } = await import('./ui-RJAMCWUI.js');
+  program.addCommand(uiCommand);
+}
+async function registerWatchCommand(program) {
+  const { watchCommand } = await import('./watch-UCDVOQAH.js');
+  program.addCommand(watchCommand);
+}
+async function registerWorkflowCommand(program) {
+  const { workflowCommand } = await import('./workflow-ZB5Q2PFY.js');
+  program.addCommand(workflowCommand);
+}
+async function registerVulnCheckCommand(program) {
+  const { vulnCheckCommand } = await import('./vuln-check-TYQNEFS7.js');
+  program.addCommand(vulnCheckCommand);
+}
+async function registerTemplateCheckCommand(program) {
+  const { templateCheckCommand } = await import('./template-check-PNG5NQ5H.js');
+  program.addCommand(templateCheckCommand);
+}
+async function registerSessionCommands(program) {
+  const { sessionCommands } = await import('./session-SFW5QSXZ.js');
+  for (const cmd of sessionCommands) {
+    program.addCommand(cmd);
+  }
+}
+var COMMAND_GROUPS = [
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["init", "prepare", "upgrade", "validate", "build", "dev"]),
+    register: registerProjectLifecycleCommands
+  },
+  {
+    shouldRegister: isTestCommand,
+    register: registerTestCommands
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["status", "check", "cache", "telemetry", "link", "unlink"]),
+    register: registerStatusCheckAndUtilityCommands
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["ci"]),
+    register: registerCiCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["db"]),
+    register: registerDbCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["services"]),
+    register: registerServicesCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["env"]),
+    register: registerEnvCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["hotfix"]),
+    register: registerHotfixCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["sdk"]),
+    register: registerSdkCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["ui"]),
+    register: registerUiCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["watch"]),
+    register: registerWatchCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["workflow"]),
+    register: registerWorkflowCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["vuln-check"]),
+    register: registerVulnCheckCommand
+  },
+  {
+    shouldRegister: (requested) => isRequestedCommand(requested, ["template-check"]),
+    register: registerTemplateCheckCommand
+  },
+  {
+    shouldRegister: isSessionCommand,
+    register: registerSessionCommands
+  }
+];
+async function registerSelectedCommands(program, options) {
+  const requested = normalizeRequestedCommandName(options.requestedCommandName);
+  const shouldLoadAll = options.loadAllCommands === true || requested === null;
+  for (const group of COMMAND_GROUPS) {
+    if (shouldLoadAll || group.shouldRegister(requested)) {
+      await group.register(program, requested, shouldLoadAll);
+    }
+  }
+}
+var RUNTIME_BOOTSTRAP_OPTIONAL_COMMANDS = /* @__PURE__ */ new Set([
+  "cache",
+  "check",
+  "inject-test-attrs",
+  "link",
+  "manifest",
+  "status",
+  "telemetry",
+  "unlink"
+]);
+function shouldRunRuntimeBootstrap(argv) {
+  const requested = getRequestedCommandNameFromArgv(argv);
+  if (!requested) return true;
+  if (RUNTIME_BOOTSTRAP_OPTIONAL_COMMANDS.has(requested)) {
+    return false;
+  }
+  if (requested.startsWith("session:")) {
+    return false;
+  }
+  return true;
+}
+function resolveGlobalOptions(thisCommand) {
+  let formatRaw;
+  let hasJsonFlag = false;
+  let hasNonInteractiveFlag = false;
+  let cur = thisCommand;
+  while (cur) {
+    const opts = cur.opts?.();
+    const value = opts?.format;
+    if (value !== void 0) {
+      formatRaw = value;
+      break;
+    }
+    if (opts?.json === true) hasJsonFlag = true;
+    if (opts?.nonInteractive === true) hasNonInteractiveFlag = true;
+    cur = cur.parent ?? null;
+  }
+  return { formatRaw, hasJsonFlag, hasNonInteractiveFlag };
+}
+async function tryLoadAdminCommand() {
+  if (!HAS_ADMIN_COMMAND) {
+    return null;
+  }
+  try {
+    const adminUrl = new URL("./admin.js", import.meta.url);
+    const mod = await import(adminUrl.href);
+    return mod.adminCommand;
+  } catch {
+    return null;
+  }
+}
+async function createProgram(options = {}) {
+  const program = new Command();
+  program.name("runa").description("runa CLI - DevOps complement features for pj-repos").version(CLI_VERSION, "-v, --version", "Output the version number");
+  program.exitOverride((err) => {
+    const code = err.code;
+    const exitCode = err.exitCode;
+    if (code === "commander.help" || (code === "commander.helpDisplayed" || code === "commander.version") && (exitCode ?? 0) === 0) {
+      process.exit(0);
+    }
+    throw new CLIError(
+      err.message,
+      code ?? "COMMANDER_ERROR",
+      ["Run with --help for usage", "If this is unexpected, run: runa check"],
+      err,
+      exitCode ?? 1
+    );
+  });
+  program.option("--format <format>", "Output format: text | json", "text");
+  program.option("--json", "Alias of --format json");
+  program.option("--non-interactive", "Force non-interactive mode (CI-safe)");
+  program.hook("preAction", (thisCommand) => {
+    if (process.env.RUNA_OUTPUT_FORMAT === "json" || process.env.RUNA_OUTPUT_FORMAT === "text") {
+      if (process.env.CI === "true") {
+        enableNonInteractiveMode();
+      }
+      enableContractModeIO();
+      return;
+    }
+    const { formatRaw, hasJsonFlag, hasNonInteractiveFlag } = resolveGlobalOptions(thisCommand);
+    const format = hasJsonFlag ? "json" : parseOutputFormat(formatRaw ?? "text");
+    setOutputFormat(format);
+    if (process.env.CI === "true" || hasNonInteractiveFlag) {
+      enableNonInteractiveMode();
+    }
+    enableContractModeIO();
+  });
+  program.hook("postAction", (thisCommand) => {
+    emitDefaultSuccessIfNeeded(thisCommand);
+  });
+  await registerSelectedCommands(program, options);
+  const requested = normalizeRequestedCommandName(options.requestedCommandName);
+  const shouldRegisterAdmin = options.loadAllCommands === true || requested === null || requested === "admin";
+  if (shouldRegisterAdmin) {
+    const adminCommand = await tryLoadAdminCommand();
+    if (adminCommand) {
+      program.addCommand(adminCommand);
+    }
+  }
+  return program;
+}
+async function executeProgram(program) {
+  const argv = process.argv.slice(2);
+  applyEarlyGlobalFlags(argv);
+  const isHelpOrVersion = argv.includes("--help") || argv.includes("-h") || argv.includes("--version") || argv.includes("-V");
+  if (!isHelpOrVersion && shouldRunRuntimeBootstrap(argv)) {
+    const [{ loadEnvFiles }, { enforceLicenseInCI }] = await Promise.all([
+      import('./env-files-K2C7O7L5.js'),
+      import('./license-OB7GVJQ2.js')
+    ]);
+    loadEnvFiles({
+      silent: true
+    });
+    await enforceLicenseInCI();
+    await import('./env-HMMRSYCI.js');
+  }
+  await program.parseAsync(process.argv);
+}
+
+export { createProgram, executeProgram };

package/dist/commands/build/actors/db-sync.d.ts

@@ -13,6 +13,8 @@ export interface DbSyncInput {
     repoRoot: string;
     tmpDir: string;
     env?: NodeJS.ProcessEnv;
+    /** Pre-computed by setup phase. When false, skip sync without re-checking. */
+    supabaseRunning?: boolean;
 }
 export interface DbSyncOutput {
     passed: boolean;