@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/chunk-KWX3JHCY.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { env } from './chunk-NPSRD26F.js';
+import { redactSecrets } from './chunk-II7VYQEM.js';
+import { init_local_supabase, buildLocalDatabaseUrl } from './chunk-VM3IWOT5.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError } from '@runa-ai/runa';
+
+createRequire(import.meta.url);
+
+// src/commands/db/utils/db-target.ts
+init_esm_shims();
+init_local_supabase();
+function getLocalDatabaseUrl() {
+  return buildLocalDatabaseUrl(process.cwd());
+}
+function isLocalHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "host.docker.internal";
+}
+function isLocalDatabaseUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return isLocalHostname(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+function resolveDatabaseUrl(environment) {
+  switch (environment) {
+    case "local": {
+      const url = process.env.DATABASE_URL_ADMIN || getLocalDatabaseUrl();
+      if (!isLocalDatabaseUrl(url)) {
+        throw new CLIError("Local database URL appears to be a remote URL", "LOCAL_DB_URL_REMOTE", [
+          "Local operations should use the local Supabase instance",
+          // SECURITY (Issue #513): Redact credentials from database URL in error message
+          `Current URL: ${redactSecrets(url)}`,
+          "If you need to connect to a remote DB, use --env preview or --env production"
+        ]);
+      }
+      return url;
+    }
+    case "preview": {
+      const url = process.env.DATABASE_URL_ADMIN || env.DATABASE_URL || process.env.DATABASE_URL;
+      if (!url) {
+        throw new CLIError("Preview database URL not found", "PREVIEW_DB_URL_NOT_FOUND", [
+          "Set DATABASE_URL_ADMIN environment variable (for DDL/migrations)",
+          "Or set DATABASE_URL as fallback"
+        ]);
+      }
+      return url;
+    }
+    case "main":
+    case "production": {
+      const url = process.env.GH_DATABASE_URL_ADMIN || process.env.DATABASE_URL_ADMIN || process.env.GH_DATABASE_URL || env.DATABASE_URL || process.env.DATABASE_URL;
+      if (!url) {
+        throw new CLIError("Production database URL not found", "PRODUCTION_DB_URL_NOT_FOUND", [
+          "Set DATABASE_URL_ADMIN environment variable (for DDL/migrations)",
+          "Or set GH_DATABASE_URL_ADMIN (CI) / DATABASE_URL as fallback"
+        ]);
+      }
+      if (isLocalDatabaseUrl(url)) {
+        throw new CLIError(
+          "Production database URL points to localhost",
+          "PRODUCTION_DB_URL_IS_LOCAL",
+          [
+            "Use --env local for local Supabase operations",
+            "Production operations require a remote database URL",
+            "Set DATABASE_URL_ADMIN or GH_DATABASE_URL_ADMIN to the production database URL"
+          ]
+        );
+      }
+      return url;
+    }
+  }
+}
+function tryResolveDatabaseUrl(environment) {
+  try {
+    return resolveDatabaseUrl(environment);
+  } catch (error) {
+    if (error instanceof CLIError) return void 0;
+    throw error;
+  }
+}
+
+export { resolveDatabaseUrl, tryResolveDatabaseUrl };

package/dist/chunk-MXRWBNIY.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { execa } from 'execa';
+
+createRequire(import.meta.url);
+
+// src/utils/vercel-project.ts
+init_esm_shims();
+async function getVercelProjectInfo() {
+  try {
+    const result = await execa("vercel", ["project", "inspect"], {
+      reject: false,
+      timeout: 3e4
+      // 30 seconds timeout
+    });
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    const output = result.stdout || result.stderr;
+    return parseVercelInspectOutput(output);
+  } catch {
+    return null;
+  }
+}
+function parseVercelInspectOutput(output) {
+  const lines = output.split("\n");
+  const info = {
+    id: "",
+    name: "",
+    owner: "",
+    rootDirectory: null,
+    nodeVersion: null,
+    frameworkPreset: null
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const match = trimmed.match(/^(\S+(?:\s+\S+)*)\s{2,}(.+)$/);
+    if (!match) continue;
+    const [, key, value] = match;
+    const normalizedKey = key.toLowerCase().replace(/\s+/g, "");
+    switch (normalizedKey) {
+      case "id":
+        info.id = value;
+        break;
+      case "name":
+        info.name = value;
+        break;
+      case "owner":
+        info.owner = value;
+        break;
+      case "rootdirectory":
+        info.rootDirectory = value;
+        break;
+      case "node.jsversion":
+      case "nodejsversion":
+        info.nodeVersion = value;
+        break;
+      case "frameworkpreset":
+        info.frameworkPreset = value;
+        break;
+    }
+  }
+  if (!info.id || !info.name) {
+    return null;
+  }
+  return info;
+}
+async function getVercelRootDirectory() {
+  const info = await getVercelProjectInfo();
+  return info?.rootDirectory ?? null;
+}
+
+export { getVercelRootDirectory };

package/dist/chunk-NPSRD26F.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_constants, constants_exports } from './chunk-VM3IWOT5.js';
+import { init_esm_shims, __toCommonJS } from './chunk-VRXHCR5K.js';
+import { z } from 'zod';
+
+createRequire(import.meta.url);
+
+// src/config/env.ts
+init_esm_shims();
+function safeOptionalUrl() {
+  return z.string().optional().transform((val) => {
+    if (!val) return void 0;
+    try {
+      new URL(val);
+      return val;
+    } catch {
+      return void 0;
+    }
+  });
+}
+var envSchema = z.object({
+  // Core environment
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+  CI: z.string().optional().transform((val) => val === "true"),
+  DEBUG: z.string().optional().transform((val) => val === "true"),
+  // Database
+  // Note: POSTGRES_PORT is now optional - use getDatabaseUrl() which detects port dynamically
+  DATABASE_URL: safeOptionalUrl(),
+  POSTGRES_PASSWORD: z.string().optional(),
+  POSTGRES_USER: z.string().default("postgres"),
+  POSTGRES_DB: z.string().default("postgres"),
+  POSTGRES_HOST: z.string().default("127.0.0.1"),
+  POSTGRES_PORT: z.string().optional(),
+  // Supabase
+  SUPABASE_URL: safeOptionalUrl(),
+  SUPABASE_ANON_KEY: z.string().optional(),
+  SUPABASE_SERVICE_ROLE_KEY: z.string().optional(),
+  SUPABASE_ACCESS_TOKEN: z.string().optional(),
+  SUPABASE_PROJECT_REF: z.string().optional(),
+  NEXT_PUBLIC_SUPABASE_URL: safeOptionalUrl(),
+  // GitHub
+  GITHUB_TOKEN: z.string().optional(),
+  GITHUB_APP_ID: z.string().optional(),
+  GITHUB_APP_PRIVATE_KEY: z.string().optional(),
+  GITHUB_INSTALLATION_ID: z.string().optional(),
+  // Vercel
+  VERCEL_TOKEN: z.string().optional(),
+  VERCEL_PROJECT_ID: z.string().optional(),
+  VERCEL_ORG_ID: z.string().optional(),
+  // Testing
+  BASE_URL: safeOptionalUrl(),
+  SKIP_SERVER: z.string().optional().transform((val) => val === "true"),
+  // Logging
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  RUNA_LOG_JSON: z.string().optional().transform((val) => val === "true")
+});
+function loadEnv() {
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    const errors = result.error.issues.map(
+      (issue) => `  - ${issue.path.map((p) => String(p)).join(".")}: ${issue.message}`
+    );
+    throw new Error(
+      `Invalid environment configuration:
+
+${errors.join("\n")}
+
+Please check your .env file or environment variables.`
+    );
+  }
+  return result.data;
+}
+var env = loadEnv();
+function hasEnv(...keys) {
+  return keys.every((key) => {
+    const value = env[key];
+    return value !== void 0 && value !== "";
+  });
+}
+function getDatabaseUrl() {
+  if (env.DATABASE_URL) {
+    return env.DATABASE_URL;
+  }
+  const { POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_HOST, POSTGRES_PORT, POSTGRES_DB } = env;
+  if (!POSTGRES_PASSWORD) {
+    throw new Error(
+      "Database credentials not configured. Set DATABASE_URL or POSTGRES_PASSWORD environment variable."
+    );
+  }
+  let port = POSTGRES_PORT;
+  if (!port) {
+    const { detectSupabasePorts } = (init_constants(), __toCommonJS(constants_exports));
+    port = String(detectSupabasePorts().db);
+  }
+  return `postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@${POSTGRES_HOST}:${port}/${POSTGRES_DB}`;
+}
+function isCI() {
+  return env.CI === true;
+}
+function isDebug() {
+  return env.DEBUG === true || env.LOG_LEVEL === "debug";
+}
+var SENSITIVE_KEYS = [
+  "DATABASE_URL",
+  // Contains password in connection string
+  "POSTGRES_PASSWORD",
+  "SUPABASE_SERVICE_ROLE_KEY",
+  "SUPABASE_ACCESS_TOKEN",
+  "SUPABASE_ANON_KEY",
+  "GITHUB_TOKEN",
+  "GITHUB_APP_PRIVATE_KEY",
+  "VERCEL_TOKEN"
+];
+var SENSITIVE_VALUE_PATTERNS = [
+  // Database URLs with passwords
+  /postgresql:\/\/[^:]+:[^@]+@/i,
+  /postgres:\/\/[^:]+:[^@]+@/i,
+  /mysql:\/\/[^:]+:[^@]+@/i,
+  // JWT tokens
+  /^eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/,
+  // GitHub tokens
+  /^gh[pousr]_[A-Za-z0-9_]+$/,
+  // API keys with common prefixes
+  /^sk[_-](?:live|test|proj)[_-]/i,
+  // AWS keys
+  /^AKIA[A-Z0-9]{16}$/
+];
+function looksLikeSecret(value) {
+  return SENSITIVE_VALUE_PATTERNS.some((pattern) => pattern.test(value));
+}
+function sanitizeEnv(envVars) {
+  const sanitized = { ...envVars };
+  for (const [key, value] of Object.entries(sanitized)) {
+    if (typeof value !== "string" || value === "") {
+      continue;
+    }
+    if (SENSITIVE_KEYS.includes(key)) {
+      sanitized[key] = "***";
+      continue;
+    }
+    if (looksLikeSecret(value)) {
+      sanitized[key] = "***";
+    }
+  }
+  return sanitized;
+}
+
+export { env, getDatabaseUrl, hasEnv, isCI, isDebug, sanitizeEnv };

