prisma-sharding 0.0.5 → 0.0.6

package/dist/cli/studio.js

@@ -1,111 +1,652 @@
 #!/usr/bin/env node
 "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 __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
+));
 
 // src/cli/studio.ts
 var import_config = require("dotenv/config");
 var import_child_process = require("child_process");
-var instances = [];
-var BASE_PORT = parseInt(process.env.SHARD_STUDIO_BASE_PORT || "51212", 10);
-var getShardConfigs = () => {
+
+// 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 parsePositiveIntegerEnv = (name, defaultValue, env = process.env) => {
+  const value = env[name]?.trim();
+  if (!value) {
+    return defaultValue;
+  }
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : defaultValue;
+};
+var isVerboseEnv = (names, env = process.env) => names.some((name) => parseBooleanEnv(name, false, env));
+
+// src/cli/utils/command.ts
+var getNpxCommand = () => process.platform === "win32" ? "npx.cmd" : "npx";
+
+// src/cli/utils/ports.ts
+var import_http = __toESM(require("http"));
+var import_net = __toESM(require("net"));
+var LISTEN_CHECK_HOSTS = ["127.0.0.1", "::1", "0.0.0.0", "::"];
+var HTTP_PROBE_HOSTS = ["127.0.0.1", "::1", "localhost"];
+var HTTP_PROBE_BODY_LIMIT = 16 * 1024;
+var unsupportedAddressCodes = /* @__PURE__ */ new Set(["EADDRNOTAVAIL", "EAFNOSUPPORT"]);
+var checkListenHost = (port, host) => {
+  return new Promise((resolve) => {
+    const server = import_net.default.createServer();
+    let settled = false;
+    const finish = (result) => {
+      if (!settled) {
+        settled = true;
+        resolve(result);
+      }
+    };
+    server.once("error", (error) => {
+      const code = error.code;
+      if (code && unsupportedAddressCodes.has(code)) {
+        finish({ host, available: true, skipped: true, code, message: error.message });
+        return;
+      }
+      finish({ host, available: false, code, message: error.message });
+    });
+    server.listen({ port, host }, () => {
+      server.close(() => {
+        finish({ host, available: true });
+      });
+    });
+  });
+};
+var getPortUsage = async (port) => {
+  const checks = [];
+  for (const host of LISTEN_CHECK_HOSTS) {
+    checks.push(await checkListenHost(port, host));
+  }
+  const occupied = checks.some((check) => check.code === "EADDRINUSE");
+  const unavailable = checks.some(
+    (check) => !check.available && check.code && check.code !== "EADDRINUSE"
+  );
+  return {
+    port,
+    status: occupied ? "occupied" : unavailable ? "unavailable" : "available",
+    checks
+  };
+};
+var responseLooksLikePrismaStudio = (body, headers) => {
+  const headerText = Object.entries(headers).map(([key, value]) => `${key}:${Array.isArray(value) ? value.join(",") : value || ""}`).join("\n");
+  const text = `${headerText}
+${body}`.toLowerCase();
+  const hasModernStudioShell = text.includes("window.__studio_config__") && text.includes("/studio.js") && text.includes("/studio.css");
+  const hasLegacyStudioShell = text.includes("createstudiobffclient") && text.includes("/data/bff/index.js") && text.includes("/ui/index.js") && text.includes("/adapter.js");
+  return text.includes("prisma studio") || text.includes("prisma-studio") || text.includes("@prisma/studio") || text.includes("prisma.io/studio") || text.includes("@prisma/studio-core") || hasModernStudioShell || hasLegacyStudioShell;
+};
+var probeHttpHost = (port, host, timeoutMs) => {
+  return new Promise((resolve) => {
+    let settled = false;
+    let body = "";
+    const finish = (probe) => {
+      if (!settled) {
+        settled = true;
+        resolve(probe);
+      }
+    };
+    const request = import_http.default.request(
+      {
+        hostname: host,
+        port,
+        path: "/",
+        method: "GET",
+        timeout: timeoutMs,
+        headers: {
+          Accept: "text/html,application/xhtml+xml,application/json;q=0.9,*/*;q=0.8"
+        }
+      },
+      (response) => {
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          if (body.length < HTTP_PROBE_BODY_LIMIT) {
+            body += chunk.slice(0, HTTP_PROBE_BODY_LIMIT - body.length);
+          }
+        });
+        response.on("end", () => {
+          const isPrismaStudio = responseLooksLikePrismaStudio(body, response.headers);
+          finish({
+            reachable: true,
+            isPrismaStudio,
+            host,
+            detail: `HTTP ${response.statusCode || "response"}`
+          });
+        });
+      }
+    );
+    request.once("timeout", () => {
+      request.destroy();
+      finish({
+        reachable: false,
+        isPrismaStudio: false,
+        host,
+        detail: `HTTP probe timed out after ${timeoutMs}ms`
+      });
+    });
+    request.once("error", (error) => {
+      finish({
+        reachable: false,
+        isPrismaStudio: false,
+        host,
+        detail: error.message
+      });
+    });
+    request.end();
+  });
+};
+var probePrismaStudio = async (port, timeoutMs = 1200) => {
+  const probes = await Promise.all(
+    HTTP_PROBE_HOSTS.map((host) => probeHttpHost(port, host, timeoutMs))
+  );
+  const prismaStudio = probes.find((probe) => probe.isPrismaStudio);
+  if (prismaStudio) {
+    return prismaStudio;
+  }
+  const reachable = probes.find((probe) => probe.reachable);
+  if (reachable) {
+    return {
+      ...reachable,
+      isPrismaStudio: false,
+      detail: `${reachable.detail}; response did not look like Prisma Studio`
+    };
+  }
+  return {
+    reachable: false,
+    isPrismaStudio: false,
+    detail: probes.map((probe) => `${probe.host}: ${probe.detail}`).join("; ")
+  };
+};
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var waitForPrismaStudio = async (port, timeoutMs, intervalMs = 400, shouldContinue = () => true) => {
+  const startedAt = Date.now();
+  let lastProbe = {
+    reachable: false,
+    isPrismaStudio: false,
+    detail: "Studio probe has not run yet"
+  };
+  while (Date.now() - startedAt < timeoutMs && shouldContinue()) {
+    lastProbe = await probePrismaStudio(port, Math.min(intervalMs, 1e3));
+    if (lastProbe.isPrismaStudio) {
+      return lastProbe;
+    }
+    if (!shouldContinue()) {
+      return lastProbe;
+    }
+    await delay(intervalMs);
+  }
+  return lastProbe;
+};
+
+// src/cli/utils/process.ts
+var isChildProcessRunning = (childProcess) => {
+  return childProcess.exitCode === null && childProcess.signalCode === null && !childProcess.killed;
+};
+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;
+  }
+};
+var waitForChildProcessClose = (childProcess, timeoutMs) => {
+  return new Promise((resolve) => {
+    if (!isChildProcessRunning(childProcess)) {
+      resolve(true);
+      return;
+    }
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve(false);
+    }, timeoutMs);
+    const onClose = () => {
+      clearTimeout(timeout);
+      cleanup();
+      resolve(true);
+    };
+    const cleanup = () => {
+      childProcess.off("close", onClose);
+      childProcess.off("exit", onClose);
+    };
+    childProcess.once("close", onClose);
+    childProcess.once("exit", onClose);
+  });
+};
+
+// 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 shardCount = parseInt(process.env.SHARD_COUNT || "0", 10);
+  const missingShardIds = [];
+  const shardCount = parseInt(env.SHARD_COUNT || "0", 10);
   for (let i = 1; i <= shardCount; i++) {
-    const url = process.env[`SHARD_${i}_URL`];
+    const url = env[`SHARD_${i}_URL`];
     if (url) {
-      shards.push({ id: `shard_${i}`, url });
+      shards.push({ id: `shard_${i}`, index: i - 1, url });
+    } else {
+      missingShardIds.push(`shard_${i}`);
     }
   }
