@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/chunk-7B5C6U2K.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { spawnSync } from 'child_process';
+import { execa } from 'execa';
+
+createRequire(import.meta.url);
+
+// src/commands/db/utils/psql.ts
+init_esm_shims();
+function parsePostgresUrl(url) {
+  const u = new URL(url);
+  const host = u.hostname;
+  const port = u.port || "5432";
+  const user = u.username || "postgres";
+  const password = u.password || void 0;
+  const database = u.pathname.replace(/^\//, "") || "postgres";
+  return { host, port, user, database, password };
+}
+function buildPsqlArgs(conn, options) {
+  const args = ["-X", "-h", conn.host, "-p", conn.port, "-U", conn.user, "-d", conn.database];
+  if (options?.onErrorStop !== false) {
+    args.splice(1, 0, "-v", "ON_ERROR_STOP=1");
+  }
+  return args;
+}
+function buildPsqlEnv(conn) {
+  if (!conn.password) return { ...process.env };
+  return { ...process.env, PGPASSWORD: conn.password };
+}
+function psqlSyncQuery(params) {
+  const conn = parsePostgresUrl(params.databaseUrl);
+  const args = buildPsqlArgs(conn, { onErrorStop: false });
+  const result = spawnSync("psql", [...args, "-t", "-c", params.sql], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+    env: buildPsqlEnv(conn),
+    timeout: params.timeout ?? 1e4
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || ""
+  };
+}
+function psqlSyncFile(params) {
+  const conn = parsePostgresUrl(params.databaseUrl);
+  const args = buildPsqlArgs(conn, { onErrorStop: params.onErrorStop ?? true });
+  const result = spawnSync("psql", [...args, "-f", params.filePath], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+    env: buildPsqlEnv(conn)
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || ""
+  };
+}
+async function psqlQuery(params) {
+  const conn = parsePostgresUrl(params.databaseUrl);
+  const args = buildPsqlArgs(conn);
+  if (params.mode === "scalar") {
+    const { stdout: stdout2 } = await execa("psql", [...args, "-A", "-t", "-c", params.sql], {
+      env: buildPsqlEnv(conn),
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return stdout2.trim();
+  }
+  const { stdout } = await execa("psql", [...args, "-A", "-t", "-c", params.sql], {
+    env: buildPsqlEnv(conn),
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  return stdout.trim();
+}
+async function psqlExec(params) {
+  const conn = parsePostgresUrl(params.databaseUrl);
+  const args = buildPsqlArgs(conn);
+  await execa("psql", [...args, "-c", params.sql], {
+    env: buildPsqlEnv(conn),
+    stdio: "inherit"
+  });
+}
+
+// src/lib/sql-comment-utils.ts
+init_esm_shims();
+var DOLLAR_TAG_PATTERN = /^\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/;
+function isOutsideAllQuotes(state) {
+  return !state.inSingleQuote && !state.inDoubleQuote && !state.inDollarQuote;
+}
+function tryConsumeLineComment(content, state) {
+  if (!isOutsideAllQuotes(state)) return false;
+  if (content[state.i] !== "-" || content[state.i + 1] !== "-") return false;
+  while (state.i < content.length && content[state.i] !== "\n") {
+    state.result += " ";
+    state.i += 1;
+  }
+  return true;
+}
+function tryConsumeBlockComment(content, state) {
+  if (!isOutsideAllQuotes(state)) return false;
+  if (content[state.i] !== "/" || content[state.i + 1] !== "*") return false;
+  let depth = 1;
+  state.result += "  ";
+  state.i += 2;
+  while (state.i < content.length && depth > 0) {
+    const current = content[state.i] ?? "";
+    const next = content[state.i + 1] ?? "";
+    if (current === "/" && next === "*") {
+      depth += 1;
+      state.result += "  ";
+      state.i += 2;
+      continue;
+    }
+    if (current === "*" && next === "/") {
+      depth -= 1;
+      state.result += "  ";
+      state.i += 2;
+      continue;
+    }
+    state.result += current === "\n" ? "\n" : " ";
+    state.i += 1;
+  }
+  return true;
+}
+function tryConsumeDollarQuoteDelimiter(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote) return false;
+  if (content[state.i] !== "$") return false;
+  if (state.inDollarQuote) {
+    const closeTag = `$${state.dollarTag}$`;
+    if (content.slice(state.i).startsWith(closeTag)) {
+      state.result += closeTag;
+      state.i += closeTag.length;
+      state.inDollarQuote = false;
+      state.dollarTag = "";
+      return true;
+    }
+    return false;
+  }
+  const tagMatch = content.slice(state.i).match(DOLLAR_TAG_PATTERN);
+  if (!tagMatch) return false;
+  state.inDollarQuote = true;
+  state.dollarTag = tagMatch[1] ?? "";
+  state.result += tagMatch[0];
+  state.i += tagMatch[0].length;
+  return true;
+}
+function consumeEQuotedString(content, state) {
+  state.result += content[state.i] ?? "";
+  state.result += "'";
+  state.i += 2;
+  while (state.i < content.length) {
+    const current = content[state.i] ?? "";
+    const next = content[state.i + 1] ?? "";
+    if (current === "\\" && state.i + 1 < content.length) {
+      state.result += current;
+      state.result += next;
+      state.i += 2;
+      continue;
+    }
+    if (current === "'") {
+      if (next === "'") {
+        state.result += "''";
+        state.i += 2;
+        continue;
+      }
+      state.result += current;
+      state.i += 1;
+      break;
+    }
+    state.result += current;
+    state.i += 1;
+  }
+}
+function tryConsumeEQuotedString(content, state) {
+  if (!isOutsideAllQuotes(state)) return false;
+  const current = content[state.i] ?? "";
+  const next = content[state.i + 1] ?? "";
+  if (current !== "E" && current !== "e" || next !== "'") return false;
+  consumeEQuotedString(content, state);
+  return true;
+}
+function tryToggleSingleQuote(content, state) {
+  if (state.inDoubleQuote || state.inDollarQuote) return false;
+  if (content[state.i] !== "'") return false;
+  if (state.inSingleQuote && content[state.i + 1] === "'") {
+    state.result += "''";
+    state.i += 2;
+    return true;
+  }
+  state.inSingleQuote = !state.inSingleQuote;
+  state.result += "'";
+  state.i += 1;
+  return true;
+}
+function tryToggleDoubleQuote(content, state) {
+  if (state.inSingleQuote || state.inDollarQuote) return false;
+  if (content[state.i] !== '"') return false;
+  if (state.inDoubleQuote && content[state.i + 1] === '"') {
+    state.result += '""';
+    state.i += 2;
+    return true;
+  }
+  state.inDoubleQuote = !state.inDoubleQuote;
+  state.result += '"';
+  state.i += 1;
+  return true;
+}
+function stripSqlComments(content) {
+  const state = {
+    i: 0,
+    result: "",
+    inSingleQuote: false,
+    inDoubleQuote: false,
+    inDollarQuote: false,
+    dollarTag: ""
+  };
+  while (state.i < content.length) {
+    if (tryConsumeLineComment(content, state)) continue;
+    if (tryConsumeBlockComment(content, state)) continue;
+    if (tryConsumeDollarQuoteDelimiter(content, state)) continue;
+    if (tryConsumeEQuotedString(content, state)) continue;
+    if (tryToggleSingleQuote(content, state)) continue;
+    if (tryToggleDoubleQuote(content, state)) continue;
+    state.result += content[state.i] ?? "";
+    state.i += 1;
+  }
+  return state.result;
+}
+function blankDollarQuotedBodies(content) {
+  let result = "";
+  let i = 0;
+  while (i < content.length) {
+    const handled = consumeDollarQuotedBody(content, i);
+    if (!handled) {
+      result += content[i] ?? "";
+      i += 1;
+      continue;
+    }
+    result += handled.value;
+    i = handled.next;
+  }
+  return result;
+}
+function parseDollarTagAt(content, index) {
+  if (content[index] !== "$") return null;
+  const tagMatch = content.slice(index).match(DOLLAR_TAG_PATTERN);
+  return tagMatch ? tagMatch[0] : null;
+}
+function blankRangePreservingNewlines(content, start, end) {
+  let result = "";
+  for (let i = start; i < end; i += 1) {
+    result += content[i] === "\n" ? "\n" : " ";
+  }
+  return result;
+}
+function consumeDollarQuotedBody(content, index) {
+  const openTag = parseDollarTagAt(content, index);
+  if (!openTag) return null;
+  const bodyStart = index + openTag.length;
+  const closeIdx = content.indexOf(openTag, bodyStart);
+  if (closeIdx < 0) {
+    return {
+      value: `${openTag}${blankRangePreservingNewlines(content, bodyStart, content.length)}`,
+      next: content.length
+    };
+  }
+  return {
+    value: `${openTag}${blankRangePreservingNewlines(content, bodyStart, closeIdx)}${openTag}`,
+    next: closeIdx + openTag.length
+  };
+}
+
+export { blankDollarQuotedBodies, buildPsqlArgs, buildPsqlEnv, parsePostgresUrl, psqlExec, psqlQuery, psqlSyncFile, psqlSyncQuery, stripSqlComments };

package/dist/chunk-AAIE4F2U.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { secureDocker, secureExeca } from './chunk-RZLYEO4U.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/diagnostics.ts
+init_esm_shims();
+async function checkDocker() {
+  try {
+    await secureDocker(["ps"]);
+    return {
+      severity: "info",
+      message: "Docker is running"
+    };
+  } catch {
+    return {
+      severity: "error",
+      message: "Docker is not running or not installed",
+      fixInstructions: [
+        "Start Colima: colima start --cpu 4 --memory 8 --disk 60 --vm-type vz --mount-type virtiofs",
+        "Install Colima: brew install colima docker",
+        "Linux: sudo systemctl start docker"
+      ]
+    };
+  }
+}
+async function checkPort(port) {
+  try {
+    const result = await secureExeca("lsof", ["-i", `:${port}`]);
+    const stdout = typeof result.stdout === "string" ? result.stdout : "";
+    const lines = stdout.trim().split("\n");
+    if (lines.length > 1) {
+      const processInfo = lines[1].split(/\s+/);
+      const processName = processInfo[0];
+      const pid = processInfo[1];
+      return {
+        severity: "warning",
+        message: `Port ${port} is in use by ${processName} (PID: ${pid})`,
+        fixInstructions: [
+          `Kill the process: kill ${pid}`,
+          "Or use a different port in your configuration"
+        ]
+      };
+    }
+  } catch {
+  }
+  return {
+    severity: "info",
+    message: `Port ${port} is available`
+  };
+}
+function detectSupabasePortsFromConfig() {
+  const configPath = path.join(process.cwd(), "supabase", "config.toml");
+  const BASE_PORTS = { api: 54321, db: 54322, studio: 54323, inbucket: 54324 };
+  if (!existsSync(configPath)) {
+    return Object.values(BASE_PORTS);
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const ports = [];
+    const apiMatch = content.match(/\[api\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(apiMatch ? Number.parseInt(apiMatch[1], 10) : BASE_PORTS.api);
+    const dbMatch = content.match(/\[db\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(dbMatch ? Number.parseInt(dbMatch[1], 10) : BASE_PORTS.db);
+    const studioMatch = content.match(/\[studio\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(studioMatch ? Number.parseInt(studioMatch[1], 10) : BASE_PORTS.studio);
+    const inbucketMatch = content.match(/\[inbucket\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(inbucketMatch ? Number.parseInt(inbucketMatch[1], 10) : BASE_PORTS.inbucket);
+    return ports;
+  } catch {
+    return Object.values(BASE_PORTS);
+  }
+}
+async function checkSupabasePorts() {
+  const ports = detectSupabasePortsFromConfig();
+  const results = [];
+  for (const port of ports) {
+    const result = await checkPort(port);
+    if (result.severity !== "info") {
+      results.push(result);
+    }
+  }
+  return results;
+}
+function checkRequiredFiles(files) {
+  const results = [];
+  for (const file of files) {
+    if (!existsSync(file)) {
+      results.push({
+        severity: "error",
+        message: `Required file not found: ${file}`,
+        fixInstructions: [`Create ${file} or run 'runa init' to set up the project`]
+      });
+    }
+  }
+  return results;
+}
+async function diagnoseSupabaseStart() {
+  const results = [];
+  const dockerCheck = await checkDocker();
+  if (dockerCheck.severity === "error") {
+    results.push(dockerCheck);
+  }
+  const portChecks = await checkSupabasePorts();
+  results.push(...portChecks);
+  const configCheck = checkRequiredFiles(["supabase/config.toml"]);
+  results.push(...configCheck);
+  return results;
+}
+function diagnoseInitFailure(errorMessage) {
+  const results = [];
+  if (errorMessage.includes("templates directory not found")) {
+    results.push({
+      severity: "error",
+      message: "@runa-ai/runa is not installed correctly",
+      fixInstructions: [
+        "Verify installation: pnpm list @runa-ai/runa",
+        "Reinstall: pnpm add -D @runa-ai/runa",
+        "Ensure you are in the project root directory"
+      ]
+    });
+  }
+  if (errorMessage.includes("package.json")) {
+    results.push({
+      severity: "error",
+      message: "Not in a valid Node.js project",
+      fixInstructions: [
+        "Run from project root (where package.json exists)",
+        "Or initialize new project: pnpm init"
+      ]
+    });
+  }
+  return results;
+}
+
+export { diagnoseInitFailure, diagnoseSupabaseStart };

package/dist/chunk-AIP6MR42.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);
+
+// src/version.ts
+init_esm_shims();
+var CLI_VERSION = "0.7.0";
+var HAS_ADMIN_COMMAND = false;
+
+export { CLI_VERSION, HAS_ADMIN_COMMAND };

package/dist/chunk-CCKG5R4Y.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { getDatabasePackagePath } from './chunk-5NKWR4FF.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+
+// src/commands/db/utils/stack-detector.ts
+init_esm_shims();
+async function detectDatabaseStack(cwd = process.cwd()) {
+  try {
+    const dbPackagePath = await getDatabasePackagePath(cwd);
+    const drizzleConfig = join(dbPackagePath, "drizzle.config.ts");
+    if (existsSync(drizzleConfig)) {
+      return {
+        stack: "drizzle",
+        confidence: "high",
+        reason: `Found drizzle.config.ts at ${dbPackagePath}`,
+        paths: { drizzleConfig }
+      };
+    }
+  } catch {
+  }
+  const supabaseSchemas = join(cwd, "supabase/schemas");
+  if (existsSync(supabaseSchemas)) {
+    return {
+      stack: "supabase",
+      confidence: "high",
+      reason: "Found supabase/schemas/ directory",
+      paths: { supabaseSchemas }
+    };
+  }
+  throw new Error(
+    "Unable to detect database stack.\nExpected one of:\n  - drizzle.config.ts in database package (Drizzle ORM)\n  - supabase/schemas/ (Supabase SQL)\n\nRun `runa init` to set up your database structure."
+  );
+}
+async function getStackPaths(stack, cwd = process.cwd()) {
+  if (stack === "drizzle") {
+    const dbPath = await getDatabasePackagePath(cwd);
+    return {
+      rootDir: dbPath,
+      schemaDir: join(dbPath, "src/schema"),
+      configFile: join(dbPath, "drizzle.config.ts")
+    };
+  }
+  if (stack === "supabase") {
+    const schemasDir = join(cwd, "supabase/schemas");
+    return {
+      rootDir: join(cwd, "supabase"),
+      schemaDir: schemasDir,
+      configFile: join(cwd, "supabase/config.toml")
+    };
+  }
+  throw new Error(`Unknown stack: ${stack}`);
+}
+
+export { detectDatabaseStack, getStackPaths };

package/dist/chunk-DRSUEMAK.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, realpathSync } from 'fs';
+import { resolve, sep, isAbsolute, relative, normalize } from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/path-security.ts
+init_esm_shims();
+function safeRealpath(targetPath) {
+  try {
+    if (existsSync(targetPath)) {
+      return realpathSync(targetPath);
+    }
+    return targetPath;
+  } catch {
+    return targetPath;
+  }
+}
+var SHELL_METACHARACTERS = /[|;`$&<>]/;
+function isControlChar(charCode) {
+  return charCode <= 31 || charCode === 127;
+}
+function hasNoDangerousChars(userPath) {
+  if (SHELL_METACHARACTERS.test(userPath)) {
+    return false;
+  }
+  for (let i = 0; i < userPath.length; i++) {
+    if (isControlChar(userPath.charCodeAt(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+function containsPathTraversal(userPath) {
+  const normalized = normalize(userPath);
+  if (normalized.includes("..")) {
+    return true;
+  }
+  if (normalized.startsWith("/") || normalized.startsWith("\\")) {
+    return true;
+  }
+  return false;
+}
+function validateSafePath(userPath, baseDir) {
+  if (!userPath || userPath.trim() === "") {
+    return false;
+  }
+  if (!hasNoDangerousChars(userPath)) {
+    return false;
+  }
+  if (containsPathTraversal(userPath)) {
+    return false;
+  }
+  const absoluteBase = resolve(baseDir);
+  const absolutePath = resolve(baseDir, userPath);
+  const realBase = safeRealpath(absoluteBase);
+  const realPath = safeRealpath(absolutePath);
+  const relativePath = relative(realBase, realPath);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    return false;
+  }
+  return true;
+}
+function resolveSafePath(baseDir, userPath) {
+  if (!validateSafePath(userPath, baseDir)) {
+    throw new Error(
+      `Invalid path: '${userPath}' is not allowed. Path must be relative and within the base directory.`
+    );
+  }
+  return resolve(baseDir, userPath);
+}
+function filterSafePaths(paths, baseDir, logger) {
+  return paths.filter((p) => {
+    const safe = validateSafePath(p, baseDir);
+    if (!safe && logger) {
+      logger.warn(`Rejected unsafe path: '${p}'`);
+    }
+    return safe;
+  });
+}
+var MAX_DIRECTORY_TRAVERSAL_DEPTH = 10;
+var SAFE_ENV_SUFFIX_PATTERN = /^[a-zA-Z0-9._-]+$/;
+function validateEnvSuffix(suffix) {
+  if (!suffix || suffix.trim() === "") {
+    throw new Error("Environment suffix cannot be empty");
+  }
+  if (suffix.includes("..") || suffix.includes("/") || suffix.includes("\\")) {
+    throw new Error(`Environment suffix '${suffix}' contains path traversal sequences`);
+  }
+  if (!SAFE_ENV_SUFFIX_PATTERN.test(suffix)) {
+    throw new Error(
+      `Environment suffix '${suffix}' contains invalid characters. Only alphanumeric, dots, hyphens, and underscores are allowed.`
+    );
+  }
+}
+function isPathContained(basePath, targetPath) {
+  const normalizedBase = resolve(basePath);
+  const normalizedTarget = resolve(targetPath);
+  const realBase = safeRealpath(normalizedBase);
+  const realTarget = safeRealpath(normalizedTarget);
+  return realTarget === realBase || realTarget.startsWith(realBase + sep);
+}
+function validateUserFilePath(filePath, baseDir) {
+  if (!filePath || filePath.trim() === "") {
+    throw new Error("File path cannot be empty");
+  }
+  if (!hasNoDangerousChars(filePath)) {
+    throw new Error(
+      "File path contains dangerous characters. Shell metacharacters and control characters are not allowed."
+    );
+  }
+  const resolvedPath = isAbsolute(filePath) ? resolve(filePath) : resolve(baseDir, filePath);
+  if (!isPathContained(baseDir, resolvedPath)) {
+    throw new Error(
+      "File path resolves outside the allowed directory. Path must be within the project root."
+    );
+  }
+  return resolvedPath;
+}
+
+export { MAX_DIRECTORY_TRAVERSAL_DEPTH, filterSafePaths, isPathContained, resolveSafePath, validateEnvSuffix, validateUserFilePath };