package/dist/chunk-QDF7QXBL.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError } from '@runa-ai/runa';
+import { createActor } from 'xstate';
+
+createRequire(import.meta.url);
+
+// src/internal/machines/machine-runner.ts
+init_esm_shims();
+function getOutputOrThrow(snapshot) {
+  const s = snapshot;
+  if (s.output === void 0) {
+    throw new CLIError("Machine completed without output", "MACHINE_NO_OUTPUT", [
+      "Ensure the machine defines an `output:` function."
+    ]);
+  }
+  return s.output;
+}
+async function runMachine(params) {
+  const timeoutMs = params.timeoutMs ?? 10 * 60 * 1e3;
+  return new Promise((resolve, reject) => {
+    const actor = createActor(params.machine, { input: params.input });
+    const timer = setTimeout(() => {
+      try {
+        actor.stop?.();
+      } catch {
+      }
+      reject(
+        new CLIError("Machine execution timed out", "MACHINE_TIMEOUT", [
+          `Timeout: ${timeoutMs}ms`,
+          "Consider increasing timeoutMs for long-running operations."
+        ])
+      );
+    }, timeoutMs);
+    const sub = actor.subscribe((snapshot) => {
+      try {
+        params.onSnapshot?.(snapshot);
+        const stateName = params.helpers.getStateName(snapshot);
+        params.onTransition?.(stateName);
+        if (params.helpers.isComplete(snapshot)) {
+          clearTimeout(timer);
+          sub.unsubscribe();
+          const out = getOutputOrThrow(snapshot);
+          resolve(out);
+        }
+      } catch (err) {
+        clearTimeout(timer);
+        sub.unsubscribe();
+        reject(err);
+      }
+    });
+    try {
+      actor.start();
+      actor.send({ type: "START" });
+    } catch (err) {
+      clearTimeout(timer);
+      sub.unsubscribe();
+      reject(err);
+    }
+  });
+}
+
+// src/internal/machines/index.ts
+init_esm_shims();
+
+export { runMachine };

