@rallycry/conveyor-agent 10.13.71 → 11.0.0

package/dist/chunk-JQVAWRVL.js

@@ -0,0 +1,697 @@
+import {
+  awaitGitReady,
+  buildSessionPreviewPorts,
+  loadForwardPorts,
+  readWorkspaceBytes,
+  statWorkspacePath,
+  workspacePathExists
+} from "./chunk-N4WSUTGV.js";
+import {
+  reportBootMilestone
+} from "./chunk-GL2DIQEQ.js";
+import {
+  getWorkbenchClient
+} from "./chunk-EXQ6AHOY.js";
+import {
+  workbenchEnabled
+} from "./chunk-KMB3BU4S.js";
+import {
+  runSetupCommand,
+  runStartCommand,
+  terminateProcessGroup
+} from "./chunk-W4LZ7R6Z.js";
+
+// src/setup/db-schema-sync.ts
+import { basename, dirname, join } from "path";
+var PRISMA_SCHEMA_CANDIDATES = [
+  "packages/db/prisma/schema.prisma",
+  "prisma/schema.prisma",
+  "apps/api/prisma/schema.prisma",
+  "packages/db/schema.prisma"
+];
+var PRISMA_DB_PUSH = "bunx prisma db push";
+var SCHEMA_SYNC_TIMEOUT_MS = 18e4;
+function depsInclude(rawDeps, dep) {
+  return (rawDeps ?? "").split(",").map((entry) => entry.trim()).includes(dep);
+}
+function isDisabled(env) {
+  const flag = env.CONVEYOR_DB_SCHEMA_SYNC?.trim().toLowerCase();
+  return flag === "0" || flag === "false";
+}
+function packageRootForSchema(schemaPath) {
+  const dir = dirname(schemaPath);
+  return basename(dir) === "prisma" ? dirname(dir) : dir;
+}
+async function resolveSchemaSyncPlan(options) {
+  const { workspaceDir, env } = options;
+  const pathExists = options.pathExists ?? workspacePathExists;
+  if (isDisabled(env)) return null;
+  const override = env.CONVEYOR_DB_SCHEMA_SYNC_COMMAND?.trim();
+  if (override) return { command: override, cwd: workspaceDir, source: "override" };
+  if (!depsInclude(env.CONVEYOR_DEPS, "postgresql")) return null;
+  if (!env.DATABASE_URL?.trim()) return null;
+  for (const relative of PRISMA_SCHEMA_CANDIDATES) {
+    const schemaPath = join(workspaceDir, relative);
+    if (await pathExists(schemaPath)) {
+      return { command: PRISMA_DB_PUSH, cwd: packageRootForSchema(schemaPath), source: "prisma" };
+    }
+  }
+  return null;
+}
+async function runDbSchemaSync(options) {
+  let plan = null;
+  try {
+    plan = await resolveSchemaSyncPlan(options);
+  } catch {
+    return "skipped";
+  }
+  if (!plan) return "skipped";
+  const { onOutput, runCommand } = options;
+  onOutput("stdout", `[db] syncing schema (${plan.source}): ${plan.command}
+`);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(abort, options.timeoutMs ?? SCHEMA_SYNC_TIMEOUT_MS);
+  timer.unref();
+  try {
+    await runCommand(plan.command, plan.cwd, onOutput, controller.signal);
+    onOutput("stdout", "[db] schema in sync\n");
+    return "synced";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    onOutput("stderr", `[db] schema sync failed: ${message}
+`);
+    return "failed";
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+  }
+}
+
+// src/setup/deps-sync.ts
+import { join as join2 } from "path";
+var INSTALLER_SCRIPT_CANDIDATES = ["scripts/install-deps.sh"];
+var BUN_INSTALL = "bun install --frozen-lockfile";
+var DEPS_SYNC_TIMEOUT_MS = 9e5;
+var REGISTRY_KEY_ENV = "NPM_CACHE_READER_KEY";
+function isDisabled2(env) {
+  const flag = env.CONVEYOR_DEPS_SYNC?.trim().toLowerCase();
+  return flag === "0" || flag === "false";
+}
+var CKSUM_POLYNOMIAL = 79764919;
+var CKSUM_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index++) {
+    let value = index << 24;
+    for (let bit = 0; bit < 8; bit++) {
+      value = value & 2147483648 ? (value << 1 ^ CKSUM_POLYNOMIAL) >>> 0 : value << 1 >>> 0;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+function posixCksum(bytes) {
+  let crc = 0;
+  for (const byte of bytes) {
+    crc = (crc << 8 ^ CKSUM_TABLE[(crc >>> 24 ^ byte) & 255]) >>> 0;
+  }
+  for (let length = bytes.length; length > 0; length >>>= 8) {
+    crc = (crc << 8 ^ CKSUM_TABLE[(crc >>> 24 ^ length & 255) & 255]) >>> 0;
+  }
+  return ~crc >>> 0;
+}
+function bunLockFingerprint(bytes) {
+  return `${posixCksum(bytes)}:${bytes.length}`;
+}
+async function defaultDirExists(path) {
+  return (await statWorkspacePath(path)).isDirectory;
+}
+async function readLockDrift(options) {
+  const { workspaceDir, readBytes } = options;
+  let baked;
+  try {
+    const raw = await readBytes(join2(workspaceDir, ".conveyor/prebake-cache.json"));
+    const parsed = JSON.parse(Buffer.from(raw).toString("utf8"));
+    const value = parsed?.bunLockCrc;
+    if (typeof value !== "string" || !value) return null;
+    baked = value;
+  } catch {
+    return null;
+  }
+  try {
+    const actual = bunLockFingerprint(await readBytes(join2(workspaceDir, "bun.lock")));
+    return actual === baked ? null : { baked, actual };
+  } catch {
+    return null;
+  }
+}
+async function resolveDepsSyncPlan(options) {
+  const { workspaceDir, env } = options;
+  const pathExists = options.pathExists ?? workspacePathExists;
+  const dirExists = options.dirExists ?? defaultDirExists;
+  const readBytes = options.readBytes ?? readWorkspaceBytes;
+  if (isDisabled2(env)) return null;
+  if (!await pathExists(join2(workspaceDir, "package.json"))) return null;
+  const override = env.CONVEYOR_DEPS_SYNC_COMMAND?.trim();
+  const resolveCommand = async () => {
+    if (override) return override;
+    for (const relative of INSTALLER_SCRIPT_CANDIDATES) {
+      if (await pathExists(join2(workspaceDir, relative))) return `bash ${relative}`;
+    }
+    return BUN_INSTALL;
+  };
+  if (!await dirExists(join2(workspaceDir, "node_modules"))) {
+    return {
+      command: await resolveCommand(),
+      cwd: workspaceDir,
+      reason: "missing_node_modules",
+      detail: "the pod booted with no node_modules \u2014 the baked dependency tree is absent"
+    };
+  }
+  const drift = await readLockDrift({ workspaceDir, readBytes });
+  if (drift) {
+    return {
+      command: await resolveCommand(),
+      cwd: workspaceDir,
+      reason: "lockfile_drift",
+      detail: `bun.lock changed since the image bake (baked ${drift.baked}, checked out ${drift.actual})`
+    };
+  }
+  return null;
+}
+function describeFailure(plan, error, env) {
+  const cause = error instanceof Error ? error.message : String(error);
+  const parts = [
+    `Dependency install failed (${plan.reason}): ${plan.detail}.`,
+    `Ran \`${plan.command}\` in ${plan.cwd} \u2014 ${cause}.`
+  ];
+  if (!env[REGISTRY_KEY_ENV]?.trim()) {
+    parts.push(
+      `${REGISTRY_KEY_ENV} is not set on this pod, so packages on the private registry cache cannot be fetched \u2014 set it as a project secret.`
+    );
+  }
+  return parts.join(" ");
+}
+async function runDepsSync(options) {
+  let plan = null;
+  try {
+    plan = await resolveDepsSyncPlan(options);
+  } catch {
+    return { outcome: "skipped" };
+  }
+  if (!plan) return { outcome: "skipped" };
+  const { onOutput, runCommand, env } = options;
+  onOutput("stdout", `[deps] ${plan.detail}
+`);
+  onOutput("stdout", `[deps] installing (${plan.reason}): ${plan.command}
+`);
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(abort, options.timeoutMs ?? DEPS_SYNC_TIMEOUT_MS);
+  timer.unref();
+  try {
+    await runCommand(plan.command, plan.cwd, onOutput, controller.signal);
+    onOutput("stdout", "[deps] dependencies installed\n");
+    return { outcome: "installed" };
+  } catch (error) {
+    const message = describeFailure(plan, error, env);
+    onOutput("stderr", `[deps] ${message}
+`);
+    return { outcome: "failed", message };
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+  }
+}
+
+// src/setup/sidecars.ts
+import net from "net";
+var POSTGRES_TIMEOUT_MS = 12e4;
+var FIREBASE_TIMEOUT_MS = 6e4;
+var FALLBACK_TIMEOUT_MS = 3e4;
+var DEFAULT_SIDECAR_POLL_INTERVAL_MS = 1e3;
+var DEFAULT_PROBE_TIMEOUT_MS = 2e3;
+var POSTGRES_DEFAULT_PORT = 5432;
+var FIREBASE_DEFAULT_PORT = 9099;
+function parseHostPort(value, defaultPort) {
+  const trimmed = value.trim().replace(/^[a-z]+:\/\//i, "");
+  if (!trimmed) return null;
+  const idx = trimmed.lastIndexOf(":");
+  if (idx === -1) {
+    return { host: trimmed, port: defaultPort };
+  }
+  const host = trimmed.slice(0, idx) || "localhost";
+  const port = Number(trimmed.slice(idx + 1));
+  return { host, port: Number.isFinite(port) ? port : defaultPort };
+}
+function resolveSidecarTargets(env = process.env) {
+  const targets = [];
+  const databaseUrl = env.DATABASE_URL;
+  if (databaseUrl) {
+    try {
+      const url = new URL(databaseUrl);
+      const host = url.hostname || "localhost";
+      const port = url.port ? Number(url.port) : POSTGRES_DEFAULT_PORT;
+      if (Number.isFinite(port)) {
+        targets.push({ name: "postgres", host, port, timeoutMs: POSTGRES_TIMEOUT_MS });
+      }
+    } catch {
+    }
+  }
+  const firebaseHost = env.FIREBASE_AUTH_EMULATOR_HOST;
+  if (firebaseHost) {
+    const parsed = parseHostPort(firebaseHost, FIREBASE_DEFAULT_PORT);
+    if (parsed) {
+      targets.push({
+        name: "firebase auth emulator",
+        host: parsed.host,
+        port: parsed.port,
+        timeoutMs: FIREBASE_TIMEOUT_MS
+      });
+    }
+  }
+  return targets;
+}
+function abortError() {
+  const error = new Error("Operation aborted");
+  error.name = "AbortError";
+  return error;
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortError();
+}
+function defaultProbe(target, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve) => {
+    let settled = false;
+    const socket = net.createConnection({ host: target.host, port: target.port });
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      signal?.removeEventListener("abort", onAbort);
+      resolve(ok);
+    };
+    const onAbort = () => done(false);
+    socket.once("connect", () => done(true));
+    socket.once("error", () => done(false));
+    socket.setTimeout(DEFAULT_PROBE_TIMEOUT_MS, () => done(false));
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var delay = (ms, signal) => {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+};
+function raceWithAbort(promise, signal) {
+  if (!signal) return promise;
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError());
+    signal.addEventListener("abort", onAbort, { once: true });
+    void promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+async function waitForTarget(target, opts) {
+  const { onLog, pollIntervalMs, probe, signal } = opts;
+  const timeoutMs = opts.timeoutMs ?? target.timeoutMs ?? FALLBACK_TIMEOUT_MS;
+  const deadline = Date.now() + timeoutMs;
+  onLog(`Waiting for ${target.name} on ${target.host}:${target.port}...`);
+  while (true) {
+    throwIfAborted(signal);
+    if (await raceWithAbort(probe(target, signal), signal)) {
+      onLog(`${target.name} is ready`);
+      return;
+    }
+    if (Date.now() >= deadline) {
+      onLog(
+        `WARNING: ${target.name} not ready after ${Math.round(timeoutMs / 1e3)}s, continuing anyway`
+      );
+      return;
+    }
+    await delay(pollIntervalMs, signal);
+  }
+}
+async function waitForSidecars(opts = {}) {
+  const {
+    env = process.env,
+    onLog = () => {
+    },
+    timeoutMs,
+    pollIntervalMs = DEFAULT_SIDECAR_POLL_INTERVAL_MS,
+    probe = defaultProbe,
+    signal
+  } = opts;
+  throwIfAborted(signal);
+  const targets = resolveSidecarTargets(env);
+  if (targets.length === 0) return;
+  await Promise.all(
+    targets.map(
+      (target) => waitForTarget(target, { onLog, timeoutMs, pollIntervalMs, probe, signal })
+    )
+  );
+}
+
+// src/setup/workspace-command-supervisor.ts
+function defaultCommandExecutors() {
+  if (workbenchEnabled()) {
+    const client = getWorkbenchClient();
+    return {
+      runStartCommand: (cmd, cwd, onOutput) => client.runStartCommand(cmd, cwd, onOutput),
+      runShellCommand: (cmd, cwd, onOutput, signal) => client.runSetupCommand(cmd, cwd, onOutput, signal)
+    };
+  }
+  return { runStartCommand, runShellCommand: runSetupCommand };
+}
+var defaultWriteOutput = (stream, data) => {
+  (stream === "stderr" ? process.stderr : process.stdout).write(data);
+};
+function stopWorkspaceCommands(supervisor) {
+  return supervisor?.stop() ?? Promise.resolve();
+}
+async function startWorkspaceCommandsAfterConnect(options) {
+  const connected = await options.connect();
+  if (!connected || options.isShuttingDown()) return null;
+  const supervisor = options.create();
+  supervisor.start();
+  return supervisor;
+}
+var WorkspaceCommandSupervisor = class {
+  abortController = new AbortController();
+  expectedStartCommandStops = /* @__PURE__ */ new WeakSet();
+  config;
+  workspaceDir;
+  connection;
+  env;
+  awaitGitReadyFn;
+  waitForSidecarsFn;
+  runStartCommandFn;
+  syncDbSchemaFn;
+  syncDepsFn;
+  loadForwardPortsFn;
+  writeOutput;
+  terminateStartCommand;
+  reportBootMilestoneFn;
+  startCommandChild = null;
+  liveStartCommandChildren = /* @__PURE__ */ new Set();
+  startCommandTerminations = /* @__PURE__ */ new WeakMap();
+  startCommandEndPromises = /* @__PURE__ */ new WeakMap();
+  resolveStartCommandEnd = /* @__PURE__ */ new WeakMap();
+  backgroundTasks = /* @__PURE__ */ new Set();
+  startCommandQueue = Promise.resolve();
+  shutdownPromise = null;
+  startCommandLaunchRequested = false;
+  started = false;
+  stopped = false;
+  /** Resolved by notifyLoopReady() once the PTY is live — the runner fires it
+   *  on the first harness event of the initial query (or when a prefill
+   *  parks), NOT after the first turn completes, so the app's start command
+   *  isn't held behind a long working turn. Also resolved by stop() if
+   *  shutdown arrives first — either way unblocks the awaiter in
+   *  runSetupAndStart so a supervisor stopped before the loop ever signals
+   *  doesn't hang its background task (and therefore stop()) forever. */
+  resolveLoopReady;
+  loopReady = new Promise((resolve) => {
+    this.resolveLoopReady = resolve;
+  });
+  constructor(options) {
+    this.config = options.config;
+    this.workspaceDir = options.workspaceDir;
+    this.connection = options.connection;
+    this.env = options.env ?? process.env;
+    this.awaitGitReadyFn = options.awaitGitReady ?? ((opts) => awaitGitReady({
+      onLog: opts.onLog,
+      signal: opts.signal
+    }));
+    this.waitForSidecarsFn = options.waitForSidecars ?? ((opts) => waitForSidecars({ onLog: opts.onLog, signal: opts.signal }));
+    const executors = defaultCommandExecutors();
+    this.runStartCommandFn = options.runStartCommand ?? executors.runStartCommand;
+    this.syncDbSchemaFn = options.syncDbSchema ?? ((opts) => runDbSchemaSync({
+      workspaceDir: this.workspaceDir,
+      env: this.env,
+      runCommand: executors.runShellCommand,
+      onOutput: opts.onOutput,
+      signal: opts.signal
+    }));
+    this.syncDepsFn = options.syncDeps ?? ((opts) => runDepsSync({
+      workspaceDir: this.workspaceDir,
+      env: this.env,
+      runCommand: executors.runShellCommand,
+      onOutput: opts.onOutput,
+      signal: opts.signal
+    }));
+    this.loadForwardPortsFn = options.loadForwardPorts ?? loadForwardPorts;
+    this.writeOutput = options.writeOutput ?? defaultWriteOutput;
+    this.terminateStartCommand = options.terminateStartCommand ?? terminateProcessGroup;
+    this.reportBootMilestoneFn = options.reportBootMilestone ?? ((key) => {
+      void reportBootMilestone({ key, env: this.env });
+    });
+  }
+  start() {
+    if (this.started || this.stopped) return;
+    this.started = true;
+    this.connection.onRunStartCommand(() => this.restartStartCommand());
+    if (this.config) {
+      this.trackBackgroundTask(
+        this.runSetupAndStart().catch((error) => this.reportUnexpectedError(error))
+      );
+    }
+  }
+  /** Release the start-command launch — called once the runner's core loop
+   *  (the PTY) is live. Idempotent; resolving an already-settled promise is a
+   *  no-op, so a late/duplicate call (or one after stop() already resolved
+   *  it) is harmless. */
+  notifyLoopReady() {
+    this.resolveLoopReady();
+  }
+  stop() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.stopped = true;
+    this.resolveLoopReady();
+    this.abortController.abort();
+    const backgroundTasks = [...this.backgroundTasks];
+    const termination = this.terminateAllStartCommands();
+    this.shutdownPromise = (async () => {
+      await Promise.allSettled([termination, this.startCommandQueue, ...backgroundTasks]);
+      await this.terminateAllStartCommands();
+    })();
+    return this.shutdownPromise;
+  }
+  async runSetupAndStart() {
+    const gitState = await this.awaitGitReadyFn({
+      onLog: (message) => this.forwardSetupOutput("stdout", `[git] ${message}
+`),
+      signal: this.abortController.signal
+    });
+    if (this.stopped) return;
+    if (gitState === "failed" || gitState === "timeout") {
+      this.connection.sendEvent({
+        type: "setup_error",
+        message: "Workspace not ready \u2014 skipping setup/start"
+      });
+      return;
+    }
+    await this.waitForSidecarsFn({
+      onLog: (message) => this.forwardSetupOutput("stdout", `[sidecars] ${message}
+`),
+      signal: this.abortController.signal
+    });
+    if (this.stopped) return;
+    this.reportBootMilestoneFn("sidecars_ready");
+    await this.loopReady;
+    if (this.stopped) return;
+    await this.syncDeps();
+    if (this.stopped) return;
+    await this.syncDbSchema();
+    if (this.stopped) return;
+    const startCommandRunning = this.config?.startCommand ? await this.ensureStartCommandLaunched(this.config.startCommand) : false;
+    if (this.stopped) return;
+    this.reportBootMilestoneFn("start_command_launched");
+    const forwardPorts = await this.loadForwardPortsFn(this.workspaceDir);
+    if (this.stopped) return;
+    const previewPorts = buildSessionPreviewPorts(forwardPorts);
+    this.connection.sendEvent({
+      type: "setup_complete",
+      startCommandRunning,
+      // Reported separately so the server can tell "nothing to run" apart from
+      // "the dev server failed to launch" — both report startCommandRunning:false.
+      startCommandConfigured: Boolean(this.config?.startCommand),
+      ...previewPorts.length > 0 ? { previewPorts } : {}
+    });
+  }
+  /** Run the dependency sync, forwarding its output as setup output so it lands
+   *  in the card's setup log. A failure is announced with its own cause rather
+   *  than thrown: the start command still launches, but the card now carries
+   *  the reason instead of a generic `start command exited with code 1`. */
+  async syncDeps() {
+    const result = await this.syncDepsFn({
+      onOutput: (stream, data) => this.forwardSetupOutput(stream, data),
+      signal: this.abortController.signal
+    });
+    if (result.outcome !== "failed" || this.stopped) return;
+    this.connection.sendEvent({
+      type: "setup_error",
+      message: result.message ?? "Dependency install failed \u2014 the start command will fail until dependencies are installed (see pod logs)"
+    });
+  }
+  /** Run the schema sync, forwarding its output as setup output so it lands in
+   *  the card's setup log. A failure is announced rather than thrown: it is the
+   *  exact condition that used to render as a silent "Displaying 0 results". */
+  async syncDbSchema() {
+    const outcome = await this.syncDbSchemaFn({
+      onOutput: (stream, data) => this.forwardSetupOutput(stream, data),
+      signal: this.abortController.signal
+    });
+    if (outcome !== "failed" || this.stopped) return;
+    this.connection.sendEvent({
+      type: "setup_error",
+      message: "Database schema sync failed \u2014 the app may error on queries touching recently added columns (see pod logs)"
+    });
+  }
+  restartStartCommand() {
+    if (this.stopped || !this.config?.startCommand) return;
+    this.connection.sendEvent({
+      type: "start_command_output",
+      stream: "stdout",
+      data: "[conveyor-agent] Restarting start command...\n"
+    });
+    void this.enqueueStartCommandReplacement(this.config.startCommand);
+  }
+  async ensureStartCommandLaunched(command) {
+    if (!this.startCommandLaunchRequested) {
+      return this.enqueueStartCommandReplacement(command);
+    }
+    await this.startCommandQueue;
+    return !this.stopped && this.liveStartCommandChildren.size > 0;
+  }
+  enqueueStartCommandReplacement(command) {
+    this.startCommandLaunchRequested = true;
+    const operation = this.startCommandQueue.then(async () => {
+      if (this.stopped) return false;
+      await this.terminateAllStartCommands();
+      if (this.stopped) return false;
+      return this.launchStartCommand(command);
+    });
+    this.startCommandQueue = operation.then(
+      () => void 0,
+      () => void 0
+    );
+    return operation;
+  }
+  launchStartCommand(command) {
+    if (this.stopped) return false;
+    this.connection.sendEvent({ type: "start_command_started" });
+    try {
+      const child = this.runStartCommandFn(command, this.workspaceDir, (stream, data) => {
+        if (this.stopped) return;
+        this.connection.sendEvent({ type: "start_command_output", stream, data });
+        this.writeOutput(stream, data);
+      });
+      this.liveStartCommandChildren.add(child);
+      const ended = new Promise((resolve) => {
+        this.resolveStartCommandEnd.set(child, resolve);
+      });
+      this.startCommandEndPromises.set(child, ended);
+      if (this.stopped) {
+        void this.terminateStartCommandChild(child);
+        return false;
+      }
+      this.startCommandChild = child;
+      child.on("exit", (code, signal) => {
+        if (this.startCommandChild === child) this.startCommandChild = null;
+        this.liveStartCommandChildren.delete(child);
+        this.settleStartCommandEnd(child);
+        if (this.stopped || this.expectedStartCommandStops.has(child)) return;
+        const message = `start command exited${code === null ? "" : ` with code ${code}`}${signal ? ` (signal: ${signal})` : ""}`;
+        this.connection.sendEvent({ type: "start_command_exited", code, signal, message });
+        if (code !== null && code !== 0) {
+          this.connection.sendEvent({
+            type: "start_command_error",
+            message: `start command exited with code ${code}${signal ? ` (signal: ${signal})` : ""}`
+          });
+        }
+      });
+      child.on("error", (error) => {
+        if (child.pid === void 0) {
+          if (this.startCommandChild === child) this.startCommandChild = null;
+          this.liveStartCommandChildren.delete(child);
+          this.settleStartCommandEnd(child);
+          this.startCommandTerminations.delete(child);
+        }
+        if (this.stopped) return;
+        this.connection.sendEvent({ type: "start_command_error", message: error.message });
+      });
+      return true;
+    } catch (error) {
+      if (!this.stopped) {
+        this.connection.sendEvent({
+          type: "start_command_error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+      return false;
+    }
+  }
+  terminateStartCommandChild(child) {
+    const existing = this.startCommandTerminations.get(child);
+    if (existing) return existing;
+    this.expectedStartCommandStops.add(child);
+    const processTermination = Promise.resolve(this.terminateStartCommand(child));
+    const ended = this.startCommandEndPromises.get(child);
+    const termination = (ended ? Promise.race([processTermination, ended]) : processTermination).then(() => void 0).finally(() => this.startCommandTerminations.delete(child));
+    this.startCommandTerminations.set(child, termination);
+    return termination;
+  }
+  async terminateAllStartCommands() {
+    const live = [...this.liveStartCommandChildren].filter((child) => child.exitCode === null);
+    await Promise.all(live.map((child) => this.terminateStartCommandChild(child)));
+  }
+  settleStartCommandEnd(child) {
+    this.resolveStartCommandEnd.get(child)?.();
+    this.resolveStartCommandEnd.delete(child);
+    this.startCommandEndPromises.delete(child);
+  }
+  trackBackgroundTask(task) {
+    this.backgroundTasks.add(task);
+    void task.finally(() => this.backgroundTasks.delete(task));
+  }
+  forwardSetupOutput(stream, data) {
+    if (this.stopped) return;
+    this.connection.sendEvent({ type: "setup_output", stream, data });
+    this.writeOutput(stream, data);
+  }
+  reportUnexpectedError(error) {
+    if (this.stopped) return;
+    this.connection.sendEvent({
+      type: "setup_error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+
+export {
+  stopWorkspaceCommands,
+  startWorkspaceCommandsAfterConnect,
+  WorkspaceCommandSupervisor
+};