opendevbrowser 0.0.25 → 0.0.26

package/dist/{chunk-7U63PZ4W.js → chunk-GTTYIAI7.js}

@@ -47,7 +47,7 @@ import {
   runResearchWorkflow,
   runShoppingWorkflow,
   toSnippet
-} from "./chunk-Z6ENAZUN.js";
+} from "./chunk-AVQL6WAS.js";
 import {
   ProviderRuntimeError
 } from "./chunk-FUSXMW3G.js";
@@ -35991,12 +35991,129 @@ function createOpenDevBrowserCore(options) {
   };
 }
 
+// src/cli/utils/http.ts
+var DEFAULT_HTTP_TIMEOUT_MS = 5e3;
+function isAbortError(error) {
+  if (!error || typeof error !== "object") return false;
+  return "name" in error && error.name === "AbortError";
+}
+var resolveTimeoutMs = (timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) => {
+  return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_HTTP_TIMEOUT_MS;
+};
+var createTimeoutError = (timeoutMs) => {
+  return new Error(`Request timed out after ${timeoutMs}ms`);
+};
+var createTimedSignal = (timeoutMs, upstreamSignal) => {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  let removeAbortListener;
+  if (upstreamSignal) {
+    if (upstreamSignal.aborted) {
+      controller.abort(upstreamSignal.reason);
+    } else {
+      const onAbort = () => controller.abort(upstreamSignal.reason);
+      upstreamSignal.addEventListener("abort", onAbort, { once: true });
+      removeAbortListener = () => upstreamSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timeoutId);
+      removeAbortListener?.();
+    }
+  };
+};
+var cancelResponseBody = (response) => {
+  try {
+    const cancelResult = response.body?.cancel?.();
+    if (cancelResult instanceof Promise) {
+      void cancelResult.catch(() => {
+      });
+    }
+  } catch {
+  }
+};
+var readResponseBodyWithTimeout = async (response, signal, timeoutMs, reader) => {
+  let bodyCancelled = false;
+  const cancelBody = () => {
+    if (bodyCancelled) {
+      return;
+    }
+    bodyCancelled = true;
+    cancelResponseBody(response);
+  };
+  if (signal.aborted) {
+    cancelBody();
+    throw createTimeoutError(timeoutMs);
+  }
+  let removeAbortListener;
+  const abortPromise = new Promise((_, reject) => {
+    const onAbort = () => {
+      cancelBody();
+      reject(createTimeoutError(timeoutMs));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([reader(), abortPromise]);
+  } catch (error) {
+    if (signal.aborted || isAbortError(error)) {
+      cancelBody();
+      throw createTimeoutError(timeoutMs);
+    }
+    throw error;
+  } finally {
+    removeAbortListener?.();
+  }
+};
+async function fetchWithTimeout(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
+  try {
+    return await fetch(input, { ...init, signal: timedSignal.signal });
+  } catch (error) {
+    if (isAbortError(error) || timedSignal.signal.aborted) {
+      throw createTimeoutError(resolvedTimeout);
+    }
+    throw error;
+  } finally {
+    timedSignal.dispose();
+  }
+}
+async function fetchWithTimeoutContext(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
+  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
+  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
+  try {
+    const response = await fetch(input, { ...init, signal: timedSignal.signal });
+    return {
+      response,
+      signal: timedSignal.signal,
+      timeoutMs: resolvedTimeout,
+      dispose: timedSignal.dispose
+    };
+  } catch (error) {
+    timedSignal.dispose();
+    if (isAbortError(error) || timedSignal.signal.aborted) {
+      throw createTimeoutError(resolvedTimeout);
+    }
+    throw error;
+  }
+}
+async function readResponseTextWithTimeout(response, signal, timeoutMs) {
+  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.text());
+}
+async function readResponseJsonWithTimeout(response, signal, timeoutMs) {
+  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.json());
+}
+
 // src/cli/daemon.ts
 import { createServer as createServer2 } from "http";
 import { createHash as createHash6, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync3, unlinkSync, existsSync as existsSync6 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join16, resolve as resolve7 } from "path";