package/dist/chunk-QM53IQHM.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { loadEnvFiles } from './chunk-644FVGIQ.js';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
+import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError, createCLILogger } from '@runa-ai/runa/cli-runtime';
+import { runChecks, RunCheckOutputSchema } from '@runa-ai/runa/check';
+import chalk from 'chalk';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/check/commands/check.ts
+init_esm_shims();
+function getStatusIcon(status, required) {
+  switch (status) {
+    case "ok":
+      return chalk.green("\u2713");
+    case "skipped":
+      return chalk.dim("\u25CB");
+    case "warning":
+      return chalk.yellow("\u26A0");
+    case "missing":
+    case "invalid":
+    case "not_running":
+      return required ? chalk.red("\u2717") : chalk.yellow("\u26A0");
+    default:
+      return chalk.dim("?");
+  }
+}
+function getStatusColor(status, required) {
+  switch (status) {
+    case "ok":
+      return chalk.green;
+    case "skipped":
+      return chalk.dim;
+    case "warning":
+      return chalk.yellow;
+    case "missing":
+    case "invalid":
+    case "not_running":
+      return required ? chalk.red : chalk.yellow;
+    default:
+      return chalk.dim;
+  }
+}
+function renderCheckDetails(logger, details, verbose) {
+  if (details.error) {
+    logger.info(chalk.red(`     \u2514\u2500 Error: ${details.error}`));
+  }
+  if (details.issue) {
+    logger.info(chalk.yellow(`     \u2514\u2500 Issue: ${details.issue}`));
+  }
+  if (details.expected && details.actual) {
+    logger.info(chalk.dim(`     \u2514\u2500 Expected: ${details.expected}`));
+    logger.info(chalk.dim(`     \u2514\u2500 Actual: ${details.actual}`));
+  }
+  if (details.hint) {
+    logger.info(chalk.cyan(`     \u2514\u2500 Hint: ${details.hint}`));
+  }
+  if (verbose && details.path) {
+    logger.info(chalk.dim(`     \u2514\u2500 Path: ${details.path}`));
+  }
+}
+function renderFixHint(logger, fix) {
+  if (fix.command) {
+    logger.info(chalk.dim(`     \u2514\u2500 Fix: ${fix.command}`));
+  } else if (fix.manual) {
+    logger.info(chalk.dim(`     \u2514\u2500 Manual: ${fix.manual}`));
+  }
+}
+function renderCheckResult(logger, check, verbose) {
+  const icon = getStatusIcon(check.status, check.required);
+  const color = getStatusColor(check.status, check.required);
+  const nameWidth = 30;
+  const name = check.name.padEnd(nameWidth);
+  const message = color(check.message);
+  logger.info(`  ${icon} ${name} ${message}`);
+  const isFailed = check.status !== "ok" && check.status !== "skipped";
+  const showDetails = isFailed || verbose;
+  if (showDetails && check.details) {
+    renderCheckDetails(logger, check.details, verbose);
+  }
+  if ((isFailed || verbose) && check.fix) {
+    renderFixHint(logger, check.fix);
+  }
+}
+function renderCategory(logger, category, verbose) {
+  if (category.checks.length === 0) return;
+  logger.info("");
+  logger.info(chalk.bold(`\u2501\u2501\u2501 ${category.label} \u2501\u2501\u2501`));
+  for (const check of category.checks) {
+    renderCheckResult(logger, check, verbose);
+  }
+}
+function renderSummary(logger, output, fix) {
+  logger.info("");
+  logger.info(chalk.bold("\u2501\u2501\u2501 Summary \u2501\u2501\u2501"));
+  const { summary } = output;
+  const parts = [];
+  if (summary.passed > 0) {
+    parts.push(chalk.green(`${summary.passed} passed`));
+  }
+  if (summary.critical > 0) {
+    parts.push(chalk.red(`${summary.critical} critical`));
+  }
+  if (summary.warning > 0) {
+    parts.push(chalk.yellow(`${summary.warning} warnings`));
+  }
+  if (summary.skipped > 0) {
+    parts.push(chalk.dim(`${summary.skipped} skipped`));
+  }
+  if (fix && summary.fixed > 0) {
+    parts.push(chalk.cyan(`${summary.fixed} fixed`));
+  }
+  logger.info(`  ${parts.join(" | ")}`);
+  if (summary.fixable > 0 && !fix) {
+    logger.info("");
+    logger.info(
+      chalk.yellow(`  ${summary.fixable} issue(s) can be auto-fixed. Run: runa check --fix`)
+    );
+  }
+}
+function renderNextActions(logger, output) {
+  if (output.nextActions.length === 0) return;
+  logger.info("");
+  logger.info(chalk.bold("\u2501\u2501\u2501 Next Actions \u2501\u2501\u2501"));
+  const topActions = output.nextActions.slice(0, 5);
+  for (const action of topActions) {
+    const prefix = action.manual ? chalk.yellow("  Manual:") : chalk.cyan("  Run:");
+    const cmd = action.command || action.action;
+    logger.info(`${prefix} ${cmd}`);
+  }
+  if (output.nextActions.length > 5) {
+    logger.info(chalk.dim(`  ... and ${output.nextActions.length - 5} more`));
+  }
+}
+function renderFinalStatus(logger, output) {
+  logger.info("");
+  if (output.exitCode === 1) {
+    logger.error("Critical issues found. Please fix before proceeding.");
+  } else if (output.summary.warning > 0) {
+    logger.warn("Checks passed with warnings. Operations should work.");
+  } else {
+    logger.success("All checks passed! Ready for operations.");
+  }
+}
+async function runCheckCommand(options, runOptions) {
+  const logger = createCLILogger(runOptions.loggerName);
+  const isJsonMode = getOutputFormatFromEnv() === "json";
+  loadEnvFiles({ runaEnv: "local", silent: true });
+  if (isJsonMode && options.fix) {
+    throw new CLIError(
+      "--fix is not allowed in --json mode (non-interactive)",
+      "NON_INTERACTIVE_REQUIRED",
+      ["Run without --json to use --fix", "Or apply fixes manually based on JSON output"]
+    );
+  }
+  const output = await runChecks({
+    targetDir: options.cwd || process.cwd(),
+    scope: options.scope || "all",
+    fix: options.fix || false,
+    dryRun: options.dryRun || false,
+    verbose: options.verbose || false
+  });
+  if (isJsonMode) {
+    emitJsonSuccess(runOptions.command, RunCheckOutputSchema, output);
+    process.exit(output.exitCode);
+  }
+  if (runOptions.deprecationNotice) {
+    logger.warn(runOptions.deprecationNotice);
+  }
+  logger.section(`Project Health Check (scope: ${options.scope || "all"})`);
+  for (const category of output.categories) {
+    renderCategory(logger, category, options.verbose || false);
+  }
+  renderSummary(logger, output, options.fix || false);
+  if (!output.success) {
+    renderNextActions(logger, output);
+  }
+  renderFinalStatus(logger, output);
+  process.exitCode = output.exitCode;
+}
+var checkCommand = new Command("run").description("Check project configuration and dependencies").option(
+  "-s, --scope <scope>",
+  "Check scope: all | build | ci | deploy | testing | layer1 | layer2 | layer3 | layer4",
+  "all"
+).option("--fix", "Attempt to auto-fix issues").option("-v, --verbose", "Show detailed output with fix hints").option("--dry-run", "Show what would be checked without running").option("--cwd <path>", "Working directory (default: current directory)").action(async (options, command) => {
+  try {
+    await runCheckCommand(options, {
+      command,
+      loggerName: "check"
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new CLIError(
+      `Project check failed: ${err.message}`,
+      "CHECK_ERROR",
+      ["Check error details above", "Verify environment setup", "Try: runa check --verbose"],
+      err
+    );
+  }
+});
+
+export { checkCommand, runCheckCommand };