@runa-ai/runa-cli 0.5.71 → 0.6.0

package/dist/chunk-M47WJJVS.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, writeFileSync, unlinkSync, readFileSync } from 'fs';
+import path from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/env-local-bridge.ts
+init_esm_shims();
+var DEFAULT_API_PORT = 54321;
+var DEFAULT_DB_PORT = 54322;
+var RUNA_ENV_LOCAL_MARKER = "# RUNA_AUTO_GENERATED \u2014 do not edit (created by `runa db start`)";
+function envLocalPath(projectRoot) {
+  return path.join(projectRoot, ".env.local");
+}
+function isNonDefaultPorts(config) {
+  return config.api !== DEFAULT_API_PORT || config.db !== DEFAULT_DB_PORT;
+}
+function buildEnvLocalContent(config) {
+  const dbUrl = `postgresql://postgres:postgres@${config.host}:${config.db}/postgres`;
+  return [
+    RUNA_ENV_LOCAL_MARKER,
+    `# Supabase is running on non-default ports (default: api=${DEFAULT_API_PORT}, db=${DEFAULT_DB_PORT}).`,
+    "# This file overrides .env.development so that `pnpm dev` uses correct ports.",
+    "# Removed automatically by `runa db stop`. Safe to delete manually.",
+    `DATABASE_URL=${dbUrl}`,
+    `DATABASE_URL_ADMIN=${dbUrl}`,
+    `DATABASE_URL_SERVICE=${dbUrl}`,
+    `NEXT_PUBLIC_SUPABASE_URL=http://${config.host}:${config.api}`,
+    ""
+  ].join("\n");
+}
+function isRunaManagedEnvLocal(projectRoot) {
+  const filePath = envLocalPath(projectRoot);
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return content.startsWith(RUNA_ENV_LOCAL_MARKER);
+  } catch {
+    return false;
+  }
+}
+function writeEnvLocalBridge(projectRoot, config) {
+  const filePath = envLocalPath(projectRoot);
+  const fileExists = existsSync(filePath);
+  if (isNonDefaultPorts(config)) {
+    if (fileExists && !isRunaManagedEnvLocal(projectRoot)) {
+      return { written: false, reason: "user-managed" };
+    }
+    writeFileSync(filePath, buildEnvLocalContent(config), "utf-8");
+    return { written: true, ports: { api: config.api, db: config.db } };
+  }
+  if (fileExists && isRunaManagedEnvLocal(projectRoot)) {
+    unlinkSync(filePath);
+    return { written: false, reason: "stale-removed" };
+  }
+  return { written: false, reason: "default-ports" };
+}
+function removeEnvLocalBridge(projectRoot) {
+  const filePath = envLocalPath(projectRoot);
+  if (!existsSync(filePath)) {
+    return { removed: false, reason: "not-found" };
+  }
+  if (!isRunaManagedEnvLocal(projectRoot)) {
+    return { removed: false, reason: "user-managed" };
+  }
+  unlinkSync(filePath);
+  return { removed: true };
+}
+
+export { removeEnvLocalBridge, writeEnvLocalBridge };

