issue-flow 0.14.0 → 0.15.0

package/dist/{chunk-LFEQIZLB.js → chunk-BMHGRYL6.js}

@@ -1,41 +1,43 @@
 #!/usr/bin/env node
 import {
   writeAgentPreference
-} from "./chunk-UJ3L2MS7.js";
+} from "./chunk-6FXOU2KR.js";
 import {
   resolvePackageDir
-} from "./chunk-KMRFRXIT.js";
+} from "./chunk-A35HE4V7.js";
 import {
   printInfo,
   printWarning
-} from "./chunk-TYRNTSPJ.js";
+} from "./chunk-NVZMBXTE.js";
 import {
   NullPublisher
 } from "./chunk-6QYMSNVA.js";
 import {
   readDiagnostics
-} from "./chunk-3WFZETIM.js";
+} from "./chunk-AYYMW33T.js";
 import {
   getGlobalRoot
 } from "./chunk-HAKDLR6N.js";
 import {
   isoNow
-} from "./chunk-J3SOTUVI.js";
+} from "./chunk-XQHFC62U.js";
 import {
   isAgentPhase,
   isAgentProviderId,
   isProcessAlive,
   webLockSchema
-} from "./chunk-LBGHI4S2.js";
+} from "./chunk-XDKGA6UX.js";
 
 // src/web/lock.ts
 import { spawn as nodeSpawn } from "child_process";
-import { readFile as readFile2, rm, writeFile } from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
 import { join as join2 } from "path";
 import chalk2 from "chalk";
+import { execa } from "execa";
 
 // src/web/server.ts
-import { createHash } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { readFile } from "fs/promises";
 import { createServer } from "http";
 import { createRequire } from "module";
