@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/upgrade-NUK3ZBCL.js

@@ -0,0 +1,637 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { fetchTemplates } from './chunk-SGJG3BKD.js';
+import { updateRunaConfigSdkVersion } from './chunk-6AALH2ED.js';
+import './chunk-DRSUEMAK.js';
+import './chunk-RZLYEO4U.js';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
+import './chunk-WJXC4MVY.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { createCLILogger, CLIError, UpgradeTransaction, readRunaVersion, syncTemplates, SyncOutputSchema, findConflictFiles, preCheckSync } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { execa } from 'execa';
+
+createRequire(import.meta.url);
+
+// src/commands/upgrade.ts
+init_esm_shims();
+var VALID_CATEGORIES = ["rules", "workflows", "config", "packages"];
+function parseOnlyOption(only) {
+  if (!only) return [];
+  const categories = only.split(",").map((c) => c.trim().toLowerCase());
+  const valid = [];
+  const invalid = [];
+  for (const cat of categories) {
+    if (VALID_CATEGORIES.includes(cat)) {
+      valid.push(cat);
+    } else {
+      invalid.push(cat);
+    }
+  }
+  if (invalid.length > 0) {
+    throw new CLIError(`Invalid category: ${invalid.join(", ")}`, "INVALID_UPGRADE_CATEGORY", [
+      `Valid categories: ${VALID_CATEGORIES.join(", ")}`
+    ]);
+  }
+  return valid;
+}
+function logVersionInfo(logger, preCheck) {
+  if (preCheck.versionJump) {
+    const { from, to, isMajor, distance } = preCheck.versionJump;
+    logger.info("");
+    if (isMajor) {
+      logger.warn(`\u26A0\uFE0F  MAJOR version jump: v${from} \u2192 v${to}`);
+      logger.warn("   Breaking changes may require manual migration.");
+    } else if (distance >= 5) {
+      logger.warn(`\u26A0\uFE0F  Version jump: v${from} \u2192 v${to} (${distance} minor versions)`);
+    } else {
+      logger.info(`Version: v${from} \u2192 v${to}`);
+    }
+    return;
+  }
+  if (preCheck.currentVersion) {
+    logger.info(`Version: v${preCheck.currentVersion} (no update)`);
+  } else {
+    logger.info(`Version: v${preCheck.targetVersion} (first sync)`);
+  }
+}
+function logConflictSummary(logger, preCheck, isNonInteractive, isPreview) {
+  if (preCheck.summary.willConflict === 0) return;
+  logger.info("");
+  logger.warn(`\u26A0\uFE0F  ${preCheck.summary.willConflict} file(s) will have conflicts:`);
+  for (const conflict of preCheck.conflicts.slice(0, 5)) {
+    logger.warn(`   - ${conflict}`);
+  }
+  if (preCheck.conflicts.length > 5) {
+    logger.warn(`   ... and ${preCheck.conflicts.length - 5} more`);
+  }
+  logger.info("");
+  logger.info("Options:");
+  logger.info("  \u2022 Continue: Merge markers will be added (resolve manually)");
+  logger.info("  \u2022 --force: Overwrite all files with SDK versions");
+  logger.info("  \u2022 --keep-local: Skip conflicts, keep your versions");
+  if (!isNonInteractive && !isPreview) {
+    logger.info("");
+    logger.info("Continue with upgrade? (use --yes to skip this prompt)");
+  }
+}
+function logPreCheckSummary(logger, preCheck) {
+  const { willCreate, willUpdate, willConflict, unchanged } = preCheck.summary;
+  if (willCreate + willUpdate + willConflict > 0) {
+    logger.info("");
+    logger.info(
+      `Pre-check: ${willCreate} create, ${willUpdate} update, ${willConflict} conflict, ${unchanged} unchanged`
+    );
+  }
+}
+function logTier2Info(logger, preCheck, isPreview) {
+  if (!isPreview || !preCheck.tier2Files || preCheck.tier2Files.length === 0) {
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const file of preCheck.tier2Files) {
+    const existing = grouped.get(file.reason) ?? [];
+    existing.push(file.path);
+    grouped.set(file.reason, existing);
+  }
+  logger.info("");
+  logger.warn("\u2501\u2501\u2501 TIER2 Files (init-only, will NOT be synced) \u2501\u2501\u2501");
+  logger.info("");
+  logger.info("These files were copied during `runa init` but are NOT updated on `runa upgrade`.");
+  logger.info("If you need SDK updates for these files, manually review the SDK templates.");
+  logger.info("");
+  for (const [reason, files] of grouped) {
+    logger.info(`${reason}:`);
+    const shown = files.slice(0, 3);
+    for (const file of shown) {
+      logger.info(`  - ${file}`);
+    }
+    if (files.length > 3) {
+      logger.info(`  ... and ${files.length - 3} more`);
+    }
+  }
+  logger.info("");
+  logger.info("Note: Some TIER2 files have TIER1 overrides (SDK-managed):");
+  logger.info("  - config/vitest/          \u2192 Test configs (SDK-managed)");
+  logger.info("  - supabase/schemas/idempotent/ \u2192 Extensions (SDK-managed)");
+  logger.info("  - supabase/tests/         \u2192 pgTAP helpers (SDK-managed)");
+  logger.info("");
+}
+function logModeInfo(logger, options, categories) {
+  if (options.preview) {
+    logger.info("");
+    logger.info("Mode: preview (dry-run)");
+  }
+  if (options.force) {
+    logger.warn("Mode: force (overwrite all)");
+    logger.warn("");
+    logger.warn("\u26A0\uFE0F  TIER2 files will also be overwritten:");
+    logger.warn("    - biome.json (linter config)");
+    logger.warn("    - runa.config.ts (project config)");
+    logger.warn("    - supabase/config.toml (local dev config)");
+    logger.warn("    - .npmrc (npm registry config)");
+    logger.warn("");
+    logger.warn("To preserve these files, add them to .runaignore");
+  }
+  if (options.keepLocal) {
+    logger.info("Mode: keep-local (skip conflicts)");
+  }
+  if (categories && categories.length > 0) {
+    logger.info(`Mode: partial upgrade (only: ${categories.join(", ")})`);
+  }
+}
+function logChanges(logger, changes, isPreview) {
+  const created = changes.filter((c) => c.action === "create");
+  const updated = changes.filter((c) => c.action === "update");
+  const conflicts = changes.filter((c) => c.action === "conflict");
+  const skipped = changes.filter((c) => c.action === "skipped");
+  if (created.length > 0) {
+    logger.info("Created:");
+    for (const c of created) {
+      logger.info(`  + ${c.path}`);
+    }
+  }
+  if (updated.length > 0) {
+    logger.info("Updated:");
+    for (const c of updated) {
+      logger.info(`  ~ ${c.path}`);
+    }
+  }
+  if (conflicts.length > 0) {
+    logger.warn("Conflicts (merge markers added):");
+    for (const c of conflicts) {
+      logger.warn(`  ! ${c.path}`);
+    }
+  }
+  if (skipped.length > 0 && isPreview) {
+    logSkippedWithDiff(logger, skipped);
+  }
+}
+function logSkippedWithDiff(logger, skipped) {
+  logger.info("Skipped:");
+  for (const c of skipped) {
+    const reason = c.reason ? ` (${c.reason})` : "";
+    logger.info(`  - ${c.path}${reason}`);
+    if (c.diff) {
+      logger.info("");
+      logDiffLines(logger, c.diff);
+      logger.info("");
+    }
+  }
+}
+function logDiffLines(logger, diff) {
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      logger.info(`    \x1B[32m${line}\x1B[0m`);
+    } else if (line.startsWith("-") && !line.startsWith("---")) {
+      logger.info(`    \x1B[31m${line}\x1B[0m`);
+    } else if (line.startsWith("@@")) {
+      logger.info(`    \x1B[36m${line}\x1B[0m`);
+    } else {
+      logger.info(`    ${line}`);
+    }
+  }
+}
+function logConflictGuidance(logger, conflictFiles) {
+  if (conflictFiles.length === 0) return;
+  logger.warn("");
+  logger.warn(`${conflictFiles.length} file(s) have merge markers.`);
+  logger.warn("");
+  logger.warn("\u2501\u2501\u2501 Conflict Resolution Steps \u2501\u2501\u2501");
+  logger.warn("");
+  logger.warn("1. Open each file and look for merge markers:");
+  logger.warn("   <<<<<<< LOCAL (your version)");
+  logger.warn("   [your customized content]");
+  logger.warn("   =======");
+  logger.warn("   [SDK updated content]");
+  logger.warn("   >>>>>>> SDK (vX.Y.Z)");
+  logger.warn("");
+  logger.warn("2. For each conflict, choose:");
+  logger.warn("   - Keep LOCAL: Remove SDK section and markers");
+  logger.warn("   - Use SDK: Remove LOCAL section and markers");
+  logger.warn("   - Merge both: Combine changes and remove markers");
+  logger.warn("");
+  logger.warn("Files to resolve:");
+  for (const file of conflictFiles) {
+    logger.warn(`  - ${file}`);
+  }
+  logger.warn("");
+  logger.warn("3. After resolving, validate:");
+  logger.warn("   runa test --layer 0");
+  logger.warn("");
+  logger.warn("Tip: Use --force to overwrite all, --keep-local to skip conflicts");
+}
+async function runVerification(logger) {
+  logger.info("");
+  logger.section("Post-Upgrade Verification");
+  const steps = [
+    { name: "type-check", command: "turbo", args: ["type-check"] },
+    { name: "lint", command: "turbo", args: ["lint"] },
+    { name: "build", command: "turbo", args: ["build"] }
+  ];
+  let allPassed = true;
+  for (const step of steps) {
+    logger.info(`Running ${step.name}...`);
+    try {
+      await execa(step.command, step.args, {
+        cwd: process.cwd(),
+        stdio: "inherit"
+      });
+      logger.info(`\u2713 ${step.name} passed`);
+    } catch {
+      logger.warn(`\u2717 ${step.name} failed`);
+      allPassed = false;
+    }
+    logger.info("");
+  }
+  if (allPassed) {
+    logger.info("All verification steps passed.");
+  } else {
+    logger.warn("Some verification steps failed. Please fix the issues above.");
+    logger.info("");
+    logger.info("Common fixes:");
+    logger.info("  \u2022 Type errors: Check updated dependencies or API changes");
+    logger.info("  \u2022 Lint errors: Run `turbo lint --fix` to auto-fix");
+    logger.info("  \u2022 Build errors: Check runa.config.ts or package versions");
+  }
+  return allPassed;
+}
+async function findWorkspacesWithSdkPackages(rootDir, packageNames) {
+  const fs = await import('fs/promises');
+  const path = await import('path');
+  const { glob } = await import('glob');
+  const result = [];
+  const packageJsonPaths = await glob("**/package.json", {
+    cwd: rootDir,
+    ignore: ["**/node_modules/**", "package.json"]
+    // Exclude root
+  });
+  for (const relPath of packageJsonPaths) {
+    const fullPath = path.join(rootDir, relPath);
+    try {
+      const content = await fs.readFile(fullPath, "utf-8");
+      const pkg = JSON.parse(content);
+      let hasAnySdkPackage = false;
+      for (const pkgName of packageNames) {
+        if (pkg.dependencies?.[pkgName] || pkg.devDependencies?.[pkgName]) {
+          hasAnySdkPackage = true;
+          break;
+        }
+      }
+      if (hasAnySdkPackage) {
+        result.push({
+          dir: path.dirname(fullPath),
+          packages: packageNames
+          // All packages, not just found ones
+        });
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function getRelativeDir(absoluteDir) {
+  return absoluteDir.replace(`${process.cwd()}/`, "");
+}
+function logDryRunPackageInfo(logger, packages, workspacesWithPackages) {
+  logger.info("Would install at workspace root:");
+  for (const pkg of packages) {
+    logger.info(`  + ${pkg}`);
+  }
+  if (workspacesWithPackages.length > 0) {
+    logger.info("");
+    logger.info("Would update in workspace packages:");
+    for (const ws of workspacesWithPackages) {
+      const relDir = getRelativeDir(ws.dir);
+      for (const pkg of ws.packages) {
+        logger.info(`  + ${relDir}: ${pkg}@latest`);
+      }
+    }
+  }
+  logger.info("");
+}
+async function updateIndividualWorkspaces(logger, workspacesWithPackages) {
+  if (workspacesWithPackages.length === 0) return;
+  logger.info("");
+  logger.info("Updating packages in workspace directories...");
+  for (const ws of workspacesWithPackages) {
+    const relDir = getRelativeDir(ws.dir);
+    const wsPackages = ws.packages.map((p) => `${p}@latest`);
+    logger.info(`  ${relDir}: ${wsPackages.join(", ")}`);
+    await execa("pnpm", ["add", "-D", ...wsPackages], {
+      cwd: ws.dir,
+      stdio: "inherit"
+    });
+  }
+}
+async function logInstalledVersions(logger, workspacesCount) {
+  const runaVersion = await getInstalledVersion("@runa-ai/runa");
+  const cliVersion = await getInstalledVersion("@runa-ai/runa-cli");
+  const xstatePluginVersion = await getInstalledVersion("@runa-ai/runa-xstate-test-plugin");
+  logger.info("");
+  logger.info("Installed:");
+  logger.info(`  @runa-ai/runa@${runaVersion}`);
+  logger.info(`  @runa-ai/runa-cli@${cliVersion}`);
+  logger.info(`  @runa-ai/runa-xstate-test-plugin@${xstatePluginVersion}`);
+  if (workspacesCount > 0) {
+    logger.info("");
+    logger.info(`Updated ${workspacesCount} workspace package(s)`);
+  }
+  logger.info("");
+  return { runa: runaVersion, cli: cliVersion, xstatePlugin: xstatePluginVersion };
+}
+async function updatePackages(logger, isDryRun) {
+  logger.section("Update SDK Packages");
+  const packageNames = ["@runa-ai/runa", "@runa-ai/runa-cli", "@runa-ai/runa-xstate-test-plugin"];
+  const packages = packageNames.map((p) => `${p}@latest`);
+  const workspacesWithPackages = await findWorkspacesWithSdkPackages(process.cwd(), packageNames);
+  if (isDryRun) {
+    logDryRunPackageInfo(logger, packages, workspacesWithPackages);
+    return { success: true };
+  }
+  logger.info("Installing latest SDK packages...");
+  logger.info(`  pnpm add -wD ${packages.join(" ")}`);
+  logger.info("");
+  try {
+    await execa("pnpm", ["add", "-wD", ...packages], {
+      cwd: process.cwd(),
+      stdio: "inherit"
+    });
+    await updateIndividualWorkspaces(logger, workspacesWithPackages);
+    const versions = await logInstalledVersions(logger, workspacesWithPackages.length);
+    return { success: true, versions };
+  } catch (error) {
+    logger.error("Failed to update packages");
+    if (error instanceof Error) {
+      logger.error(`  ${error.message}`);
+    }
+    return { success: false };
+  }
+}
+async function getInstalledVersion(packageName) {
+  try {
+    const result = await execa("pnpm", ["list", packageName, "--json", "--depth=0"], {
+      cwd: process.cwd()
+    });
+    const parsed = JSON.parse(result.stdout);
+    const deps = parsed[0]?.devDependencies ?? parsed[0]?.dependencies ?? {};
+    return deps[packageName]?.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function runPreCheck(logger, options, isNonInteractive, templatesDir) {
+  if (options.force || options.keepLocal) return;
+  const preCheck = await preCheckSync({
+    targetDir: process.cwd(),
+    mode: "sync",
+    templatesDir
+  });
+  logVersionInfo(logger, preCheck);
+  logConflictSummary(logger, preCheck, isNonInteractive, options.preview === true);
+  logPreCheckSummary(logger, preCheck);
+  logTier2Info(logger, preCheck, options.preview === true);
+}
+function logBackupInfo(logger, transactionId) {
+  if (!transactionId) return;
+  logger.info("");
+  logger.info("Backup created (use --rollback to restore):");
+  logger.info(`  Transaction ID: ${transactionId}`);
+  logger.info("  Commands:");
+  logger.info(`    runa upgrade --rollback ${transactionId}`);
+  logger.info("    runa upgrade --rollback-latest");
+  logger.info("    runa upgrade --list-backups");
+}
+function logHumanOutput(logger, result, options) {
+  if (process.env.RUNA_OUTPUT_FORMAT === "json") return;
+  const { summary, changes } = result;
+  logger.info("");
+  logger.info(`SDK Version: v${result.sdkVersion}`);
+  logger.info("");
+  const summaryParts = [
+    `Created: ${summary.created}`,
+    `Updated: ${summary.updated}`,
+    `Unchanged: ${summary.unchanged}`,
+    `Skipped: ${summary.skipped}`
+  ];
+  if (summary.conflicts > 0) {
+    summaryParts.push(`Conflicts: ${summary.conflicts}`);
+  }
+  logger.info(`Summary: ${summaryParts.join(", ")}`);
+  logger.info("");
+  logChanges(logger, changes, options.preview === true);
+  const conflictFiles = findConflictFiles(changes);
+  if (conflictFiles.length > 0 && !options.preview) {
+    logConflictGuidance(logger, conflictFiles);
+  }
+  if (summary.conflicts === 0) {
+    logger.info("");
+    logger.info("Upgrade complete.");
+  }
+  if (options.backup && result.transactionId) {
+    logBackupInfo(logger, result.transactionId);
+  }
+}
+async function executePackageUpdate(logger, options) {
+  const packageResult = await updatePackages(logger, options.preview === true);
+  if (!packageResult.success && !options.preview) {
+    throw new CLIError("Package update failed", "PACKAGE_UPDATE_FAILED", [
+      "Check your network connection",
+      "Ensure gh auth is valid: gh auth status",
+      "Ensure NODE_AUTH_TOKEN is set: echo $NODE_AUTH_TOKEN",
+      "Try with --no-packages to skip package updates"
+    ]);
+  }
+  if (packageResult.success && packageResult.versions?.runa && !options.preview) {
+    const configUpdateResult = updateRunaConfigSdkVersion(packageResult.versions.runa);
+    if (configUpdateResult.updated) {
+      logger.info(`Updated runa.config.ts sdkVersion: ${configUpdateResult.reason}`);
+    }
+  }
+}
+async function executeTemplateSync(ctx, templatesDir) {
+  const { logger, options, onlyCategories, isNonInteractive } = ctx;
+  logger.section("Upgrade SDK Templates");
+  await runPreCheck(logger, options, isNonInteractive, templatesDir);
+  logModeInfo(logger, options, onlyCategories);
+  const result = await syncTemplates({
+    targetDir: process.cwd(),
+    mode: "sync",
+    dryRun: options.preview === true,
+    force: options.force === true,
+    keepLocal: options.keepLocal === true,
+    keepBackup: options.backup === true,
+    only: onlyCategories.length > 0 ? onlyCategories : void 0,
+    templatesDir
+  });
+  emitJsonSuccess(upgradeCommand, SyncOutputSchema, result);
+  logHumanOutput(logger, result, options);
+  if (result.summary.conflicts > 0 && !options.preview) {
+    const conflictFiles = findConflictFiles(result.changes);
+    throw new CLIError(
+      `${result.summary.conflicts} file(s) have unresolved merge markers`,
+      "UPGRADE_UNRESOLVED_CONFLICTS",
+      [
+        `Files: ${conflictFiles.slice(0, 5).join(", ")}${conflictFiles.length > 5 ? ` and ${conflictFiles.length - 5} more` : ""}`,
+        "Resolve merge markers in the files listed above",
+        "Then run: runa check (to verify no markers remain)",
+        "Or re-run: runa upgrade --force (to overwrite with SDK version)"
+      ]
+    );
+  }
+}
+async function executeVerification(logger) {
+  const verificationPassed = await runVerification(logger);
+  if (!verificationPassed) {
+    throw new CLIError("Verification failed", "VERIFICATION_FAILED", [
+      "Fix the errors above and re-run verification",
+      "Run `runa test --layer 0` for static analysis only",
+      "Run `turbo lint --fix` to auto-fix lint issues"
+    ]);
+  }
+}
+async function executeUpgrade(ctx) {
+  const { logger, options, shouldUpdatePackages } = ctx;
+  logger.section("Fetching Templates");
+  const templateResult = await fetchTemplates({
+    version: options.templatesVersion,
+    fresh: options.fresh,
+    verbose: process.env.DEBUG === "true"
+  });
+  logger.info(
+    templateResult.cached ? `Using ${templateResult.version === "workspace" ? "workspace" : "cached"} templates v${templateResult.version}` : `Fetched templates v${templateResult.version}`
+  );
+  if (shouldUpdatePackages) {
+    await executePackageUpdate(logger, options);
+  }
+  await executeTemplateSync(ctx, templateResult.templatesDir);
+  if (options.verify && !options.preview) {
+    await executeVerification(logger);
+  }
+}
+async function handleRollbackOperations(logger, options) {
+  if (options.listBackups) {
+    await listBackupsAction(logger);
+    return true;
+  }
+  if (options.rollbackLatest) {
+    await rollbackLatestAction(logger);
+    return true;
+  }
+  if (options.rollback) {
+    await rollbackAction(logger, options.rollback);
+    return true;
+  }
+  return false;
+}
+async function listBackupsAction(logger) {
+  logger.section("Available Backups");
+  const transactions = await UpgradeTransaction.listTransactions();
+  if (transactions.length === 0) {
+    logger.info("No backups available.");
+    logger.info("");
+    logger.info("Backups are created when you run:");
+    logger.info("  runa upgrade --backup");
+    return;
+  }
+  const currentVersion = readRunaVersion(process.cwd());
+  const lastTransactionId = currentVersion?.lastTransactionId;
+  logger.info(`Found ${transactions.length} backup(s):`);
+  logger.info("");
+  for (const tx of transactions) {
+    const isLatest = tx.id === lastTransactionId;
+    const marker = isLatest ? " \u2190 (current)" : "";
+    const date = new Date(tx.timestamp).toLocaleString();
+    logger.info(`  ${tx.id}  ${date}${marker}`);
+  }
+  logger.info("");
+  logger.info("To rollback:");
+  logger.info("  runa upgrade --rollback <id>");
+  logger.info("  runa upgrade --rollback-latest");
+}
+async function rollbackAction(logger, transactionId) {
+  logger.section("Rollback");
+  logger.info(`Rolling back to transaction: ${transactionId}`);
+  try {
+    const metadata = await UpgradeTransaction.loadMetadata(transactionId);
+    if (!metadata) {
+      throw new CLIError(
+        `Transaction ${transactionId} not found`,
+        "ROLLBACK_TRANSACTION_NOT_FOUND",
+        ["Run `runa upgrade --list-backups` to see available backups"]
+      );
+    }
+    logger.info("");
+    logger.info(`Files to restore: ${metadata.files.length}`);
+    for (const file of metadata.files.slice(0, 5)) {
+      logger.info(`  - ${file.original}`);
+    }
+    if (metadata.files.length > 5) {
+      logger.info(`  ... and ${metadata.files.length - 5} more`);
+    }
+    logger.info("");
+    await UpgradeTransaction.rollbackFromMetadata(transactionId);
+    logger.info("Rollback complete.");
+    logger.info("");
+    logger.info("Note: The backup has been consumed and is no longer available.");
+    logger.info("Run `runa upgrade` to upgrade again.");
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      `Rollback failed: ${error instanceof Error ? error.message : String(error)}`,
+      "ROLLBACK_FAILED",
+      ["Check if the backup files still exist", "Run `runa upgrade --list-backups` to verify"]
+    );
+  }
+}
+async function rollbackLatestAction(logger) {
+  const currentVersion = readRunaVersion(process.cwd());
+  if (currentVersion?.lastTransactionId) {
+    await rollbackAction(logger, currentVersion.lastTransactionId);
+    return;
+  }
+  const transactions = await UpgradeTransaction.listTransactions();
+  if (transactions.length === 0) {
+    throw new CLIError("No backups available", "NO_BACKUPS_AVAILABLE", [
+      "Run `runa upgrade --backup` to create a backup during upgrade",
+      "Backups are automatically created but cleaned up unless --backup is used"
+    ]);
+  }
+  await rollbackAction(logger, transactions[0].id);
+}
+var upgradeCommand = new Command("upgrade").description("Upgrade SDK packages and templates to latest version").option("--preview", "Preview changes without writing files (dry-run)").option("--force", "Overwrite all files, even if modified locally").option("--keep-local", "Skip conflicts and keep local versions").option("-y, --yes", "Skip confirmation prompts").option("--verify", "Run type-check, lint, and build after upgrade").option("--no-packages", "Skip package updates (templates only)").option("--backup", "Keep backup after upgrade (for manual rollback)").option("--rollback <id>", "Rollback to a specific backup by transaction ID").option("--rollback-latest", "Rollback to the most recent backup").option("--list-backups", "List available backups for rollback").option("--only <categories>", "Only sync specific categories (rules,workflows,config,packages)").option("--templates-version <version>", "Override templates version").option("--fresh", "Clear templates cache before fetching").action(async (options) => {
+  const logger = createCLILogger("upgrade");
+  if (await handleRollbackOperations(logger, options)) {
+    return;
+  }
+  const onlyCategories = parseOnlyOption(options.only);
+  const shouldUpdatePackages = options.packages !== false && (onlyCategories.length === 0 || onlyCategories.includes("packages"));
+  const isJsonMode = process.env.RUNA_OUTPUT_FORMAT === "json";
+  const isNonInteractive = options.yes || isJsonMode || !process.stdin.isTTY;
+  const ctx = {
+    logger,
+    options,
+    onlyCategories,
+    shouldUpdatePackages,
+    isNonInteractive
+  };
+  try {
+    await executeUpgrade(ctx);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      "Upgrade failed",
+      "UPGRADE_FAILED",
+      [
+        "Run with --preview to see what would change",
+        "Run with --force to overwrite all files",
+        "Run with --keep-local to keep your modifications",
+        "Run with --no-packages to skip package updates"
+      ],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+export { upgradeCommand };

package/dist/utils/config-loader.d.ts

@@ -10,9 +10,6 @@
  * - Config-first with smart fallbacks
  */
 import type { RunaConfig } from '@runa-ai/runa';
-/**
- * Load runa.config.ts from project root (synchronous)
- */
 export declare function loadRunaConfig(cwd?: string): RunaConfig;
 /**
  * Get database configuration with defaults