-  if (shards.length === 0 && process.env.DATABASE_URL) {
-    shards.push({ id: "shard_1", url: process.env.DATABASE_URL });
+  if (shards.length === 0 && env.DATABASE_URL) {
+    shards.push({ id: "shard_1", index: 0, url: env.DATABASE_URL });
+  }
+  return { shards, missingShardIds };
+};
+var maskShardUrl = (url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
+    }
+    return parsed.toString();
+  } catch {
+    return url.replace(/:[^:@]+@/, ":***@");
+  }
+};
+
+// src/cli/studio.ts
+var instances = [];
+var activeOptions;
+var isShuttingDown = false;
+var keepAliveTimer;
+var getStudioOptions = () => {
+  return {
+    basePort: parsePositiveIntegerEnv("SHARD_STUDIO_BASE_PORT", 51212),
+    reuseExisting: parseBooleanEnv("SHARD_STUDIO_REUSE_EXISTING", true),
+    startupTimeoutMs: parsePositiveIntegerEnv("SHARD_STUDIO_START_TIMEOUT_MS", 15e3),
+    stabilityMs: parsePositiveIntegerEnv("SHARD_STUDIO_STABILITY_MS", 500),
+    shutdownTimeoutMs: parsePositiveIntegerEnv("SHARD_STUDIO_SHUTDOWN_TIMEOUT_MS", 5e3),
+    strictPortCheck: parseBooleanEnv("SHARD_STUDIO_STRICT_PORT_CHECK", false),
+    verbose: isVerboseEnv(["SHARD_STUDIO_VERBOSE", "SHARD_STUDIO_DEBUG"])
+  };
+};
+var studioUrl = (port) => `http://localhost:${port}`;
+var isAddressInUseOutput = (output) => output.includes("EADDRINUSE");
+var outputLooksReady = (output, port) => {
+  const normalized = output.toLowerCase();
+  return normalized.includes("prisma studio is running") || normalized.includes("prisma studio is up") || normalized.includes(`localhost:${port}`) || normalized.includes(`127.0.0.1:${port}`);
+};
+var logVerbose = (options, message, writer = console.log) => {
+  if (options.verbose) {
+    writer(message);
   }
-  return shards;
 };
