@runa-ai/runa-cli 0.5.71 → 0.6.0

package/dist/prepare-32DOVHTE.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { CLIError, createCLILogger } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { execa } from 'execa';
+
+createRequire(import.meta.url);
+
+// src/commands/prepare/index.ts
+init_esm_shims();
+
+// src/commands/prepare/commands/prepare.ts
+init_esm_shims();
+function hasVercelAuth() {
+  return !!(process.env.VERCEL_TOKEN && process.env.VERCEL_PROJECT_ID);
+}
+function hasVercelLinked(cwd) {
+  return existsSync(resolve(cwd, ".vercel", "project.json"));
+}
+function hasDatabaseConfig(cwd) {
+  const supabasePath = resolve(cwd, "supabase");
+  const dbPackagePath = resolve(cwd, "packages", "database");
+  return existsSync(supabasePath) || existsSync(dbPackagePath);
+}
+function hasEnvDevelopment(cwd) {
+  return existsSync(resolve(cwd, ".env.development"));
+}
+async function runEnvPull(cwd, logger, dryRun) {
+  if (hasEnvDevelopment(cwd)) {
+    return {
+      step: "env-pull",
+      status: "skipped",
+      message: ".env.development already exists"
+    };
+  }
+  const canPull = hasVercelAuth() || hasVercelLinked(cwd);
+  if (!canPull) {
+    return {
+      step: "env-pull",
+      status: "skipped",
+      message: "No Vercel auth (set VERCEL_TOKEN + VERCEL_PROJECT_ID or run vercel link)"
+    };
+  }
+  if (dryRun) {
+    return {
+      step: "env-pull",
+      status: "ok",
+      message: "Would run: runa env pull"
+    };
+  }
+  logger.info("Pulling environment variables from Vercel...");
+  try {
+    await execa("runa", ["env", "pull"], {
+      cwd,
+      stdio: "inherit"
+    });
+    return {
+      step: "env-pull",
+      status: "ok",
+      message: "Environment variables pulled and encrypted"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      step: "env-pull",
+      status: "failed",
+      message: `Failed to pull env: ${message}`
+    };
+  }
+}
+async function runDbSync(cwd, logger, dryRun) {
+  if (!hasDatabaseConfig(cwd)) {
+    return {
+      step: "db-sync",
+      status: "skipped",
+      message: "No database configuration found"
+    };
+  }
+  if (dryRun) {
+    return {
+      step: "db-sync",
+      status: "ok",
+      message: "Would run: runa db sync"
+    };
+  }
+  logger.info("Syncing database schema...");
+  try {
+    await execa("runa", ["db", "sync"], {
+      cwd,
+      stdio: "inherit"
+    });
+    return {
+      step: "db-sync",
+      status: "ok",
+      message: "Database schema synced"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      step: "db-sync",
+      status: "failed",
+      message: `Failed to sync DB: ${message}`
+    };
+  }
+}
+async function runBuild(cwd, logger, dryRun) {
+  if (dryRun) {
+    return {
+      step: "build",
+      status: "ok",
+      message: "Would run: turbo build"
+    };
+  }
+  logger.info("Building project...");
+  try {
+    await execa("turbo", ["build"], {
+      cwd,
+      stdio: "inherit"
+    });
+    return {
+      step: "build",
+      status: "ok",
+      message: "Build completed"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return {
+      step: "build",
+      status: "failed",
+      message: `Build failed: ${message}`
+    };
+  }
+}
+async function runCheck(cwd, logger, dryRun) {
+  if (dryRun) {
+    return {
+      step: "check",
+      status: "ok",
+      message: "Would run: runa check run --scope build --fix"
+    };
+  }
+  logger.info("Running environment checks...");
+  try {
+    await execa("runa", ["check", "run", "--scope", "build", "--fix"], {
+      cwd,
+      stdio: "inherit"
+    });
+    return {
+      step: "check",
+      status: "ok",
+      message: "Environment checks passed"
+    };
+  } catch {
+    return {
+      step: "check",
+      status: "ok",
+      message: "Environment checks completed (some warnings may exist)"
+    };
+  }
+}
+async function runPrepareAction(options) {
+  const logger = createCLILogger("prepare");
+  const cwd = process.cwd();
+  const dryRun = options.check ?? false;
+  logger.section("runa prepare");
+  logger.info(`Working directory: ${cwd}`);
+  if (dryRun) {
+    logger.info("Dry-run mode: showing what would be done");
+  }
+  logger.info("");
+  logger.info("Auth detection:");
+  logger.info(`  VERCEL_TOKEN: ${process.env.VERCEL_TOKEN ? "\u2713" : "\u2717"}`);
+  logger.info(`  VERCEL_PROJECT_ID: ${process.env.VERCEL_PROJECT_ID ? "\u2713" : "\u2717"}`);
+  logger.info(`  GH_TOKEN: ${process.env.GH_TOKEN || process.env.GITHUB_TOKEN ? "\u2713" : "\u2717"}`);
+  logger.info(`  .vercel/project.json: ${hasVercelLinked(cwd) ? "\u2713" : "\u2717"}`);
+  logger.info("");
+  const results = [];
+  logger.section("Step 1: Environment Check");
+  const checkResult = await runCheck(cwd, logger, dryRun);
+  results.push(checkResult);
+  logStepResult(logger, checkResult);
+  logger.section("Step 2: Environment Variables");
+  const envResult = await runEnvPull(cwd, logger, dryRun);
+  results.push(envResult);
+  logStepResult(logger, envResult);
+  logger.section("Step 3: Database Sync");
+  const dbResult = await runDbSync(cwd, logger, dryRun);
+  results.push(dbResult);
+  logStepResult(logger, dbResult);
+  if (options.build) {
+    logger.section("Step 4: Build");
+    const buildResult = await runBuild(cwd, logger, dryRun);
+    results.push(buildResult);
+    logStepResult(logger, buildResult);
+  }
+  logger.section("Summary");
+  const okCount = results.filter((r) => r.status === "ok").length;
+  const skippedCount = results.filter((r) => r.status === "skipped").length;
+  const failedCount = results.filter((r) => r.status === "failed").length;
+  logger.info(`  \u2713 Completed: ${okCount}`);
+  logger.info(`  \u2298 Skipped: ${skippedCount}`);
+  if (failedCount > 0) {
+    logger.warn(`  \u2717 Failed: ${failedCount}`);
+  }
+  if (failedCount > 0) {
+    logger.info("");
+    logger.warn("Some steps failed. Review the output above for details.");
+    process.exitCode = 1;
+  } else {
+    logger.info("");
+    logger.success("Preparation complete! Your development environment is ready.");
+    if (!options.build) {
+      logger.info("");
+      logger.info("Next steps:");
+      logger.info("  runa build    # Build the project");
+      logger.info("  pnpm dev      # Start development server");
+    }
+  }
+}
+function logStepResult(logger, result) {
+  switch (result.status) {
+    case "ok":
+      logger.success(`  \u2713 ${result.step}: ${result.message}`);
+      break;
+    case "skipped":
+      logger.info(`  \u2298 ${result.step}: ${result.message}`);
+      break;
+    case "failed":
+      logger.error(`  \u2717 ${result.step}: ${result.message}`);
+      break;
+  }
+}
+var prepareCommand = new Command("prepare").description("Prepare local development environment (Developer command, no auth required)").option("--build", "Include build step").option("--check", "Dry-run mode (show what would be done)").option("--verbose", "Show detailed output").action(async (options) => {
+  try {
+    await runPrepareAction(options);
+  } catch (error) {
+    if (error instanceof CLIError) throw error;
+    throw new CLIError(
+      error instanceof Error ? error.message : "Preparation failed",
+      "PREPARE_FAILED",
+      ["Check the output above for details", "Run: runa check run --verbose for more info"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+
+export { prepareCommand };

package/dist/risk-detector-BXUY2WKS.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+export { categorizeRisks, detectSchemaRisks } from './chunk-22CS6EMA.js';
+import './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);

package/dist/risk-detector-core-O7I7SPR7.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { maskWrapperFunctions, stripSqlCommentsPreserveLines, stripSqlStringsPreserveLines, buildLineStarts, detectRisksFromContent, lineNumberFromIndex, QUALIFIED_IDENTIFIER } from './chunk-3FDQW524.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, statSync } from 'fs';
+import { readFile } from 'fs/promises';
+
+createRequire(import.meta.url);
+
+// src/validators/risk-detector-core.ts
+init_esm_shims();
+var RE_FK_REFERENCES = new RegExp(`\\bREFERENCES\\s+${QUALIFIED_IDENTIFIER}\\s*\\(`, "gi");
+function getRiskConfidenceWeight(confidence) {
+  return RISK_CONFIDENCE_WEIGHT[confidence];
+}
+var RISK_SEVERITY_WEIGHT = {
+  high: 3,
+  medium: 2,
+  low: 1
+};
+var RISK_CONFIDENCE_WEIGHT = {
+  high: 3,
+  medium: 2,
+  low: 1
+};
+var ONE_MB = 1024 * 1024;
+var DEFAULT_SCHEMA_RISK_SCAN_LIMIT_BYTES = 8 * ONE_MB;
+var MIN_SCHEMA_RISK_SCAN_LIMIT_BYTES = 256 * 1024;
+var MAX_SCHEMA_RISK_SCAN_LIMIT_BYTES = 50 * ONE_MB;
+var MAX_SCHEMA_RISK_ANALYSIS_BYTES = Math.max(
+  MIN_SCHEMA_RISK_SCAN_LIMIT_BYTES,
+  Math.min(
+    MAX_SCHEMA_RISK_SCAN_LIMIT_BYTES,
+    Number.parseInt(process.env.RUNA_RISK_DETECT_MAX_BYTES ?? "", 10) || DEFAULT_SCHEMA_RISK_SCAN_LIMIT_BYTES
+  )
+);
+var SCAN_ABORT_REASON_CODE = "SCHEMA_SCAN_TOO_LARGE";
+var plpgsqlModulePromise = null;
+async function loadPlpgsqlRiskDetectorModule() {
+  if (!plpgsqlModulePromise) {
+    plpgsqlModulePromise = import('./risk-detector-plpgsql-SGMVKYJP.js').catch((error) => {
+      plpgsqlModulePromise = null;
+      throw error;
+    });
+  }
+  return plpgsqlModulePromise;
+}
+function makeSchemaScanLimitError(filePath, sizeBytes, limitBytes) {
+  return {
+    level: "high",
+    description: "UNRESOLVED_SCHEMA_RISK_SCAN: schema file exceeds static risk analysis size limit",
+    mitigation: "Split and simplify schema definitions in this file, or validate manually in production-apply precheck scope",
+    line: 1,
+    reasonCode: SCAN_ABORT_REASON_CODE,
+    confidence: "high",
+    evidence: {
+      source: "detectSchemaRisks",
+      detail: `Static risk scan skipped for ${filePath}: size ${sizeBytes} bytes exceeds limit ${limitBytes} bytes`
+    }
+  };
+}
+function detectForeignKeyRisks(searchableContent, originalContent, lineStarts) {
+  const risks = [];
+  RE_FK_REFERENCES.lastIndex = 0;
+  for (const match of searchableContent.matchAll(RE_FK_REFERENCES)) {
+    risks.push({
+      level: "low",
+      description: "Foreign key columns should have indexes",
+      mitigation: "Add index on foreign key column for better performance",
+      reasonCode: "LOW_RISK_FOREIGN_KEY_INDEX_HINT",
+      confidence: "high",
+      evidence: {
+        source: "detectForeignKeyRisks",
+        snippet: searchableContent.slice(
+          Math.max(0, (match.index ?? 0) - 20),
+          (match.index ?? 0) + 80
+        ),
+        detail: "REFERENCES token matched in FK definition"
+      },
+      line: lineNumberFromIndex(originalContent, match.index ?? 0, lineStarts)
+    });
+  }
+  return risks;
+}
+async function detectSchemaRisks(filePath) {
+  try {
+    if (!existsSync(filePath)) {
+      return [];
+    }
+    const fileSizeBytes = statSync(filePath).size;
+    if (fileSizeBytes > MAX_SCHEMA_RISK_ANALYSIS_BYTES) {
+      return [makeSchemaScanLimitError(filePath, fileSizeBytes, MAX_SCHEMA_RISK_ANALYSIS_BYTES)];
+    }
+    const content = await readFile(filePath, "utf-8");
+    const maskedContent = maskWrapperFunctions(content);
+    const commentStripped = stripSqlCommentsPreserveLines(maskedContent);
+    const searchableContent = stripSqlStringsPreserveLines(commentStripped);
+    const contentLineStarts = buildLineStarts(content);
+    const contentRisks = detectRisksFromContent(searchableContent, content, contentLineStarts);
+    const { detectPlpgsqlDynamicExecutionRisks } = await loadPlpgsqlRiskDetectorModule();
+    const plpgsqlRisks = detectPlpgsqlDynamicExecutionRisks(content);
+    const fkRisks = detectForeignKeyRisks(searchableContent, content, contentLineStarts);
+    const risks = deduplicateSchemaRisksBySeverity([...contentRisks, ...plpgsqlRisks, ...fkRisks]);
+    return risks;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown parse error";
+    return [
+      {
+        level: "high",
+        description: "UNRESOLVED_SCHEMA_RISK_SCAN: failed to analyze SQL for schema risks",
+        mitigation: "Fix the schema file syntax/structure so risk scanning can classify statements safely",
+        line: 1,
+        reasonCode: "SCHEMA_SCAN_FAILURE",
+        confidence: "high",
+        evidence: {
+          source: "detectSchemaRisks",
+          detail: `Read failed for ${filePath}: ${message}`
+        }
+      },
+      {
+        level: "high",
+        description: `Risk scan error details: ${message}`,
+        mitigation: "Inspect schema file and rerun schema risk precheck",
+        line: 1,
+        reasonCode: "SCHEMA_SCAN_ERROR_DETAILS",
+        confidence: "high",
+        evidence: {
+          source: "detectSchemaRisks",
+          detail: message
+        }
+      }
+    ];
+  }
+}
+function deduplicateSchemaRisksBySeverity(risks) {
+  const byLocationAndDescription = /* @__PURE__ */ new Map();
+  for (const risk of risks) {
+    const line = risk.line ?? 0;
+    const key = `${risk.description}@@${line}`;
+    const existing = byLocationAndDescription.get(key);
+    const riskConfidence = getRiskConfidenceWeight(risk.confidence ?? "low");
+    const existingConfidence = getRiskConfidenceWeight(existing?.confidence ?? "low");
+    if (!existing || RISK_SEVERITY_WEIGHT[risk.level] > RISK_SEVERITY_WEIGHT[existing.level] || RISK_SEVERITY_WEIGHT[risk.level] === RISK_SEVERITY_WEIGHT[existing.level] && riskConfidence > existingConfidence) {
+      byLocationAndDescription.set(key, risk);
+    }
+  }
+  return [...byLocationAndDescription.values()].sort((left, right) => {
+    const leftLine = left.line ?? 0;
+    const rightLine = right.line ?? 0;
+    if (leftLine !== rightLine) return leftLine - rightLine;
+    const leftWeight = RISK_SEVERITY_WEIGHT[left.level];
+    const rightWeight = RISK_SEVERITY_WEIGHT[right.level];
+    if (leftWeight !== rightWeight) return rightWeight - leftWeight;
+    const leftConfidence = getRiskConfidenceWeight(left.confidence ?? "low");
+    const rightConfidence = getRiskConfidenceWeight(right.confidence ?? "low");
+    if (leftConfidence !== rightConfidence) return rightConfidence - leftConfidence;
+    const leftReasonCode = left.reasonCode ?? "";
+    const rightReasonCode = right.reasonCode ?? "";
+    if (leftReasonCode !== rightReasonCode) {
+      return leftReasonCode.localeCompare(rightReasonCode);
+    }
+    return left.description.localeCompare(right.description);
+  });
+}
+
+export { detectSchemaRisks };