@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/cli-2JNBJUBB.js

@@ -0,0 +1,704 @@
+#!/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-AIP6MR42.js';
+import { emitDefaultSuccessIfNeeded } from './chunk-WJXC4MVY.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 pickCommands(commands) {
+  return commands.filter((command) => {
+    if (!(command instanceof Command)) {
+      return false;
+    }
+    return true;
+  });
+}
+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-ZIL6LRFO.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-NUK3ZBCL.js');
+      program.addCommand(upgradeCommand2);
+      return;
+    }
+    if (requested === "validate") {
+      const { validateCommand: validateCommand2 } = await import('./validate-CAAW4Y44.js');
+      program.addCommand(validateCommand2);
+      return;
+    }
+    if (requested === "build") {
+      const { buildCommand: buildCommand2 } = await import('./build-V66FAQXB.js');
+      program.addCommand(buildCommand2);
+      return;
+    }
+    if (requested === "dev") {
+      const { devCommand: devCommand2 } = await import('./dev-5YXNPTCJ.js');
+      program.addCommand(devCommand2);
+      return;
+    }
+  }
+  const [
+    { initCommand },
+    { prepareCommand },
+    { upgradeCommand },
+    { validateCommand },
+    { buildCommand },
+    { devCommand }
+  ] = await Promise.all([
+    import('./init-ZIL6LRFO.js'),
+    import('./prepare-32DOVHTE.js'),
+    import('./upgrade-NUK3ZBCL.js'),
+    import('./validate-CAAW4Y44.js'),
+    import('./build-V66FAQXB.js'),
+    import('./dev-5YXNPTCJ.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 addSingleTestCommand(program, requested) {
+  if (requested === "manifest") {
+    const { manifestCommand } = await import('./manifest-TMFLESHW.js');
+    program.addCommand(manifestCommand);
+    return true;
+  }
+  if (requested === "inject-test-attrs") {
+    const { injectTestAttrsCommand } = await import('./inject-test-attrs-P44BVTQS.js');
+    program.addCommand(injectTestAttrsCommand);
+    return true;
+  }
+  if (!TEST_GENERATION_COMMANDS.has(requested)) return false;
+  const testGenModule = await import('./test-gen-FS4CEY3P.js');
+  const commandMap = {
+    "db:test:update-golden": testGenModule.dbTestUpdateGoldenCommand,
+    "test:api:gen": testGenModule.testApiGenerateCommand,
+    "test:component:gen": testGenModule.testComponentGenerateCommand,
+    "test:e2e:generate": testGenModule.testE2EGenerateCommand,
+    "test:e2e:scaffold": testGenModule.testE2EScaffoldCommand,
+    "test:security:generate": testGenModule.testSecurityGenerateCommand,
+    "test:unit:generate": testGenModule.testUnitGenerateCommand
+  };
+  const command = commandMap[requested];
+  if (!command) return false;
+  program.addCommand(command);
+  return true;
+}
+async function registerFocusedTestCommand(program, requested) {
+  const testModule = await import('./test-V4KQL574.js');
+  const {
+    testCommand,
+    testDbCommand,
+    testE2ECommand,
+    testApiCommand,
+    testBrowserCommand,
+    testFastCommand,
+    testIntegrationCommand,
+    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 candidates = pickCommands([
+    testCommand,
+    testDbCommand,
+    testE2ECommand,
+    testFastCommand,
+    testLintCommand,
+    testLogicCommand,
+    testSchemaCommand,
+    testApiCommand,
+    testBrowserCommand,
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    testStaticCommand,
+    testServiceCommand,
+    testIntegrationCommand,
+    testOWASPGenerateCommand
+  ]);
+  const matched = candidates.find((command) => command.name() === requested);
+  if (matched) {
+    program.addCommand(matched);
+    return true;
+  }
+  if (!requested.startsWith("test:") && requested !== "test") {
+    return false;
+  }
+  for (const command of candidates) {
+    program.addCommand(command);
+  }
+  return true;
+}
+async function registerAllTestCommands(program) {
+  const [testModule, testGenModule, injectModule, manifestModule] = await Promise.all([
+    import('./test-V4KQL574.js'),
+    import('./test-gen-FS4CEY3P.js'),
+    import('./inject-test-attrs-P44BVTQS.js'),
+    import('./manifest-TMFLESHW.js')
+  ]);
+  const { injectTestAttrsCommand } = injectModule;
+  const { manifestCommand } = manifestModule;
+  const {
+    testCommand,
+    testApiCommand,
+    testBrowserCommand,
+    testDbCommand,
+    testE2ECommand,
+    testFastCommand,
+    testIntegrationCommand,
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    testLintCommand,
+    testLogicCommand,
+    testOWASPGenerateCommand,
+    testSchemaCommand,
+    testServiceCommand,
+    testStaticCommand
+  } = testModule;
+  const {
+    dbTestUpdateGoldenCommand,
+    testApiGenerateCommand,
+    testComponentGenerateCommand,
+    testE2EGenerateCommand,
+    testE2EScaffoldCommand,
+    testSecurityGenerateCommand,
+    testUnitGenerateCommand
+  } = testGenModule;
+  const allCommands = pickCommands([
+    testFastCommand,
+    testDbCommand,
+    testE2ECommand,
+    testLintCommand,
+    testLogicCommand,
+    testSchemaCommand,
+    testApiCommand,
+    testBrowserCommand,
+    testLayer0Command,
+    testLayer1Command,
+    testLayer2Command,
+    testLayer3Command,
+    testLayer4Command,
+    testStaticCommand,
+    testServiceCommand,
+    testIntegrationCommand,
+    testUnitGenerateCommand,
+    testE2EGenerateCommand,
+    testSecurityGenerateCommand,
+    testOWASPGenerateCommand,
+    testApiGenerateCommand,
+    testComponentGenerateCommand,
+    dbTestUpdateGoldenCommand,
+    testE2EScaffoldCommand,
+    testCommand,
+    injectTestAttrsCommand,
+    manifestCommand
+  ]);
+  for (const command of allCommands) {
+    program.addCommand(command);
+  }
+}
+async function registerTestCommands(program, requested, loadAllCommands) {
+  if (!loadAllCommands && requested) {
+    const addedSingle = await addSingleTestCommand(program, requested);
+    if (addedSingle) {
+      return;
+    }
+    if (requested === "test" || requested.startsWith("test:")) {
+      const addedFocused = await registerFocusedTestCommand(program, requested);
+      if (addedFocused) {
+        return;
+      }
+      return;
+    }
+    return;
+  }
+  if (loadAllCommands) {
+    await registerAllTestCommands(program);
+    return;
+  }
+  if (!requested || isTestCommand(requested)) {
+    const commandToLoad = requested ?? "test";
+    await registerFocusedTestCommand(program, commandToLoad);
+    return;
+  }
+  await registerAllTestCommands(program);
+}
+async function registerStatusCheckAndUtilityCommands(program, requested, loadAllCommands) {
+  if (!loadAllCommands && requested) {
+    if (requested === "status") {
+      const { statusCommand: statusCommand2 } = await import('./status-UTKS63AB.js');
+      program.addCommand(statusCommand2);
+      return;
+    }
+    if (requested === "check") {
+      const { checkCommand: checkCommand2 } = await import('./check-LOMVIRHX.js');
+      program.addCommand(checkCommand2.name("check"));
+      return;
+    }
+    if (requested === "doctor") {
+      const { doctorCommand: doctorCommand2 } = await import('./doctor-MZLOA53G.js');
+      program.addCommand(doctorCommand2);
+      return;
+    }
+    if (requested === "cache") {
+      const { cacheCommand: cacheCommand2 } = await import('./cache-N7WNPEYF.js');
+      program.addCommand(cacheCommand2);
+      return;
+    }
+    if (requested === "telemetry") {
+      const { telemetryCommand: telemetryCommand2 } = await import('./telemetry-P56UBLZ2.js');
+      program.addCommand(telemetryCommand2);
+      return;
+    }
+    if (requested === "link" || requested === "unlink") {
+      const { linkCommand: linkCommand2, unlinkCommand: unlinkCommand2 } = await import('./link-VSNDVZZD.js');
+      program.addCommand(linkCommand2);
+      program.addCommand(unlinkCommand2);
+      return;
+    }
+  }
+  const [
+    { statusCommand },
+    { checkCommand },
+    { doctorCommand },
+    { cacheCommand },
+    { telemetryCommand },
+    { linkCommand, unlinkCommand }
+  ] = await Promise.all([
+    import('./status-UTKS63AB.js'),
+    import('./check-LOMVIRHX.js'),
+    import('./doctor-MZLOA53G.js'),
+    import('./cache-N7WNPEYF.js'),
+    import('./telemetry-P56UBLZ2.js'),
+    import('./link-VSNDVZZD.js')
+  ]);
+  program.addCommand(statusCommand);
+  program.addCommand(checkCommand.name("check"));
+  program.addCommand(doctorCommand);
+  program.addCommand(cacheCommand);
+  program.addCommand(telemetryCommand);
+  program.addCommand(linkCommand);
+  program.addCommand(unlinkCommand);
+}
+async function registerCiCommand(program) {
+  const { ciCommand } = await import('./ci-ZWRVWNFX.js');
+  program.addCommand(ciCommand);
+}
+async function registerDbCommand(program) {
+  const { dbCommand } = await import('./db-XULCILOU.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-SS66PZ4B.js');
+  program.addCommand(envCommand);
+}
+async function registerHotfixCommand(program) {
+  const { hotfixCommand } = await import('./hotfix-YA3DGLOM.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-PNTKZYFB.js');
+  program.addCommand(watchCommand);
+}
+async function registerWorkflowCommand(program) {
+  const { workflowCommand } = await import('./workflow-H75N4BXX.js');
+  program.addCommand(workflowCommand);
+}
+async function registerVulnCheckCommand(program) {
+  const { vulnCheckCommand } = await import('./vuln-check-2W7N5TA2.js');
+  program.addCommand(vulnCheckCommand);
+}
+async function registerTemplateCheckCommand(program) {
+  const { templateCheckCommand } = await import('./template-check-3P4HZXVY.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",
+      "doctor",
+      "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
+  }
+];
+function shouldLoadAllCommands(requested, loadAllCommands) {
+  if (loadAllCommands === true || requested === null) {
+    return true;
+  }
+  return !COMMAND_GROUPS.some((group) => group.shouldRegister(requested));
+}
+async function registerSelectedCommands(program, options) {
+  const requested = normalizeRequestedCommandName(options.requestedCommandName);
+  const shouldLoadAll = shouldLoadAllCommands(requested, options.loadAllCommands);
+  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",
+  "doctor",
+  "inject-test-attrs",
+  "link",
+  "manifest",
+  "status",
+  "telemetry",
+  "unlink"
+]);
+function shouldRunRuntimeBootstrap(argv) {
+  const requested = getRequestedCommandNameFromArgv(argv);
+  if (!requested) return true;
+  if (!COMMAND_GROUPS.some((group) => group.shouldRegister(requested))) {
+    return false;
+  }
+  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-2UIUYLLR.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;