@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/chunk-5NKWR4FF.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { findPackage, findWorkspaceRoot } from './chunk-JMJP4A47.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync } from 'fs';
+import path, { join } from 'path';
+import { loadRunaConfigOrThrow } from '@runa-ai/runa';
+
+createRequire(import.meta.url);
+
+// src/utils/config-loader.ts
+init_esm_shims();
+function getDefaultDrizzlePaths(isMonorepo2) {
+  if (!isMonorepo2) {
+    return { schemaPath: "src/schema", outputPath: "src/zod" };
+  }
+  const workspaceRoot = findWorkspaceRoot(process.cwd()) || process.cwd();
+  const databaseSchemaDir = join(workspaceRoot, "packages", "database", "src", "schema");
+  if (existsSync(databaseSchemaDir)) {
+    return {
+      schemaPath: "packages/database/src/schema",
+      outputPath: "packages/database/src/zod"
+    };
+  }
+  return {
+    schemaPath: "packages/db/src/schema",
+    outputPath: "packages/db/src/zod"
+  };
+}
+var _configCache = /* @__PURE__ */ new Map();
+function loadRunaConfig(cwd = process.cwd()) {
+  const cached = _configCache.get(cwd);
+  if (cached) return cached;
+  const config = loadRunaConfigOrThrow(cwd).config;
+  _configCache.set(cwd, config);
+  return config;
+}
+function getDatabaseConfig(config) {
+  const dbConfig = config.database;
+  if (!dbConfig) {
+    const defaults = getDefaultDrizzlePaths(config.project.monorepo ?? false);
+    return {
+      type: "supabase",
+      schemaPath: defaults.schemaPath,
+      outputPath: defaults.outputPath
+    };
+  }
+  if (dbConfig.type === "supabase" || dbConfig.type === void 0) {
+    const defaults = getDefaultDrizzlePaths(config.project.monorepo ?? false);
+    return {
+      type: "supabase",
+      schemaPath: dbConfig.drizzle?.schemaPath || defaults.schemaPath,
+      outputPath: dbConfig.drizzle?.outputPath || defaults.outputPath
+    };
+  }
+  return {
+    type: "none",
+    schemaPath: "",
+    outputPath: ""
+  };
+}
+function getAppConfig(config) {
+  return {
+    directory: config.app?.directory || ".",
+    framework: config.app?.framework || "next"
+  };
+}
+function getDeployConfig(config) {
+  const preview = config.deploy?.environments?.preview || "preview";
+  const production = config.deploy?.environments?.production || "production";
+  return {
+    provider: config.deploy?.provider || "vercel",
+    environments: {
+      preview,
+      production
+    }
+  };
+}
+function isMonorepo(config) {
+  return config.project.monorepo ?? false;
+}
+function validateProjectName(config, errors) {
+  if (!config.project.name) {
+    errors.push("project.name is required");
+  }
+}
+function validateFramework(config, errors) {
+  if (config.app?.framework) {
+    const validFrameworks = ["next", "vite", "remix"];
+    if (!validFrameworks.includes(config.app.framework)) {
+      errors.push(
+        `app.framework must be one of: ${validFrameworks.join(", ")} (got: ${config.app.framework})`
+      );
+    }
+  }
+}
+function validateDeploymentProvider(config, errors) {
+  if (config.deploy?.provider) {
+    const validProviders = ["vercel", "cloudflare", "amplify", "none"];
+    if (!validProviders.includes(config.deploy.provider)) {
+      errors.push(
+        `deploy.provider must be one of: ${validProviders.join(", ")} (got: ${config.deploy.provider})`
+      );
+    }
+  }
+}
+function validateDatabaseType(config, errors) {
+  if (config.database?.type) {
+    const validTypes = ["supabase", "none"];
+    if (!validTypes.includes(config.database.type)) {
+      errors.push(
+        `database.type must be one of: ${validTypes.join(", ")} (got: ${config.database.type})`
+      );
+    }
+  }
+}
+function validateDrizzleConfig(config, errors) {
+  if (config.database?.drizzle) {
+    if (config.database.drizzle.schemaPath && !config.database.drizzle.schemaPath.trim()) {
+      errors.push("database.drizzle.schemaPath cannot be empty");
+    }
+    if (config.database.drizzle.outputPath && !config.database.drizzle.outputPath.trim()) {
+      errors.push("database.drizzle.outputPath cannot be empty");
+    }
+  }
+}
+function validateAppDirectory(config, errors) {
+  if (config.app?.directory && !config.app.directory.trim()) {
+    errors.push("app.directory cannot be empty");
+  }
+}
+function validateRunaConfig(config) {
+  const errors = [];
+  validateProjectName(config, errors);
+  validateFramework(config, errors);
+  validateDeploymentProvider(config, errors);
+  validateDatabaseType(config, errors);
+  validateDrizzleConfig(config, errors);
+  validateAppDirectory(config, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function hasValidDatabaseIndicators(dir) {
+  const hasPrimaryIndicator = existsSync(path.join(dir, "drizzle.config.ts")) || existsSync(path.join(dir, "supabase", "schemas")) || existsSync(path.join(dir, "src", "schema")) || existsSync(path.join(dir, "scripts", "db-sync.ts"));
+  if (hasPrimaryIndicator) {
+    return true;
+  }
+  const pkgJsonPath = path.join(dir, "package.json");
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const name = pkgJson.name?.toLowerCase() ?? "";
+      if (name.includes("database") || name.endsWith("-db") || name.endsWith("/db")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function tryResolveFromConfig(cwd) {
+  try {
+    const loaded = loadRunaConfigOrThrow(cwd);
+    const configDir = path.dirname(loaded.configPath);
+    const config = loaded.config;
+    if (config.project.monorepo === false && hasValidDatabaseIndicators(configDir)) {
+      return configDir;
+    }
+    const dbConfig = getDatabaseConfig(config);
+    const schemaPath = dbConfig.schemaPath;
+    const dbPath = schemaPath.includes("/src/") ? schemaPath.split("/src/")[0] : schemaPath.startsWith("src/") ? "." : path.dirname(schemaPath);
+    const fullPath = dbPath === "." ? configDir : path.join(configDir, dbPath);
+    return existsSync(fullPath) ? fullPath : null;
+  } catch {
+    return null;
+  }
+}
+async function getDatabasePackagePath(cwd = process.cwd()) {
+  const configResult = tryResolveFromConfig(cwd);
+  if (configResult) return configResult;
+  const dbPackage = findPackage("database", cwd) ?? findPackage("db", cwd);
+  if (dbPackage) return dbPackage;
+  const baseDir = findWorkspaceRoot(cwd) || cwd;
+  const conventionalPaths = [
+    path.join(baseDir, "packages", "database"),
+    path.join(baseDir, "packages", "db"),
+    path.join(baseDir, "db"),
+    baseDir
+  ];
+  for (const candidate of conventionalPaths) {
+    if (existsSync(candidate) && hasValidDatabaseIndicators(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`\u274C Database package not found
+
+Expected locations:
+  - packages/database/ (monorepo structure, recommended)
+  - packages/db/ (monorepo structure, legacy)
+  - db/ (single-package structure)
+  - . (project root with drizzle.config.ts or supabase/schemas/)
+
+Valid indicators (at least one required):
+  - package.json
+  - drizzle.config.ts (Drizzle ORM)
+  - supabase/schemas/ (Supabase SQL-First)
+  - src/schema/ (TypeScript schemas)
+
+Solutions:
+  1. Run: runa init (generates structure)
+  2. Set project.monorepo: false in runa.config.ts for single-app
+  3. Ensure supabase/schemas/ exists for Supabase projects
+`);
+}
+async function getSDKScriptsPath(cwd = process.cwd()) {
+  const sdkPackage = findPackage("sdk", cwd);
+  if (sdkPackage) {
+    const scriptsPath = path.join(sdkPackage, "scripts");
+    if (existsSync(scriptsPath)) {
+      return scriptsPath;
+    }
+  }
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const baseDir = workspaceRoot || cwd;
+  const installedPath = path.join(baseDir, "node_modules", "@runa-ai", "runa", "scripts");
+  if (existsSync(installedPath)) {
+    return installedPath;
+  }
+  throw new Error(
+    "\u274C SDK scripts directory not found\n\nExpected locations:\n  - packages/sdk/scripts (workspace development)\n  - node_modules/@runa-ai/runa/scripts (npm installed)\n\nSolutions:\n  1. Install @runa-ai/runa: pnpm add @runa-ai/runa\n  2. Check workspace structure: pnpm list @runa-ai/runa\n  3. Run: pnpm install (reinstall dependencies)\n"
+  );
+}
+async function getSDKTemplatesPath(cwd = process.cwd()) {
+  const sdkPackage = findPackage("sdk", cwd);
+  if (sdkPackage) {
+    const templatesPath = path.join(sdkPackage, "templates");
+    if (existsSync(templatesPath)) {
+      return templatesPath;
+    }
+  }
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const baseDir = workspaceRoot || cwd;
+  const installedPath = path.join(baseDir, "node_modules", "@runa-ai", "runa", "templates");
+  if (existsSync(installedPath)) {
+    return installedPath;
+  }
+  throw new Error(
+    "\u274C SDK templates directory not found\n\nExpected locations:\n  - packages/sdk/templates (workspace development)\n  - node_modules/@runa-ai/runa/templates (npm installed)\n\nSolutions:\n  1. Install @runa-ai/runa: pnpm add @runa-ai/runa\n  2. Check: ls node_modules/@runa-ai/runa/templates\n  3. Run: pnpm install (reinstall dependencies)\n"
+  );
+}
+
+export { getAppConfig, getDatabaseConfig, getDatabasePackagePath, getDeployConfig, getSDKScriptsPath, getSDKTemplatesPath, isMonorepo, loadRunaConfig, validateRunaConfig };

package/dist/chunk-644FVGIQ.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { validateEnvSuffix, isPathContained, MAX_DIRECTORY_TRAVERSAL_DEPTH } from './chunk-DRSUEMAK.js';
+import { findWorkspaceRoot } from './chunk-JMJP4A47.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-6AALH2ED.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/config-updater.ts
+init_esm_shims();
+var VALID_DIRECTORY_PATTERN = /^[a-zA-Z0-9.][a-zA-Z0-9/_.-]*$/;
+var VALID_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[a-zA-Z0-9.-]+)?$/;
+function isControlChar(charCode) {
+  return charCode <= 31 || charCode === 127;
+}
+function isValidDirectoryPath(dir) {
+  if (!dir || typeof dir !== "string") {
+    return false;
+  }
+  if (dir.trim() === "") {
+    return false;
+  }
+  if (/['"\\]/.test(dir)) {
+    return false;
+  }
+  for (let i = 0; i < dir.length; i++) {
+    if (isControlChar(dir.charCodeAt(i))) {
+      return false;
+    }
+  }
+  return VALID_DIRECTORY_PATTERN.test(dir);
+}
+function isValidVersion(version) {
+  if (!version || typeof version !== "string") {
+    return false;
+  }
+  return VALID_VERSION_PATTERN.test(version);
+}
+function escapeReplacementString(str) {
+  return str.replace(/\$/g, "$$$$");
+}
+function updateRunaConfigAppDirectory(appDirectory, targetDir = process.cwd()) {
+  if (!isValidDirectoryPath(appDirectory)) {
+    return { updated: false, reason: "Invalid directory path format" };
+  }
+  const configPath = resolve(targetDir, "runa.config.ts");
+  if (!existsSync(configPath)) {
+    return { updated: false, reason: "runa.config.ts not found" };
+  }
+  const content = readFileSync(configPath, "utf-8");
+  const currentMatch = content.match(/directory:\s*['"]([^'"]+)['"]/);
+  const currentValue = currentMatch?.[1];
+  if (currentValue && currentValue !== "." && currentValue !== "apps/web") {
+    if (currentValue === appDirectory) {
+      return { updated: false, reason: "Already set to the same value" };
+    }
+    return { updated: false, reason: `Already customized to '${currentValue}'` };
+  }
+  const directoryPattern = /(directory:\s*)(['"])([^'"]*)\2/;
+  if (!directoryPattern.test(content)) {
+    return { updated: false, reason: "Could not find directory field in config" };
+  }
+  const safeDirectory = escapeReplacementString(appDirectory);
+  const newContent = content.replace(directoryPattern, `$1'${safeDirectory}'`);
+  if (newContent === content) {
+    return { updated: false, reason: "No changes needed" };
+  }
+  writeFileSync(configPath, newContent, "utf-8");
+  return { updated: true, reason: `Updated to '${appDirectory}'` };
+}
+function syncRunaConfigWithVercel(targetDir, vercelRootDirectory) {
+  if (!vercelRootDirectory) {
+    return null;
+  }
+  const result = updateRunaConfigAppDirectory(vercelRootDirectory, targetDir);
+  return {
+    updated: result.updated,
+    field: "app.directory",
+    reason: result.reason
+  };
+}
+function updateRunaConfigSdkVersion(version, targetDir = process.cwd()) {
+  if (!isValidVersion(version)) {
+    return { updated: false, reason: "Invalid version format" };
+  }
+  const configPath = resolve(targetDir, "runa.config.ts");
+  if (!existsSync(configPath)) {
+    return { updated: false, reason: "runa.config.ts not found" };
+  }
+  const content = readFileSync(configPath, "utf-8");
+  const currentMatch = content.match(/sdkVersion:\s*['"]([^'"]+)['"]/);
+  const currentVersion = currentMatch?.[1];
+  if (currentVersion === version) {
+    return { updated: false, reason: "Already at this version" };
+  }
+  const sdkVersionPattern = /(sdkVersion:\s*)(['"])([^'"]*)\2/;
+  const safeVersion = escapeReplacementString(version);
+  if (sdkVersionPattern.test(content)) {
+    const newContent = content.replace(sdkVersionPattern, `$1'${safeVersion}'`);
+    if (newContent === content) {
+      return { updated: false, reason: "No changes needed" };
+    }
+    writeFileSync(configPath, newContent, "utf-8");
+    return {
+      updated: true,
+      reason: currentVersion ? `Updated from '${currentVersion}' to '${version}'` : `Set to '${version}'`
+    };
+  }
+  const configVersionPattern = /(configVersion:\s*\d+,?)(\s*\n)/;
+  if (configVersionPattern.test(content)) {
+    const newContent = content.replace(
+      configVersionPattern,
+      `$1$2  sdkVersion: '${safeVersion}',$2`
+    );
+    writeFileSync(configPath, newContent, "utf-8");
+    return { updated: true, reason: `Added sdkVersion: '${version}'` };
+  }
+  return { updated: false, reason: "Could not find appropriate location to add sdkVersion" };
+}
+
+export { syncRunaConfigWithVercel, updateRunaConfigSdkVersion };

package/dist/chunk-6FAU4IGR.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { redactSecrets } from './chunk-II7VYQEM.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import path from 'path';
+import { execa } from 'execa';
+
+createRequire(import.meta.url);
+
+// src/commands/ci/utils/execa-helpers.ts
+init_esm_shims();
+function redactArgsForLog(args) {
+  return args.map((a) => redactSecrets(a));
+}
+function pipeToSharedLog(params) {
+  let pending = 0;
+  const maybeEnd = () => {
+    if (pending !== 0) return;
+    try {
+      params.logStream.end();
+    } catch (error) {
+    }
+  };
+  for (const s of params.streams) {
+    if (!s) continue;
+    pending += 1;
+    s.pipe(params.logStream, { end: false });
+    const done = () => {
+      pending -= 1;
+      maybeEnd();
+    };
+    s.once("end", done);
+    s.once("close", done);
+    s.once("error", done);
+  }
+  maybeEnd();
+}
+async function ensureRunaTmpDir(cwd) {
+  const root = cwd ?? process.cwd();
+  const dir = path.join(root, ".runa", "tmp");
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+function runLogged(params) {
+  console.log(`\u25B6 ${params.label}: ${params.command} ${redactArgsForLog(params.args).join(" ")}`);
+  const proc = execa(params.command, params.args, {
+    cwd: params.cwd,
+    env: { DOTENVX_QUIET: "1", ...params.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false,
+    timeout: params.timeoutMs,
+    reject: params.reject
+  });
+  const stream = createWriteStream(params.logFile, { flags: "a" });
+  if (proc.stdout) proc.stdout.pipe(process.stdout, { end: false });
+  if (proc.stderr) proc.stderr.pipe(process.stderr, { end: false });
+  pipeToSharedLog({ streams: [proc.stdout, proc.stderr], logStream: stream });
+  return proc;
+}
+
+export { ensureRunaTmpDir, runLogged };

package/dist/chunk-6Y3LAUGL.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError } from '@runa-ai/runa/cli-runtime';
+
+createRequire(import.meta.url);
+
+// src/cli/non-interactive.ts
+init_esm_shims();
+function isTrueEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function isNonInteractiveEnabled() {
+  if (isTrueEnv(process.env.RUNA_NON_INTERACTIVE)) return true;
+  if (process.env.CI === "true") return true;
+  if (process.env.RUNA_OUTPUT_FORMAT === "json") return true;
+  return false;
+}
+function enableNonInteractiveMode() {
+  process.env.RUNA_NON_INTERACTIVE = "true";
+}
+function assertTtyRequired(featureName) {
+  const stdinTty = process.stdin.isTTY === true;
+  const stdoutTty = process.stdout.isTTY === true;
+  if (stdinTty && stdoutTty) return;
+  throw new CLIError(
+    `${featureName} requires an interactive TTY`,
+    "TTY_REQUIRED",
+    ["Run in a terminal (TTY)", "Avoid piping stdin/stdout when using TUI features"],
+    void 0,
+    2
+  );
+}
+
+export { assertTtyRequired, enableNonInteractiveMode, isNonInteractiveEnabled };