@runa-ai/runa-cli 0.5.71 → 0.6.0

package/dist/chunk-CE3DEYFT.js

@@ -0,0 +1,480 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { spawnSync, execFileSync } from 'child_process';
+import { execa } from 'execa';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { isIP } from 'net';
+
+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
+  };
+}
+
+// src/commands/db/utils/schema-detector.ts
+init_esm_shims();
+var EXCLUDED_SCHEMAS = /* @__PURE__ */ new Set([
+  // PostgreSQL system
+  "pg_catalog",
+  "information_schema",
+  "pg_toast",
+  // Supabase services
+  "auth",
+  "storage",
+  "realtime",
+  "pgsodium",
+  "pgsodium_masks",
+  // Supabase extensions
+  "extensions",
+  "graphql",
+  "graphql_public",
+  "net",
+  "vault",
+  // Supabase internal
+  "supabase_functions",
+  "supabase_migrations",
+  "pgbouncer",
+  "cron"
+]);
+var IDENTIFIER_PATTERN = "[A-Za-z_][A-Za-z0-9_]*";
+var SQL_IDENTIFIER = `(?:"(?:[^"]|"")*"|${IDENTIFIER_PATTERN})`;
+var CREATE_SCHEMA_PATTERN = new RegExp(
+  `^\\s*CREATE\\s+SCHEMA\\s+(?:IF\\s+NOT\\s+EXISTS\\s+)?(${SQL_IDENTIFIER})`,
+  "gim"
+);
+function collectSchemaSqlFiles(schemasDir) {
+  const entries = readdirSync(schemasDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const filePath = join(schemasDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...collectSchemaSqlFiles(filePath));
+    } else if (entry.isFile() && filePath.endsWith(".sql")) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+function unquoteIdentifier(identifier) {
+  const trimmed = identifier.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/""/g, '"');
+  }
+  return trimmed;
+}
+function detectAppSchemas(schemasDir, verbose) {
+  const schemas = /* @__PURE__ */ new Set(["public"]);
+  if (!existsSync(schemasDir)) {
+    return Array.from(schemas);
+  }
+  const files = collectSchemaSqlFiles(schemasDir).sort();
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const contentWithoutComments = stripSqlComments(content);
+    CREATE_SCHEMA_PATTERN.lastIndex = 0;
+    const matches = contentWithoutComments.matchAll(CREATE_SCHEMA_PATTERN);
+    for (const match of Array.from(matches)) {
+      const schemaNameRaw = unquoteIdentifier(match[1] ?? "");
+      if (!schemaNameRaw) {
+        continue;
+      }
+      const schemaName = schemaNameRaw.toLowerCase();
+      if (!EXCLUDED_SCHEMAS.has(schemaName)) {
+        schemas.add(schemaName);
+      }
+    }
+  }
+  const result = Array.from(schemas).sort();
+  if (verbose) {
+    console.log(`   \u2192 Detected app schemas: ${result.join(", ")}`);
+  }
+  return result;
+}
+var VALID_PG_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/;
+function formatSchemasForSql(schemas) {
+  return schemas.map((s) => {
+    if (!VALID_PG_IDENTIFIER.test(s)) {
+      throw new Error(`Invalid schema name "${s}": must be a valid PostgreSQL identifier`);
+    }
+    return `'${s.replace(/'/g, "''")}'`;
+  }).join(", ");
+}
+
+// src/commands/ci/utils/db-url-utils.ts
+init_esm_shims();
+function resolveHostToIPv4(hostname) {
+  const ipVersion = isIP(hostname);
+  if (ipVersion === 4) return hostname;
+  if (ipVersion === 6) return null;
+  try {
+    const output = execFileSync("getent", ["ahostsv4", hostname], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const firstLine = output.split("\n").find((l) => l.trim().length > 0);
+    if (!firstLine) return null;
+    const ip = firstLine.trim().split(/\s+/u)[0] ?? "";
+    return isIP(ip) === 4 ? ip : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeDatabaseUrlForDdl(databaseUrl) {
+  try {
+    const url = new URL(databaseUrl);
+    const port = url.port ? Number(url.port) : void 0;
+    if (port === 6543) url.port = "5432";
+    if (url.searchParams.has("pgbouncer")) url.searchParams.delete("pgbouncer");
+    if (process.env.CI === "true") {
+      const ipv4 = resolveHostToIPv4(url.hostname);
+      if (ipv4) {
+        url.hostname = ipv4;
+      }
+    }
+    return url.toString();
+  } catch {
+    return databaseUrl;
+  }
+}
+function parseBoolish(value) {
+  return value === "t" || value === "true" || value === "1";
+}
+function isIPv6Only(hostname) {
+  const ipVersion = isIP(hostname);
+  if (ipVersion === 4) return false;
+  if (ipVersion === 6) return true;
+  const ipv4 = resolveHostToIPv4(hostname);
+  if (ipv4) return false;
+  try {
+    const output = execFileSync("getent", ["ahosts", hostname], {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return output.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function appendIpv4AddonGuidance(error) {
+  return `${error}
+
+\u{1F4A1} **\u89E3\u6C7A\u7B56**: Supabase IPv4 Add-on \u3092\u6709\u52B9\u5316\u3057\u3066\u304F\u3060\u3055\u3044 ($4/month)
+   Supabase Dashboard \u2192 Project Settings \u2192 Add-ons \u2192 IPv4 Add-on
+   (GitHub Actions \u306F IPv6 \u3092\u30B5\u30DD\u30FC\u30C8\u3057\u3066\u3044\u307E\u305B\u3093)`;
+}
+function appendConnectionRefusedGuidance(error) {
+  return `${error}
+
+\u{1F4A1} **\u78BA\u8A8D\u4E8B\u9805**:
+   1. DATABASE_URL \u304C Direct URL (port 5432) \u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u304B\uFF1F
+   2. Supabase \u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u304C\u7A3C\u50CD\u4E2D\u3067\u3059\u304B\uFF1F`;
+}
+function appendAuthFailureGuidance(error) {
+  return `${error}
+
+\u{1F4A1} **\u78BA\u8A8D\u4E8B\u9805**:
+   1. DATABASE_URL \u306E\u30D1\u30B9\u30EF\u30FC\u30C9\u304C\u6B63\u3057\u3044\u3067\u3059\u304B\uFF1F
+   2. Supabase Database Settings \u3067\u30D1\u30B9\u30EF\u30FC\u30C9\u3092\u30EA\u30BB\u30C3\u30C8\u3067\u304D\u307E\u3059`;
+}
+function isIpv6ConnectionError(error) {
+  return error.includes("Network is unreachable") || error.includes("IPv6");
+}
+function hasIpv6AddressPattern(error) {
+  return /\([0-9a-f:]+\)/i.test(error);
+}
+function canDetectIpv6OnlyFromUrl(databaseUrl) {
+  try {
+    const url = new URL(databaseUrl);
+    return isIPv6Only(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function shouldShowIpv4AddonGuidance(error, databaseUrl) {
+  if (!isIpv6ConnectionError(error)) {
+    return false;
+  }
+  if (databaseUrl && canDetectIpv6OnlyFromUrl(databaseUrl)) {
+    return true;
+  }
+  return hasIpv6AddressPattern(error);
+}
+function enhanceConnectionError(error, databaseUrl) {
+  if (shouldShowIpv4AddonGuidance(error, databaseUrl)) {
+    return appendIpv4AddonGuidance(error);
+  }
+  if (error.includes("Connection refused") || error.includes("connection refused")) {
+    return appendConnectionRefusedGuidance(error);
+  }
+  if (error.includes("password authentication failed") || error.includes("FATAL:  password")) {
+    return appendAuthFailureGuidance(error);
+  }
+  return error;
+}
+
+export { blankDollarQuotedBodies, buildPsqlArgs, buildPsqlEnv, detectAppSchemas, enhanceConnectionError, formatSchemasForSql, normalizeDatabaseUrlForDdl, parseBoolish, parsePostgresUrl, psqlExec, psqlQuery, psqlSyncFile, psqlSyncQuery, stripSqlComments };

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

package/dist/chunk-GOGRLQNP.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.6.0";
+var HAS_ADMIN_COMMAND = false;
+
+export { CLI_VERSION, HAS_ADMIN_COMMAND };