opendevbrowser 0.0.28 → 0.0.30

package/dist/chunk-MD655IPO.js

@@ -0,0 +1,838 @@
+import {
+  DAEMON_STOP_DEBUG_ENV,
+  createDaemonStopHeaders,
+  fetchDaemonStatus,
+  fetchWithTimeout,
+  fetchWithTimeoutContext,
+  getCacheRoot,
+  isCurrentDaemonFingerprint,
+  persistDaemonStatusMetadata,
+  readDaemonMetadata,
+  readResponseJsonWithTimeout,
+  readResponseTextWithTimeout,
+  resolveCurrentDaemonEntrypointPath
+} from "./chunk-COAOWH3G.js";
+import {
+  loadGlobalConfig
+} from "./chunk-MX3NFLCE.js";
+import {
+  CliError,
+  EXIT_EXECUTION,
+  createDisconnectedError
+} from "./chunk-IPE7TF2P.js";
+import {
+  writeFileAtomic
+} from "./chunk-TBUCZX4A.js";
+
+// src/cli/daemon-client.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+import { randomUUID } from "crypto";
+import { fileURLToPath } from "url";
+var CLIENT_ID_FILE = "client.json";
+var DEFAULT_RENEW_AFTER_MS = 2e4;
+var MIN_RENEW_AFTER_MS = 5e3;
+var TRANSPORT_TIMEOUT_BUFFER_MS = 5e3;
+var MAX_DERIVED_TRANSPORT_TIMEOUT_MS = 3e5;
+var TRANSPORT_TIMEOUT_HINT_KEYS = ["timeoutMs", "waitTimeoutMs"];
+var DAEMON_STATUS_RETRY_OPTIONS = {
+  retryAttempts: 5,
+  retryDelayMs: 250
+};
+var DAEMON_CONFIG_PREFER_OPTIONS = {
+  timeoutMs: 500,
+  retryAttempts: 3,
+  retryDelayMs: 250
+};
+var DAEMON_RESTART_STATUS_TIMEOUT_MS = 5e3;
+var DAEMON_RECOVERY_READY_TIMEOUT_MS = 5e3;
+var DAEMON_RESTART_READY_TIMEOUT_MS = 15e3;
+var DAEMON_RESTART_POLL_DELAY_MS = 250;
+var cachedClientState;
+var 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}`);
+};
+var getClientStateFilePath = () => {
+  const cacheRoot = getCacheRoot();
+  return join(cacheRoot, CLIENT_ID_FILE);
+};
+var readCachedClientState = () => {
+  if (cachedClientState !== void 0) {
+    return cachedClientState;
+  }
+  const filePath = getClientStateFilePath();
+  if (existsSync(filePath)) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (typeof parsed.clientId === "string" && parsed.clientId.trim()) {
+        cachedClientState = {
+          clientId: parsed.clientId.trim(),
+          createdAt: typeof parsed.createdAt === "string" && parsed.createdAt.trim() ? parsed.createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+          ...parsed.binding && typeof parsed.binding === "object" ? { binding: parsed.binding } : {}
+        };
+        return cachedClientState;
+      }
+    } catch {
+    }
+  }
+  cachedClientState = null;
+  return cachedClientState;
+};
+var writeCachedClientState = (state) => {
+  const filePath = getClientStateFilePath();
+  writeFileAtomic(filePath, JSON.stringify(state, null, 2), { mode: 384 });
+  cachedClientState = state;
+};
+var loadClientState = () => {
+  const existing = readCachedClientState();
+  if (existing) {
+    return existing;
+  }
+  const state = {
+    clientId: randomUUID(),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeCachedClientState(state);
+  return state;
+};
+var parseBindingResponse = (data) => {
+  const expiresAtMs = Date.parse(data.expiresAt);
+  if (!Number.isFinite(expiresAtMs)) {
+    throw new Error("Invalid binding expiry timestamp");
+  }
+  const renewAfterMs = Math.max(
+    MIN_RENEW_AFTER_MS,
+    typeof data.renewAfterMs === "number" && Number.isFinite(data.renewAfterMs) ? data.renewAfterMs : DEFAULT_RENEW_AFTER_MS
+  );
+  return {
+    bindingId: data.bindingId,
+    expiresAtMs,
+    renewAfterMs
+  };
+};
+var serializeBindingState = (binding) => ({
+  bindingId: binding.bindingId,
+  expiresAt: new Date(binding.expiresAtMs).toISOString(),
+  renewAfterMs: binding.renewAfterMs
+});
+var updateCachedBindingState = (clientId, binding) => {
+  const current = loadClientState();
+  const base = current.clientId === clientId ? current : { clientId, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+  if (binding) {
+    writeCachedClientState({
+      ...base,
+      binding: serializeBindingState(binding)
+    });
+    return;
+  }
+  writeCachedClientState({
+    clientId: base.clientId,
+    createdAt: base.createdAt
+  });
+};
+var isBindingRequiredError = (error) => {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return message.startsWith("RELAY_BINDING_REQUIRED") || message.startsWith("RELAY_BINDING_INVALID");
+};
+var isLeaseInvalidError = (error) => {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return message.startsWith("RELAY_LEASE_INVALID");
+};
+var isTransportTimeoutError = (error) => {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return message.startsWith("Request timed out after ");
+};
+var DaemonClient = class {
+  binding = null;
+  renewTimer = null;
+  clientId;
+  autoRenew;
+  bindingAcquiredInProcess = false;
+  sessionLeases = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    const cachedState = loadClientState();
+    this.clientId = options.clientId ?? cachedState.clientId;
+    this.autoRenew = options.autoRenew ?? false;
+    if (cachedState.clientId === this.clientId && cachedState.binding) {
+      try {
+        this.setBinding(parseBindingResponse(cachedState.binding), { acquiredInProcess: false });
+      } catch {
+        updateCachedBindingState(this.clientId, null);
+      }
+    }
+  }
+  async call(name, params = {}, options = {}) {
+    try {
+      const result = await this.callWithBinding(name, params, options);
+      this.maybeTrackLease(name, params, result);
+      return result;
+    } catch (error) {
+      const sessionId = typeof params.sessionId === "string" ? params.sessionId : void 0;
+      if (sessionId && !("leaseId" in params) && isLeaseInvalidError(error) && this.sessionLeases.has(sessionId)) {
+        this.sessionLeases.delete(sessionId);
+        const result = await this.callWithBinding(name, params, options);
+        this.maybeTrackLease(name, params, result);
+        return result;
+      }
+      if (isBindingRequiredError(error)) {
+        if (this.binding) {
+          this.clearBinding();
+        }
+        await this.ensureBinding();
+        const result = await this.callWithBinding(name, params, { ...options, requireBinding: true });
+        this.maybeTrackLease(name, params, result);
+        return result;
+      }
+      throw error;
+    }
+  }
+  async releaseBinding() {
+    if (!this.binding) return;
+    if (!this.bindingAcquiredInProcess) {
+      this.clearBinding({ persist: false });
+      return;
+    }
+    const bindingId = this.binding.bindingId;
+    try {
+      await this.callRaw("relay.release", { clientId: this.clientId, bindingId });
+    } finally {
+      this.clearBinding();
+    }
+  }
+  async callWithBinding(name, params, options) {
+    const requireBinding = options.requireBinding ?? false;
+    const bindingId = requireBinding ? await this.ensureBinding() : this.binding?.bindingId;
+    const sessionId = typeof params.sessionId === "string" ? params.sessionId : void 0;
+    const leaseId = sessionId ? this.sessionLeases.get(sessionId) : void 0;
+    const payload = {
+      ...params,
+      clientId: this.clientId,
+      ...bindingId ? { bindingId } : {},
+      ...leaseId ? { leaseId } : {}
+    };
+    return await this.callRaw(name, payload, deriveTransportTimeoutMs(params, options.timeoutMs));
+  }
+  maybeTrackLease(name, params, result) {
+    if (name === "session.disconnect") {
+      const sessionId2 = typeof params.sessionId === "string" ? params.sessionId : void 0;
+      if (sessionId2) {
+        this.sessionLeases.delete(sessionId2);
+      }
+      if (result && typeof result === "object" && result.bindingReleased === true) {
+        this.clearBinding();
+      }
+      return;
+    }
+    if (name !== "session.launch" && name !== "session.connect") return;
+    if (!result || typeof result !== "object") return;
+    const record = result;
+    const sessionId = record.sessionId;
+    const leaseId = record.leaseId;
+    if (typeof sessionId === "string" && typeof leaseId === "string") {
+      this.sessionLeases.set(sessionId, leaseId);
+    }
+  }
+  async ensureBinding() {
+    if (this.binding && Date.now() < this.binding.expiresAtMs - MIN_RENEW_AFTER_MS) {
+      return this.binding.bindingId;
+    }
+    const data = await this.callRaw("relay.bind", { clientId: this.clientId });
+    const state = await this.resolveBindingState(data);
+    this.setBinding(state, { acquiredInProcess: true });
+    return state.bindingId;
+  }
+  async resolveBindingState(data) {
+    if ("queued" in data && data.queued) {
+      const waitMs = typeof data.waitMs === "number" && Number.isFinite(data.waitMs) ? data.waitMs : null;
+      const timeoutMs = waitMs ? Math.max(1e3, waitMs) : data.bindingConfig?.waitMaxMs;
+      const waitResponse = await this.callRaw("relay.wait", {
+        clientId: this.clientId,
+        ...timeoutMs ? { timeoutMs } : {}
+      });
+      if ("queued" in waitResponse && waitResponse.queued) {
+        throw new Error("RELAY_WAIT_TIMEOUT: Timed out waiting for relay binding.");
+      }
+      return parseBindingResponse(waitResponse);
+    }
+    return parseBindingResponse(data);
+  }
+  async renewBinding() {
+    if (!this.binding) return;
+    const data = await this.callRaw("relay.renew", {
+      clientId: this.clientId,
+      bindingId: this.binding.bindingId
+    });
+    this.setBinding(parseBindingResponse(data), { acquiredInProcess: this.bindingAcquiredInProcess });
+  }
+  setBinding(state, options = {}) {
+    this.binding = state;
+    if (options.acquiredInProcess !== void 0) {
+      this.bindingAcquiredInProcess = options.acquiredInProcess;
+    }
+    updateCachedBindingState(this.clientId, state);
+    if (this.autoRenew) {
+      this.scheduleRenew(resolveRenewDelayMs(state));
+    }
+  }
+  scheduleRenew(delayMs) {
+    if (!this.autoRenew) return;
+    this.clearRenewTimer();
+    this.renewTimer = setTimeout(() => {
+      this.renewTimer = null;
+      this.renewBinding().catch(() => this.clearBinding());
+    }, delayMs);
+  }
+  clearBinding(options = {}) {
+    this.binding = null;
+    this.bindingAcquiredInProcess = false;
+    if (options.persist !== false) {
+      updateCachedBindingState(this.clientId, null);
+    }
+    this.clearRenewTimer();
+  }
+  clearRenewTimer() {
+    if (this.renewTimer) {
+      clearTimeout(this.renewTimer);
+      this.renewTimer = null;
+    }
+  }
+  async callRaw(name, params, timeoutMs) {
+    const budget = createTimeoutBudget(timeoutMs);
+    const connection = await resolveDaemonConnection(budget, {
+      preferConfiguredRecovery: requiresConfiguredRecovery(name)
+    });
+    let timedResponse;
+    try {
+      timedResponse = await openDaemonCommand(
+        connection.port,
+        connection.token,
+        name,
+        params,
+        readRemainingBudgetMs(budget)
+      );
+    } catch (error) {
+      if (isTransportTimeoutError(error)) {
+        throw error;
+      }
+      timedResponse = await retryWithRefreshedConnection(name, params, budget);
+    }
+    try {
+      if (!timedResponse.response.ok) {
+        const message = await readDaemonErrorMessage(timedResponse);
+        if (message.includes("Unauthorized") || timedResponse.response.status === 401) {
+          timedResponse.dispose();
+          timedResponse = await retryWithRefreshedConnection(name, params, budget);
+          if (!timedResponse.response.ok) {
+            throw new CliError(await readDaemonErrorMessage(timedResponse), EXIT_EXECUTION);
+          }
+        } else {
+          throw new CliError(message, EXIT_EXECUTION);
+        }
+      }
+      const payload = await readResponseJsonWithTimeout(
+        timedResponse.response,
+        timedResponse.signal,
+        timedResponse.timeoutMs
+      );
+      if (!payload.ok) {
+        throw new CliError(payload.error || "Daemon command failed.", EXIT_EXECUTION);
+      }
+      return payload.data;
+    } finally {
+      timedResponse.dispose();
+    }
+  }
+};
+var asPositiveNumber = (value) => {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+};
+var createTransportTimeoutError = (timeoutMs) => {
+  return new Error(`Request timed out after ${timeoutMs}ms`);
+};
+var createTimeoutBudget = (timeoutMs) => {
+  const resolved = asPositiveNumber(timeoutMs);
+  return resolved === void 0 ? null : { timeoutMs: resolved, deadlineMs: Date.now() + resolved };
+};
+var readRemainingBudgetMs = (budget) => {
+  if (!budget) {
+    return void 0;
+  }
+  const remainingMs = budget.deadlineMs - Date.now();
+  if (remainingMs <= 0) {
+    throw createTransportTimeoutError(budget.timeoutMs);
+  }
+  return remainingMs;
+};
+var capTimeoutToBudget = (timeoutMs, budget) => {
+  const remainingMs = readRemainingBudgetMs(budget);
+  return remainingMs === void 0 ? timeoutMs : Math.max(1, Math.min(timeoutMs, remainingMs));
+};
+var resolveReadyDeadlineMs = (readyTimeoutMs, budget) => {
+  const localDeadlineMs = Date.now() + readyTimeoutMs;
+  return budget ? Math.min(localDeadlineMs, budget.deadlineMs) : localDeadlineMs;
+};
+var hasBudgetTimedOut = (budget, deadlineMs) => {
+  if (!budget) {
+    return false;
+  }
+  return deadlineMs >= budget.deadlineMs && Date.now() >= budget.deadlineMs;
+};
+var deriveTransportTimeoutMs = (params, explicitTimeoutMs) => {
+  const explicit = asPositiveNumber(explicitTimeoutMs);
+  if (explicit !== void 0) {
+    return explicit;
+  }
+  for (const key of TRANSPORT_TIMEOUT_HINT_KEYS) {
+    const value = asPositiveNumber(params[key]);
+    if (value !== void 0) {
+      return Math.min(value + TRANSPORT_TIMEOUT_BUFFER_MS, MAX_DERIVED_TRANSPORT_TIMEOUT_MS);
+    }
+  }
+  return void 0;
+};
+var resolveRenewDelayMs = (binding) => {
+  const remainingMs = Math.max(0, binding.expiresAtMs - Date.now() - MIN_RENEW_AFTER_MS);
+  return Math.max(0, Math.min(binding.renewAfterMs, remainingMs));
+};
+var cliClient = new DaemonClient({ autoRenew: false });
+async function callDaemon(command, params, options) {
+  return cliClient.call(command, params ?? {}, options);
+}
+var TYPESCRIPT_ENTRY_RE = /\.[cm]?ts$/i;
+var RESTART_LOADER_ARG_FLAGS = /* @__PURE__ */ new Set(["--experimental-loader", "--import", "--loader", "--require", "-r"]);
+var RESTART_TYPESCRIPT_CONTEXT_ARG_FLAGS = /* @__PURE__ */ new Set(["--experimental-strip-types", "--experimental-transform-types"]);
+var RESTART_DEBUG_ARG_FLAGS = /* @__PURE__ */ new Set(["--inspect", "--inspect-brk", "--inspect-port", "--debug", "--debug-brk"]);
+var isInlineRestartArg = (arg, flags) => {
+  for (const flag of flags) {
+    if (arg.startsWith(`${flag}=`)) {
+      return true;
+    }
+  }
+  return false;
+};
+var isRestartLoaderArg = (arg) => {
+  return RESTART_LOADER_ARG_FLAGS.has(arg) || isInlineRestartArg(arg, RESTART_LOADER_ARG_FLAGS);
+};
+var isRestartTypeScriptContextArg = (arg) => {
+  return RESTART_TYPESCRIPT_CONTEXT_ARG_FLAGS.has(arg) || isInlineRestartArg(arg, RESTART_TYPESCRIPT_CONTEXT_ARG_FLAGS);
+};
+var isRestartDebugArg = (arg) => {
+  return RESTART_DEBUG_ARG_FLAGS.has(arg) || isInlineRestartArg(arg, RESTART_DEBUG_ARG_FLAGS);
+};
+var resolveRestartSplitArgValue = (arg, value) => {
+  if (arg.includes("=")) return null;
+  if (typeof value !== "string") return null;
+  return value.startsWith("-") ? null : value;
+};
+var resolveRestartExecArgv = (entryPath, execArgv) => {
+  const preserved = [];
+  let hasLoaderContext = false;
+  for (let index = 0; index < execArgv.length; index += 1) {
+    const arg = execArgv[index];
+    if (!arg) {
+      continue;
+    }
+    if (isRestartDebugArg(arg)) {
+      const next = resolveRestartSplitArgValue(arg, execArgv[index + 1]);
+      if (RESTART_DEBUG_ARG_FLAGS.has(arg) && next) {
+        index += 1;
+      }
+      continue;
+    }
+    preserved.push(arg);
+    if (isRestartLoaderArg(arg) || isRestartTypeScriptContextArg(arg)) {
+      hasLoaderContext = true;
+    }
+    const value = resolveRestartSplitArgValue(arg, execArgv[index + 1]);
+    if (!value) continue;
+    preserved.push(value);
+    index += 1;
+  }
+  return TYPESCRIPT_ENTRY_RE.test(entryPath) && !hasLoaderContext ? [] : preserved;
+};
+var fetchCurrentDaemonStatus = async (connection, options, budget = null) => {
+  const attempts = typeof options.retryAttempts === "number" && Number.isFinite(options.retryAttempts) && options.retryAttempts > 1 ? Math.floor(options.retryAttempts) : 1;
+  const retryDelayMs = typeof options.retryDelayMs === "number" && Number.isFinite(options.retryDelayMs) && options.retryDelayMs > 0 ? options.retryDelayMs : 0;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: capTimeoutToBudget(options.timeoutMs ?? DAEMON_RESTART_STATUS_TIMEOUT_MS, budget)
+    });
+    if (status?.ok && isCurrentDaemonFingerprint(status.fingerprint)) {
+      return status;
+    }
+    if (attempt < attempts) {
+      await sleep(Math.min(retryDelayMs, readRemainingBudgetMs(budget) ?? retryDelayMs));
+    }
+  }
+  return null;
+};
+var fetchAnyDaemonStatus = async (connection, options, budget = null) => {
+  const attempts = typeof options.retryAttempts === "number" && Number.isFinite(options.retryAttempts) && options.retryAttempts > 1 ? Math.floor(options.retryAttempts) : 1;
+  const retryDelayMs = typeof options.retryDelayMs === "number" && Number.isFinite(options.retryDelayMs) && options.retryDelayMs > 0 ? options.retryDelayMs : 0;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: capTimeoutToBudget(options.timeoutMs ?? DAEMON_RESTART_STATUS_TIMEOUT_MS, budget)
+    });
+    if (status?.ok) {
+      return status;
+    }
+    if (attempt < attempts) {
+      await sleep(Math.min(retryDelayMs, readRemainingBudgetMs(budget) ?? retryDelayMs));
+    }
+  }
+  return null;
+};
+var sleep = async (delayMs) => {
+  if (!(Number.isFinite(delayMs) && delayMs > 0)) {
+    return;
+  }
+  await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+};
+var requiresConfiguredRecovery = (name) => {
+  return name === "canvas.execute" || name === "inspiredesign.run";
+};
+var getConfiguredDaemonConnection = () => {
+  const config = loadGlobalConfig();
+  if (!(config.daemonPort > 0 && config.daemonToken)) {
+    return null;
+  }
+  return { port: config.daemonPort, token: config.daemonToken };
+};
+var sameDaemonConnection = (left, right) => {
+  return left.port === right.port && left.token === right.token;
+};
+var persistResolvedDaemonStatus = (connection, status) => {
+  const config = loadGlobalConfig();
+  persistDaemonStatusMetadata({
+    port: connection.port,
+    token: connection.token,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fingerprint: status.fingerprint
+  }, status, config);
+};
+var persistCurrentConfiguredConnection = async (configuredConnection, status, staleMetadata) => {
+  if (staleMetadata && !sameDaemonConnection(staleMetadata.connection, configuredConnection)) {
+    void stopDaemonConnection(staleMetadata.connection, null, "persistCurrentConfiguredConnection.staleMetadata").catch(() => void 0);
+  }
+  persistResolvedDaemonStatus(configuredConnection, status);
+  return configuredConnection;
+};
+var resolveConfiguredPreferenceOptions = (budget) => {
+  if (!budget) {
+    return DAEMON_CONFIG_PREFER_OPTIONS;
+  }
+  const remainingMs = readRemainingBudgetMs(budget);
+  if (remainingMs === void 0 || remainingMs <= 1) {
+    return null;
+  }
+  const timeoutMs = Math.min(DAEMON_CONFIG_PREFER_OPTIONS.timeoutMs ?? remainingMs, remainingMs);
+  const retryDelayMs = Math.max(0, DAEMON_CONFIG_PREFER_OPTIONS.retryDelayMs ?? 0);
+  const maxAttempts = Math.max(1, DAEMON_CONFIG_PREFER_OPTIONS.retryAttempts ?? 1);
+  let retryAttempts = 1;
+  while (retryAttempts < maxAttempts) {
+    const nextAttempts = retryAttempts + 1;
+    const nextWorstCaseMs = nextAttempts * timeoutMs + (nextAttempts - 1) * retryDelayMs;
+    if (nextWorstCaseMs > remainingMs) {
+      break;
+    }
+    retryAttempts = nextAttempts;
+  }
+  return {
+    timeoutMs,
+    retryAttempts,
+    retryDelayMs: retryAttempts > 1 ? retryDelayMs : 0
+  };
+};
+var stopDaemonConnection = async (connection, budget = null, reason = "unknown") => {
+  const stopTimeoutMs = capTimeoutToBudget(DAEMON_RESTART_STATUS_TIMEOUT_MS, budget);
+  logDaemonStopDebug("client.stop.request", { reason, port: connection.port });
+  try {
+    const response = await fetchWithTimeout(`http://127.0.0.1:${connection.port}/stop`, {
+      method: "POST",
+      headers: createDaemonStopHeaders(connection.token, reason)
+    }, stopTimeoutMs);
+    if (response.status === 409) {
+      logDaemonStopDebug("client.stop.fingerprintRejected", { reason, port: connection.port });
+      return "fingerprint_rejected";
+    }
+    if (!response.ok) {
+      logDaemonStopDebug("client.stop.rejected", { reason, port: connection.port, status: response.status });
+      return "unreachable";
+    }
+    logDaemonStopDebug("client.stop.complete", { reason, port: connection.port });
+    return "stopped";
+  } catch {
+    logDaemonStopDebug("client.stop.error", { reason, port: connection.port });
+    return "unreachable";
+  }
+};
+function resolveDaemonRestartCommand(options = {}) {
+  const execPath = options.execPath ?? process.execPath;
+  const execArgv = options.execArgv ?? process.execArgv;
+  const moduleUrl = options.moduleUrl ?? import.meta.url;
+  const argv1 = options.argv1 ?? process.argv[1];
+  const entryPath = resolveCurrentDaemonEntrypointPath({
+    argv1,
+    moduleUrl,
+    entryExists: options.entryExists ?? existsSync
+  });
+  if (!(typeof argv1 === "string" && argv1.trim().length > 0)) {
+    const modulePath = resolve(fileURLToPath(moduleUrl));
+    if (entryPath === modulePath) {
+      throw createDisconnectedError("Daemon restart requires a stable CLI entrypoint. Start with `opendevbrowser serve`.");
+    }
+  }
+  const restartExecArgv = resolveRestartExecArgv(entryPath, execArgv);
+  if (TYPESCRIPT_ENTRY_RE.test(entryPath) && restartExecArgv.length === 0) {
+    throw createDisconnectedError("Daemon restart requires the original loader context. Start with `opendevbrowser serve`.");
+  }
+  return {
+    command: execPath,
+    args: [...restartExecArgv, entryPath]
+  };
+}
+var restartDaemonConnection = async (connection) => {
+  const restart = resolveDaemonRestartCommand();
+  const child = spawn(restart.command, [
+    ...restart.args,
+    "serve",
+    "--port",
+    String(connection.port),
+    "--token",
+    connection.token,
+    "--output-format",
+    "json"
+  ], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+};
+var waitForCurrentDaemonStatus = async (connection, readyTimeoutMs = DAEMON_RESTART_READY_TIMEOUT_MS, budget = null) => {
+  const deadline = resolveReadyDeadlineMs(readyTimeoutMs, budget);
+  while (true) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      if (hasBudgetTimedOut(budget, deadline)) {
+        throw createTransportTimeoutError(budget.timeoutMs);
+      }
+      return null;
+    }
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: Math.min(DAEMON_RESTART_STATUS_TIMEOUT_MS, remainingMs)
+    });
+    if (status?.ok && isCurrentDaemonFingerprint(status.fingerprint)) {
+      return status;
+    }
+    if (Date.now() >= deadline) {
+      return null;
+    }
+    await sleep(Math.min(DAEMON_RESTART_POLL_DELAY_MS, Math.max(0, deadline - Date.now())));
+  }
+};
+var waitForDaemonShutdown = async (connection, readyTimeoutMs = DAEMON_RECOVERY_READY_TIMEOUT_MS, budget = null) => {
+  const deadline = resolveReadyDeadlineMs(readyTimeoutMs, budget);
+  while (true) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      if (hasBudgetTimedOut(budget, deadline)) {
+        throw createTransportTimeoutError(budget.timeoutMs);
+      }
+      return null;
+    }
+    const status = await fetchDaemonStatus(connection.port, connection.token, {
+      timeoutMs: Math.min(DAEMON_RESTART_STATUS_TIMEOUT_MS, remainingMs)
+    });
+    if (!status?.ok) {
+      return "stopped";
+    }
+    if (isCurrentDaemonFingerprint(status.fingerprint)) {
+      return status;
+    }
+    if (Date.now() >= deadline) {
+      return null;
+    }
+    await sleep(Math.min(DAEMON_RESTART_POLL_DELAY_MS, Math.max(0, deadline - Date.now())));
+  }
+};
+var resolveMetadataConnection = async (metadataConnection, configuredConnection, budget = null) => {
+  const status = await fetchAnyDaemonStatus(metadataConnection, DAEMON_STATUS_RETRY_OPTIONS, budget);
+  if (!status?.ok) {
+    return null;
+  }
+  if (isCurrentDaemonFingerprint(status.fingerprint)) {
+    persistResolvedDaemonStatus(metadataConnection, status);
+    return { connection: metadataConnection, status };
+  }
+  if (sameDaemonConnection(metadataConnection, configuredConnection)) {
+    return null;
+  }
+  return { connection: metadataConnection, status };
+};
+var resolveFreshDaemonConnection = async (budget = null, options = {}) => {
+  const configuredConnection = getConfiguredDaemonConnection();
+  if (!configuredConnection) {
+    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+  }
+  const configuredStatus = await fetchAnyDaemonStatus(configuredConnection, DAEMON_STATUS_RETRY_OPTIONS, budget);
+  let currentConfiguredStatus = configuredStatus?.ok && isCurrentDaemonFingerprint(configuredStatus.fingerprint) ? configuredStatus : null;
+  const metadata = readDaemonMetadata();
+  const metadataConnection = metadata ? { port: metadata.port, token: metadata.token } : null;
+  const staleMetadata = metadataConnection ? await resolveMetadataConnection(metadataConnection, configuredConnection, budget) : null;
+  if (currentConfiguredStatus?.ok) {
+    return await persistCurrentConfiguredConnection(configuredConnection, currentConfiguredStatus, staleMetadata);
+  }
+  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, "resolveFreshDaemonConnection.configuredCurrentMetadataPreferred").catch(() => void 0);
+    }
+    return staleMetadata.connection;
+  }
+  if (!configuredStatus?.ok && staleMetadata) {
+    currentConfiguredStatus = await waitForCurrentDaemonStatus(
+      configuredConnection,
+      DAEMON_RECOVERY_READY_TIMEOUT_MS,
+      budget
+    );
+    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({ connection: configuredConnection, status: configuredStatus });
+  }
+  if (staleConnections.length === 0) {
+    const recoveringStatus = await waitForCurrentDaemonStatus(
+      configuredConnection,
+      DAEMON_RECOVERY_READY_TIMEOUT_MS,
+      budget
+    );
+    if (recoveringStatus?.ok) {
+      persistResolvedDaemonStatus(configuredConnection, recoveringStatus);
+      return configuredConnection;
+    }
+    throw createDisconnectedError("Daemon not running. Start with `opendevbrowser serve`.");
+  }
+  for (const staleConnection of staleConnections) {
+    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);
+    if (!shutdownOutcome) {
+      throw createDisconnectedError("Daemon restart could not reclaim the configured port after fingerprint mismatch. Start with `opendevbrowser serve`.");
+    }
+    if (shutdownOutcome !== "stopped") {
+      persistResolvedDaemonStatus(configuredConnection, shutdownOutcome);
+      return configuredConnection;
+    }
+  }
+  await restartDaemonConnection(configuredConnection);
+  const refreshedStatus = await waitForCurrentDaemonStatus(configuredConnection, DAEMON_RESTART_READY_TIMEOUT_MS, budget);
+  if (!refreshedStatus?.ok) {
+    throw createDisconnectedError("Daemon restart failed after fingerprint mismatch. Start with `opendevbrowser serve`.");
+  }
+  persistResolvedDaemonStatus(configuredConnection, refreshedStatus);
+  return configuredConnection;
+};
+var resolveDaemonConnection = async (budget = null, options = {}) => {
+  const metadata = readDaemonMetadata();
+  if (metadata && isCurrentDaemonFingerprint(metadata.fingerprint)) {
+    const metadataConnection = { port: metadata.port, token: metadata.token };
+    const configuredConnection = getConfiguredDaemonConnection();
+    if (!configuredConnection || sameDaemonConnection(metadataConnection, configuredConnection)) {
+      return metadataConnection;
+    }
+    const configuredOptions = resolveConfiguredPreferenceOptions(budget);
+    if (!configuredOptions) {
+      if (options.preferConfiguredRecovery) {
+        return await resolveFreshDaemonConnection(budget, options);
+      }
+      return metadataConnection;
+    }
+    const configuredStatus = await fetchCurrentDaemonStatus(configuredConnection, configuredOptions, budget);
+    if (configuredStatus?.ok) {
+      return await persistCurrentConfiguredConnection(
+        configuredConnection,
+        configuredStatus,
+        { connection: metadataConnection }
+      );
+    }
+    if (options.preferConfiguredRecovery) {
+      return await resolveFreshDaemonConnection(budget, options);
+    }
+    return metadataConnection;
+  }
+  return await resolveFreshDaemonConnection(budget, options);
+};
+var retryWithRefreshedConnection = async (name, params, budget) => {
+  const connection = await resolveFreshDaemonConnection(budget, {
+    preferConfiguredRecovery: requiresConfiguredRecovery(name)
+  });
+  return await openDaemonCommand(connection.port, connection.token, name, params, readRemainingBudgetMs(budget));
+};
+var openDaemonCommand = async (port, token, name, params, timeoutMs) => {
+  return await fetchWithTimeoutContext(`http://127.0.0.1:${port}/command`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ name, params })
+  }, timeoutMs);
+};
+var readDaemonErrorMessage = async (timedResponse) => {
+  const text = await readResponseTextWithTimeout(
+    timedResponse.response,
+    timedResponse.signal,
+    timedResponse.timeoutMs
+  );
+  let message = text || String(timedResponse.response.status);
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object") {
+      if (typeof parsed.error === "string" && parsed.error.trim()) {
+        message = parsed.error;
+      } else if (typeof parsed.message === "string" && parsed.message.trim()) {
+        message = parsed.message;
+      }
+    }
+  } catch {
+  }
+  return message;
+};
+
+export {
+  DaemonClient,
+  callDaemon
+};
+//# sourceMappingURL=chunk-MD655IPO.js.map