@runa-ai/runa-cli 0.5.72 → 0.6.0

package/dist/chunk-HPYJPB5Y.js

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_constants, detectSupabasePorts } from './chunk-VM3IWOT5.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { execSync, spawnSync } from 'child_process';
+import { existsSync, statSync, readFileSync } from 'fs';
+import path, { join } from 'path';
+import { fromPromise } from 'xstate';
+
+createRequire(import.meta.url);
+
+// src/commands/build/actors/setup.ts
+init_esm_shims();
+init_constants();
+function needsDepsInstall(repoRoot) {
+  const nodeModulesPath = join(repoRoot, "node_modules");
+  join(repoRoot, "package.json");
+  const lockfilePath = join(repoRoot, "pnpm-lock.yaml");
+  if (!existsSync(nodeModulesPath)) {
+    return true;
+  }
+  if (existsSync(lockfilePath)) {
+    try {
+      const nodeModulesStat = statSync(nodeModulesPath);
+      const lockfileStat = statSync(lockfilePath);
+      if (lockfileStat.mtimeMs > nodeModulesStat.mtimeMs) {
+        return true;
+      }
+    } catch {
+      return true;
+    }
+  }
+  return false;
+}
+function extractPortFromDbUrl(dbUrl) {
+  const match = dbUrl.match(/:(\d+)\//);
+  if (!match?.[1]) return void 0;
+  const port = Number.parseInt(match[1], 10);
+  return Number.isFinite(port) && port > 0 ? port : void 0;
+}
+function parseSupabaseStatusDbPort(rawStatus) {
+  try {
+    const parsed = JSON.parse(rawStatus);
+    const dbUrl = (typeof parsed["DB URL"] === "string" ? parsed["DB URL"] : void 0) ?? (typeof parsed.db_url === "string" ? parsed.db_url : void 0);
+    if (dbUrl) {
+      const port = extractPortFromDbUrl(dbUrl);
+      if (port !== void 0) return port;
+    }
+  } catch {
+  }
+  const dbUrlLine = rawStatus.match(/DB URL:\s*([^\s]+)/i);
+  if (dbUrlLine?.[1]) {
+    const port = extractPortFromDbUrl(dbUrlLine[1]);
+    if (port !== void 0) return port;
+  }
+  const genericDbUrl = rawStatus.match(/postgres(?:ql)?:\/\/[^\s]+/i);
+  if (genericDbUrl?.[0]) {
+    return extractPortFromDbUrl(genericDbUrl[0]);
+  }
+  return void 0;
+}
+function detectRunningSupabaseDbPort(repoRoot) {
+  const statusCommands = [["status", "--output", "json"], ["status"]];
+  for (const args of statusCommands) {
+    try {
+      const result = spawnSync("supabase", args, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: 1e4
+      });
+      if (result.status !== 0 || !result.stdout) {
+        continue;
+      }
+      const port = parseSupabaseStatusDbPort(result.stdout);
+      if (port !== void 0) {
+        return port;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function extractSupabaseProjectFromContainerName(containerName) {
+  const match = containerName.match(/^supabase_db_(.+)$/);
+  return match?.[1];
+}
+function findSupabaseProjectUsingPort(actualDbPort) {
+  try {
+    const dockerResult = spawnSync(
+      "docker",
+      ["ps", "--filter", "name=supabase_db", "--format", "{{.Names}}	{{.Ports}}"],
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    if (dockerResult.status !== 0 || !dockerResult.stdout?.trim()) {
+      return void 0;
+    }
+    const lines = dockerResult.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+    for (const line of lines) {
+      const [name, ports = ""] = line.split("	");
+      if (!name || !ports.includes(`:${actualDbPort}->`)) continue;
+      return extractSupabaseProjectFromContainerName(name);
+    }
+    for (const line of lines) {
+      const [name] = line.split("	");
+      if (!name) continue;
+      const project = extractSupabaseProjectFromContainerName(name);
+      if (project) return project;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function checkSupabaseStatus(repoRoot) {
+  const supabaseConfigPath = join(repoRoot, "supabase", "config.toml");
+  const configured = existsSync(supabaseConfigPath);
+  if (!configured) {
+    return { configured: false, running: false, portInUse: false };
+  }
+  const ports = detectSupabasePorts(repoRoot);
+  const actualDbPort = ports.db;
+  const reportedPort = detectRunningSupabaseDbPort(repoRoot);
+  if (reportedPort === actualDbPort) {
+    return { configured, running: true, portInUse: false, actualPort: actualDbPort };
+  }
+  try {
+    const result = spawnSync("lsof", ["-i", `:${actualDbPort}`, "-t"], {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    if (result.status === 0 && result.stdout?.trim()) {
+      const conflictingProject = findSupabaseProjectUsingPort(actualDbPort);
+      return {
+        configured,
+        running: false,
+        portInUse: true,
+        conflictingProject,
+        actualPort: actualDbPort
+      };
+    }
+  } catch {
+  }
+  return { configured, running: false, portInUse: false, actualPort: actualDbPort };
+}
+function checkEnvFiles(repoRoot) {
+  const envFiles = [".env.development", ".env.preview", ".env.production"];
+  const missing = [];
+  for (const file of envFiles) {
+    if (!existsSync(join(repoRoot, file))) {
+      missing.push(file);
+    }
+  }
+  return missing;
+}
+var depsInstallActor = fromPromise(
+  async ({ input }) => {
+    const startTime = Date.now();
+    const needed = needsDepsInstall(input.repoRoot);
+    if (!needed) {
+      return {
+        needed: false,
+        installed: false,
+        durationMs: Date.now() - startTime
+      };
+    }
+    console.log("  \u26A0\uFE0F  Dependencies outdated, running pnpm install...");
+    try {
+      execSync("pnpm install --frozen-lockfile", {
+        cwd: input.repoRoot,
+        stdio: input.verbose ? "inherit" : "pipe",
+        timeout: 3e5
+        // 5 minutes
+      });
+      return {
+        needed: true,
+        installed: true,
+        durationMs: Date.now() - startTime
+      };
+    } catch (_error) {
+      try {
+        execSync("pnpm install", {
+          cwd: input.repoRoot,
+          stdio: input.verbose ? "inherit" : "pipe",
+          timeout: 3e5
+        });
+        return {
+          needed: true,
+          installed: true,
+          durationMs: Date.now() - startTime
+        };
+      } catch (installError) {
+        return {
+          needed: true,
+          installed: false,
+          durationMs: Date.now() - startTime,
+          error: installError instanceof Error ? installError.message : "pnpm install failed"
+        };
+      }
+    }
+  }
+);
+var envCheckActor = fromPromise(
+  async ({ input }) => {
+    const missingFiles = checkEnvFiles(input.repoRoot);
+    if (missingFiles.length === 0) {
+      return {
+        configured: true,
+        missingFiles: []
+      };
+    }
+    const hasKeys = existsSync(join(input.repoRoot, ".env.keys"));
+    if (missingFiles.length > 0) {
+      const warning = hasKeys ? `Missing ${missingFiles.join(", ")}. Run 'runa env encrypt' to regenerate.` : `Missing ${missingFiles.join(", ")}. Run 'runa env pull' to configure.`;
+      console.log(`  \u26A0\uFE0F  ${warning}`);
+      return {
+        configured: false,
+        missingFiles,
+        warning
+      };
+    }
+    return {
+      configured: true,
+      missingFiles: []
+    };
+  }
+);
+var supabaseStartActor = fromPromise(
+  async ({ input }) => {
+    const { configured, running, portInUse, conflictingProject, actualPort } = checkSupabaseStatus(
+      input.repoRoot
+    );
+    if (!configured) {
+      return {
+        needed: false,
+        started: false,
+        alreadyRunning: false
+      };
+    }
+    if (running) {
+      return {
+        needed: true,
+        started: false,
+        alreadyRunning: true
+      };
+    }
+    if (portInUse) {
+      const portInfo = actualPort ? ` (port ${actualPort})` : "";
+      const warning = conflictingProject ? `Port${portInfo} in use by project '${conflictingProject}'. Run 'supabase stop --project-id ${conflictingProject}' first, or use --skip-db.` : `Port${portInfo} is already in use by another process. Stop the process or use --skip-db.`;
+      console.log(`  \u26A0\uFE0F  ${warning}`);
+      return {
+        needed: true,
+        started: false,
+        alreadyRunning: false,
+        warning
+      };
+    }
+    console.log("  \u26A0\uFE0F  Supabase not running, starting...");
+    try {
+      execSync("supabase start", {
+        cwd: input.repoRoot,
+        stdio: input.verbose ? "inherit" : "pipe",
+        timeout: 12e4
+        // 2 minutes
+      });
+      return {
+        needed: true,
+        started: true,
+        alreadyRunning: false
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "unknown error";
+      const portMatch = errorMsg.match(/supabase stop --project-id ([^\s]+)/);
+      if (portMatch) {
+        const project = portMatch[1];
+        const warning2 = `Port conflict with project '${project}'. Run 'supabase stop --project-id ${project}' first, or use --skip-db.`;
+        console.log(`  \u26A0\uFE0F  ${warning2}`);
+        return {
+          needed: true,
+          started: false,
+          alreadyRunning: false,
+          warning: warning2
+        };
+      }
+      const warning = `Supabase start failed. Run 'supabase start' manually.`;
+      console.log(`  \u26A0\uFE0F  ${warning}`);
+      return {
+        needed: true,
+        started: false,
+        alreadyRunning: false,
+        warning
+      };
+    }
+  }
+);
+
+// src/commands/build/guards.ts
+init_esm_shims();
+function shouldClean({ context }) {
+  return context.input.clean || context.input.fresh;
+}
+function shouldFresh({ context }) {
+  return context.input.fresh;
+}
+function shouldSkipForOnly({ context }, phase) {
+  const { only } = context.input;
+  if (!only || only.length === 0) return false;
+  return !only.includes(phase);
+}
+function shouldSkipTypes({ context }) {
+  return shouldSkipForOnly({ context }, "types");
+}
+function shouldSkipLint({ context }) {
+  return shouldSkipForOnly({ context }, "lint");
+}
+function shouldSkipBuild({ context }) {
+  return shouldSkipForOnly({ context }, "build");
+}
+function shouldSkipStaticAnalysis({ context }) {
+  return shouldSkipTypes({ context }) && shouldSkipLint({ context });
+}
+function shouldSkipDb({ context }) {
+  return context.input.skipDb || !context.hasDatabase || shouldSkipForOnly({ context }, "db");
+}
+function shouldSkipManifest({ context }) {
+  return context.input.skipManifest || !context.hasManifestTask || shouldSkipForOnly({ context }, "manifest");
+}
+function isDryRun({ context }) {
+  return context.input.check;
+}
+function shouldSkipSetup({ context }) {
+  return context.input.noSetup;
+}
+function isE2EMode({ context }) {
+  return context.input.e2e;
+}
+function detectDatabase(repoRoot) {
+  const configPath = path.join(repoRoot, "runa.config.ts");
+  if (!existsSync(configPath)) {
+    const jsConfigPath = path.join(repoRoot, "runa.config.js");
+    if (!existsSync(jsConfigPath)) {
+      return false;
+    }
+  }
+  const supabaseDir = path.join(repoRoot, "supabase");
+  if (existsSync(supabaseDir)) {
+    return true;
+  }
+  const databasePkg = path.join(repoRoot, "packages", "database");
+  if (existsSync(databasePkg)) {
+    return true;
+  }
+  return false;
+}
+function detectManifestTask(repoRoot) {
+  const runaConfigPath = path.join(repoRoot, "runa.config.ts");
+  if (existsSync(runaConfigPath)) {
+    return true;
+  }
+  const rootPkgPath = path.join(repoRoot, "package.json");
+  if (hasXStateDependency(rootPkgPath)) {
+    return true;
+  }
+  const appDirs = ["apps/web", "apps/app", "apps/dashboard", "app"];
+  for (const appDir of appDirs) {
+    const appPkgPath = path.join(repoRoot, appDir, "package.json");
+    if (hasXStateDependency(appPkgPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasXStateDependency(pkgPath) {
+  if (!existsSync(pkgPath)) {
+    return false;
+  }
+  try {
+    const content = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const allDeps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    return Boolean(
+      allDeps.xstate || allDeps["@xstate/react"] || allDeps["@runa-ai/runa-xstate-test-plugin"] || allDeps["@runa-ai/runa"]
+      // SDK includes XState support
+    );
+  } catch {
+    return false;
+  }
+}
+function detectTurbo(repoRoot) {
+  const turboJsonPath = path.join(repoRoot, "turbo.json");
+  return existsSync(turboJsonPath);
+}
+var guards = {
+  shouldClean,
+  shouldFresh,
+  shouldSkipTypes,
+  shouldSkipLint,
+  shouldSkipBuild,
+  shouldSkipStaticAnalysis,
+  shouldSkipDb,
+  shouldSkipManifest,
+  shouldSkipSetup,
+  isDryRun,
+  isE2EMode
+};
+
+export { checkSupabaseStatus, depsInstallActor, detectDatabase, detectManifestTask, detectTurbo, envCheckActor, guards, supabaseStartActor };

package/dist/chunk-IBVVGH6X.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);
+
+// src/internal/machines/snapshot-helpers.ts
+init_esm_shims();
+function getSnapshotStateName(snapshot) {
+  if (typeof snapshot.value === "string") {
+    return snapshot.value;
+  }
+  if (!snapshot.value || typeof snapshot.value !== "object") {
+    return "unknown";
+  }
+  const entries = Object.entries(snapshot.value);
+  if (entries.length === 0) {
+    return "unknown";
+  }
+  const [parent, child] = entries[0];
+  if (typeof child === "string") {
+    return `${parent}.${child}`;
+  }
+  return parent;
+}
+function isSnapshotComplete(snapshot) {
+  return snapshot.status === "done";
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export { getErrorMessage, getSnapshotStateName, isSnapshotComplete };

package/dist/chunk-II7VYQEM.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);
+
+// src/commands/ci/utils/env-security.ts
+init_esm_shims();
+var SENSITIVE_ENV_PATTERNS = [
+  // Database credentials
+  /^DATABASE_URL$/i,
+  /^DRIZZLE_.*URL$/i,
+  /^.*_DATABASE_URL$/i,
+  /^PGPASSWORD$/i,
+  // Supabase
+  /^SUPABASE_.*KEY$/i,
+  /^SUPABASE_.*TOKEN$/i,
+  /^SUPABASE_.*SECRET$/i,
+  /^SUPABASE_ACCESS_TOKEN$/i,
+  // GitHub
+  /^GITHUB_TOKEN$/i,
+  /^GH_TOKEN$/i,
+  /^GITHUB_PAT$/i,
+  // Generic secrets
+  /^.*_SECRET$/i,
+  /^.*_PASSWORD$/i,
+  /^.*_TOKEN$/i,
+  /^.*_API_KEY$/i,
+  /^.*_PRIVATE_KEY$/i,
+  /^.*_CREDENTIALS$/i,
+  // Encryption keys
+  /^DOTENV_PRIVATE_KEY.*$/i,
+  /^ENCRYPTION_KEY$/i,
+  // Cloud providers
+  /^AWS_SECRET_ACCESS_KEY$/i,
+  /^AZURE_.*_KEY$/i,
+  /^GCP_.*_KEY$/i,
+  // CI-specific secrets
+  /^RUNA_APP_API_TOKEN$/i,
+  /^VERCEL_TOKEN$/i
+];
+var SAFE_ENV_PASSTHROUGH = [
+  // Standard shell environment
+  "PATH",
+  "HOME",
+  "USER",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TMPDIR",
+  "TZ",
+  // Node.js
+  "NODE_ENV",
+  "NODE_PATH",
+  "NODE_OPTIONS",
+  "npm_config_registry",
+  // CI environment (non-sensitive)
+  "CI",
+  "GITHUB_ACTIONS",
+  "GITHUB_WORKFLOW",
+  "GITHUB_RUN_ID",
+  "GITHUB_RUN_NUMBER",
+  "GITHUB_JOB",
+  "GITHUB_ACTION",
+  "GITHUB_EVENT_NAME",
+  "GITHUB_EVENT_PATH",
+  "GITHUB_WORKSPACE",
+  "GITHUB_SHA",
+  "GITHUB_REF",
+  "GITHUB_REF_NAME",
+  "GITHUB_HEAD_REF",
+  "GITHUB_BASE_REF",
+  "GITHUB_ACTOR",
+  "GITHUB_REPOSITORY",
+  "GITHUB_REPOSITORY_OWNER",
+  "GITHUB_OUTPUT",
+  "GITHUB_STEP_SUMMARY",
+  "GITHUB_ENV",
+  "RUNNER_OS",
+  "RUNNER_ARCH",
+  "RUNNER_NAME",
+  "RUNNER_TOOL_CACHE",
+  "RUNNER_TEMP",
+  // Vercel (non-sensitive)
+  "VERCEL",
+  "VERCEL_ENV",
+  "VERCEL_URL",
+  "VERCEL_GIT_COMMIT_SHA",
+  "VERCEL_GIT_COMMIT_REF",
+  // Supabase (non-sensitive)
+  "NEXT_PUBLIC_SUPABASE_URL",
+  // runa debug/config (non-sensitive)
+  "RUNA_DEBUG",
+  "RUNA_SKIP_SCHEMA_RISK",
+  // dotenvx (non-sensitive)
+  "DOTENVX_QUIET"
+];
+function isSensitiveEnvVar(name) {
+  return SENSITIVE_ENV_PATTERNS.some((pattern) => pattern.test(name));
+}
+function getSafeEnv(additionalSafe = [], requiredSecrets = []) {
+  const result = {};
+  const allowedNames = /* @__PURE__ */ new Set([...SAFE_ENV_PASSTHROUGH, ...additionalSafe]);
+  for (const name of allowedNames) {
+    if (process.env[name] !== void 0) {
+      result[name] = process.env[name];
+    }
+  }
+  for (const name of requiredSecrets) {
+    if (process.env[name] !== void 0) {
+      result[name] = process.env[name];
+    }
+  }
+  return result;
+}
+function getFilteredEnv() {
+  const result = {};
+  for (const [name, value] of Object.entries(process.env)) {
+    if (!isSensitiveEnvVar(name)) {
+      result[name] = value;
+    }
+  }
+  return result;
+}
+var SECRET_VALUE_PATTERNS = [
+  // PostgreSQL URLs with passwords
+  {
+    pattern: /postgresql:\/\/([^/:@]+):([^@]+)@/gi,
+    replacement: "postgresql://$1:***@"
+  },
+  {
+    pattern: /postgres:\/\/([^/:@]+):([^@]+)@/gi,
+    replacement: "postgres://$1:***@"
+  },
+  // Generic URL with credentials
+  {
+    pattern: /https?:\/\/([^/:@]+):([^@]+)@/gi,
+    replacement: "https://$1:***@"
+  },
+  // Supabase keys (long base64-like strings)
+  {
+    pattern: /eyJ[A-Za-z0-9_-]{100,}/g,
+    replacement: "[SUPABASE_KEY_REDACTED]"
+  },
+  // GitHub tokens
+  {
+    pattern: /gh[ps]_[A-Za-z0-9_]{36,}/g,
+    replacement: "[GITHUB_TOKEN_REDACTED]"
+  },
+  {
+    pattern: /github_pat_[A-Za-z0-9_]{36,}/g,
+    replacement: "[GITHUB_PAT_REDACTED]"
+  },
+  // Generic API keys (32+ char alphanumeric)
+  {
+    pattern: /[A-Za-z0-9_-]{40,}/g,
+    replacement: (match) => {
+      if (/[a-z]/.test(match) && /[A-Z0-9_]/.test(match)) {
+        return `[KEY_REDACTED:${match.length}chars]`;
+      }
+      return match;
+    }
+  }
+];
+function redactSecrets(input) {
+  let result = input;
+  for (const { pattern, replacement } of SECRET_VALUE_PATTERNS) {
+    if (typeof replacement === "function") {
+      result = result.replace(pattern, replacement);
+    } else {
+      result = result.replace(pattern, replacement);
+    }
+  }
+  return result;
+}
+
+export { getFilteredEnv, getSafeEnv, redactSecrets };