@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/cache-N7WNPEYF.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
+import './chunk-WJXC4MVY.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { cacheClear, CacheClearOutputSchema, cachePrune, CachePruneOutputSchema, cacheStats, CacheStatsOutputSchema, cacheList, CacheListOutputSchema, cacheInvalidate, CacheInvalidateOutputSchema } from '@runa-ai/runa/cache';
+import { createCLILogger, CLIError } from '@runa-ai/runa/cli-runtime';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/cache.ts
+init_esm_shims();
+var logger = createCLILogger("cache");
+var cacheClearCommand = new Command("clear").description("Clear all caches").option("--namespace <name>", "Clear specific cache namespace").action(async (options) => {
+  try {
+    logger.section("Cache Clearing");
+    const output = await cacheClear({
+      namespace: options.namespace ? String(options.namespace) : void 0
+    });
+    emitJsonSuccess(cacheClearCommand, CacheClearOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to clear cache",
+      "CACHE_CLEAR_ERROR",
+      ["Check cache directory permissions"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cachePruneCommand = new Command("prune").description("Remove expired cache entries").option("--namespace <name>", "Prune specific cache namespace").action(async (options) => {
+  try {
+    logger.section("Cache Pruning");
+    const output = await cachePrune({
+      namespace: options.namespace ? String(options.namespace) : void 0
+    });
+    emitJsonSuccess(cachePruneCommand, CachePruneOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to prune cache",
+      "CACHE_PRUNE_ERROR",
+      ["Check cache directory exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheStatsCommand = new Command("stats").description("Show cache statistics").option("--namespace <name>", "Show stats for specific namespace").action(async (options) => {
+  try {
+    logger.section("Cache Statistics");
+    const output = await cacheStats({
+      namespace: options.namespace ? String(options.namespace) : void 0
+    });
+    emitJsonSuccess(cacheStatsCommand, CacheStatsOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to get cache stats",
+      "CACHE_STATS_ERROR",
+      ["Check cache directory exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheListCommand = new Command("list").description("List cache namespaces").action(async () => {
+  try {
+    logger.section("Cache Namespaces");
+    const output = await cacheList({});
+    emitJsonSuccess(cacheListCommand, CacheListOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to list caches",
+      "CACHE_LIST_ERROR",
+      ["Check cache directory exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheInvalidateCommand = new Command("invalidate").description("Invalidate caches based on file changes").option("--pattern <glob>", "File pattern to watch for changes").action(async (options) => {
+  try {
+    logger.section("Cache Invalidation");
+    const output = await cacheInvalidate({
+      pattern: options.pattern ? String(options.pattern) : void 0
+    });
+    emitJsonSuccess(cacheInvalidateCommand, CacheInvalidateOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to invalidate cache",
+      "CACHE_INVALIDATE_ERROR",
+      ["Check file patterns", "Verify cache exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheCommand = new Command("cache").description("Manage CLI cache").addCommand(cacheClearCommand).addCommand(cachePruneCommand).addCommand(cacheStatsCommand).addCommand(cacheListCommand).addCommand(cacheInvalidateCommand);
+
+export { cacheClearCommand, cacheCommand, cacheInvalidateCommand, cacheListCommand, cachePruneCommand, cacheStatsCommand };

package/dist/check-LOMVIRHX.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+export { checkCommand, runCheckCommand } from './chunk-QM53IQHM.js';
+import './chunk-644FVGIQ.js';
+import './chunk-DRSUEMAK.js';
+import './chunk-KE6QJBZG.js';
+import './chunk-WJXC4MVY.js';
+import './chunk-HKUWEGUX.js';
+import './chunk-JMJP4A47.js';
+import './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);

package/dist/chunk-2APB25TT.js

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { runLogged } from './chunk-6FAU4IGR.js';
+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 path2, { join } from 'path';
+import { fromPromise } from 'xstate';
+import { mkdir } from 'fs/promises';
+
+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/actors/manifest.ts
+init_esm_shims();
+var manifestActor = fromPromise(
+  async ({ input }) => {
+    const { repoRoot, tmpDir, env = process.env } = input;
+    const startTime = Date.now();
+    try {
+      const fullTmpDir = path2.join(repoRoot, tmpDir);
+      await mkdir(fullTmpDir, { recursive: true });
+      await runLogged({
+        cwd: repoRoot,
+        env,
+        label: "manifest",
+        command: "pnpm",
+        args: ["exec", "runa", "manifest"],
+        logFile: path2.join(fullTmpDir, "manifest.log")
+      });
+      return {
+        passed: true,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        passed: false,
+        durationMs: Date.now() - startTime,
+        error: `Manifest generation failed: ${errorMessage}. Run 'runa manifest --verbose' for details.`
+      };
+    }
+  }
+);
+
+// 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 = path2.join(repoRoot, "runa.config.ts");
+  if (!existsSync(configPath)) {
+    const jsConfigPath = path2.join(repoRoot, "runa.config.js");
+    if (!existsSync(jsConfigPath)) {
+      return false;
+    }
+  }
+  const supabaseDir = path2.join(repoRoot, "supabase");
+  if (existsSync(supabaseDir)) {
+    return true;
+  }
+  const databasePkg = path2.join(repoRoot, "packages", "database");
+  if (existsSync(databasePkg)) {
+    return true;
+  }
+  return false;
+}
+function detectManifestTask(repoRoot) {
+  const runaConfigPath = path2.join(repoRoot, "runa.config.ts");
+  if (existsSync(runaConfigPath)) {
+    return true;
+  }
+  const rootPkgPath = path2.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 = path2.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 = path2.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, manifestActor, supabaseStartActor };