+import { basename as basename2, dirname as dirname8, join as join16, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli/daemon-commands.ts
@@ -36247,7 +36364,14 @@ var DOM_CAPTURE_EMPTY_MESSAGE = "DOM capture returned empty HTML.";
 var SKIPPED_AFTER_TRANSPORT_TIMEOUT_SUFFIX = "transport timeout.";
 var createRemainingCaptureTimeout = (timeoutMs) => {
   const startedAtMs = Date.now();
-  return () => Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
+  let firstRead = true;
+  return () => {
+    if (firstRead) {
+      firstRead = false;
+      return timeoutMs;
+    }
+    return Math.max(1, timeoutMs - Math.max(0, Date.now() - startedAtMs));
+  };
 };
 var clampInspiredesignCaptureTimeout = (timeoutMs) => {
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) return INSPIREDESIGN_CAPTURE_TIMEOUT_MS;
@@ -37172,119 +37296,6 @@ var getBindingRenewConfig = () => ({
   waitMaxMs: WAIT_MAX_MS
 });
 
-// src/cli/utils/http.ts
-var DEFAULT_HTTP_TIMEOUT_MS = 5e3;
-function isAbortError(error) {
-  if (!error || typeof error !== "object") return false;
-  return "name" in error && error.name === "AbortError";
-}
-var resolveTimeoutMs = (timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) => {
-  return Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_HTTP_TIMEOUT_MS;
-};
-var createTimeoutError = (timeoutMs) => {
-  return new Error(`Request timed out after ${timeoutMs}ms`);
-};
-var createTimedSignal = (timeoutMs, upstreamSignal) => {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-  let removeAbortListener;
-  if (upstreamSignal) {
-    if (upstreamSignal.aborted) {
-      controller.abort(upstreamSignal.reason);
-    } else {
-      const onAbort = () => controller.abort(upstreamSignal.reason);
-      upstreamSignal.addEventListener("abort", onAbort, { once: true });
-      removeAbortListener = () => upstreamSignal.removeEventListener("abort", onAbort);
-    }
-  }
-  return {
-    signal: controller.signal,
-    dispose: () => {
-      clearTimeout(timeoutId);
-      removeAbortListener?.();
-    }
-  };
-};
-var cancelResponseBody = (response) => {
-  try {
-    void response.body?.cancel?.();
-  } catch {
-  }
-};
-var readResponseBodyWithTimeout = async (response, signal, timeoutMs, reader) => {
-  let bodyCancelled = false;
-  const cancelBody = () => {
-    if (bodyCancelled) {
-      return;
-    }
-    bodyCancelled = true;
-    cancelResponseBody(response);
-  };
-  if (signal.aborted) {
-    cancelBody();
-    throw createTimeoutError(timeoutMs);
-  }
-  let removeAbortListener;
-  const abortPromise = new Promise((_, reject) => {
-    const onAbort = () => {
-      cancelBody();
-      reject(createTimeoutError(timeoutMs));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    removeAbortListener = () => signal.removeEventListener("abort", onAbort);
-  });
-  try {
-    return await Promise.race([reader(), abortPromise]);
-  } catch (error) {
-    if (signal.aborted || isAbortError(error)) {
-      cancelBody();
-      throw createTimeoutError(timeoutMs);
-    }
-    throw error;
-  } finally {
-    removeAbortListener?.();
-  }
-};
-async function fetchWithTimeout(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
-  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
-  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
-  try {
-    return await fetch(input, { ...init, signal: timedSignal.signal });
-  } catch (error) {
-    if (isAbortError(error) || timedSignal.signal.aborted) {
-      throw createTimeoutError(resolvedTimeout);
-    }
-    throw error;
-  } finally {
-    timedSignal.dispose();
-  }
-}
-async function fetchWithTimeoutContext(input, init = {}, timeoutMs = DEFAULT_HTTP_TIMEOUT_MS) {
-  const resolvedTimeout = resolveTimeoutMs(timeoutMs);
-  const timedSignal = createTimedSignal(resolvedTimeout, init?.signal ?? void 0);
-  try {
-    const response = await fetch(input, { ...init, signal: timedSignal.signal });
-    return {
-      response,
-      signal: timedSignal.signal,
-      timeoutMs: resolvedTimeout,
-      dispose: timedSignal.dispose
-    };
-  } catch (error) {
-    timedSignal.dispose();
-    if (isAbortError(error) || timedSignal.signal.aborted) {
-      throw createTimeoutError(resolvedTimeout);
-    }
-    throw error;
-  }
-}
-async function readResponseTextWithTimeout(response, signal, timeoutMs) {
-  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.text());
-}
-async function readResponseJsonWithTimeout(response, signal, timeoutMs) {
-  return await readResponseBodyWithTimeout(response, signal, timeoutMs, () => response.json());
-}
-
 // src/cli/daemon-commands.ts
 var createDaemonWorkflowRuntime = (core, options) => resolveBundledProviderRuntime({
   existingRuntime: core.providerRuntime,
@@ -39020,6 +39031,11 @@ async function resolveMacroExpression(options, config, manager, browserFallbackP
 
 // src/cli/daemon.ts
 var DEFAULT_DAEMON_PORT2 = 8788;
+var DAEMON_STOP_DEBUG_ENV = "OPDEVBROWSER_DEBUG_DAEMON_STOP";
+var DAEMON_FINGERPRINT_FILE = "daemon-fingerprint.json";
+var DAEMON_STOP_REASON_HEADER = "x-opendevbrowser-stop-reason";
+var DAEMON_STOP_CLIENT_PID_HEADER = "x-opendevbrowser-stop-client-pid";
+var DAEMON_STOP_FINGERPRINT_HEADER = "x-opendevbrowser-stop-fingerprint";
 var RECOVERABLE_PLAYWRIGHT_TRANSPORT_ERRORS = [
   "Cannot find context with specified id",
   "Detached while handling command."
@@ -39076,23 +39092,58 @@ function hashFileContents(entryPath) {
     return "missing";
   }
 }
+function resolveDaemonFingerprintDistRoot(modulePath) {
+  let currentDir = dirname8(modulePath);
+  while (true) {
+    if (basename2(currentDir) === "dist") {
+      return currentDir;
+    }
+    const parentDir = dirname8(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+function readDaemonFingerprintArtifact(modulePath) {
+  const distRoot = resolveDaemonFingerprintDistRoot(modulePath);
+  if (distRoot === null) {
+    return null;
+  }
+  try {
+    const content = readFileSync5(join16(distRoot, DAEMON_FINGERPRINT_FILE), "utf-8");
+    const payload = JSON.parse(content);
+    if (typeof payload.fingerprint === "string" && payload.fingerprint.trim().length > 0) {
+      return payload.fingerprint.trim();
+    }
+  } catch {
+  }
+  return null;
+}
 function getCurrentDaemonFingerprint(options = {}) {
-  const entryPath = resolveCurrentDaemonEntrypointPath(options);
   const modulePath = resolve7(fileURLToPath2(options.moduleUrl ?? import.meta.url));
+  const sharedFingerprint = readDaemonFingerprintArtifact(modulePath);
   const fingerprintParts = [
     DAEMON_FINGERPRINT_VERSION,
-    process.execPath,
-    entryPath,
-    hashFileContents(entryPath)
+    sharedFingerprint ?? hashFileContents(modulePath)
   ];
-  if (modulePath !== entryPath) {
-    fingerprintParts.push(modulePath, hashFileContents(modulePath));
-  }
   return createHash6("sha256").update(fingerprintParts.join("\n")).digest("hex");
 }
 function isCurrentDaemonFingerprint(fingerprint) {
   return typeof fingerprint === "string" && fingerprint === getCurrentDaemonFingerprint();
 }
+function createDaemonStopHeaders(token, reason) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    [DAEMON_STOP_FINGERPRINT_HEADER]: getCurrentDaemonFingerprint(),
+    [DAEMON_STOP_REASON_HEADER]: reason
+  };
+  if (process.env[DAEMON_STOP_DEBUG_ENV] === "1") {
+    headers[DAEMON_STOP_CLIENT_PID_HEADER] = String(process.pid);
+  }
+  return headers;
+}
 function resolveDaemonFingerprint(...candidates) {
   for (const candidate of candidates) {
     if (typeof candidate === "string" && candidate.trim().length > 0) {
@@ -39134,6 +39185,20 @@ function sendJson(response, status, payload) {
   });
   response.end(JSON.stringify(payload));
 }
+function logDaemonStopDebug(message, details) {
+  if (process.env[DAEMON_STOP_DEBUG_ENV] !== "1") {
+    return;
+  }
+  const suffix = details ? ` ${JSON.stringify(details)}` : "";
+  console.error(`[daemon-stop-debug] ${message}${suffix}`);
+}
+function readSingleHeader(request, name) {
+  const value = request.headers[name];
+  if (typeof value === "string") {
+    return value;
+  }
+  return null;
+}
 var isDaemonCommandRequest = (value) => {
   if (typeof value.name !== "string") {
     return false;
@@ -39185,8 +39250,20 @@ async function startDaemon(options = {}) {
       return;
     }
     if (request.method === "POST" && url.pathname === "/stop") {
+      const stopFingerprint = readSingleHeader(request, DAEMON_STOP_FINGERPRINT_HEADER);
+      logDaemonStopDebug("http.stop", {
+        remoteAddress: request.socket.remoteAddress ?? null,
+        remotePort: request.socket.remotePort ?? null,
+        reason: readSingleHeader(request, DAEMON_STOP_REASON_HEADER),
+        clientPid: readSingleHeader(request, DAEMON_STOP_CLIENT_PID_HEADER),
+        fingerprintMatches: stopFingerprint === fingerprint
+      });
+      if (stopFingerprint !== fingerprint) {
+        sendJson(response, 409, { ok: false, error: "Stale daemon stop request." });
+        return;
+      }
       sendJson(response, 200, { ok: true });
-      await stop();
+      await stop("http.stop");
       return;
     }
     if (request.method === "POST" && url.pathname === "/command") {
@@ -39240,7 +39317,7 @@ async function startDaemon(options = {}) {
       return;
     }
     console.error(error);
-    void stop().finally(() => {
+    void stop("uncaughtException").finally(() => {
       process.exitCode = 1;
     });
   };
@@ -39249,15 +39326,16 @@ async function startDaemon(options = {}) {
       return;
     }
     console.error(reason);
-    void stop().finally(() => {
+    void stop("unhandledRejection").finally(() => {
       process.exitCode = 1;
     });
   };
-  const stop = async () => {
+  const stop = async (reason = "unknown") => {
     if (stopping) {
       return;
     }
     stopping = true;
+    logDaemonStopDebug("stop.begin", { reason });
     clearDaemonMetadata();
     clearBinding();
     process.off("SIGINT", sigintHandler);
@@ -39268,13 +39346,14 @@ async function startDaemon(options = {}) {
     await new Promise((resolve9) => {
       server.close(() => resolve9());
     });
+    logDaemonStopDebug("stop.complete", { reason });
   };
   const sigintHandler = () => {
-    stop().catch(() => {
+    void stop("SIGINT").catch(() => {
     });
   };
   const sigtermHandler = () => {
-    stop().catch(() => {
+    void stop("SIGTERM").catch(() => {
     });
   };
   process.on("SIGINT", sigintHandler);
@@ -39348,7 +39427,15 @@ function resolveExitCode(result) {
   return result.success ? EXIT_SUCCESS : EXIT_EXECUTION;
 }
 
+// src/cli/daemon-status-policy.ts
+var DEFAULT_DAEMON_STATUS_FETCH_OPTIONS = {
+  timeoutMs: 5e3,
+  retryAttempts: 5,
+  retryDelayMs: 250
+};
+
 // src/cli/daemon-status.ts
+var DEFAULT_DAEMON_STATUS_TIMEOUT_MS = DEFAULT_DAEMON_STATUS_FETCH_OPTIONS.timeoutMs;
 var sleep2 = async (delayMs) => {
   if (!(Number.isFinite(delayMs) && delayMs > 0)) {
     return;
@@ -39361,17 +39448,66 @@ var resolveRetryAttempts = (retryAttempts) => {
 var resolveRetryDelayMs = (retryDelayMs) => {
   return typeof retryDelayMs === "number" && Number.isFinite(retryDelayMs) && retryDelayMs > 0 ? retryDelayMs : 0;
 };
+var resolveStatusTimeoutMs = (timeoutMs) => {
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_DAEMON_STATUS_TIMEOUT_MS;
+};
+var withFingerprintCurrent = (status) => ({
+  ...status,
+  fingerprintCurrent: isCurrentDaemonFingerprint(status.fingerprint)
+});
+var readRemainingBudgetMs = (deadlineMs) => {
+  return Math.max(0, deadlineMs - Date.now());
+};
+var readSeedTimeoutMs = (remainingBudgetMs, remainingSeedCount) => {
+  if (remainingSeedCount <= 1) {
+    return remainingBudgetMs;
+  }
+  return Math.max(1, Math.floor(remainingBudgetMs / remainingSeedCount));
+};
+var resolveDaemonStatusSeeds = (metadata, config) => {
+  const seeds = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addSeed = (seed) => {
+    if (!seed) {
+      return;
+    }
+    const key = `${seed.port}:${seed.token}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    seeds.push(seed);
+  };
+  addSeed(
+    config.daemonPort > 0 && config.daemonToken ? {
+      port: config.daemonPort,
+      token: config.daemonToken,
+      relayPort: config.relayPort
+    } : null
+  );
+  addSeed(metadata);
+  return seeds;
+};
 async function fetchDaemonStatus(port, token, options = {}) {
   const attempts = resolveRetryAttempts(options.retryAttempts);
   const retryDelayMs = resolveRetryDelayMs(options.retryDelayMs);
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      const response = await fetchWithTimeout(`http://127.0.0.1:${port}/status`, {
+      const timedResponse = await fetchWithTimeoutContext(`http://127.0.0.1:${port}/status`, {
         method: "GET",
         headers: { Authorization: `Bearer ${token}` }
       }, options.timeoutMs);
-      if (response.ok) {
-        return await response.json();
+      try {
+        if (timedResponse.response.ok) {
+          const status = await readResponseJsonWithTimeout(
+            timedResponse.response,
+            timedResponse.signal,
+            timedResponse.timeoutMs
+          );
+          return withFingerprintCurrent(status);
+        }
+      } finally {
+        timedResponse.dispose();
       }
     } catch {
     }
@@ -39385,32 +39521,34 @@ async function fetchDaemonStatusFromMetadata(config, options = {}) {
   const resolvedConfig = config ?? loadGlobalConfig();
   const attempts = resolveRetryAttempts(options.retryAttempts);
   const retryDelayMs = resolveRetryDelayMs(options.retryDelayMs);
+  const deadlineMs = Date.now() + resolveStatusTimeoutMs(options.timeoutMs);
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     const metadata = readDaemonMetadata();
-    if (metadata) {
-      const status = await fetchDaemonStatus(metadata.port, metadata.token, { timeoutMs: options.timeoutMs });
-      if (status?.ok) {
-        persistDaemonStatusMetadata(metadata, status, resolvedConfig);
-        return status;
+    const seeds = resolveDaemonStatusSeeds(metadata, resolvedConfig);
+    for (let seedIndex = 0; seedIndex < seeds.length; seedIndex += 1) {
+      const seed = seeds[seedIndex];
+      if (!seed) {
+        continue;
       }
-    }
-    if (resolvedConfig.daemonPort > 0 && resolvedConfig.daemonToken) {
-      const status = await fetchDaemonStatus(resolvedConfig.daemonPort, resolvedConfig.daemonToken, {
-        timeoutMs: options.timeoutMs
+      const remainingBudgetMs = readRemainingBudgetMs(deadlineMs);
+      if (remainingBudgetMs <= 0) {
+        return null;
+      }
+      const timeoutMs = readSeedTimeoutMs(remainingBudgetMs, seeds.length - seedIndex);
+      const status = await fetchDaemonStatus(seed.port, seed.token, {
+        timeoutMs
       });
       if (status?.ok) {
-        persistDaemonStatusMetadata({
-          port: resolvedConfig.daemonPort,
-          token: resolvedConfig.daemonToken,
-          pid: status.pid,
-          relayPort: status.relay.port ?? resolvedConfig.relayPort,
-          startedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }, status, resolvedConfig);
+        persistDaemonStatusMetadata(seed, status, resolvedConfig);
         return status;
       }
     }
     if (attempt < attempts) {
-      await sleep2(retryDelayMs);
+      const remainingBudgetMs = readRemainingBudgetMs(deadlineMs);
+      if (remainingBudgetMs <= 0) {
+        break;
+      }
+      await sleep2(Math.min(retryDelayMs, remainingBudgetMs));
     }
   }
   return null;
@@ -39456,6 +39594,13 @@ var DAEMON_RECOVERY_READY_TIMEOUT_MS = 5e3;
 var DAEMON_RESTART_READY_TIMEOUT_MS = 15e3;
 var DAEMON_RESTART_POLL_DELAY_MS = 250;
 var cachedClientState;
+var logDaemonStopDebug2 = (message, details) => {
+  if (process.env[DAEMON_STOP_DEBUG_ENV] !== "1") {
+    return;
+  }
+  const suffix = details ? ` ${JSON.stringify(details)}` : "";
+  console.error(`[daemon-stop-debug] ${message}${suffix}`);
+};
 var getClientStateFilePath = () => {
   const cacheRoot = getCacheRoot();
   return join17(cacheRoot, CLIENT_ID_FILE);
@@ -39579,7 +39724,7 @@ var DaemonClient = class {
         this.maybeTrackLease(name, params2, result);
         return result;
       }
-      if (!options.requireBinding && isBindingRequiredError(error)) {
+      if (isBindingRequiredError(error)) {
         if (this.binding) {
           this.clearBinding();
         }
@@ -39703,7 +39848,9 @@ var DaemonClient = class {
   }
   async callRaw(name, params2, timeoutMs) {
     const budget = createTimeoutBudget(timeoutMs);
-    const connection = await resolveDaemonConnection(budget);
+    const connection = await resolveDaemonConnection(budget, {
+      preferConfiguredRecovery: requiresConfiguredRecovery(name)
+    });
     let timedResponse;
     try {
       timedResponse = await openDaemonCommand(
@@ -39711,7 +39858,7 @@ var DaemonClient = class {
         connection.token,
         name,
         params2,
-        readRemainingBudgetMs(budget)
+        readRemainingBudgetMs2(budget)
       );
     } catch (error) {
       if (isTransportTimeoutError2(error)) {
@@ -39756,7 +39903,7 @@ var createTimeoutBudget = (timeoutMs) => {
   const resolved = asPositiveNumber(timeoutMs);
   return resolved === void 0 ? null : { timeoutMs: resolved, deadlineMs: Date.now() + resolved };
 };
-var readRemainingBudgetMs = (budget) => {
+var readRemainingBudgetMs2 = (budget) => {
   if (!budget) {
     return void 0;
   }
@@ -39767,7 +39914,7 @@ var readRemainingBudgetMs = (budget) => {
   return remainingMs;
 };
 var capTimeoutToBudget = (timeoutMs, budget) => {
-  const remainingMs = readRemainingBudgetMs(budget);
+  const remainingMs = readRemainingBudgetMs2(budget);
   return remainingMs === void 0 ? timeoutMs : Math.max(1, Math.min(timeoutMs, remainingMs));
 };
 var resolveReadyDeadlineMs = (readyTimeoutMs, budget) => {
@@ -39864,7 +40011,7 @@ var fetchCurrentDaemonStatus = async (connection, options, budget = null) => {
       return status;
     }
     if (attempt < attempts) {
-      await sleep3(Math.min(retryDelayMs, readRemainingBudgetMs(budget) ?? retryDelayMs));
+      await sleep3(Math.min(retryDelayMs, readRemainingBudgetMs2(budget) ?? retryDelayMs));
     }
   }
   return null;
@@ -39880,7 +40027,7 @@ var fetchAnyDaemonStatus = async (connection, options, budget = null) => {
       return status;
     }
     if (attempt < attempts) {
-      await sleep3(Math.min(retryDelayMs, readRemainingBudgetMs(budget) ?? retryDelayMs));
+      await sleep3(Math.min(retryDelayMs, readRemainingBudgetMs2(budget) ?? retryDelayMs));
     }
   }
   return null;
@@ -39891,6 +40038,9 @@ var sleep3 = async (delayMs) => {
   }
   await new Promise((resolve9) => setTimeout(resolve9, delayMs));
 };
+var requiresConfiguredRecovery = (name) => {
+  return name === "canvas.execute";
+};
 var getConfiguredDaemonConnection = () => {
   const config = loadGlobalConfig();
   if (!(config.daemonPort > 0 && config.daemonToken)) {
@@ -39912,7 +40062,7 @@ var persistResolvedDaemonStatus = (connection, status) => {
 };
 var persistCurrentConfiguredConnection = async (configuredConnection, status, staleMetadata) => {
   if (staleMetadata && !sameDaemonConnection(staleMetadata.connection, configuredConnection)) {
-    void stopDaemonConnection(staleMetadata.connection).catch(() => void 0);
+    void stopDaemonConnection(staleMetadata.connection, null, "persistCurrentConfiguredConnection.staleMetadata").catch(() => void 0);
   }
   persistResolvedDaemonStatus(configuredConnection, status);
   return configuredConnection;
@@ -39921,7 +40071,7 @@ var resolveConfiguredPreferenceOptions = (budget) => {
   if (!budget) {
     return DAEMON_CONFIG_PREFER_OPTIONS;
   }
-  const remainingMs = readRemainingBudgetMs(budget);
+  const remainingMs = readRemainingBudgetMs2(budget);
   if (remainingMs === void 0 || remainingMs <= 1) {
     return null;
   }
@@ -39943,14 +40093,27 @@ var resolveConfiguredPreferenceOptions = (budget) => {
     retryDelayMs: retryAttempts > 1 ? retryDelayMs : 0
   };
 };
-var stopDaemonConnection = async (connection, budget = null) => {
+var stopDaemonConnection = async (connection, budget = null, reason = "unknown") => {
   const stopTimeoutMs = capTimeoutToBudget(DAEMON_RESTART_STATUS_TIMEOUT_MS, budget);
+  logDaemonStopDebug2("client.stop.request", { reason, port: connection.port });
   try {
-    await fetchWithTimeout(`http://127.0.0.1:${connection.port}/stop`, {
+    const response = await fetchWithTimeout(`http://127.0.0.1:${connection.port}/stop`, {
       method: "POST",
-      headers: { Authorization: `Bearer ${connection.token}` }
+      headers: createDaemonStopHeaders(connection.token, reason)
     }, stopTimeoutMs);
+    if (response.status === 409) {
+      logDaemonStopDebug2("client.stop.fingerprintRejected", { reason, port: connection.port });
+      return "fingerprint_rejected";
+    }
+    if (!response.ok) {
+      logDaemonStopDebug2("client.stop.rejected", { reason, port: connection.port, status: response.status });
+      return "unreachable";
+    }
+    logDaemonStopDebug2("client.stop.complete", { reason, port: connection.port });
+    return "stopped";
   } catch {
+    logDaemonStopDebug2("client.stop.error", { reason, port: connection.port });
+    return "unreachable";
   }
 };
 function resolveDaemonRestartCommand(options = {}) {
@@ -40056,7 +40219,7 @@ var resolveMetadataConnection = async (metadataConnection, configuredConnection,
   }
   return { connection: metadataConnection, status };
 };
-var resolveFreshDaemonConnection = async (budget = null) => {
+var resolveFreshDaemonConnection = async (budget = null, options = {}) => {
   const configuredConnection = getConfiguredDaemonConnection();
   if (!configuredConnection) {
     throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
@@ -40069,9 +40232,22 @@ var resolveFreshDaemonConnection = async (budget = null) => {
   if (currentConfiguredStatus?.ok) {
     return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
   }
-  if (staleMetadata?.status.ok && isCurrentDaemonFingerprint(staleMetadata.status.fingerprint)) {
+  if (options.preferConfiguredRecovery && staleMetadata) {
+    currentConfiguredStatus = await waitForCurrentDaemonStatus(
+      configuredConnection,
+      DAEMON_RECOVERY_READY_TIMEOUT_MS,
+      budget
+    );
+    if (currentConfiguredStatus?.ok) {
+      return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
+    }
+    if (!configuredStatus?.ok) {
+      throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+    }
+  }
+  if (!options.preferConfiguredRecovery && staleMetadata?.status.ok && isCurrentDaemonFingerprint(staleMetadata.status.fingerprint)) {
     if (configuredStatus?.ok) {
-      void stopDaemonConnection(configuredConnection, budget).catch(() => void 0);
+      void stopDaemonConnection(configuredConnection, budget, "resolveFreshDaemonConnection.configuredCurrentMetadataPreferred").catch(() => void 0);
     }
     return staleMetadata.connection;
   }
@@ -40084,13 +40260,11 @@ var resolveFreshDaemonConnection = async (budget = null) => {
     if (currentConfiguredStatus?.ok) {
       return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
     }
+    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
   }
   const staleConnections = [];
   if (configuredStatus?.ok) {
-    staleConnections.push(configuredConnection);
-  }
-  if (staleMetadata && !sameDaemonConnection(staleMetadata.connection, configuredConnection)) {
-    staleConnections.push(staleMetadata.connection);
+    staleConnections.push({ connection: configuredConnection, status: configuredStatus });
   }
   if (staleConnections.length === 0) {
     const recoveringStatus = await waitForCurrentDaemonStatus(
@@ -40105,7 +40279,16 @@ var resolveFreshDaemonConnection = async (budget = null) => {
     throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
   }
   for (const staleConnection of staleConnections) {
-    await stopDaemonConnection(staleConnection, budget);
+    const stopOutcome = await stopDaemonConnection(
+      staleConnection.connection,
+      budget,
+      "resolveFreshDaemonConnection.staleConnections"
+    );
+    if (stopOutcome === "fingerprint_rejected") {
+      throw createDisconnectedError(
+        `Daemon on 127.0.0.1:${staleConnection.connection.port} pid=${staleConnection.status.pid} is protected by a different opendevbrowser build. Start with \`opendevbrowser serve\`.`
+      );
+    }
   }
   if (configuredStatus?.ok) {
     const shutdownOutcome = await waitForDaemonShutdown(configuredConnection, DAEMON_RECOVERY_READY_TIMEOUT_MS, budget);
@@ -40125,7 +40308,7 @@ var resolveFreshDaemonConnection = async (budget = null) => {
   persistResolvedDaemonStatus(configuredConnection, refreshedStatus);
   return configuredConnection;
 };
-var resolveDaemonConnection = async (budget = null) => {
+var resolveDaemonConnection = async (budget = null, options = {}) => {
   const metadata = readDaemonMetadata();
   if (metadata && isCurrentDaemonFingerprint(metadata.fingerprint)) {
     const metadataConnection = { port: metadata.port, token: metadata.token };
@@ -40135,6 +40318,9 @@ var resolveDaemonConnection = async (budget = null) => {
     }
     const configuredOptions = resolveConfiguredPreferenceOptions(budget);
     if (!configuredOptions) {
+      if (options.preferConfiguredRecovery) {
+        return await resolveFreshDaemonConnection(budget, options);
+      }
       return metadataConnection;
     }
     const configuredStatus = await fetchCurrentDaemonStatus(configuredConnection, configuredOptions, budget);
@@ -40145,13 +40331,18 @@ var resolveDaemonConnection = async (budget = null) => {
         { connection: metadataConnection }
       );
     }
+    if (options.preferConfiguredRecovery) {
+      return await resolveFreshDaemonConnection(budget, options);
+    }
     return metadataConnection;
   }
-  return await resolveFreshDaemonConnection(budget);
+  return await resolveFreshDaemonConnection(budget, options);
 };
 var retryWithRefreshedConnection = async (name, params2, budget) => {
-  const connection = await resolveFreshDaemonConnection(budget);
-  return await openDaemonCommand(connection.port, connection.token, name, params2, readRemainingBudgetMs(budget));
+  const connection = await resolveFreshDaemonConnection(budget, {
+    preferConfiguredRecovery: requiresConfiguredRecovery(name)
+  });
+  return await openDaemonCommand(connection.port, connection.token, name, params2, readRemainingBudgetMs2(budget));
 };
 var openDaemonCommand = async (port, token, name, params2, timeoutMs) => {
   return await fetchWithTimeoutContext(`http://127.0.0.1:${port}/command`, {
@@ -43320,15 +43511,18 @@ export {
   executeMacroWithRuntime,
   fetchWithTimeout,
   readDaemonMetadata,
-  getCurrentDaemonFingerprint,
+  isCurrentDaemonFingerprint,
+  createDaemonStopHeaders,
   startDaemon,
   EXIT_USAGE,
   EXIT_EXECUTION,
   EXIT_DISCONNECTED,
   createUsageError,
+  createDisconnectedError,
   toCliError,
   formatErrorPayload,
   resolveExitCode,
+  DEFAULT_DAEMON_STATUS_FETCH_OPTIONS,
   fetchDaemonStatus,
   fetchDaemonStatusFromMetadata,
   DaemonClient,
@@ -43350,4 +43544,4 @@ export {
   TOOL_SURFACE_ENTRIES
 };
 /* v8 ignore next -- @preserve */
-//# sourceMappingURL=chunk-7U63PZ4W.js.map
+//# sourceMappingURL=chunk-GTTYIAI7.js.map