@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/chunk-VM3IWOT5.js

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { __esm, init_esm_shims, __export } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync } from 'fs';
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { BASE_PORTS } from '@runa-ai/runa';
+
+createRequire(import.meta.url);
+function isValidPort(value) {
+  if (typeof value !== "number") {
+    return false;
+  }
+  return Number.isInteger(value) && value > 0 && value < 65536;
+}
+function asPort(value, fallback) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : NaN;
+  return isValidPort(parsed) ? parsed : fallback;
+}
+function asHost(value) {
+  if (!value) return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function getStatusValue(status, keys) {
+  for (const key of keys) {
+    const value = status[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+function extractHost(rawUrl) {
+  if (!rawUrl) return null;
+  try {
+    return new URL(rawUrl).hostname;
+  } catch {
+    return null;
+  }
+}
+function extractPort(rawUrl) {
+  if (!rawUrl) return null;
+  try {
+    const port = new URL(rawUrl).port;
+    if (!port) return null;
+    const parsed = Number.parseInt(port, 10);
+    return isValidPort(parsed) ? parsed : null;
+  } catch {
+    const match = rawUrl.match(/:(\d+)\//);
+    if (!match) return null;
+    const parsed = Number.parseInt(match[1], 10);
+    return isValidPort(parsed) ? parsed : null;
+  }
+}
+function parseTomlPort(content, section, key) {
+  const sectionRegex = new RegExp(`\\[${section}\\]([\\s\\S]*?)(?=\\n\\[|$)`);
+  const sectionMatch = sectionRegex.exec(content);
+  if (!sectionMatch) return null;
+  const sectionContent = sectionMatch[1];
+  const keyRegex = new RegExp(`^\\s*${key}\\s*=\\s*(\\d+)`, "m");
+  const keyMatch = keyRegex.exec(sectionContent);
+  if (!keyMatch) return null;
+  const parsed = Number.parseInt(keyMatch[1], 10);
+  return isValidPort(parsed) ? parsed : null;
+}
+function parseTomlPorts(configRoot) {
+  const configPath = path.join(configRoot, "supabase", "config.toml");
+  if (!existsSync(configPath)) return null;
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return {
+      api: parseTomlPort(content, "api", "port"),
+      db: parseTomlPort(content, "db", "port")
+    };
+  } catch {
+    return null;
+  }
+}
+function detectStatus(projectRoot) {
+  try {
+    const result = spawnSync("supabase", ["status", "--output", "json"], {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    if (result.status !== 0 || !result.stdout) return null;
+    const jsonMatch = result.stdout.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return null;
+    return JSON.parse(jsonMatch[0]);
+  } catch {
+    return null;
+  }
+}
+function resolveSupabaseRoot(projectRoot) {
+  const start = path.resolve(projectRoot);
+  let current = start;
+  while (true) {
+    if (existsSync(path.join(current, "supabase", "config.toml"))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return start;
+    }
+    current = parent;
+  }
+}
+function isAllowedLocalhostHost(host) {
+  return host === "127.0.0.1" || host === "localhost" || host === "host.docker.internal";
+}
+function buildDetectionCacheKey(projectRoot) {
+  return [
+    projectRoot,
+    process.env.LOCAL_SUPABASE_HOST ?? "",
+    process.env.LOCAL_SUPABASE_API_PORT ?? "",
+    process.env.LOCAL_SUPABASE_DB_PORT ?? "",
+    process.env.LOCAL_SUPABASE_STUDIO_PORT ?? ""
+  ].join("|");
+}
+function readSupabaseOverrides() {
+  return {
+    host: asHost(process.env.LOCAL_SUPABASE_HOST),
+    api: asPort(process.env.LOCAL_SUPABASE_API_PORT, DEFAULT_API_PORT),
+    db: asPort(process.env.LOCAL_SUPABASE_DB_PORT, DEFAULT_DB_PORT),
+    studio: asPort(process.env.LOCAL_SUPABASE_STUDIO_PORT, DEFAULT_STUDIO_PORT)
+  };
+}
+function detectLocalSupabasePorts(projectRoot = process.cwd()) {
+  const resolvedRoot = resolveSupabaseRoot(projectRoot);
+  const cacheKey = buildDetectionCacheKey(resolvedRoot);
+  if (detectionCache?.key === cacheKey) {
+    return detectionCache.config;
+  }
+  const overrides = readSupabaseOverrides();
+  const explicitHost = asHost(process.env.LOCAL_SUPABASE_HOST);
+  const explicitApiPort = process.env.LOCAL_SUPABASE_API_PORT;
+  const explicitDbPort = process.env.LOCAL_SUPABASE_DB_PORT;
+  const explicitStudioPort = process.env.LOCAL_SUPABASE_STUDIO_PORT;
+  if (explicitHost && explicitApiPort && explicitDbPort) {
+    const explicitConfig = {
+      host: explicitHost,
+      api: asPort(explicitApiPort, DEFAULT_API_PORT),
+      db: asPort(explicitDbPort, DEFAULT_DB_PORT),
+      studio: asPort(explicitStudioPort, DEFAULT_STUDIO_PORT)
+    };
+    detectionCache = {
+      key: cacheKey,
+      config: explicitConfig
+    };
+    return explicitConfig;
+  }
+  const status = detectStatus(resolvedRoot);
+  const tomlPorts = parseTomlPorts(resolvedRoot);
+  const statusApiUrl = status ? getStatusValue(status, ["API_URL", "API URL", "api_url"]) : null;
+  const statusDbUrl = status ? getStatusValue(status, ["DB_URL", "DB URL", "db_url"]) : null;
+  const statusStudioUrl = status ? getStatusValue(status, ["STUDIO_URL", "Studio URL", "studio_url"]) : null;
+  const detectedHost = asHost(
+    overrides.host ?? extractHost(statusApiUrl) ?? extractHost(statusDbUrl) ?? extractHost(statusStudioUrl)
+  );
+  const detectedApiPort = asPort(
+    overrides.api !== DEFAULT_API_PORT ? overrides.api : void 0,
+    extractPort(statusApiUrl) ?? tomlPorts?.api ?? DEFAULT_API_PORT
+  );
+  const detectedDbPort = asPort(
+    overrides.db !== DEFAULT_DB_PORT ? overrides.db : void 0,
+    extractPort(statusDbUrl) ?? tomlPorts?.db ?? DEFAULT_DB_PORT
+  );
+  const detectedStudioPort = asPort(
+    overrides.studio !== DEFAULT_STUDIO_PORT ? overrides.studio : void 0,
+    extractPort(statusStudioUrl) ?? detectedApiPort + 2
+  );
+  const detectedConfig = {
+    host: detectedHost ?? DEFAULT_HOST,
+    api: detectedApiPort,
+    db: detectedDbPort,
+    studio: detectedStudioPort
+  };
+  detectionCache = {
+    key: cacheKey,
+    config: detectedConfig
+  };
+  return detectedConfig;
+}
+function buildLocalSupabaseUrl(projectRoot = process.cwd()) {
+  const config = detectLocalSupabasePorts(projectRoot);
+  return `http://${config.host}:${config.api}`;
+}
+function buildLocalDatabaseUrl(projectRoot = process.cwd()) {
+  const config = detectLocalSupabasePorts(projectRoot);
+  return `postgresql://postgres:postgres@${config.host}:${config.db}/postgres`;
+}
+function getLocalSupabaseEnvValues(projectRoot = process.cwd()) {
+  const config = detectLocalSupabasePorts(projectRoot);
+  const supabaseUrl = buildLocalSupabaseUrl(projectRoot);
+  const databaseUrl = buildLocalDatabaseUrl(projectRoot);
+  return {
+    LOCAL_SUPABASE_HOST: config.host,
+    LOCAL_SUPABASE_API_PORT: String(config.api),
+    LOCAL_SUPABASE_DB_PORT: String(config.db),
+    DATABASE_URL: databaseUrl,
+    DATABASE_URL_ADMIN: databaseUrl,
+    DATABASE_URL_SERVICE: databaseUrl,
+    NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: LOCAL_SUPABASE_ANON_KEY,
+    SUPABASE_SERVICE_ROLE_KEY: LOCAL_SUPABASE_SERVICE_ROLE_KEY
+  };
+}
+function getLocalValueDescriptions(projectRoot = process.cwd()) {
+  const config = detectLocalSupabasePorts(projectRoot);
+  return {
+    LOCAL_SUPABASE_HOST: `supabase local host ${config.host}`,
+    LOCAL_SUPABASE_API_PORT: `supabase local api port ${config.api}`,
+    LOCAL_SUPABASE_DB_PORT: `supabase local db port ${config.db}`,
+    DATABASE_URL: `supabase local DB ${config.host}:${config.db}`,
+    DATABASE_URL_ADMIN: `supabase local DB ${config.host}:${config.db}`,
+    DATABASE_URL_SERVICE: `supabase local DB ${config.host}:${config.db}`,
+    NEXT_PUBLIC_SUPABASE_URL: `supabase local API ${config.host}:${config.api}`,
+    NEXT_PUBLIC_SUPABASE_ANON_KEY: "local anon key (supabase-demo)",
+    SUPABASE_SERVICE_ROLE_KEY: "local service key (supabase-demo)"
+  };
+}
+function validateLocalhostValues(envValues) {
+  const urlKeys = [
+    "DATABASE_URL",
+    "DATABASE_URL_ADMIN",
+    "DATABASE_URL_SERVICE",
+    "NEXT_PUBLIC_SUPABASE_URL"
+  ];
+  const invalidEntries = [];
+  for (const key of urlKeys) {
+    const value = envValues[key];
+    if (!value) continue;
+    try {
+      const hostname = new URL(value).hostname;
+      if (!isAllowedLocalhostHost(hostname)) {
+        invalidEntries.push(key);
+      }
+    } catch {
+      invalidEntries.push(key);
+    }
+  }
+  if (invalidEntries.length > 0) {
+    throw new Error(
+      `Local Supabase replacement aborted: not a local endpoint. The following keys are not local: ${invalidEntries.join(", ")}`
+    );
+  }
+}
+var DEFAULT_HOST, DEFAULT_API_PORT, DEFAULT_DB_PORT, DEFAULT_STUDIO_PORT, detectionCache, LOCAL_SUPABASE_ANON_KEY, LOCAL_SUPABASE_SERVICE_ROLE_KEY, LOCAL_SUPABASE_ENV_VALUES;
+var init_local_supabase = __esm({
+  "src/commands/env/constants/local-supabase.ts"() {
+    init_esm_shims();
+    DEFAULT_HOST = "127.0.0.1";
+    DEFAULT_API_PORT = BASE_PORTS.api;
+    DEFAULT_DB_PORT = BASE_PORTS.db;
+    DEFAULT_STUDIO_PORT = BASE_PORTS.studio;
+    detectionCache = null;
+    LOCAL_SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6ImFub24iLCJleHAiOjE5ODM4MTI5OTZ9.CRXP1A7WOeoJeXxjNni43kdQwgnWNReilDMblYTn_I0";
+    LOCAL_SUPABASE_SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJzdJsyH-qQwv8Hdp7fsn3W0YpN81IU";
+    LOCAL_SUPABASE_ENV_VALUES = getLocalSupabaseEnvValues();
+    getLocalValueDescriptions();
+    validateLocalhostValues(LOCAL_SUPABASE_ENV_VALUES);
+  }
+});
+
+// src/commands/db/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  DATABASE_DEFAULTS: () => DATABASE_DEFAULTS,
+  ERROR_MESSAGES: () => ERROR_MESSAGES,
+  SCRIPT_LOCATIONS: () => SCRIPT_LOCATIONS,
+  SEED_DEFAULTS: () => SEED_DEFAULTS,
+  detectSupabasePorts: () => detectSupabasePorts,
+  getSupabaseAccessPoints: () => getSupabaseAccessPoints
+});
+function detectSupabasePorts(projectRoot) {
+  const cwd = projectRoot || process.cwd();
+  const result = spawnSync("supabase", ["status", "--output", "json"], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+    timeout: 5e3,
+    // 5 second timeout
+    cwd
+  });
+  if (result.status !== 0 || !result.stdout) {
+    throw new Error(
+      "Supabase is not running.\n\nStart Supabase with: supabase start\nOr run: runa check --fix"
+    );
+  }
+  let status;
+  try {
+    status = JSON.parse(result.stdout);
+  } catch {
+    throw new Error(
+      "Failed to parse Supabase status output.\n\nTry restarting Supabase: supabase stop && supabase start"
+    );
+  }
+  const apiUrl = status.API_URL || status["API URL"] || status.api_url;
+  const dbUrl = status.DB_URL || status["DB URL"] || status.db_url;
+  const studioUrl = status.STUDIO_URL || status["Studio URL"] || status.studio_url;
+  const extractPort2 = (url) => {
+    try {
+      const parsed = new URL(url);
+      return parsed.port ? Number.parseInt(parsed.port, 10) : null;
+    } catch {
+      const match = url.match(/:(\d+)\//);
+      return match ? Number.parseInt(match[1], 10) : null;
+    }
+  };
+  const apiPort = apiUrl ? extractPort2(apiUrl) : null;
+  const dbPort = dbUrl ? extractPort2(dbUrl) : null;
+  const studioPort = studioUrl ? extractPort2(studioUrl) : null;
+  if (!apiPort || !dbPort) {
+    throw new Error(
+      "Could not detect Supabase ports from status output.\n\nTry restarting Supabase: supabase stop && supabase start"
+    );
+  }
+  return {
+    api: apiPort,
+    db: dbPort,
+    studio: studioPort ?? apiPort + 2
+  };
+}
+function getSupabaseAccessPoints(projectRoot) {
+  const ports = detectLocalSupabasePorts(projectRoot);
+  const buildSupabaseUrl = (port) => {
+    const url = new URL(buildLocalSupabaseUrl(projectRoot));
+    url.port = String(port);
+    return url.toString().replace(/\/$/, "");
+  };
+  return {
+    studio: buildSupabaseUrl(ports.studio),
+    api: buildLocalSupabaseUrl(projectRoot),
+    db: buildLocalDatabaseUrl(projectRoot)
+  };
+}
+var DATABASE_DEFAULTS, SEED_DEFAULTS, SCRIPT_LOCATIONS, ERROR_MESSAGES;
+var init_constants = __esm({
+  "src/commands/db/constants.ts"() {
+    init_esm_shims();
+    init_local_supabase();
+    DATABASE_DEFAULTS = {
+      // Supabase Local defaults (for development)
+      // Note: PORT is detected from running Supabase instance
+      // AI HINT: Local Supabase Default Credentials (Non-Production)
+      // postgres:postgres is the standard default for `supabase start`.
+      // This is a documented public value, not a secret.
+      // Production uses environment variables via .env.production.
+      SUPABASE_LOCAL: {
+        get HOST() {
+          return detectLocalSupabasePorts().host;
+        },
+        get PORT() {
+          return detectSupabasePorts().db;
+        },
+        USER: "postgres",
+        PASSWORD: "postgres",
+        DATABASE: "postgres"
+      },
+      // Standard PostgreSQL defaults (more generic)
+      POSTGRES: {
+        HOST: "127.0.0.1",
+        PORT: 5432,
+        USER: "postgres",
+        PASSWORD: "",
+        DATABASE: "postgres"
+      },
+      // Timeouts
+      CONNECTION_TIMEOUT_MS: 5e3,
+      SCRIPT_TIMEOUT_MS: 3e5,
+      // 5 minutes for schema/seed operations
+      // Get actual connection URL from environment or default
+      get defaultUrl() {
+        if (process.env.NODE_ENV === "production") {
+          if (!process.env.DATABASE_URL) {
+            throw new Error(
+              "DATABASE_URL is required in production environment.\nSet DATABASE_URL environment variable or configure in .env file."
+            );
+          }
+          return process.env.DATABASE_URL;
+        }
+        const databaseUrl = process.env.DATABASE_URL;
+        if (databaseUrl) {
+          try {
+            const url2 = new URL(databaseUrl);
+            const isLocalhost = url2.hostname === "127.0.0.1" || url2.hostname === "localhost" || url2.hostname === "host.docker.internal";
+            if (isLocalhost) {
+              return databaseUrl;
+            }
+          } catch {
+          }
+        }
+        const host = process.env.LOCAL_DB_HOST || process.env.DB_HOST || process.env.LOCAL_SUPABASE_HOST || this.SUPABASE_LOCAL.HOST;
+        const port = process.env.LOCAL_DB_PORT || process.env.DB_PORT || process.env.LOCAL_SUPABASE_DB_PORT || String(this.SUPABASE_LOCAL.PORT);
+        const user = process.env.LOCAL_DB_USER || process.env.DB_USER || this.SUPABASE_LOCAL.USER;
+        const password = process.env.LOCAL_DB_PASSWORD || process.env.DB_PASSWORD || this.SUPABASE_LOCAL.PASSWORD;
+        const database = process.env.LOCAL_DB_NAME || process.env.DB_NAME || this.SUPABASE_LOCAL.DATABASE;
+        const url = `postgresql://${user}:${password}@${host}:${port}/${database}`;
+        if (!process.env.DATABASE_URL && !process.env.LOCAL_DB_HOST && !process.env.DB_HOST) ;
+        return url;
+      }
+    };
+    SEED_DEFAULTS = {
+      // Unified 'ci.sql' for local and CI/preview (production does not use seeds)
+      REQUIRED_FILES: ["ci.sql"],
+      // Generic default paths (used only if config.toml parse fails)
+      // Projects should define their own sql_paths in config.toml
+      DEFAULT_PATHS: [
+        "./seeds/[0-9]*.sql",
+        // Prerequisite seeds (e.g., 00_auth_users.sql)
+        "./seeds/ci.sql"
+        // Unified seed for local and CI/preview
+      ],
+      CONFIG_SECTION: "[db.seed]"
+    };
+    SCRIPT_LOCATIONS = {
+      VALIDATE_SCHEMAS: {
+        relativePath: "supabase/validate-schemas.sh",
+        description: "Schema validation script",
+        required: true
+      },
+      DETECT_RISKS: {
+        relativePath: "supabase/detect-risks.sh",
+        description: "Risk detection script",
+        required: true
+      },
+      APPLY_SCHEMAS: {
+        relativePath: "supabase/apply-schemas.sh",
+        description: "Schema application script",
+        required: true
+      },
+      APPLY_SEEDS: {
+        relativePath: "packages/sdk/scripts/apply-seeds.sh",
+        description: "Seed application script (SDK)",
+        required: false
+      },
+      GENERATE_TYPES: {
+        relativePath: "packages/sdk/scripts/generate-types.sh",
+        description: "Type generation script (SDK)",
+        required: false
+      }
+    };
+    ERROR_MESSAGES = {
+      SCRIPT_NOT_FOUND: (scriptName, expectedPath) => `${scriptName} not found
+
+Expected location: ${expectedPath}`,
+      SEED_DIR_NOT_FOUND: "Seed directory not found\n\nRun: runa db seed init",
+      CONFIG_PARSE_FAILED: "Failed to parse config.toml, using default seed paths",
+      VALIDATION_FAILED: "Schema validation failed",
+      RISK_DETECTION_FAILED: "Risk detection failed",
+      SEED_VALIDATION_FAILED: "Seed validation failed",
+      TYPE_GENERATION_FAILED: "Type generation failed"
+    };
+  }
+});
+
+export { DATABASE_DEFAULTS, SCRIPT_LOCATIONS, SEED_DEFAULTS, buildLocalDatabaseUrl, constants_exports, detectLocalSupabasePorts, detectSupabasePorts, getLocalSupabaseEnvValues, getLocalValueDescriptions, init_constants, init_local_supabase };

package/dist/chunk-VRXHCR5K.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const require$1 = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require$1 !== "undefined" ? require$1 : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require$1 !== "undefined" ? require$1 : a)[b]
+}) : x)(function(x) {
+  if (typeof require$1 !== "undefined") return require$1.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getFilename, getDirname, __dirname$1;
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname$1 = /* @__PURE__ */ getDirname();
+  }
+});
+
+export { __dirname$1 as __dirname, __esm, __export, __require, __toCommonJS, init_esm_shims };

package/dist/chunk-WJXC4MVY.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+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) {
+  const parts = [];
+  let cur = cmd;
+  while (cur) {
+    const name = cur.name?.();
+    if (name && name !== "runa") {
+      parts.unshift(name);
+    }
+    cur = cur.parent ?? null;
+  }
+  return parts.length > 0 ? `runa ${parts.join(" ")}` : "runa";
+}
+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;
+  const payload = {
+    version: CLI_CONTRACT_VERSION,
+    ok: true,
+    command: getCommandPath(cmd),
+    data: {}
+  };
+  process.env.RUNA_JSON_EMITTING = "true";
+  try {
+    const schema = createSuccessEnvelopeSchema(z.object({}).strict());
+    const parsed = schema.parse(payload);
+    writeJsonEnvelope(`${JSON.stringify(parsed)}
+`);
+  } finally {
+    process.env.RUNA_JSON_EMITTING = "false";
+  }
+  markJsonEmitted();
+}
+
+export { emitDefaultSuccessIfNeeded, markJsonEmitted, writeJsonEnvelope };