@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/chunk-XDCHRVE3.js

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { stripSqlComments } from './chunk-7B5C6U2K.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { execFileSync } from 'child_process';
+import { isIP } from 'net';
+
+createRequire(import.meta.url);
+
+// 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 { detectAppSchemas, enhanceConnectionError, formatSchemasForSql, normalizeDatabaseUrlForDdl, parseBoolish };