-var startStudio = (shard, index) => {
+var writeVerboseOutput = (options, shardId, output, writer) => {
+  if (!options.verbose) {
+    return;
+  }
+  output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).forEach((line) => writer(`   [${shardId}] ${line}`));
+};
+var failedInstance = (shard, port, message, details, severity = "error") => {
+  return {
+    shardId: shard.id,
+    port,
+    url: studioUrl(port),
+    status: "failed",
+    message,
+    details,
+    severity
+  };
+};
+var reusedInstance = (shard, port, details) => {
+  return {
+    shardId: shard.id,
+    port,
+    url: studioUrl(port),
+    status: "reused",
+    details
+  };
+};
+var getShardPort = (shard, options) => {
+  return options.basePort + shard.index;
+};
+var handleOccupiedPort = async (shard, port, options, source) => {
+  logVerbose(
+    options,
+    `   Waiting for occupied ${shard.id} port ${port} to identify Prisma Studio...`
+  );
+  const probe = await waitForPrismaStudio(port, options.startupTimeoutMs);
+  if (probe.isPrismaStudio && options.reuseExisting) {
+    return reusedInstance(shard, port, "Existing Prisma Studio instance is already active");
+  }
+  if (probe.isPrismaStudio && !options.reuseExisting) {
+    return failedInstance(
+      shard,
+      port,
+      "Studio already running but reuse is disabled",
+      "Prisma Studio is already running on this port, but SHARD_STUDIO_REUSE_EXISTING is false"
+    );
+  }
+  const details = probe.reachable ? `Port ${port} is active but did not look like Prisma Studio (${probe.detail})` : `Port ${port} is active but could not be identified as Prisma Studio (${probe.detail})`;
+  const sourceDetails = source === "spawn" ? `${details}; Prisma Studio reported EADDRINUSE during startup` : details;
+  return failedInstance(
+    shard,
+    port,
+    "Port already used by another process",
+    sourceDetails,
+    "warning"
+  );
+};
+var startSpawnedStudio = (shard, port, options) => {
   return new Promise((resolve, reject) => {
-    const port = BASE_PORT + index;
     const shardId = shard.id;
-    console.log(`
+    const processGroup = process.platform !== "win32";
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let readySeen = false;
+    let addressInUse = false;
+    let stabilityTimer;
+    let resolvedInstance;
+    logVerbose(options, `
 \u{1F680} Starting Prisma Studio for ${shardId} on port ${port}...`);
-    console.log(`   URL: ${shard.url.replace(/:[^:@]+@/, ":***@")}`);
+    logVerbose(options, `   URL: ${maskShardUrl(shard.url)}`);
     const studioProcess = (0, import_child_process.spawn)(
-      "npx",
+      getNpxCommand(),
       ["prisma", "studio", "--port", port.toString(), "--browser", "none"],
       {
         env: {
           ...process.env,
           DATABASE_URL: shard.url
         },
-        shell: true,
+        detached: processGroup,
+        shell: false,
         stdio: "pipe"
       }
     );
+    const settle = (instance) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      resolvedInstance = instance;
+      if (stabilityTimer) {
+        clearTimeout(stabilityTimer);
+      }
+      resolve(instance);
+    };
+    const fail = (message, details) => {
+      terminateChildProcess(studioProcess, { processGroup });
+      settle(failedInstance(shard, port, message, details));
+    };
+    const settleStartedAfterStability = () => {
+      if (settled || readySeen) {
+        return;
+      }
+      readySeen = true;
+      stabilityTimer = setTimeout(() => {
+        settle({
+          shardId,
+          port,
+          url: studioUrl(port),
+          status: "started",
+          process: studioProcess,
+          processGroup
+        });
+      }, options.stabilityMs);
+    };
     studioProcess.stdout?.on("data", (data) => {
       const output = data.toString();
-      if (output.includes("Prisma Studio is running")) {
-        console.log(`   \u2705 ${shardId} ready at http://localhost:${port}`);
+      stdout += output;
+      if (outputLooksReady(output, port)) {
+        settleStartedAfterStability();
       }
+      writeVerboseOutput(options, shardId, output, console.log);
     });
     studioProcess.stderr?.on("data", (data) => {
       const output = data.toString();
-      if (!output.includes("warn") && !output.includes("Loaded")) {
-        console.error(`   [${shardId}] ${output}`);
+      stderr += output;
+      if (isAddressInUseOutput(output)) {
+        addressInUse = true;
+        return;
       }
+      writeVerboseOutput(options, shardId, output, console.error);
     });
     studioProcess.on("error", (err) => {
-      console.error(`   \u274C Failed to start ${shardId}:`, err.message);
-      reject(err);
+      fail("Failed to start", err.message);
+    });
+    studioProcess.on("close", (code, signal) => {
+      const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+      if (settled) {
+        if (resolvedInstance?.status === "started" && !isShuttingDown) {
+          console.warn(`\u26A0\uFE0F ${shardId} Studio exited after startup (${reason})`);
+        }
+        return;
+      }
+      if (readySeen) {
+        const output2 = (stderr || stdout).trim();
+        settle(
+          failedInstance(
+            shard,
+            port,
+            "Failed to start",
+            `Prisma Studio exited during startup stability check (${reason})${output2 ? `: ${output2}` : ""}`
+          )
+        );
+        return;
+      }
+      if (addressInUse || isAddressInUseOutput(stderr)) {
+        handleOccupiedPort(shard, port, options, "spawn").then(settle).catch((error) => reject(error));
+        return;
+      }
+      const output = (stderr || stdout).trim();
+      settle(
+        failedInstance(
+          shard,
+          port,
+          "Failed to start",
+          `Prisma Studio exited before it was ready (${reason})${output ? `: ${output}` : ""}`
+        )
+      );
     });
-    const instance = {
-      shardId,
+    waitForPrismaStudio(port, options.startupTimeoutMs, 400, () => !settled && !readySeen).then((probe) => {
+      if (settled || readySeen) {
+        return;
+      }
+      if (probe.isPrismaStudio) {
+        settleStartedAfterStability();
+        return;
+      }
+      fail("Failed to start", `Timed out waiting for ${studioUrl(port)} (${probe.detail})`);
+    }).catch((error) => {
+      if (!settled) {
+        fail("Failed to start", error.message);
+      }
+    });
+  });
+};
+var startStudio = async (shard, options) => {
+  const port = getShardPort(shard, options);
+  logVerbose(options, `
+\u{1F50E} Checking ${shard.id} Studio port ${port}...`);
+  const portUsage = await getPortUsage(port);
+  if (portUsage.status === "occupied") {
+    return handleOccupiedPort(shard, port, options, "preflight");
+  }
+  if (portUsage.status === "unavailable") {
+    const details = portUsage.checks.filter((check) => !check.available && check.code !== "EADDRINUSE").map((check) => `${check.host}: ${check.code || check.message}`).join("; ");
+    return failedInstance(
+      shard,
       port,
-      process: studioProcess
-    };
-    instances.push(instance);
-    setTimeout(() => resolve(instance), 2e3);
+      "Port check failed",
+      `Could not safely check port ${port}${details ? ` (${details})` : ""}`,
+      "warning"
+    );
+  }
+  return startSpawnedStudio(shard, port, options);
+};
+var getStatusIcon = (instance) => {
+  if (instance.status === "started") {
+    return "\u2705";
+  }
+  if (instance.status === "reused") {
+    return "\u267B\uFE0F";
+  }
+  return instance.severity === "warning" ? "\u26A0\uFE0F" : "\u274C";
+};
+var getStatusText = (instance) => {
+  if (instance.status === "started" || instance.status === "reused") {
+    return instance.url;
+  }
+  return instance.message || "Failed to start";
+};
+var printCompactResults = (results, options) => {
+  const failed = results.filter((instance) => instance.status === "failed");
+  const hasErrorFailure = failed.some((instance) => instance.severity !== "warning");
+  console.log("\u{1F5C4}\uFE0F Prisma Sharding Studio\n");
+  results.forEach((instance) => {
+    console.log(`${getStatusIcon(instance)} ${instance.shardId}  ${getStatusText(instance)}`);
   });
+  if (options.verbose) {
+    printVerboseSummary(results, options);
+  }
+  if (hasErrorFailure && !options.verbose) {
+    console.log("\nRun with SHARD_STUDIO_VERBOSE=true for details.");
+  }
+};
+var printVerboseSummary = (results, options) => {
+  const started = results.filter((instance) => instance.status === "started");
+  const reused = results.filter((instance) => instance.status === "reused");
+  const failed = results.filter((instance) => instance.status === "failed");
+  console.log("\nVerbose details:");
+  console.log(`   Base port: ${options.basePort}`);
+  console.log(`   Reuse existing Studio ports: ${options.reuseExisting ? "yes" : "no"}`);
+  console.log(`   Startup timeout: ${options.startupTimeoutMs}ms`);
+  console.log(`   Startup stability window: ${options.stabilityMs}ms`);
+  console.log(`   Strict port check: ${options.strictPortCheck ? "yes" : "no"}`);
+  console.log(`   Total: ${results.length}`);
+  console.log(`   Started: ${started.length}`);
+  console.log(`   Reused: ${reused.length}`);
+  console.log(`   Failed: ${failed.length}`);
+  failed.forEach((instance) => {
+    console.log(`   ${instance.shardId}: ${instance.details || instance.message || "Failed"}`);
+  });
+};
+var getOwnedInstances = () => {
+  return instances.filter(
+    (instance) => instance.status === "started" && Boolean(instance.process)
+  );
+};
+var shutdownOwnedInstances = async (options, announce = true) => {
+  const ownedInstances = getOwnedInstances();
+  if (ownedInstances.length === 0) {
+    return;
+  }
+  if (announce) {
+    console.log("\nStopping owned Studio processes...");
+  }
+  ownedInstances.forEach((instance) => {
+    logVerbose(options, `   Stopping ${instance.shardId}...`);
+    terminateChildProcess(instance.process, { processGroup: instance.processGroup });
+  });
+  const closed = await Promise.all(
+    ownedInstances.map(
+      (instance) => waitForChildProcessClose(instance.process, options.shutdownTimeoutMs)
+    )
+  );
+  closed.forEach((didClose, index) => {
+    if (!didClose) {
+      const instance = ownedInstances[index];
+      logVerbose(options, `   Force stopping ${instance.shardId}...`, console.warn);
+      terminateChildProcess(instance.process, {
+        signal: "SIGKILL",
+        processGroup: instance.processGroup
+      });
+    }
+  });
+  if (announce) {
+    console.log("Stopped.");
+  }
 };
 var startAllStudios = async () => {
-  const shards = getShardConfigs();
-  console.log("=".repeat(60));
-  console.log("\u{1F5C4}\uFE0F  prisma-sharding: Multi-Shard Studio Viewer");
-  console.log("=".repeat(60));
-  console.log(`
-\u{1F4CA} Starting ${shards.length} Prisma Studio instance(s)...
-`);
+  const options = getStudioOptions();
+  const { shards, missingShardIds } = getShardConfigResult();
+  activeOptions = options;
   if (shards.length === 0) {
-    console.error(
-      "\u274C No shards configured. Set SHARD_COUNT and SHARD_N_URL environment variables."
-    );
+    console.log("\u{1F5C4}\uFE0F Prisma Sharding Studio\n");
+    console.error(`\u274C ${NO_SHARDS_CONFIGURED_MESSAGE}`);
     process.exit(1);
   }
-  for (let i = 0; i < shards.length; i++) {
+  if (missingShardIds.length > 0) {
+    logVerbose(options, `Missing shard URLs: ${missingShardIds.join(", ")}`, console.warn);
+  }
+  for (const shard of shards) {
     try {
-      await startStudio(shards[i], i);
+      const instance = await startStudio(shard, options);
+      instances.push(instance);
     } catch (error) {
-      console.error(`Failed to start studio for ${shards[i].id}:`, error);
+      const message = error instanceof Error ? error.message : String(error);
+      instances.push(failedInstance(shard, getShardPort(shard, options), "Failed to start", message));
     }
   }
-  console.log("\n" + "=".repeat(60));
-  console.log("\u{1F4CB} All Studios Running:");
-  console.log("=".repeat(60));
-  instances.forEach((instance) => {
-    console.log(`   \u2022 ${instance.shardId}: http://localhost:${instance.port}`);
-  });
-  console.log("\n   Press Ctrl+C to stop all instances\n");
+  printCompactResults(instances, options);
+  const failed = instances.filter((instance) => instance.status === "failed");
+  if (failed.length > 0 && options.strictPortCheck) {
+    isShuttingDown = true;
+    await shutdownOwnedInstances(options, options.verbose);
+    process.exit(1);
+  }
+  if (failed.length === 0 && getOwnedInstances().length === 0) {
+    keepAliveTimer = setInterval(() => void 0, 2147483647);
+  }
 };
-var gracefulShutdown = () => {
-  console.log("\n\n\u{1F6D1} Shutting down all Prisma Studio instances...\n");
-  instances.forEach((instance) => {
-    console.log(`   Stopping ${instance.shardId}...`);
-    instance.process.kill("SIGTERM");
-  });
-  setTimeout(() => {
-    console.log("\n\u2705 All instances stopped\n");
-    process.exit(0);
-  }, 1e3);
+var gracefulShutdown = async () => {
+  if (isShuttingDown) {
+    return;
+  }
+  isShuttingDown = true;
+  if (keepAliveTimer) {
+    clearInterval(keepAliveTimer);
+    keepAliveTimer = void 0;
+  }
+  const options = activeOptions || getStudioOptions();
+  await shutdownOwnedInstances(options, options.verbose);
+  process.exit(0);
 };
-process.on("SIGINT", gracefulShutdown);
-process.on("SIGTERM", gracefulShutdown);
+process.on("SIGINT", () => {
+  void gracefulShutdown();
+});
+process.on("SIGTERM", () => {
+  void gracefulShutdown();
+});
 startAllStudios().catch((error) => {
   console.error("Failed to start studios:", error);
   process.exit(1);