@@ -44,11 +46,13 @@ import chalk from "chalk";
 var require2 = createRequire(import.meta.url);
 var SESSION_LIST_DESCRIPTION_MAX = 280;
 function readPackageVersion() {
-  try {
-    return require2("../../package.json").version;
-  } catch {
-    return "0.0.0";
+  for (const candidate of ["../package.json", "../../package.json"]) {
+    try {
+      return require2(candidate).version;
+    } catch {
+    }
   }
+  return "0.0.0";
 }
 function truncateSessionDescription(text, max = SESSION_LIST_DESCRIPTION_MAX) {
   if (text === null || text === void 0) return null;
@@ -99,8 +103,9 @@ async function loadStaticAssets(publicDir) {
   }
   return assets;
 }
-function baseHeaders(res) {
+function baseHeaders(res, instanceId) {
   res.setHeader("Cache-Control", "no-store");
+  res.setHeader("X-Issue-Flow-Instance", instanceId);
   res.setHeader("X-Content-Type-Options", "nosniff");
   res.setHeader("Referrer-Policy", "no-referrer");
   res.setHeader("X-Robots-Tag", "noindex, nofollow");
@@ -131,6 +136,7 @@ async function startWebServer(options) {
   const info = options.info ?? printInfo;
   const warn = options.warn ?? printWarning;
   const version = options.version ?? readPackageVersion();
+  const instanceId = options.instanceId ?? randomUUID();
   const startedAtMs = Date.now();
   const assets = await loadStaticAssets(
     options.publicDir ?? resolvePackageDir(join("web", "public"))
@@ -148,7 +154,7 @@ async function startWebServer(options) {
     return entry;
   };
   const handleRequest = async (req, res) => {
-    baseHeaders(res);
+    baseHeaders(res, instanceId);
     const requestUrl = new URL(req.url ?? "/", "http://localhost");
     const path = requestUrl.pathname;
     if (req.method === "POST" && path === "/api/config/agent") {
@@ -290,6 +296,9 @@ async function startWebServer(options) {
     if (path === "/api/health") {
       respondJson(res, 200, {
         ok: true,
+        pid: process.pid,
+        instanceId,
+        startedAt: new Date(startedAtMs).toISOString(),
         uptime: Math.round((Date.now() - startedAtMs) / 1e3),
         version,
         refreshSeconds: options.refreshSeconds ?? 5,
@@ -358,7 +367,7 @@ async function startWebServer(options) {
     closePromise = doClose();
     return closePromise;
   };
-  const handle = { server, host: options.host, port, url, close };
+  const handle = { server, host: options.host, port, url, instanceId, close };
   const onSignal = (signal) => {
     void handle.close().finally(() => {
       process.kill(process.pid, signal);
@@ -371,12 +380,16 @@ async function startWebServer(options) {
 
 // src/web/lock.ts
 var WEB_LOCK_FILENAME = "web.lock";
+var WEB_RESTART_LOCK_FILENAME = "web.restart.lock";
 var HEALTH_PROBE_TIMEOUT_MS = 1e3;
 var LOCK_CLAIM_RETRIES = 5;
 var LOCK_CLAIM_RETRY_DELAY_MS = 100;
 function getWebLockFile(options = {}) {
   return join2(getGlobalRoot(options), WEB_LOCK_FILENAME);
 }
+function getWebRestartLockFile(options = {}) {
+  return join2(getGlobalRoot(options), WEB_RESTART_LOCK_FILENAME);
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -389,11 +402,81 @@ async function probeHealth(host, port) {
     const res = await fetch(probeUrl(host, port), {
       signal: AbortSignal.timeout(HEALTH_PROBE_TIMEOUT_MS)
     });
-    return res.ok;
+    if (!res.ok) return null;
+    const body = await res.json();
+    if (body.ok !== true) return null;
+    return {
+      ok: true,
+      ...typeof body.pid === "number" && Number.isInteger(body.pid) && body.pid > 0 ? { pid: body.pid } : {},
+      ...typeof body.instanceId === "string" && body.instanceId !== "" ? { instanceId: body.instanceId } : {},
+      ...typeof body.startedAt === "string" && body.startedAt !== "" ? { startedAt: body.startedAt } : {},
+      ...typeof body.uptime === "number" && Number.isFinite(body.uptime) ? { uptime: body.uptime } : {},
+      ...typeof body.version === "string" && body.version !== "" ? { version: body.version } : {}
+    };
   } catch {
-    return false;
+    return null;
+  }
+}
+function sameLock(a, b) {
+  return a !== null && a.pid === b.pid && a.port === b.port && a.host === b.host && a.startedAt === b.startedAt && a.instanceId === b.instanceId;
+}
+async function removeWebLockIfOwned(lockFile, expected) {
+  if (sameLock(await readWebLock(lockFile), expected)) {
+    await removeWebLock(lockFile);
   }
 }
+async function inspectProcessCommand(pid) {
+  const invocation = process.platform === "win32" ? {
+    command: "powershell.exe",
+    args: [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
+    ]
+  } : { command: "ps", args: ["-p", String(pid), "-o", "command="] };
+  try {
+    const result = await execa(invocation.command, invocation.args, { reject: false });
+    const command = result.stdout.trim();
+    return result.exitCode === 0 && command !== "" ? command : null;
+  } catch {
+    return null;
+  }
+}
+async function findListeningProcess(port) {
+  try {
+    let pids;
+    if (process.platform === "win32") {
+      const result = await execa(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          `(Get-NetTCPConnection -State Listen -LocalPort ${port} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess -Unique) -join [Environment]::NewLine`
+        ],
+        { reject: false }
+      );
+      pids = result.stdout.split(/\s+/).map(Number).filter((pid2) => Number.isInteger(pid2) && pid2 > 0);
+    } else {
+      const result = await execa("lsof", ["-nP", "-t", `-iTCP:${port}`, "-sTCP:LISTEN"], {
+        reject: false
+      });
+      pids = result.stdout.split(/\s+/).map(Number).filter((pid2) => Number.isInteger(pid2) && pid2 > 0);
+    }
+    const unique = [...new Set(pids)];
+    if (unique.length !== 1) return null;
+    const pid = unique[0];
+    const command = await inspectProcessCommand(pid);
+    return command === null ? null : { pid, command };
+  } catch {
+    return null;
+  }
+}
+function isIssueFlowWebServe(owner, port) {
+  const escapedPort = String(port).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return /(?:^|\s)web\s+serve(?:\s|$)/.test(owner.command) && new RegExp(`(?:^|\\s)--port(?:=|\\s+)${escapedPort}(?:\\s|$)`).test(owner.command) && /issue-flow|(?:^|[/\\])dist[/\\]cli\.js/.test(owner.command);
+}
 async function readWebLock(lockFile) {
   let raw;
   try {
@@ -417,10 +500,11 @@ async function removeWebLock(lockFile) {
 async function detectActiveInstance(lockFile) {
   const lock = await readWebLock(lockFile);
   if (lock === null) return null;
-  if (isProcessAlive(lock.pid) && await probeHealth(lock.host, lock.port)) {
+  const health = isProcessAlive(lock.pid) ? await probeHealth(lock.host, lock.port) : null;
+  if (health !== null && (lock.instanceId === void 0 || health.instanceId === lock.instanceId)) {
     return lock;
   }
-  await removeWebLock(lockFile);
+  await removeWebLockIfOwned(lockFile, lock);
   return null;
 }
 async function claimWebLock(lockFile, lock) {
@@ -432,12 +516,74 @@ async function claimWebLock(lockFile, lock) {
     throw err;
   }
 }
+async function readRestartLock(file) {
+  try {
+    const value = JSON.parse(await readFile2(file, "utf-8"));
+    return typeof value.pid === "number" && Number.isInteger(value.pid) && value.pid > 0 && typeof value.operationId === "string" && value.operationId !== "" && typeof value.startedAt === "string" && value.startedAt !== "" ? { pid: value.pid, operationId: value.operationId, startedAt: value.startedAt } : null;
+  } catch {
+    return null;
+  }
+}
+async function removeRestartLockIfOwned(file, expected) {
+  const current = await readRestartLock(file);
+  if (current?.operationId === expected.operationId) {
+    await rm(file, { force: true }).catch(() => {
+    });
+  }
+}
+async function waitForRestart(file, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const lock = await readRestartLock(file);
+    if (lock === null) {
+      return true;
+    }
+    if (!isProcessAlive(lock.pid)) {
+      await removeRestartLockIfOwned(file, lock);
+      return true;
+    }
+    await sleep(LOCK_CLAIM_RETRY_DELAY_MS);
+  }
+  return false;
+}
+async function acquireRestartLock(file, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let waited = false;
+  while (Date.now() < deadline) {
+    const lock = {
+      pid: process.pid,
+      operationId: randomUUID2(),
+      startedAt: isoNow()
+    };
+    try {
+      await writeFile(file, JSON.stringify(lock, null, 2), { encoding: "utf-8", flag: "wx" });
+      return {
+        lock,
+        waited,
+        release: () => removeRestartLockIfOwned(file, lock)
+      };
+    } catch (err) {
+      if (err.code !== "EEXIST") return null;
+    }
+    waited = true;
+    const existing = await readRestartLock(file);
+    if (existing === null || !isProcessAlive(existing.pid)) {
+      if (existing === null) await rm(file, { force: true }).catch(() => {
+      });
+      else await removeRestartLockIfOwned(file, existing);
+      continue;
+    }
+    await sleep(LOCK_CLAIM_RETRY_DELAY_MS);
+  }
+  return null;
+}
 function reusedHandle(lock) {
   const displayHost = lock.host === "0.0.0.0" ? "localhost" : lock.host;
   return {
     host: lock.host,
     port: lock.port,
     url: `http://${displayHost}:${lock.port}`,
+    instanceId: lock.instanceId ?? `legacy-${lock.pid}-${lock.startedAt}`,
     close: async () => {
     }
   };
@@ -463,7 +609,8 @@ async function ensureSingleWebServer(options, lockOptions = {}) {
         pid: process.pid,
         port: handle.port,
         host: handle.host,
-        startedAt: isoNow()
+        startedAt: isoNow(),
+        instanceId: handle.instanceId
       });
     } catch (err) {
       await handle.close();
@@ -486,73 +633,258 @@ async function ensureSingleWebServer(options, lockOptions = {}) {
 }
 var DETACHED_CLAIM_TIMEOUT_MS = 5e3;
 var DETACHED_CLAIM_POLL_MS = 150;
+function inferredStartedAt(health) {
+  if (health.startedAt !== void 0) return health.startedAt;
+  if (health.uptime !== void 0) {
+    return new Date(Date.now() - Math.max(0, health.uptime) * 1e3).toISOString();
+  }
+  return isoNow();
+}
+async function discoverManagedInstance(lockFile, options, monitorOptions) {
+  const existingLock = await readWebLock(lockFile);
+  if (existingLock !== null) {
+    const health2 = isProcessAlive(existingLock.pid) ? await probeHealth(existingLock.host, existingLock.port) : null;
+    if (health2 !== null && (existingLock.instanceId === void 0 || health2.instanceId === existingLock.instanceId)) {
+      return { instance: { lock: existingLock, health: health2, source: "lock" }, unownedMonitor: false };
+    }
+    await removeWebLockIfOwned(lockFile, existingLock);
+  }
+  const health = await probeHealth(options.host, options.port);
+  if (health === null) return { instance: null, unownedMonitor: false };
+  const inspect = monitorOptions.inspectProcess ?? inspectProcessCommand;
+  let owner = null;
+  if (health.pid !== void 0) {
+    const command = await inspect(health.pid);
+    if (command !== null) owner = { pid: health.pid, command };
+  }
+  owner ??= await (monitorOptions.findPortOwner ?? findListeningProcess)(options.port);
+  if (owner === null || !isIssueFlowWebServe(owner, options.port)) {
+    return { instance: null, unownedMonitor: true };
+  }
+  const recovered = {
+    pid: owner.pid,
+    port: options.port,
+    host: options.host,
+    startedAt: inferredStartedAt(health),
+    ...health.instanceId === void 0 ? {} : { instanceId: health.instanceId }
+  };
+  const claimed = await claimWebLock(lockFile, recovered).catch(() => false);
+  if (!claimed) {
+    const winner = await readWebLock(lockFile);
+    if (winner !== null) {
+      const winnerHealth = await probeHealth(winner.host, winner.port);
+      if (winnerHealth !== null) {
+        return {
+          instance: { lock: winner, health: winnerHealth, source: "lock" },
+          unownedMonitor: false
+        };
+      }
+    }
+  }
+  return { instance: { lock: recovered, health, source: "port" }, unownedMonitor: false };
+}
+async function stopManagedInstance(instance, lockFile, options, monitorOptions) {
+  const info = options.info ?? printInfo;
+  const warn = options.warn ?? printWarning;
+  const version = instance.health.version === void 0 ? "" : `, version ${instance.health.version}`;
+  info(`Web monitor: stopping previous instance (pid ${instance.lock.pid}${version}).`);
+  try {
+    (monitorOptions.kill ?? process.kill)(instance.lock.pid, "SIGTERM");
+  } catch (err) {
+    if (err.code === "ESRCH") {
+      await removeWebLockIfOwned(lockFile, instance.lock);
+      info(`Web monitor: previous pid ${instance.lock.pid} was already gone; stale lock removed.`);
+      return true;
+    }
+    warn(
+      `Web monitor: failed to stop pid ${instance.lock.pid} (${err instanceof Error ? err.message : String(err)}). Continuing the pipeline without restarting it.`
+    );
+    return false;
+  }
+  const isAlive = monitorOptions.isAlive ?? isProcessAlive;
+  const deadline = Date.now() + (monitorOptions.shutdownTimeoutMs ?? 5e3);
+  const pollMs = monitorOptions.claimPollIntervalMs ?? DETACHED_CLAIM_POLL_MS;
+  while (Date.now() < deadline) {
+    const alive = isAlive(instance.lock.pid);
+    const health = alive ? await probeHealth(instance.lock.host, instance.lock.port) : null;
+    if (!alive || health === null) {
+      await removeWebLockIfOwned(lockFile, instance.lock);
+      info(`Web monitor: previous instance stopped (pid ${instance.lock.pid}).`);
+      info(
+        "Web monitor: process-local static asset and ETag caches invalidated; no on-disk web build cache exists."
+      );
+      return true;
+    }
+    await sleep(pollMs);
+  }
+  warn(
+    `Web monitor: pid ${instance.lock.pid} did not confirm shutdown in time. Continuing the pipeline without starting a competing instance.`
+  );
+  return false;
+}
+async function stopWebMonitor(options, monitorOptions = {}) {
+  const info = options.info ?? printInfo;
+  const warn = options.warn ?? printWarning;
+  let lockFile;
+  let restartLockFile;
+  try {
+    await mkdir(getGlobalRoot(monitorOptions), { recursive: true });
+    lockFile = getWebLockFile(monitorOptions);
+    restartLockFile = getWebRestartLockFile(monitorOptions);
+  } catch (err) {
+    warn(
+      `Web monitor: global storage unavailable (${err instanceof Error ? err.message : String(err)}).`
+    );
+    return "failed";
+  }
+  const lease = await acquireRestartLock(
+    restartLockFile,
+    monitorOptions.restartLockTimeoutMs ?? 5e3
+  );
+  if (lease === null) {
+    warn("Web monitor: could not acquire the maintenance lock; no process was stopped.");
+    return "failed";
+  }
+  try {
+    const stale = await readWebLock(lockFile);
+    const discovered = await discoverManagedInstance(lockFile, options, monitorOptions);
+    if (discovered.instance === null) {
+      if (stale !== null && !isProcessAlive(stale.pid)) {
+        info(`Web monitor: stale lock for dead pid ${stale.pid} removed.`);
+      }
+      if (discovered.unownedMonitor) {
+        warn(
+          `Web monitor: port ${options.port} looks like an Issue Flow monitor, but its process ownership could not be verified; it was left untouched.`
+        );
+        return "unowned";
+      }
+      info("No web monitor is currently running.");
+      return "not-running";
+    }
+    return await stopManagedInstance(discovered.instance, lockFile, options, monitorOptions) ? "stopped" : "failed";
+  } finally {
+    await lease.release();
+  }
+}
 async function ensureWebMonitor(options, monitorOptions = {}) {
   const warn = options.warn ?? printWarning;
   const info = options.info ?? printInfo;
   let lockFile;
+  let restartLockFile;
   try {
+    await mkdir(getGlobalRoot(monitorOptions), { recursive: true });
     lockFile = getWebLockFile(monitorOptions);
+    restartLockFile = getWebRestartLockFile(monitorOptions);
   } catch (err) {
     warn(
       `Web monitor: global storage unavailable (${err instanceof Error ? err.message : String(err)}). Falling back to legacy in-process mode.`
     );
     return startWebServer(options);
   }
-  const active = await detectActiveInstance(lockFile);
-  if (active !== null) {
-    info(`Reusing existing web monitor at ${reusedHandle(active).url}`);
-    return reusedHandle(active);
-  }
-  const execPath = monitorOptions.execPath ?? process.execPath;
-  const entryScript = monitorOptions.entryScript ?? process.argv[1];
-  if (entryScript === void 0) {
-    warn("Web monitor: could not determine the CLI entry point to spawn a detached server.");
+  const coordinationTimeout = monitorOptions.restartLockTimeoutMs ?? 5e3;
+  const restartRequestedAt = Date.now();
+  const restartLease = monitorOptions.restart ? await acquireRestartLock(restartLockFile, coordinationTimeout) : null;
+  if (monitorOptions.restart && restartLease === null) {
+    warn(
+      "Web monitor: could not acquire the restart lock. Continuing the pipeline without changing the server."
+    );
     return null;
   }
-  const args = [
-    entryScript,
-    "web",
-    "serve",
-    "--port",
-    String(options.port),
-    "--host",
-    options.host
-  ];
-  if (options.refreshSeconds !== void 0) {
-    args.push("--refresh", String(options.refreshSeconds));
-  }
-  const spawnFn = monitorOptions.spawn ?? nodeSpawn;
-  try {
-    const child = spawnFn(execPath, args, { detached: true, stdio: "ignore" });
-    child.unref();
-  } catch (err) {
+  if (!monitorOptions.restart && !await waitForRestart(restartLockFile, coordinationTimeout)) {
     warn(
-      `Web monitor: failed to start the detached server (${err instanceof Error ? err.message : String(err)}). Continuing without the web server.`
+      "Web monitor: another restart is still in progress. Continuing the pipeline without starting a competing instance."
     );
     return null;
   }
-  const timeoutMs = monitorOptions.claimTimeoutMs ?? DETACHED_CLAIM_TIMEOUT_MS;
-  const pollMs = monitorOptions.claimPollIntervalMs ?? DETACHED_CLAIM_POLL_MS;
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const claimed = await detectActiveInstance(lockFile);
-    if (claimed !== null) {
-      info(`Web monitor running at ${chalk2.bold.cyan(reusedHandle(claimed).url)}`);
-      return reusedHandle(claimed);
+  try {
+    const discovered = await discoverManagedInstance(lockFile, options, monitorOptions);
+    const active = discovered.instance;
+    if (monitorOptions.restart && restartLease?.waited === true && active !== null && Date.parse(active.lock.startedAt) >= restartRequestedAt) {
+      info(
+        `Web monitor: a concurrent restart already started pid ${active.lock.pid}; reusing ${reusedHandle(active.lock).url}`
+      );
+      return reusedHandle(active.lock);
     }
-    await sleep(pollMs);
+    if (active !== null && !monitorOptions.restart) {
+      if (active.source === "port") {
+        info(
+          `Recovered orphaned web monitor pid ${active.lock.pid} on port ${active.lock.port} and restored web.lock.`
+        );
+      }
+      info(`Reusing existing web monitor at ${reusedHandle(active.lock).url}`);
+      return reusedHandle(active.lock);
+    }
+    if (active !== null && monitorOptions.restart) {
+      if (!await stopManagedInstance(active, lockFile, options, monitorOptions)) return null;
+    } else if (discovered.unownedMonitor) {
+      warn(
+        `Web monitor: port ${options.port} answers an Issue Flow health check, but its owning process could not be verified. It was left untouched and no competing server was started.`
+      );
+      return null;
+    } else if (monitorOptions.restart) {
+      info("Web monitor: no previous managed instance was found; starting a fresh one.");
+      info("Web monitor: no on-disk web build cache exists; no files were removed.");
+    }
+    const execPath = monitorOptions.execPath ?? process.execPath;
+    const entryScript = monitorOptions.entryScript ?? process.argv[1];
+    if (entryScript === void 0) {
+      warn("Web monitor: could not determine the CLI entry point to spawn a detached server.");
+      return null;
+    }
+    const args = [
+      entryScript,
+      "web",
+      "serve",
+      "--port",
+      String(options.port),
+      "--host",
+      options.host
+    ];
+    if (options.refreshSeconds !== void 0) {
+      args.push("--refresh", String(options.refreshSeconds));
+    }
+    const spawnFn = monitorOptions.spawn ?? nodeSpawn;
+    try {
+      const child = spawnFn(execPath, args, { detached: true, stdio: "ignore" });
+      child.unref();
+    } catch (err) {
+      warn(
+        `Web monitor: failed to start the detached server (${err instanceof Error ? err.message : String(err)}). Continuing without the web server.`
+      );
+      return null;
+    }
+    const timeoutMs = monitorOptions.claimTimeoutMs ?? DETACHED_CLAIM_TIMEOUT_MS;
+    const pollMs = monitorOptions.claimPollIntervalMs ?? DETACHED_CLAIM_POLL_MS;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const claimed = await detectActiveInstance(lockFile);
+      if (claimed !== null) {
+        const handle = reusedHandle(claimed);
+        const health = await probeHealth(claimed.host, claimed.port);
+        if (monitorOptions.restart) {
+          const version = health?.version === void 0 ? "" : `, version ${health.version}`;
+          info(
+            `Web monitor: new instance started (pid ${claimed.pid}${version}) at ${chalk2.bold.cyan(handle.url)}`
+          );
+        } else {
+          info(`Web monitor running at ${chalk2.bold.cyan(handle.url)}`);
+        }
+        return handle;
+      }
+      await sleep(pollMs);
+    }
+    warn(
+      "Web monitor: the detached server did not start in time. Continuing without the web server."
+    );
+    return null;
+  } finally {
+    await restartLease?.release();
   }
-  warn(
-    "Web monitor: the detached server did not start in time. Continuing without the web server."
-  );
-  return null;
 }
 
 export {
-  getWebLockFile,
-  readWebLock,
-  removeWebLock,
   ensureSingleWebServer,
+  stopWebMonitor,
   ensureWebMonitor
 };
-//# sourceMappingURL=chunk-LFEQIZLB.js.map
+//# sourceMappingURL=chunk-BMHGRYL6.js.map