prisma-sharding 0.0.5 → 0.0.7

package/dist/cli/update.js

@@ -25,109 +25,374 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/cli/update.ts
 var import_config = require("dotenv/config");
+
+// src/utils/env.ts
+var parseBooleanEnv = (name, defaultValue, env = process.env) => {
+  const value = env[name]?.trim();
+  if (value === void 0 || value === "") {
+    return defaultValue;
+  }
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+};
+var isVerboseEnv = (names, env = process.env) => names.some((name) => parseBooleanEnv(name, false, env));
+
+// src/cli/utils/command.ts
 var import_child_process = require("child_process");
 var import_path = __toESM(require("path"));
-var getShardConfigs = () => {
-  const shards = [];
-  const shardCount = parseInt(process.env.SHARD_COUNT || "0", 10);
-  for (let i = 1; i <= shardCount; i++) {
-    const url = process.env[`SHARD_${i}_URL`];
-    if (url) {
-      shards.push({ id: `shard_${i}`, url });
+
+// src/constants/internal.ts
+var INTERNAL_DEFAULTS = {
+  HEALTH_CHECK_TIMEOUT_MS: 5e3,
+  CROSS_SHARD_CONCURRENCY: 4,
+  CROSS_SHARD_TIMEOUT_MS: 1e4,
+  CLI_COMMAND_TIMEOUT_MS: 12e4,
+  CLI_FORCE_KILL_GRACE_MS: 5e3,
+  CLI_MAX_OUTPUT_LENGTH: 1e6,
+  CLI_TEST_TCP_TIMEOUT_MS: 5e3,
+  CLI_TEST_COMMAND_TIMEOUT_MS: 15e3,
+  STUDIO_BASE_PORT: 51212,
+  STUDIO_REUSE_EXISTING: true,
+  STUDIO_STRICT_PORT_CHECK: false,
+  STUDIO_START_TIMEOUT_MS: 15e3,
+  STUDIO_STABILITY_MS: 500,
+  STUDIO_SHUTDOWN_TIMEOUT_MS: 5e3
+};
+
+// src/utils/sanitize.ts
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var maskDatabaseUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
+    }
+    return parsed.toString();
+  } catch {
+    return url.replace(/:[^:@]+@/, ":***@");
+  }
+};
+var sanitizeDatabaseText = (output, databaseUrls) => {
+  let sanitized = output;
+  for (const url of databaseUrls) {
+    sanitized = sanitized.replace(new RegExp(escapeRegExp(url), "g"), maskDatabaseUrl(url));
+    try {
+      const password = new URL(url).password;
+      if (password.length >= 4) {
+        sanitized = sanitized.replace(
+          new RegExp(escapeRegExp(decodeURIComponent(password)), "g"),
+          "***"
+        );
+      }
+    } catch {
+    }
+  }
+  return sanitized.replace(
+    /(postgres(?:ql)?:\/\/[^:/\s]+:)[^@\s]+(@)/gi,
+    "$1***$2"
+  );
+};
+
+// src/cli/utils/process.ts
+var isChildProcessRunning = (childProcess) => {
+  return childProcess.exitCode === null && childProcess.signalCode === null;
+};
+var terminateChildProcess = (childProcess, options = {}) => {
+  if (!isChildProcessRunning(childProcess)) {
+    return false;
+  }
+  const signal = options.signal || "SIGTERM";
+  try {
+    if (options.processGroup && childProcess.pid && process.platform !== "win32") {
+      try {
+        process.kill(-childProcess.pid, signal);
+        return true;
+      } catch {
+      }
     }
+    return childProcess.kill(signal);
+  } catch {
+    return false;
+  }
+};
+
+// src/cli/utils/command.ts
+var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+var OUTPUT_TRUNCATED_MARKER = "\n[output truncated]\n";
+var appendBoundedOutput = (current, chunk, limit) => {
+  const combined = current + chunk;
+  if (combined.length <= limit) {
+    return combined;
   }
-  if (shards.length === 0 && process.env.DATABASE_URL) {
-    shards.push({ id: "shard_1", url: process.env.DATABASE_URL });
+  if (limit <= OUTPUT_TRUNCATED_MARKER.length) {
+    return combined.slice(-limit);
   }
-  return shards;
+  return OUTPUT_TRUNCATED_MARKER + combined.slice(-(limit - OUTPUT_TRUNCATED_MARKER.length));
 };
-var runCommand = (command, args, env = process.env, cwd = process.cwd()) => {
+var sanitizeCommandOutput = (output, env = process.env) => {
+  const databaseUrls = Object.entries(env).filter(
+    ([name, value]) => Boolean(value) && (name === "DATABASE_URL" || /^SHARD_\d+_URL$/.test(name))
+  ).map(([, value]) => value);
+  return sanitizeDatabaseText(output, databaseUrls).replace(/(\bpassword\s*[=:]\s*)[^\s,;]+/gi, "$1***");
+};
+var runCommand = (command, args, options = {}) => {
   return new Promise((resolve) => {
-    const proc = (0, import_child_process.spawn)(command, args, {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let forceKillTimeout;
+    const env = options.env || process.env;
+    const timeoutMs = options.timeoutMs ?? INTERNAL_DEFAULTS.CLI_COMMAND_TIMEOUT_MS;
+    const forceKillGraceMs = options.forceKillGraceMs ?? INTERNAL_DEFAULTS.CLI_FORCE_KILL_GRACE_MS;
+    const maxOutputLength = options.maxOutputLength ?? INTERNAL_DEFAULTS.CLI_MAX_OUTPUT_LENGTH;
+    const processGroup = process.platform !== "win32";
+    const child = (0, import_child_process.spawn)(command, args, {
       env,
-      cwd: import_path.default.resolve(cwd),
-      shell: true
-    });
-    let output = "";
-    let errorOutput = "";
-    proc.stdout.on("data", (data) => {
-      process.stdout.write(data);
-      output += data.toString();
+      cwd: import_path.default.resolve(options.cwd || process.cwd()),
+      detached: processGroup,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
     });
-    proc.stderr.on("data", (data) => {
-      process.stderr.write(data);
-      errorOutput += data.toString();
+    const settle = (result) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        if (forceKillTimeout) {
+          clearTimeout(forceKillTimeout);
+        }
+        const sanitizedResult = {
+          ...result,
+          stdout: sanitizeCommandOutput(result.stdout, env),
+          stderr: sanitizeCommandOutput(result.stderr, env),
+          error: result.error ? sanitizeCommandOutput(result.error, env) : void 0
+        };
+        if (options.verbose) {
+          if (sanitizedResult.stdout) {
+            process.stdout.write(sanitizedResult.stdout);
+          }
+          if (sanitizedResult.stderr) {
+            process.stderr.write(sanitizedResult.stderr);
+          }
+        }
+        resolve(sanitizedResult);
+      }
+    };
+    child.stdout?.on("data", (data) => {
+      if (!settled) {
+        stdout = appendBoundedOutput(stdout, data.toString(), maxOutputLength);
+      }
     });
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve({ success: true, output });
-      } else {
-        resolve({ success: false, output, error: errorOutput || `Exit code: ${code}` });
+    child.stderr?.on("data", (data) => {
+      if (!settled) {
+        stderr = appendBoundedOutput(stderr, data.toString(), maxOutputLength);
       }
     });
-    proc.on("error", (err) => {
-      resolve({ success: false, output, error: err.message });
+    child.once("error", (error) => {
+      settle({
+        success: false,
+        stdout,
+        stderr,
+        exitCode: null,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : error.message
+      });
+    });
+    child.once("close", (exitCode) => {
+      settle({
+        success: !timedOut && exitCode === 0,
+        stdout,
+        stderr,
+        exitCode,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${exitCode}`
+      });
     });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminateChildProcess(child, { signal: "SIGTERM", processGroup });
+      forceKillTimeout = setTimeout(() => {
+        terminateChildProcess(child, { signal: "SIGKILL", processGroup });
+        settle({
+          success: false,
+          stdout,
+          stderr,
+          exitCode: null,
+          error: `Command timed out after ${timeoutMs}ms`
+        });
+      }, forceKillGraceMs);
+      forceKillTimeout.unref?.();
+    }, timeoutMs);
+    timeout.unref?.();
   });
 };
-var updateAll = async () => {
-  console.log("\n" + "=".repeat(60));
-  console.log("\u{1F504} PRISMA SHARDING UPDATE");
-  console.log("=".repeat(60) + "\n");
-  console.log("\u{1F6E0}\uFE0F  Step 1: Generating Prisma Client Types...");
-  const genResult = await runCommand("npx", ["prisma", "generate"]);
-  if (!genResult.success) {
-    console.error("\n\u274C Failed to generate client. Aborting migration.");
-    process.exit(1);
+var runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
+
+// src/cli/utils/output.ts
+var import_readline = __toESM(require("readline"));
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var printCliHeader = (icon, title) => {
+  console.log(`${icon} ${title}
+`);
+};
+var printCliRow = (icon, label, message) => {
+  console.log(`${icon} ${label}  ${message}`);
+};
+var printVerboseHint = () => {
+  console.log("\nRun with SHARD_CLI_VERBOSE=true for details.");
+};
+var createCliLoader = (label, message, enabled = true) => {
+  const animated = enabled && Boolean(process.stdout.isTTY);
+  let frameIndex = 0;
+  let timer;
+  let finished = false;
+  const clear = () => {
+    if (animated) {
+      import_readline.default.clearLine(process.stdout, 0);
+      import_readline.default.cursorTo(process.stdout, 0);
+    }
+  };
+  const render = () => {
+    clear();
+    process.stdout.write(`${SPINNER_FRAMES[frameIndex]} ${label}  ${message}`);
+    frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+  };
+  if (animated) {
+    render();
+    timer = setInterval(render, 80);
   }
-  console.log("\u2705 Client types generated successfully.\n");
-  const shards = getShardConfigs();
-  const extraArgs = process.argv.slice(2);
-  console.log("\u{1F4E6} Step 2: Migrating Shards...");
-  console.log(`\u{1F4CA} Total shards to migrate: ${shards.length}`);
-  if (extraArgs.length > 0) {
-    console.log(`\u{1F527} Using flags: ${extraArgs.join(" ")}`);
+  const finish = (icon, finalMessage) => {
+    if (finished) {
+      return;
+    }
+    finished = true;
+    if (timer) {
+      clearInterval(timer);
+    }
+    clear();
+    printCliRow(icon, label, finalMessage);
+  };
+  return {
+    succeed: (finalMessage) => finish("\u2705", finalMessage),
+    fail: (finalMessage) => finish("\u274C", finalMessage)
+  };
+};
+
+// src/cli/utils/shards.ts
+var NO_SHARDS_CONFIGURED_MESSAGE = "No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables.";
+var getShardConfigResult = (env = process.env) => {
+  const shards = [];
+  const missingShardIds = [];
+  const shardCount = parseInt(env.SHARD_COUNT || "0", 10);
+  for (let i = 1; i <= shardCount; i++) {
+    const url = env[`SHARD_${i}_URL`];
+    if (url) {
+      shards.push({ id: `shard_${i}`, index: i - 1, url });
+    } else {
+      missingShardIds.push(`shard_${i}`);
+    }
   }
-  console.log("");
-  if (shards.length === 0) {
-    console.error(
-      "\u274C No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables."
+  if (shards.length === 0 && env.DATABASE_URL) {
+    shards.push({ id: "shard_1", index: 0, url: env.DATABASE_URL });
+  }
+  return { shards, missingShardIds };
+};
+var maskShardUrl = maskDatabaseUrl;
+
+// src/cli/utils/prisma.ts
+var executeShardCommand = async (shard, commandArgs, verbose, action) => {
+  const commandEnv = { ...process.env, DATABASE_URL: shard.url };
+  if (verbose) {
+    console.log(`
+${action} ${shard.id}...`);
+    console.log(`Database: ${maskShardUrl(shard.url)}
+`);
+    console.log(
+      `Command: ${sanitizeCommandOutput(`prisma ${commandArgs.join(" ")}`, commandEnv)}`
     );
-    process.exit(1);
   }
+  const result = await runPrismaCommand(commandArgs, {
+    env: commandEnv,
+    verbose
+  });
+  if (verbose) {
+    console.log(`Exit code: ${result.exitCode ?? "unavailable"}`);
+  }
+  if (verbose && result.error && !result.stderr.trim() && !result.stdout.trim()) {
+    console.error(result.error);
+  }
+  if (verbose && !result.success) {
+    console.error(`Next: verify ${shard.id} connectivity and migration state, then retry.`);
+  }
+  return result;
+};
+var runShardCommands = async ({
+  shards,
+  args,
+  extraArgs,
+  verbose,
+  action
+}) => {
   const results = [];
   for (const shard of shards) {
-    console.log(`
-\u{1F449} Processing ${shard.id}...`);
-    const env = { ...process.env, DATABASE_URL: shard.url };
-    const args = ["prisma", "db", "push", "--accept-data-loss", ...extraArgs];
-    const { success, output, error } = await runCommand("npx", args, env);
-    if (!success) {
-      console.error(`   \u274C Failed`);
-      results.push({ shardId: shard.id, success: false, output, error });
+    const loader = createCliLoader(shard.id, action, !verbose);
+    const commandArgs = [...args, ...extraArgs];
+    const result = await executeShardCommand(shard, commandArgs, verbose, action);
+    results.push({ shardId: shard.id, success: result.success });
+    if (result.success) {
+      loader.succeed("Synced");
     } else {
-      console.log(`   \u2705 Success`);
-      results.push({ shardId: shard.id, success: true, output });
+      loader.fail("Failed");
     }
   }
-  console.log("\n" + "=".repeat(60));
-  console.log("\u{1F4CB} Update Summary");
-  console.log("=".repeat(60));
-  const successful = results.filter((r) => r.success).length;
-  const failed = results.filter((r) => !r.success).length;
-  results.forEach((result) => {
-    const status = result.success ? "\u2705" : "\u274C";
-    console.log(`   ${status} ${result.shardId}`);
-  });
-  console.log(`
-   Total: ${results.length} | Success: ${successful} | Failed: ${failed}`);
+  return results;
+};
+var syncShardSchemas = (shards, extraArgs, verbose) => runShardCommands({
+  shards,
+  args: ["db", "push"],
+  extraArgs,
+  verbose,
+  action: "Syncing"
+});
+
+// src/cli/update.ts
+var updateAll = async () => {
+  const verbose = isVerboseEnv(["SHARD_UPDATE_VERBOSE", "SHARD_CLI_VERBOSE"]);
+  const { shards, missingShardIds } = getShardConfigResult();
+  const extraArgs = process.argv.slice(2);
+  printCliHeader("\u{1F504}", "Prisma Sharding Update");
+  if (missingShardIds.length > 0) {
+    printCliRow("\u274C", "config", `Missing shard URLs: ${missingShardIds.join(", ")}`);
+    process.exit(1);
+  }
+  if (shards.length === 0) {
+    printCliRow("\u274C", "config", NO_SHARDS_CONFIGURED_MESSAGE);
+    process.exit(1);
+  }
+  if (verbose) {
+    console.log("Generating Prisma Client...\n");
+  }
+  const generateLoader = createCliLoader("client", "Generating", !verbose);
+  const generateResult = await runPrismaCommand(["generate"], { verbose });
+  if (verbose && generateResult.error && !generateResult.stderr.trim() && !generateResult.stdout.trim()) {
+    console.error(generateResult.error);
+  }
+  if (!generateResult.success) {
+    generateLoader.fail("Generation failed");
+    if (!verbose) {
+      printVerboseHint();
+    }
+    process.exit(1);
+  }
+  generateLoader.succeed("Generated");
+  const results = await syncShardSchemas(shards, extraArgs, verbose);
+  const successful = results.filter((result) => result.success).length;
+  const failed = results.length - successful;
   if (failed > 0) {
-    console.log("\n\u26A0\uFE0F  Some migrations failed. Run with --force-reset if needed.");
+    if (!verbose) {
+      printVerboseHint();
+    }
     process.exit(1);
   }
-  console.log("\n\u2728 All updates completed successfully!");
 };
 updateAll().catch((error) => {
-  console.error("Update script failed:", error);
+  console.error(error instanceof Error ? error.message : String(error));
   process.exit(1);
 });

package/dist/cli/utils/command.js

@@ -0,0 +1,232 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/utils/command.ts
+var command_exports = {};
+__export(command_exports, {
+  getNpxCommand: () => getNpxCommand,
+  runCommand: () => runCommand,
+  runPrismaCommand: () => runPrismaCommand,
+  sanitizeCommandOutput: () => sanitizeCommandOutput
+});
+module.exports = __toCommonJS(command_exports);
+var import_child_process = require("child_process");
+var import_path = __toESM(require("path"));
+
+// src/constants/internal.ts
+var INTERNAL_DEFAULTS = {
+  HEALTH_CHECK_TIMEOUT_MS: 5e3,
+  CROSS_SHARD_CONCURRENCY: 4,
+  CROSS_SHARD_TIMEOUT_MS: 1e4,
+  CLI_COMMAND_TIMEOUT_MS: 12e4,
+  CLI_FORCE_KILL_GRACE_MS: 5e3,
+  CLI_MAX_OUTPUT_LENGTH: 1e6,
+  CLI_TEST_TCP_TIMEOUT_MS: 5e3,
+  CLI_TEST_COMMAND_TIMEOUT_MS: 15e3,
+  STUDIO_BASE_PORT: 51212,
+  STUDIO_REUSE_EXISTING: true,
+  STUDIO_STRICT_PORT_CHECK: false,
+  STUDIO_START_TIMEOUT_MS: 15e3,
+  STUDIO_STABILITY_MS: 500,
+  STUDIO_SHUTDOWN_TIMEOUT_MS: 5e3
+};
+
+// src/utils/sanitize.ts
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var maskDatabaseUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
+    }
+    return parsed.toString();
+  } catch {
+    return url.replace(/:[^:@]+@/, ":***@");
+  }
+};
+var sanitizeDatabaseText = (output, databaseUrls) => {
+  let sanitized = output;
+  for (const url of databaseUrls) {
+    sanitized = sanitized.replace(new RegExp(escapeRegExp(url), "g"), maskDatabaseUrl(url));
+    try {
+      const password = new URL(url).password;
+      if (password.length >= 4) {
+        sanitized = sanitized.replace(
+          new RegExp(escapeRegExp(decodeURIComponent(password)), "g"),
+          "***"
+        );
+      }
+    } catch {
+    }
+  }
+  return sanitized.replace(
+    /(postgres(?:ql)?:\/\/[^:/\s]+:)[^@\s]+(@)/gi,
+    "$1***$2"
+  );
+};
+
+// src/cli/utils/process.ts
+var isChildProcessRunning = (childProcess) => {
+  return childProcess.exitCode === null && childProcess.signalCode === null;
+};
+var terminateChildProcess = (childProcess, options = {}) => {
+  if (!isChildProcessRunning(childProcess)) {
+    return false;
+  }
+  const signal = options.signal || "SIGTERM";
+  try {
+    if (options.processGroup && childProcess.pid && process.platform !== "win32") {
+      try {
+        process.kill(-childProcess.pid, signal);
+        return true;
+      } catch {
+      }
+    }
+    return childProcess.kill(signal);
+  } catch {
+    return false;
+  }
+};
+
+// src/cli/utils/command.ts
+var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+var OUTPUT_TRUNCATED_MARKER = "\n[output truncated]\n";
+var appendBoundedOutput = (current, chunk, limit) => {
+  const combined = current + chunk;
+  if (combined.length <= limit) {
+    return combined;
+  }
+  if (limit <= OUTPUT_TRUNCATED_MARKER.length) {
+    return combined.slice(-limit);
+  }
+  return OUTPUT_TRUNCATED_MARKER + combined.slice(-(limit - OUTPUT_TRUNCATED_MARKER.length));
+};
+var sanitizeCommandOutput = (output, env = process.env) => {
+  const databaseUrls = Object.entries(env).filter(
+    ([name, value]) => Boolean(value) && (name === "DATABASE_URL" || /^SHARD_\d+_URL$/.test(name))
+  ).map(([, value]) => value);
+  return sanitizeDatabaseText(output, databaseUrls).replace(/(\bpassword\s*[=:]\s*)[^\s,;]+/gi, "$1***");
+};
+var runCommand = (command, args, options = {}) => {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let timedOut = false;
+    let forceKillTimeout;
+    const env = options.env || process.env;
+    const timeoutMs = options.timeoutMs ?? INTERNAL_DEFAULTS.CLI_COMMAND_TIMEOUT_MS;
+    const forceKillGraceMs = options.forceKillGraceMs ?? INTERNAL_DEFAULTS.CLI_FORCE_KILL_GRACE_MS;
+    const maxOutputLength = options.maxOutputLength ?? INTERNAL_DEFAULTS.CLI_MAX_OUTPUT_LENGTH;
+    const processGroup = process.platform !== "win32";
+    const child = (0, import_child_process.spawn)(command, args, {
+      env,
+      cwd: import_path.default.resolve(options.cwd || process.cwd()),
+      detached: processGroup,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const settle = (result) => {
+      if (!settled) {
+        settled = true;
+        clearTimeout(timeout);
+        if (forceKillTimeout) {
+          clearTimeout(forceKillTimeout);
+        }
+        const sanitizedResult = {
+          ...result,
+          stdout: sanitizeCommandOutput(result.stdout, env),
+          stderr: sanitizeCommandOutput(result.stderr, env),
+          error: result.error ? sanitizeCommandOutput(result.error, env) : void 0
+        };
+        if (options.verbose) {
+          if (sanitizedResult.stdout) {
+            process.stdout.write(sanitizedResult.stdout);
+          }
+          if (sanitizedResult.stderr) {
+            process.stderr.write(sanitizedResult.stderr);
+          }
+        }
+        resolve(sanitizedResult);
+      }
+    };
+    child.stdout?.on("data", (data) => {
+      if (!settled) {
+        stdout = appendBoundedOutput(stdout, data.toString(), maxOutputLength);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      if (!settled) {
+        stderr = appendBoundedOutput(stderr, data.toString(), maxOutputLength);
+      }
+    });
+    child.once("error", (error) => {
+      settle({
+        success: false,
+        stdout,
+        stderr,
+        exitCode: null,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : error.message
+      });
+    });
+    child.once("close", (exitCode) => {
+      settle({
+        success: !timedOut && exitCode === 0,
+        stdout,
+        stderr,
+        exitCode,
+        error: timedOut ? `Command timed out after ${timeoutMs}ms` : exitCode === 0 ? void 0 : stderr.trim() || stdout.trim() || `Command exited with code ${exitCode}`
+      });
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      terminateChildProcess(child, { signal: "SIGTERM", processGroup });
+      forceKillTimeout = setTimeout(() => {
+        terminateChildProcess(child, { signal: "SIGKILL", processGroup });
+        settle({
+          success: false,
+          stdout,
+          stderr,
+          exitCode: null,
+          error: `Command timed out after ${timeoutMs}ms`
+        });
+      }, forceKillGraceMs);
+      forceKillTimeout.unref?.();
+    }, timeoutMs);
+    timeout.unref?.();
+  });
+};
+var runPrismaCommand = (args, options = {}) => runCommand(getNpxCommand(), ["prisma", ...args], options);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getNpxCommand,
+  runCommand,
+  runPrismaCommand,
+  sanitizeCommandOutput
+});