package/dist/chunk-MNPMZERI.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { findWorkspaceRoot } from './chunk-JMJP4A47.js';
+import { validateEnvSuffix, isPathContained, MAX_DIRECTORY_TRAVERSAL_DEPTH } from './chunk-DRSUEMAK.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { config } from '@dotenvx/dotenvx';
+import { parse } from 'dotenv';
+import { expand } from 'dotenv-expand';
+
+createRequire(import.meta.url);
+
+// src/config/env-files.ts
+init_esm_shims();
+process.env.DOTENVX_QUIET = "true";
+function isSupportedNodeEnv(value) {
+  if (typeof value !== "string") return false;
+  return value === "development" || value === "production" || value === "test";
+}
+function findProjectRoot(from) {
+  const workspaceRoot = findWorkspaceRoot(from);
+  if (workspaceRoot) return workspaceRoot;
+  let current = path.resolve(from);
+  const root = path.parse(current).root;
+  let depth = 0;
+  while (current !== root && depth < MAX_DIRECTORY_TRAVERSAL_DEPTH) {
+    const hasGit = existsSync(path.join(current, ".git"));
+    const hasPackageJson = existsSync(path.join(current, "package.json"));
+    if (hasGit || hasPackageJson) return current;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+    depth++;
+  }
+  return path.resolve(from);
+}
+function mapRunaEnvToVercelEnv(runaEnv) {
+  if (runaEnv === "preview") return "preview";
+  if (runaEnv === "main" || runaEnv === "production") return "production";
+  return "development";
+}
+function inferVercelEnv(params) {
+  if (params.runaEnv) return mapRunaEnvToVercelEnv(params.runaEnv);
+  if (params.nodeEnv === "production") return "production";
+  return "development";
+}
+function loadEnvFileIntoTarget(params) {
+  if (!existsSync(params.filePath)) return false;
+  const raw = readFileSync(params.filePath, "utf-8");
+  const parsed = parse(raw);
+  const parsedKeys = new Set(Object.keys(parsed));
+  const processEnv = Object.fromEntries(
+    Object.entries(params.targetEnv).filter((entry) => {
+      const [key, value] = entry;
+      if (parsedKeys.has(key)) return false;
+      return typeof value === "string";
+    })
+  );
+  const expanded = expand({
+    parsed,
+    processEnv
+  });
+  const finalParsed = expanded.parsed ?? parsed;
+  for (const [key, value] of Object.entries(finalParsed)) {
+    if (params.protectedKeys.has(key)) continue;
+    params.targetEnv[key] = value;
+  }
+  return true;
+}
+function loadEnvFiles(options = {}) {
+  const protectedKeys = new Set(Object.keys(process.env));
+  const cwd = options.cwd ?? process.cwd();
+  const nodeEnv = resolveNodeEnv(options.nodeEnv);
+  const projectRoot = findProjectRoot(cwd);
+  const vercelEnv = options.vercelEnv ?? inferVercelEnv({ nodeEnv, runaEnv: options.runaEnv });
+  const keysFile = path.join(projectRoot, ".env.keys");
+  const baseFilePaths = buildBaseEnvFilePaths({ nodeEnv, vercelEnv });
+  const runaFilePaths = options.runaEnv ? buildRunaEnvFilePaths(options.runaEnv) : [];
+  const allRelPaths = [...baseFilePaths, ...runaFilePaths];
+  const hasEncryptedFiles = existsSync(keysFile);
+  let loadedFiles;
+  if (hasEncryptedFiles) {
+    const reversedRelPaths = [...allRelPaths].reverse();
+    const filePaths = [
+      keysFile,
+      // Load keys first (needed for decryption)
+      ...reversedRelPaths.map((rel) => path.join(projectRoot, rel)).filter(existsSync)
+    ];
+    config({
+      path: filePaths,
+      override: false,
+      // Don't override existing process.env values
+      quiet: true
+      // Suppress dotenvx verbose output
+    });
+    loadedFiles = allRelPaths.filter((rel) => existsSync(path.join(projectRoot, rel)));
+  } else {
+    const targetEnv = { ...process.env };
+    loadedFiles = [
+      ...loadEnvFilesIntoTarget({
+        projectRoot,
+        relPaths: baseFilePaths,
+        targetEnv,
+        protectedKeys
+      }),
+      ...loadEnvFilesIntoTarget({
+        projectRoot,
+        relPaths: runaFilePaths,
+        targetEnv,
+        protectedKeys
+      })
+    ];
+    applyTargetEnvToProcessEnv({ targetEnv, protectedKeys });
+  }
+  if (options.runaEnv === "local") {
+    const localExcludedKeys = ["DATABASE_URL", "DATABASE_URL_ADMIN", "DATABASE_URL_SERVICE"];
+    for (const key of localExcludedKeys) {
+      delete process.env[key];
+    }
+  }
+  if (!options.silent && loadedFiles.length > 0) {
+    process.stderr.write(`\u2705 Loaded env files: ${loadedFiles.join(", ")}
+`);
+    process.stderr.write(`   Project root: ${projectRoot}
+`);
+    process.stderr.write(`   NODE_ENV: ${nodeEnv}
+`);
+    process.stderr.write(`   Vercel env: ${vercelEnv}
+`);
+    if (hasEncryptedFiles) {
+      process.stderr.write("   \u{1F513} Auto-decrypted with .env.keys\n");
+    }
+    if (options.runaEnv === "local") {
+      process.stderr.write("   \u{1F3E0} Local mode: DATABASE_URL excluded (using local Supabase)\n");
+    }
+  }
+  return { projectRoot, loadedFiles };
+}
+function resolveNodeEnv(requested) {
+  if (isSupportedNodeEnv(requested)) return requested;
+  if (isSupportedNodeEnv(process.env.NODE_ENV)) return process.env.NODE_ENV;
+  return "development";
+}
+function buildBaseEnvFilePaths(params) {
+  validateEnvSuffix(params.nodeEnv);
+  validateEnvSuffix(params.vercelEnv);
+  const baseFiles = [
+    ".env",
+    // Vercel-aligned: .env.{environment} (3 files = 3 keys)
+    `.env.${params.vercelEnv}`,
+    `.env.${params.nodeEnv}`
+  ];
+  baseFiles.push(`.vercel/.env.${params.vercelEnv}.local`);
+  const includeDotEnvLocal = params.nodeEnv !== "test";
+  if (includeDotEnvLocal) baseFiles.push(".env.local");
+  baseFiles.push(".env.personal");
+  baseFiles.push(`.env.${params.nodeEnv}.local`);
+  return baseFiles;
+}
+function buildRunaEnvFilePaths(runaEnv) {
+  validateEnvSuffix(runaEnv);
+  const runaFiles = [`.env.${runaEnv}`, `.env.${runaEnv}.local`];
+  if (runaEnv === "main" || runaEnv === "production") {
+    runaFiles.push(".env.production", ".env.production.local");
+  }
+  return runaFiles;
+}
+function loadEnvFilesIntoTarget(params) {
+  const loadedFiles = [];
+  for (const relPath of params.relPaths) {
+    const fullPath = path.join(params.projectRoot, relPath);
+    const resolvedPath = path.resolve(fullPath);
+    if (!isPathContained(params.projectRoot, resolvedPath)) {
+      continue;
+    }
+    const loaded = loadEnvFileIntoTarget({
+      filePath: resolvedPath,
+      targetEnv: params.targetEnv,
+      protectedKeys: params.protectedKeys
+    });
+    if (loaded) loadedFiles.push(relPath);
+  }
+  return loadedFiles;
+}
+function applyTargetEnvToProcessEnv(params) {
+  for (const [key, value] of Object.entries(params.targetEnv)) {
+    if (value === void 0) continue;
+    if (params.protectedKeys.has(key)) continue;
+    process.env[key] = value;
+  }
+}
+
+export { loadEnvFiles };

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 };