@runa-ai/runa-cli 0.6.0 → 0.7.0

package/dist/{chunk-22CS6EMA.js → chunk-H2AHNI75.js}

@@ -9,7 +9,7 @@ init_esm_shims();
 var riskDetectorModulePromise = null;
 async function loadRiskDetectorModule() {
   if (!riskDetectorModulePromise) {
-    riskDetectorModulePromise = import('./risk-detector-core-O7I7SPR7.js').catch((error) => {
+    riskDetectorModulePromise = import('./risk-detector-core-TK4OAI3N.js').catch((error) => {
       riskDetectorModulePromise = null;
       throw error;
     });

package/dist/{chunk-UU55OH7P.js → chunk-KE6QJBZG.js}

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { markJsonEmitted } from './chunk-RRGQCUKT.js';
-import { createSuccessEnvelopeSchema, CLI_CONTRACT_VERSION } from './chunk-JT5SUTWE.js';
+import { createSuccessEnvelopeSchema, CLI_CONTRACT_VERSION, writeJsonEnvelope, markJsonEmitted } from './chunk-WJXC4MVY.js';
 import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 
@@ -31,7 +30,7 @@ function emitJsonSuccess(cmd, dataSchema, data) {
   const parsed = schema.parse(payload);
   process.env.RUNA_JSON_EMITTING = "true";
   try {
-    process.stdout.write(`${JSON.stringify(parsed)}
+    writeJsonEnvelope(`${JSON.stringify(parsed)}
 `);
   } finally {
     process.env.RUNA_JSON_EMITTING = "false";

package/dist/{check-6AB5NGWK.js → chunk-QM53IQHM.js}

@@ -1,11 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { loadEnvFiles } from './chunk-MNPMZERI.js';
-import './chunk-JMJP4A47.js';
-import './chunk-DRSUEMAK.js';
-import { emitJsonSuccess } from './chunk-UU55OH7P.js';
-import './chunk-RRGQCUKT.js';
-import './chunk-JT5SUTWE.js';
+import { loadEnvFiles } from './chunk-644FVGIQ.js';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { CLIError, createCLILogger } from '@runa-ai/runa/cli-runtime';
@@ -150,8 +146,8 @@ function renderFinalStatus(logger, output) {
     logger.success("All checks passed! Ready for operations.");
   }
 }
-async function runCheckAction(options) {
-  const logger = createCLILogger("check");
+async function runCheckCommand(options, runOptions) {
+  const logger = createCLILogger(runOptions.loggerName);
   const isJsonMode = getOutputFormatFromEnv() === "json";
   loadEnvFiles({ runaEnv: "local", silent: true });
   if (isJsonMode && options.fix) {
@@ -169,9 +165,12 @@ async function runCheckAction(options) {
     verbose: options.verbose || false
   });
   if (isJsonMode) {
-    emitJsonSuccess(checkCommand, RunCheckOutputSchema, output);
+    emitJsonSuccess(runOptions.command, RunCheckOutputSchema, output);
     process.exit(output.exitCode);
   }
+  if (runOptions.deprecationNotice) {
+    logger.warn(runOptions.deprecationNotice);
+  }
   logger.section(`Project Health Check (scope: ${options.scope || "all"})`);
   for (const category of output.categories) {
     renderCategory(logger, category, options.verbose || false);
@@ -187,9 +186,12 @@ var checkCommand = new Command("run").description("Check project configuration a
   "-s, --scope <scope>",
   "Check scope: all | build | ci | deploy | testing | layer1 | layer2 | layer3 | layer4",
   "all"
-).option("--fix", "Attempt to auto-fix issues").option("-v, --verbose", "Show detailed output with fix hints").option("--dry-run", "Show what would be checked without running").option("--cwd <path>", "Working directory (default: current directory)").action(async (options) => {
+).option("--fix", "Attempt to auto-fix issues").option("-v, --verbose", "Show detailed output with fix hints").option("--dry-run", "Show what would be checked without running").option("--cwd <path>", "Working directory (default: current directory)").action(async (options, command) => {
   try {
-    await runCheckAction(options);
+    await runCheckCommand(options, {
+      command,
+      loggerName: "check"
+    });
   } catch (error) {
     if (error instanceof CLIError) {
       throw error;
@@ -204,4 +206,4 @@ var checkCommand = new Command("run").description("Check project configuration a
   }
 });
 
-export { checkCommand, runCheckAction as runCheckCommand };
+export { checkCommand, runCheckCommand };

package/dist/{chunk-RRGQCUKT.js → chunk-WJXC4MVY.js}

@@ -1,12 +1,17 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { createSuccessEnvelopeSchema, CLI_CONTRACT_VERSION } from './chunk-JT5SUTWE.js';
 import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { createSuccessEnvelopeSchema, CLI_CONTRACT_VERSION } from '@runa-ai/runa';
+export { CLI_CONTRACT_VERSION, ErrorEnvelopeSchema, createSuccessEnvelopeSchema } from '@runa-ai/runa';
+import { writeSync } from 'fs';
 import { z } from 'zod';
 
 createRequire(import.meta.url);
 
+// src/contracts/envelope.ts
+init_esm_shims();
+
 // src/cli/contract-output.ts
 init_esm_shims();
 function getCommandPath(cmd) {
@@ -24,6 +29,28 @@ function getCommandPath(cmd) {
 function markJsonEmitted() {
   process.env.RUNA_JSON_EMITTED = "true";
 }
+function writeJsonEnvelope(payload) {
+  const buffer = Buffer.from(payload, "utf-8");
+  const waitBuffer = new Int32Array(new SharedArrayBuffer(4));
+  let offset = 0;
+  while (offset < buffer.length) {
+    try {
+      const written = writeSync(process.stdout.fd, buffer, offset, buffer.length - offset);
+      if (written === 0) {
+        Atomics.wait(waitBuffer, 0, 0, 1);
+        continue;
+      }
+      offset += written;
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? String(error.code) : null;
+      if (code === "EAGAIN" || code === "EINTR") {
+        Atomics.wait(waitBuffer, 0, 0, 1);
+        continue;
+      }
+      throw error;
+    }
+  }
+}
 function emitDefaultSuccessIfNeeded(cmd) {
   if (getOutputFormatFromEnv() !== "json") return;
   if (process.env.RUNA_JSON_EMITTED === "true") return;
@@ -37,7 +64,7 @@ function emitDefaultSuccessIfNeeded(cmd) {
   try {
     const schema = createSuccessEnvelopeSchema(z.object({}).strict());
     const parsed = schema.parse(payload);
-    process.stdout.write(`${JSON.stringify(parsed)}
+    writeJsonEnvelope(`${JSON.stringify(parsed)}
 `);
   } finally {
     process.env.RUNA_JSON_EMITTING = "false";
@@ -45,4 +72,4 @@ function emitDefaultSuccessIfNeeded(cmd) {
   markJsonEmitted();
 }
 
-export { emitDefaultSuccessIfNeeded, markJsonEmitted };
+export { emitDefaultSuccessIfNeeded, markJsonEmitted, writeJsonEnvelope };

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

package/dist/{chunk-P7U52PBY.js → chunk-Z4Z5DNW4.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import { isPathContained } from './chunk-DRSUEMAK.js';
-import { emitJsonSuccess } from './chunk-UU55OH7P.js';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import { init_esm_shims, __dirname as __dirname$1 } from './chunk-VRXHCR5K.js';
 import * as fs2 from 'fs';
 import * as path3 from 'path';
@@ -1146,4 +1146,51 @@ async function injectTestAttrsAction(rawOptions, command) {
   }
 }
 
-export { injectTestAttrsAction, processFiles };
+// src/commands/inject-test-attrs/defaults.ts
+init_esm_shims();
+var DEFAULT_INCLUDE_PATTERNS = [
+  "app/**/*.tsx",
+  "app/**/*.ts",
+  "pages/**/*.tsx",
+  "pages/**/*.ts",
+  "src/**/*.tsx",
+  "src/**/*.ts",
+  "components/**/*.tsx",
+  "components/**/*.ts",
+  "hooks/**/*.tsx",
+  "hooks/**/*.ts",
+  "lib/**/*.tsx",
+  "lib/**/*.ts",
+  "machines/**/*.tsx",
+  "machines/**/*.ts",
+  "features/**/*.tsx",
+  "features/**/*.ts",
+  "modules/**/*.tsx",
+  "modules/**/*.ts",
+  "domain/**/*.tsx",
+  "domain/**/*.ts",
+  "screens/**/*.tsx",
+  "screens/**/*.ts",
+  "views/**/*.tsx",
+  "views/**/*.ts",
+  "routes/**/*.tsx",
+  "routes/**/*.ts",
+  "api/**/*.tsx",
+  "api/**/*.ts",
+  "server/**/*.tsx",
+  "server/**/*.ts",
+  "apps/**/*.tsx",
+  "apps/**/*.ts",
+  "packages/**/*.tsx",
+  "packages/**/*.ts"
+];
+var DEFAULT_EXCLUDE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/dist/**",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*.stories.*"
+];
+
+export { DEFAULT_EXCLUDE_PATTERNS, DEFAULT_INCLUDE_PATTERNS, injectTestAttrsAction, processFiles };