@runa-ai/runa-cli 0.5.72 → 0.6.0

package/dist/chunk-HD74F6W2.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims, __require } from './chunk-VRXHCR5K.js';
+import { existsSync, createWriteStream } from 'fs';
+import path from 'path';
+import { loadRunaConfig, CLIError } from '@runa-ai/runa';
+import { writeFile, readFile } from 'fs/promises';
+import { z } from 'zod';
+
+createRequire(import.meta.url);
+
+// src/commands/ci/machine/actors/setup/pr-common.ts
+init_esm_shims();
+function resolvePrContext(input) {
+  const prNumberStr = input.githubRef?.match(/refs\/pull\/(\d+)/)?.[1];
+  const prNumber = prNumberStr ? Number.parseInt(prNumberStr, 10) : null;
+  return {
+    prNumber,
+    action: input.githubEventAction ?? null,
+    sha: input.githubSha ?? null,
+    baseBranch: input.githubBaseRef ?? null,
+    headBranch: input.githubHeadRef ?? null
+  };
+}
+function resolvePolicy(_config, _repoKind) {
+  return {
+    allowLocalFallback: true,
+    allowPartialPhases: false,
+    source: "default"
+  };
+}
+function detectRepoKind(repoRoot) {
+  const hasApps = existsSync(path.join(repoRoot, "apps"));
+  const hasPackages = existsSync(path.join(repoRoot, "packages"));
+  const hasTurbo = existsSync(path.join(repoRoot, "turbo.json"));
+  if (hasApps || hasPackages || hasTurbo) {
+    return "monorepo";
+  }
+  const hasSrc = existsSync(path.join(repoRoot, "src"));
+  const hasApp = existsSync(path.join(repoRoot, "app"));
+  if (hasSrc || hasApp) {
+    return "pj-repo";
+  }
+  return "unknown";
+}
+var APP_PRIORITY = ["web", "dashboard", "app", "frontend", "client"];
+function hasKnownFrameworkConfig(dir) {
+  if (existsSync(path.join(dir, "next.config.js")) || existsSync(path.join(dir, "next.config.mjs")) || existsSync(path.join(dir, "next.config.ts"))) {
+    return true;
+  }
+  if (existsSync(path.join(dir, "vite.config.js")) || existsSync(path.join(dir, "vite.config.ts"))) {
+    return true;
+  }
+  if (existsSync(path.join(dir, "remix.config.js"))) {
+    return true;
+  }
+  if (existsSync(path.join(dir, "astro.config.mjs")) || existsSync(path.join(dir, "astro.config.ts"))) {
+    return true;
+  }
+  if (existsSync(path.join(dir, "nuxt.config.js")) || existsSync(path.join(dir, "nuxt.config.ts"))) {
+    return true;
+  }
+  if (existsSync(path.join(dir, "svelte.config.js"))) {
+    return true;
+  }
+  return false;
+}
+function hasPackageJson(dir) {
+  return existsSync(path.join(dir, "package.json"));
+}
+function readAppsSubdirectoryNames(appsDir) {
+  try {
+    const { readdirSync } = __require("fs");
+    const entries = readdirSync(appsDir, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return null;
+  }
+}
+function splitAppCandidates(names) {
+  const nameSet = new Set(names);
+  const prioritySet = new Set(APP_PRIORITY);
+  const priorityCandidates = APP_PRIORITY.filter((name) => nameSet.has(name));
+  const secondaryCandidates = names.filter((name) => !prioritySet.has(name));
+  return { priorityCandidates, secondaryCandidates };
+}
+function findFirstMatchingAppDir(appsDir, names, predicate) {
+  for (const name of names) {
+    const candidate = path.join(appsDir, name);
+    if (predicate(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+var PORT_PATTERNS = [
+  /-p\s*([0-9]+)/i,
+  /--port[=\s]+([0-9]+)/i,
+  /\bPORT\s*=\s*([0-9]+)/
+];
+function extractPortFromScript(script) {
+  for (const pattern of PORT_PATTERNS) {
+    const match = script.match(pattern);
+    if (match?.[1]) {
+      const port = Number.parseInt(match[1], 10);
+      if (!Number.isNaN(port) && port > 0 && port < 65536) {
+        return port;
+      }
+    }
+  }
+  return null;
+}
+function readPortFromScripts(appDir) {
+  const pkgPath = path.join(appDir, "package.json");
+  if (!existsSync(pkgPath)) return 3e3;
+  try {
+    const { readFileSync } = __require("fs");
+    const raw = readFileSync(pkgPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed.scripts;
+    for (const key of ["start:ci", "start", "dev"]) {
+      const script = scripts?.[key];
+      if (script) {
+        const port = extractPortFromScript(script);
+        if (port !== null) return port;
+      }
+    }
+  } catch {
+  }
+  return 3e3;
+}
+function findWebAppUnderApps(repoRoot) {
+  const appsDir = path.join(repoRoot, "apps");
+  if (!existsSync(appsDir)) return null;
+  const names = readAppsSubdirectoryNames(appsDir);
+  if (!names) return null;
+  const { priorityCandidates, secondaryCandidates } = splitAppCandidates(names);
+  return findFirstMatchingAppDir(appsDir, priorityCandidates, hasKnownFrameworkConfig) ?? findFirstMatchingAppDir(appsDir, secondaryCandidates, hasKnownFrameworkConfig) ?? findFirstMatchingAppDir(appsDir, priorityCandidates, hasPackageJson) ?? findFirstMatchingAppDir(appsDir, secondaryCandidates, hasPackageJson);
+}
+function detectApp(repoRoot, configOverride) {
+  if (configOverride?.directory && configOverride.directory !== ".") {
+    const configuredDir = path.join(repoRoot, configOverride.directory);
+    if (existsSync(configuredDir) && hasPackageJson(configuredDir)) {
+      return {
+        appDir: configuredDir,
+        port: configOverride.port ?? readPortFromScripts(configuredDir)
+      };
+    }
+  }
+  const appUnderApps = findWebAppUnderApps(repoRoot);
+  if (appUnderApps) {
+    return {
+      appDir: appUnderApps,
+      port: configOverride?.port ?? readPortFromScripts(appUnderApps)
+    };
+  }
+  if (hasKnownFrameworkConfig(repoRoot)) {
+    return {
+      appDir: repoRoot,
+      port: configOverride?.port ?? readPortFromScripts(repoRoot)
+    };
+  }
+  if (hasPackageJson(repoRoot)) {
+    return {
+      appDir: repoRoot,
+      port: configOverride?.port ?? readPortFromScripts(repoRoot)
+    };
+  }
+  return null;
+}
+function createErrorOutput(repoRoot, error, extraFields) {
+  const baseError = {
+    repoRoot,
+    tmpDir: "",
+    repoKind: "unknown",
+    prContext: { prNumber: null, action: null, sha: null, baseBranch: null, headBranch: null },
+    policy: {
+      allowLocalFallback: true,
+      allowPartialPhases: false,
+      source: "default"
+    },
+    app: null,
+    databaseUrl: "",
+    supabaseUrl: "",
+    anonKey: "",
+    layers: [],
+    expectedDrift: [],
+    error: error instanceof Error ? error.message : String(error)
+  };
+  return { ...baseError, ...extraFields };
+}
+async function executePrSetupBase(input, ensureTmpDir) {
+  const repoRoot = input.targetDir || process.cwd();
+  const tmpDir = await ensureTmpDir(repoRoot);
+  const repoKind = detectRepoKind(repoRoot);
+  const prContext = resolvePrContext({
+    githubRef: input.githubRef,
+    githubEventAction: input.githubEventAction,
+    githubSha: input.githubSha,
+    githubBaseRef: input.githubBaseRef,
+    githubHeadRef: input.githubHeadRef
+  });
+  const policy = resolvePolicy(input.config);
+  const configResult = loadRunaConfig(repoRoot);
+  const appConfigOverride = configResult?.config?.app?.directory ? {
+    directory: configResult.config.app.directory
+    // Port is auto-detected via readPortFromScripts() - not in config schema
+  } : void 0;
+  const app = detectApp(repoRoot, appConfigOverride);
+  const layers = input.layers || [1, 2, 3, 4];
+  const rawDrift = configResult?.config?.database?.pgSchemaDiff?.expectedDrift;
+  const expectedDrift = rawDrift ? rawDrift : [];
+  return { repoRoot, tmpDir, repoKind, prContext, policy, app, layers, expectedDrift };
+}
+
+// src/commands/ci/utils/app-runtime.ts
+init_esm_shims();
+function pipeChildOutputToLog(params) {
+  const sources = [];
+  if (params.stdout) sources.push({ stream: params.stdout, isStderr: false });
+  if (params.stderr) sources.push({ stream: params.stderr, isStderr: true });
+  if (sources.length === 0) {
+    params.logStream.end();
+    return { cleanup: () => {
+    } };
+  }
+  let pending = sources.length;
+  let cleanedUp = false;
+  const onSourceEnd = () => {
+    pending -= 1;
+    if (pending === 0 && !cleanedUp) {
+      params.logStream.end();
+    }
+  };
+  for (const { stream: source, isStderr } of sources) {
+    const onData = (chunk) => {
+      if (cleanedUp) return;
+      const canContinue = params.logStream.write(chunk);
+      if (params.streamToTerminal) {
+        const terminalStream = isStderr ? process.stderr : process.stdout;
+        terminalStream.write(chunk);
+      }
+      if (!canContinue) {
+        source.pause();
+        params.logStream.once("drain", () => {
+          if (!cleanedUp) source.resume();
+        });
+      }
+    };
+    source.on("data", onData);
+    source.once("end", onSourceEnd);
+    source.once("close", onSourceEnd);
+    source.once("error", () => {
+      onSourceEnd();
+    });
+  }
+  const cleanup = () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    for (const { stream: source } of sources) {
+      source.removeAllListeners("data");
+      source.removeAllListeners("end");
+      source.removeAllListeners("close");
+      source.removeAllListeners("error");
+      if ("destroy" in source && typeof source.destroy === "function") {
+        source.destroy();
+      }
+    }
+    try {
+      const stream = params.logStream;
+      if (!stream.writableEnded) {
+        params.logStream.end();
+      }
+    } catch {
+    }
+  };
+  return { cleanup };
+}
+async function writeEnvLocal(params) {
+  const filePath = path.join(params.appDir, ".env.local");
+  const content = `${Object.entries(params.values).map(([k, v]) => `${k}=${v}`).join("\n")}
+`;
+  await writeFile(filePath, content, "utf-8");
+}
+async function readLastLines(filePath, lineCount) {
+  try {
+    if (!existsSync(filePath)) return null;
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.split("\n");
+    const lastLines = lines.slice(-lineCount).join("\n");
+    return lastLines.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function waitHttpOk(params) {
+  const { url, timeoutSeconds, logFilePath } = params;
+  const startTime = Date.now();
+  const deadline = startTime + timeoutSeconds * 1e3;
+  let lastError = null;
+  let lastStatus = null;
+  let lastStatusText = null;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(url, { method: "GET", redirect: "manual" });
+      lastStatus = res.status;
+      lastStatusText = res.statusText;
+      if (res.status < 400) return;
+    } catch (error) {
+      lastError = error;
+      lastStatus = null;
+      lastStatusText = null;
+    }
+    await new Promise((r) => setTimeout(r, 2e3));
+  }
+  const elapsedSeconds = Math.round((Date.now() - startTime) / 1e3);
+  const errorParts = [`App did not become ready: ${url}`];
+  errorParts.push(`Timeout: ${timeoutSeconds}s (waited ${elapsedSeconds}s)`);
+  if (lastStatus !== null) {
+    errorParts.push(`Last HTTP status: ${lastStatus} ${lastStatusText ?? ""}`);
+  }
+  if (lastError instanceof Error) {
+    errorParts.push(`Last error: ${lastError.message}`);
+  }
+  const hints = [];
+  if (logFilePath) {
+    const logTail = await readLastLines(logFilePath, 30);
+    if (logTail) {
+      errorParts.push("");
+      errorParts.push("\u2501\u2501\u2501 Last 30 lines of app.log \u2501\u2501\u2501");
+      errorParts.push(logTail);
+      errorParts.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    }
+    hints.push(`Full log: ${logFilePath}`);
+  } else {
+    hints.push("Check app logs under .runa/tmp/app.log");
+  }
+  hints.push("Verify build/start commands");
+  throw new CLIError(
+    errorParts.join("\n"),
+    "CI_APP_NOT_READY",
+    hints,
+    lastError instanceof Error ? lastError : void 0,
+    30
+  );
+}
+async function readPackageScripts(pkgPath) {
+  if (!existsSync(pkgPath)) return null;
+  try {
+    const raw = await readFile(pkgPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return z.object({ scripts: z.record(z.string(), z.string()).optional() }).passthrough().parse(parsed).scripts ?? null;
+  } catch {
+    return null;
+  }
+}
+function selectScriptName(mode, scripts, ciScriptName) {
+  if (scripts?.[ciScriptName]) {
+    return ciScriptName;
+  }
+  if (mode === "start" && scripts?.start) {
+    return "start";
+  }
+  return null;
+}
+function getAppDirArgs(isMonorepo, repoRoot, appDir) {
+  return isMonorepo ? ["-C", path.relative(repoRoot, appDir)] : [];
+}
+function createDirectNextCommand(params) {
+  const nextCommand = params.mode === "dev" ? "dev" : "start";
+  const dirArgs = getAppDirArgs(params.isMonorepo, params.repoRoot, params.appDir);
+  const bundlerArgs = params.bundler ? [`--${params.bundler}`] : [];
+  return {
+    command: [
+      "pnpm",
+      ...dirArgs,
+      "exec",
+      "next",
+      nextCommand,
+      ...bundlerArgs,
+      "-p",
+      String(params.port)
+    ],
+    useRootScript: false
+  };
+}
+function determineAppCommand(mode, isMonorepo, rootScripts, appScripts, repoRoot, appDir, port, bundler) {
+  const ciScriptName = mode === "dev" ? "dev:ci" : "start:ci";
+  const rootScriptName = selectScriptName(mode, rootScripts, ciScriptName);
+  const appScriptName = selectScriptName(mode, appScripts, ciScriptName);
+  if (isMonorepo && rootScriptName) {
+    return { command: ["pnpm", rootScriptName], useRootScript: true };
+  }
+  if (appScriptName) {
+    const dirArgs = getAppDirArgs(isMonorepo, repoRoot, appDir);
+    return { command: ["pnpm", ...dirArgs, appScriptName], useRootScript: false };
+  }
+  return createDirectNextCommand({ mode, isMonorepo, repoRoot, appDir, bundler, port });
+}
+async function startAppBackground(params) {
+  const mode = params.mode ?? "start";
+  const isMonorepo = params.appDir !== params.repoRoot;
+  const rootPkgPath = path.join(params.repoRoot, "package.json");
+  const appPkgPath = path.join(params.appDir, "package.json");
+  const rootScripts = await readPackageScripts(rootPkgPath);
+  const appScripts = isMonorepo ? await readPackageScripts(appPkgPath) : rootScripts;
+  const { command, useRootScript } = determineAppCommand(
+    mode,
+    isMonorepo,
+    rootScripts,
+    appScripts,
+    params.repoRoot,
+    params.appDir,
+    params.port,
+    params.bundler
+  );
+  const appLog = path.join(params.tmpDir, "app.log");
+  const out = createWriteStream(appLog, { flags: "a" });
+  const commandStr = command.join(" ");
+  const modeLabel = mode === "dev" ? "development (hot reload)" : "production";
+  const logHeader = [
+    `[runa] Starting app at ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    `[runa] Mode: ${modeLabel}`,
+    `[runa] Command: ${commandStr}`,
+    `[runa] Working directory: ${params.repoRoot}`,
+    `[runa] App directory: ${path.relative(params.repoRoot, params.appDir) || "."}`,
+    useRootScript ? "[runa] Using root package.json script" : "[runa] Using app package.json script",
+    "---",
+    ""
+  ].join("\n");
+  out.write(logHeader);
+  const { spawn } = await import('child_process');
+  const child = spawn(command[0], command.slice(1), {
+    cwd: params.repoRoot,
+    env: params.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+    shell: true
+  });
+  const { cleanup: cleanupStreams } = pipeChildOutputToLog({
+    stdout: child.stdout,
+    stderr: child.stderr,
+    logStream: out,
+    streamToTerminal: params.stream
+  });
+  const pid = child.pid ?? -1;
+  await writeFile(path.join(params.tmpDir, "app.pid"), `${pid}
+`, "utf-8");
+  return { pid, cleanupStreams };
+}
+async function waitForAppReady(params) {
+  const logFilePath = params.tmpDir ? path.join(params.tmpDir, "app.log") : void 0;
+  await waitHttpOk({
+    url: `http://127.0.0.1:${params.port}/`,
+    timeoutSeconds: params.timeoutSeconds,
+    logFilePath
+  });
+}
+
+export { createErrorOutput, detectApp, executePrSetupBase, startAppBackground, waitForAppReady, writeEnvLocal };

package/dist/chunk-HKUWEGUX.js

@@ -0,0 +1,36 @@
+#!/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/output-format.ts
+init_esm_shims();
+function isOutputFormat(value) {
+  return value === "text" || value === "json";
+}
+function getOutputFormatFromEnv() {
+  const raw = process.env.RUNA_OUTPUT_FORMAT;
+  if (!raw) return "text";
+  if (raw === "text" || raw === "json") return raw;
+  return "text";
+}
+function setOutputFormat(format) {
+  process.env.RUNA_OUTPUT_FORMAT = format;
+  if (format === "json") {
+    process.env.RUNA_NON_INTERACTIVE = "true";
+  }
+}
+function parseOutputFormat(input) {
+  if (isOutputFormat(input)) return input;
+  throw new CLIError(
+    "Invalid --format value. Allowed: text, json",
+    "INVALID_OUTPUT_FORMAT",
+    ["Use: --format text", "Use: --format json"],
+    void 0,
+    2
+  );
+}
+
+export { getOutputFormatFromEnv, parseOutputFormat, setOutputFormat };