visual-remote 0.3.1 → 0.3.3

package/apps/cli/dist/vite.js

@@ -1,4 +1,5 @@
 // src/vite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { resolve as resolve7 } from "node:path";
 
 // ../../packages/bridge-core/src/agents/types.ts
@@ -25,27 +26,530 @@ var AgentCanceledError = class extends Error {
   }
 };
 
+// ../../packages/bridge-core/src/agents/claude-event-parser.ts
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asText(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function contentBlocks(record) {
+  const message = asRecord(record.message);
+  return Array.isArray(message?.content) ? message.content.flatMap((block) => {
+    const parsed = asRecord(block);
+    return parsed === void 0 ? [] : [parsed];
+  }) : [];
+}
+function toolSummary(name, input) {
+  return asText(input.description) ?? asText(input.command) ?? asText(input.file_path) ?? asText(input.path) ?? (name === "Bash" ? "Run command" : void 0);
+}
+function filePath(input) {
+  return asText(input.file_path) ?? asText(input.path) ?? asText(input.notebook_path);
+}
+var ClaudeEventParser = class {
+  #defaultCwd;
+  #tools = /* @__PURE__ */ new Map();
+  #sessionId;
+  constructor(defaultCwd = "") {
+    this.#defaultCwd = defaultCwd;
+  }
+  parse(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return [];
+    let value;
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      return [{ type: "warning", text: trimmed }];
+    }
+    const record = asRecord(value);
+    if (!record) return [{ type: "message", text: trimmed }];
+    const events = [];
+    const foundSession = asText(record.session_id) ?? asText(record.sessionId);
+    if (foundSession !== void 0 && foundSession !== this.#sessionId) {
+      this.#sessionId = foundSession;
+      events.push({ type: "session", sessionId: foundSession });
+    }
+    const type = asText(record.type) ?? "unknown";
+    if (type === "system") {
+      const subtype = asText(record.subtype);
+      if (subtype) events.push({ type: "phase", name: subtype });
+      return events;
+    }
+    if (type === "assistant") {
+      for (const block of contentBlocks(record)) {
+        if (block.type === "text") {
+          const text = asText(block.text);
+          if (text) events.push({ type: "message", text });
+          continue;
+        }
+        if (block.type !== "tool_use") continue;
+        const name = asText(block.name) ?? "tool";
+        const id = asText(block.id);
+        const input = asRecord(block.input) ?? {};
+        if (id) this.#tools.set(id, name);
+        const summary = toolSummary(name, input);
+        events.push(
+          summary ? { type: "tool_start", name, summary } : { type: "tool_start", name }
+        );
+        const command = name === "Bash" ? asText(input.command) : void 0;
+        if (command) {
+          events.push({ type: "command", command, cwd: this.#defaultCwd });
+        }
+        const path = filePath(input);
+        if (path && ["Edit", "Write", "NotebookEdit"].includes(name)) {
+          events.push({ type: "file_hint", path });
+        }
+      }
+      return events;
+    }
+    if (type === "user") {
+      for (const block of contentBlocks(record)) {
+        if (block.type !== "tool_result") continue;
+        const id = asText(block.tool_use_id);
+        const name = (id ? this.#tools.get(id) : void 0) ?? "tool";
+        if (id) this.#tools.delete(id);
+        events.push({ type: "tool_end", name, ok: block.is_error !== true });
+      }
+      return events;
+    }
+    if (type === "result") {
+      const usage = asRecord(record.usage);
+      if (usage) {
+        const cachedInputTokens = asNumber(usage.cache_read_input_tokens);
+        events.push({
+          type: "usage",
+          inputTokens: asNumber(usage.input_tokens) + asNumber(usage.cache_creation_input_tokens) + cachedInputTokens,
+          outputTokens: asNumber(usage.output_tokens),
+          ...cachedInputTokens > 0 ? { cachedInputTokens } : {}
+        });
+      }
+      const result = asText(record.result);
+      const subtype = asText(record.subtype);
+      if (record.is_error === true || subtype?.startsWith("error") === true) {
+        events.push({ type: "error", text: result ?? "Claude reported an error" });
+      } else {
+        events.push(result ? { type: "complete", summary: result } : { type: "complete" });
+      }
+      return events;
+    }
+    return events;
+  }
+};
+
+// ../../packages/bridge-core/src/agents/claude-adapter.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+
+// ../../packages/bridge-core/src/runtime/managed-process.ts
+function safeChildProcessId(child) {
+  const pid = child.pid;
+  if (pid === void 0 || !Number.isSafeInteger(pid) || pid <= 1 || pid === process.pid) {
+    return void 0;
+  }
+  return pid;
+}
+function safeDetachedProcessGroupId(child) {
+  return process.platform === "win32" ? void 0 : safeChildProcessId(child);
+}
+function isMissingProcess(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
+}
+function processGroupIsAlive(processGroupId) {
+  try {
+    process.kill(-processGroupId, 0);
+    return true;
+  } catch (error) {
+    if (isMissingProcess(error)) return false;
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "EPERM") {
+      return true;
+    }
+    throw error;
+  }
+}
+function childIsAlive(child) {
+  return child.exitCode === null && child.signalCode === null;
+}
+function signalChildProcessTree(child, signal) {
+  const pid = safeChildProcessId(child);
+  if (pid === void 0) return false;
+  try {
+    if (process.platform === "win32") {
+      if (!childIsAlive(child)) return false;
+      return child.kill(signal);
+    }
+    process.kill(-pid, signal);
+    return true;
+  } catch (error) {
+    if (isMissingProcess(error)) return false;
+    throw error;
+  }
+}
+function installEmergencyChildExitHook(child, processLike = process) {
+  let removed = false;
+  const emergencyExit = () => {
+    removed = true;
+    try {
+      signalChildProcessTree(child, "SIGKILL");
+    } catch {
+    }
+  };
+  processLike.once("exit", emergencyExit);
+  return () => {
+    if (removed) return;
+    removed = true;
+    processLike.off("exit", emergencyExit);
+  };
+}
+async function waitForProcessTreeExit(child, processGroupId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (processGroupId === void 0 ? childIsAlive(child) : processGroupIsAlive(processGroupId)) {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return false;
+    await new Promise((resolve8) => {
+      setTimeout(resolve8, Math.min(25, remaining));
+    });
+  }
+  return true;
+}
+async function terminateChildProcessTree(child, killGraceMs = 3e3) {
+  const processGroupId = safeDetachedProcessGroupId(child);
+  if (processGroupId === void 0 && !childIsAlive(child)) return;
+  const sendSignal = (signal) => {
+    signalChildProcessTree(child, signal);
+  };
+  sendSignal("SIGTERM");
+  if (await waitForProcessTreeExit(
+    child,
+    processGroupId,
+    Math.max(0, killGraceMs)
+  )) {
+    return;
+  }
+  sendSignal("SIGKILL");
+  await waitForProcessTreeExit(
+    child,
+    processGroupId,
+    Math.min(Math.max(0, killGraceMs), 1e3)
+  );
+}
+
+// ../../packages/bridge-core/src/agents/async-queue.ts
+var AsyncQueue = class {
+  #values = [];
+  #waiters = [];
+  #ended = false;
+  #error;
+  push(value) {
+    if (this.#ended) return;
+    const waiter = this.#waiters.shift();
+    if (waiter) waiter.resolve({ value, done: false });
+    else this.#values.push(value);
+  }
+  end(error) {
+    if (this.#ended) return;
+    this.#ended = true;
+    this.#error = error;
+    for (const waiter of this.#waiters.splice(0)) {
+      if (error !== void 0) waiter.reject(error);
+      else waiter.resolve({ value: void 0, done: true });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        const value = this.#values.shift();
+        if (value !== void 0) return { value, done: false };
+        if (this.#ended) {
+          if (this.#error !== void 0) throw this.#error;
+          return { value: void 0, done: true };
+        }
+        return await new Promise((resolve8, reject) => {
+          this.#waiters.push({ resolve: resolve8, reject });
+        });
+      }
+    };
+  }
+};
+
+// ../../packages/bridge-core/src/agents/claude-adapter.ts
+var execFileAsync = promisify(execFile);
+var INHERITED_ENVIRONMENT = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "TERM",
+  "TMPDIR",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "ANTHROPIC_API_KEY",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "HTTPS_PROXY",
+  "HTTP_PROXY",
+  "NO_PROXY",
+  "USERPROFILE",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "SystemRoot",
+  "COMSPEC",
+  "PATHEXT"
+];
+var EMPTY_MCP_CONFIG = JSON.stringify({ mcpServers: {} });
+var CLAUDE_SETTINGS = JSON.stringify({
+  permissions: {
+    disableBypassPermissionsMode: "disable",
+    deny: [
+      "Read(./.env)",
+      "Read(./.env.*)",
+      "Read(./**/*.pem)",
+      "Read(./**/*.key)",
+      "Edit(./.git/**)",
+      "Edit(./.visualdev/runtime/**)",
+      "Edit(./node_modules/**)"
+    ]
+  },
+  sandbox: {
+    enabled: true,
+    autoAllowBashIfSandboxed: true,
+    allowUnsandboxedCommands: false,
+    network: { strictAllowlist: true }
+  }
+});
+function processEnv(overrides) {
+  const environment = {};
+  for (const key of INHERITED_ENVIRONMENT) {
+    const value = process.env[key];
+    if (value !== void 0) environment[key] = value;
+  }
+  return { ...environment, ...overrides };
+}
+function splitLines(chunk, previous, onLine) {
+  const combined = previous + chunk.toString();
+  const lines = combined.split(/\r?\n/);
+  const remainder = lines.pop() ?? "";
+  for (const line of lines) onLine(line);
+  return remainder;
+}
+var ClaudeAdapter = class {
+  id = "claude";
+  #executable;
+  #killGraceMs;
+  #model;
+  #reasoningEffort;
+  #rtkExecutable;
+  #rtkVersion;
+  constructor(options = {}) {
+    this.#executable = options.executable ?? "claude";
+    this.#killGraceMs = options.killGraceMs ?? 2e3;
+    this.#model = options.model;
+    this.#reasoningEffort = options.reasoningEffort;
+    this.#rtkExecutable = options.rtkExecutable ?? "rtk";
+  }
+  #probeRtk(environment) {
+    if (this.#rtkExecutable === false) return Promise.resolve(void 0);
+    this.#rtkVersion ??= execFileAsync(this.#rtkExecutable, ["--version"], {
+      encoding: "utf8",
+      env: environment,
+      timeout: 1e3,
+      windowsHide: true,
+      maxBuffer: 16 * 1024
+    }).then(({ stdout }) => stdout.trim().split(/\r?\n/, 1)[0] || void 0).catch(() => void 0);
+    return this.#rtkVersion;
+  }
+  async #runtimePrompt(input, environment) {
+    if (this.#rtkExecutable === false) return input.prompt;
+    const guidance = await this.#probeRtk(environment).then(
+      (version) => version ? `RTK command proxy:
+- ${version} is installed and available in this runtime.
+- Prefix shell commands with RTK by default (for example: rtk git status, rtk rg <pattern>, rtk read <file>, rtk npm test).
+- Use the native command only when RTK has no suitable proxy or RTK execution fails. Do not spend time rediscovering or reinstalling RTK.` : `RTK command proxy:
+- RTK was not detected in this runtime. Use native repository commands directly and do not spend time searching for RTK.`
+    );
+    return `${input.prompt.trimEnd()}
+
+${guidance}
+`;
+  }
+  #baseArgs() {
+    return [
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--permission-mode",
+      "acceptEdits",
+      "--strict-mcp-config",
+      "--mcp-config",
+      EMPTY_MCP_CONFIG,
+      "--no-chrome",
+      "--tools",
+      "Read,Glob,Grep,Edit,Write,Bash",
+      "--settings",
+      CLAUDE_SETTINGS,
+      ...this.#model === void 0 ? [] : ["--model", this.#model],
+      ...this.#reasoningEffort === void 0 ? [] : ["--effort", this.#reasoningEffort]
+    ];
+  }
+  async probe() {
+    return await new Promise((resolve8) => {
+      const child = spawn(this.#executable, ["--version"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        shell: false
+      });
+      let output = "";
+      child.stdout?.on("data", (chunk) => {
+        output += chunk.toString();
+      });
+      child.once("error", () => {
+        resolve8({ available: false, supportsResume: true, structuredOutput: true });
+      });
+      child.once("close", (code) => {
+        const match = output.match(/(\d+\.\d+\.\d+(?:[-+][^\s]+)?)/);
+        const capabilities = {
+          available: code === 0,
+          supportsResume: true,
+          structuredOutput: true
+        };
+        if (match?.[1]) capabilities.version = match[1];
+        resolve8(capabilities);
+      });
+    });
+  }
+  async *run(input, signal) {
+    yield* this.#execute(input, signal, this.#baseArgs());
+  }
+  async *resume(input, signal) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/.test(input.sessionId)) {
+      throw new Error("Refusing to resume an invalid Claude session id");
+    }
+    yield* this.#execute(
+      input,
+      signal,
+      [...this.#baseArgs(), "--resume", input.sessionId]
+    );
+  }
+  async *#execute(input, signal, args) {
+    const queue = new AsyncQueue();
+    const environment = processEnv(input.environment);
+    const prompt = await this.#runtimePrompt(input, environment);
+    const parser = new ClaudeEventParser(input.workspaceRoot);
+    const child = spawn(this.#executable, args, {
+      cwd: input.workspaceRoot,
+      env: environment,
+      detached: process.platform !== "win32",
+      shell: false,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const removeEmergencyExitHook = installEmergencyChildExitHook(child);
+    let stdoutRemainder = "";
+    let stderrRemainder = "";
+    let timedOut = false;
+    let aborted = signal.aborted;
+    let termination;
+    const requestTermination = () => {
+      termination ??= terminateChildProcessTree(
+        child,
+        this.#killGraceMs
+      ).finally(removeEmergencyExitHook);
+      return termination;
+    };
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      void requestTermination();
+    }, Math.max(1, input.maxRunMs));
+    timeout.unref();
+    const abort = () => {
+      aborted = true;
+      void requestTermination();
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+    child.stdout.on("data", (chunk) => {
+      stdoutRemainder = splitLines(chunk, stdoutRemainder, (line) => {
+        for (const event of parser.parse(line)) queue.push(event);
+      });
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrRemainder = splitLines(chunk, stderrRemainder, (line) => {
+        if (line.trim()) queue.push({ type: "warning", text: line });
+      });
+    });
+    child.once("error", (error) => queue.end(error));
+    child.once("close", (code, closeSignal) => {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", abort);
+      void (async () => {
+        await requestTermination();
+        if (stdoutRemainder.trim()) {
+          for (const event of parser.parse(stdoutRemainder)) queue.push(event);
+        }
+        if (stderrRemainder.trim()) queue.push({ type: "warning", text: stderrRemainder });
+        if (timedOut) queue.end(new AgentTimeoutError());
+        else if (aborted) queue.end(new AgentCanceledError());
+        else if (code !== 0) {
+          queue.end(
+            new AgentProcessError(
+              `Claude exited with code ${String(code)}`,
+              code,
+              closeSignal
+            )
+          );
+        } else {
+          queue.end();
+        }
+      })().catch((error) => queue.end(error));
+    });
+    child.stdin.on("error", (error) => {
+      if (error.code !== "EPIPE") queue.end(error);
+    });
+    child.stdin.end(prompt);
+    try {
+      for await (const event of queue) yield event;
+    } finally {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", abort);
+      try {
+        if (child.exitCode === null && child.signalCode === null) {
+          await requestTermination();
+        } else if (termination) {
+          await termination;
+        }
+      } finally {
+        removeEmergencyExitHook();
+      }
+    }
+  }
+};
+
 // ../../packages/bridge-core/src/agents/codex-event-parser.ts
-function asRecord(value) {
+function asRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
-function asText(value) {
+function asText2(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function sessionId(record) {
-  const thread = asRecord(record.thread);
-  return asText(record.thread_id) ?? asText(record.threadId) ?? asText(record.session_id) ?? asText(record.sessionId) ?? (thread ? asText(thread.id) : void 0);
+  const thread = asRecord2(record.thread);
+  return asText2(record.thread_id) ?? asText2(record.threadId) ?? asText2(record.session_id) ?? asText2(record.sessionId) ?? (thread ? asText2(thread.id) : void 0);
 }
 function itemFiles(item) {
   const changes = Array.isArray(item.changes) ? item.changes : [];
   const files = changes.flatMap((change) => {
-    const record = asRecord(change);
+    const record = asRecord2(change);
     if (!record) return [];
-    return [asText(record.path) ?? asText(record.file_path) ?? asText(record.filePath)].filter(
+    return [asText2(record.path) ?? asText2(record.file_path) ?? asText2(record.filePath)].filter(
       (path) => path !== void 0
     );
   });
-  const direct = asText(item.path) ?? asText(item.file_path) ?? asText(item.filePath);
+  const direct = asText2(item.path) ?? asText2(item.file_path) ?? asText2(item.filePath);
   if (direct) files.push(direct);
   return [...new Set(files)];
 }
@@ -59,28 +563,28 @@ function isDirectExecItem(item) {
   return item.type === "mcp_tool_call" && item.server === "visual_remote_exec" && item.tool === "run_readonly";
 }
 function directExecSummary(item) {
-  const arguments_ = asRecord(item.arguments);
+  const arguments_ = asRecord2(item.arguments);
   const commands = Array.isArray(arguments_?.commands) ? arguments_.commands : [];
   const summaries = commands.flatMap((candidate) => {
-    const command = asRecord(candidate);
+    const command = asRecord2(candidate);
     const argv = stringArray(command?.argv);
     return argv === void 0 ? [] : [formatArgv(argv)];
   });
   return summaries.length === 0 ? void 0 : summaries.join(" \xB7 ");
 }
 function directExecResults(item, defaultCwd) {
-  const result = asRecord(item.result);
-  const structured = asRecord(result?.structured_content ?? result?.structuredContent);
+  const result = asRecord2(item.result);
+  const structured = asRecord2(result?.structured_content ?? result?.structuredContent);
   const results = Array.isArray(structured?.results) ? structured.results : [];
   return results.flatMap((candidate) => {
-    const command = asRecord(candidate);
+    const command = asRecord2(candidate);
     const argv = stringArray(command?.argv);
     if (argv === void 0) return [];
     const exitCode = typeof command?.exitCode === "number" ? command.exitCode : void 0;
     const durationMs = typeof command?.durationMs === "number" ? command.durationMs : void 0;
     return [{
       command: formatArgv(argv),
-      cwd: asText(command?.cwd) ?? defaultCwd,
+      cwd: asText2(command?.cwd) ?? defaultCwd,
       ok: exitCode === 0,
       ...exitCode === void 0 ? {} : { exitCode },
       ...durationMs === void 0 ? {} : { durationMs },
@@ -91,8 +595,8 @@ function directExecResults(item, defaultCwd) {
   });
 }
 function normalizedUsage(record) {
-  const result = asRecord(record.result);
-  const usage = asRecord(record.usage) ?? (result ? asRecord(result.usage) : void 0);
+  const result = asRecord2(record.result);
+  const usage = asRecord2(record.usage) ?? (result ? asRecord2(result.usage) : void 0);
   if (usage === void 0) return void 0;
   const inputTokens = usage.input_tokens ?? usage.inputTokens;
   const outputTokens = usage.output_tokens ?? usage.outputTokens;
@@ -116,17 +620,17 @@ function parseCodexJsonLine(line, defaultCwd = "") {
   } catch {
     return [{ type: "warning", text: trimmed }];
   }
-  const record = asRecord(value);
+  const record = asRecord2(value);
   if (!record) return [{ type: "message", text: trimmed }];
-  const type = asText(record.type) ?? "unknown";
+  const type = asText2(record.type) ?? "unknown";
   const events = [];
   const foundSession = sessionId(record);
   if (foundSession) events.push({ type: "session", sessionId: foundSession });
   if (type === "thread.started" || type === "thread.created") return events;
   if (type === "turn.started") return [...events, { type: "phase", name: "turn.started" }];
   if (type === "turn.completed") {
-    const result = asRecord(record.result);
-    const summary = asText(record.summary) ?? (result ? asText(result.summary) : void 0);
+    const result = asRecord2(record.result);
+    const summary = asText2(record.summary) ?? (result ? asText2(result.summary) : void 0);
     const usage = normalizedUsage(record);
     return [
       ...events,
@@ -135,31 +639,31 @@ function parseCodexJsonLine(line, defaultCwd = "") {
     ];
   }
   if (type === "turn.failed" || type === "error") {
-    const error = asRecord(record.error);
-    const text = asText(record.message) ?? (error ? asText(error.message) : void 0) ?? "Codex reported an error";
+    const error = asRecord2(record.error);
+    const text = asText2(record.message) ?? (error ? asText2(error.message) : void 0) ?? "Codex reported an error";
     return [...events, { type: "error", text }];
   }
-  const item = asRecord(record.item);
+  const item = asRecord2(record.item);
   if (type === "item.started" && item) {
-    const itemType = asText(item.type) ?? "item";
+    const itemType = asText2(item.type) ?? "item";
     const directExec = isDirectExecItem(item);
-    const summary = directExec ? directExecSummary(item) : asText(item.command) ?? asText(item.text);
+    const summary = directExec ? directExecSummary(item) : asText2(item.command) ?? asText2(item.text);
     const start = summary ? { type: "tool_start", name: directExec ? "direct_exec" : itemType, summary } : { type: "tool_start", name: directExec ? "direct_exec" : itemType };
     return [...events, start];
   }
   if (type === "item.completed" && item) {
-    const itemType = asText(item.type) ?? "item";
+    const itemType = asText2(item.type) ?? "item";
     if (itemType === "agent_message") {
-      const text = asText(item.text) ?? asText(item.message);
+      const text = asText2(item.text) ?? asText2(item.message);
       return text ? [...events, { type: "message", text }] : events;
     }
     if (itemType === "command_execution") {
-      const command = asText(item.command);
+      const command = asText2(item.command);
       if (command) {
         events.push({
           type: "command",
           command,
-          cwd: asText(item.cwd) ?? defaultCwd
+          cwd: asText2(item.cwd) ?? defaultCwd
         });
       }
     }
@@ -185,151 +689,18 @@ function parseCodexJsonLine(line, defaultCwd = "") {
     });
     return events;
   }
-  const message = asText(record.message);
+  const message = asText2(record.message);
   if (message) events.push({ type: "message", text: message });
   return events;
 }
 
 // ../../packages/bridge-core/src/agents/codex-adapter.ts
-import { execFile, spawn } from "node:child_process";
+import { execFile as execFile2, spawn as spawn2 } from "node:child_process";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
-
-// ../../packages/bridge-core/src/agents/async-queue.ts
-var AsyncQueue = class {
-  #values = [];
-  #waiters = [];
-  #ended = false;
-  #error;
-  push(value) {
-    if (this.#ended) return;
-    const waiter = this.#waiters.shift();
-    if (waiter) waiter.resolve({ value, done: false });
-    else this.#values.push(value);
-  }
-  end(error) {
-    if (this.#ended) return;
-    this.#ended = true;
-    this.#error = error;
-    for (const waiter of this.#waiters.splice(0)) {
-      if (error !== void 0) waiter.reject(error);
-      else waiter.resolve({ value: void 0, done: true });
-    }
-  }
-  [Symbol.asyncIterator]() {
-    return {
-      next: async () => {
-        const value = this.#values.shift();
-        if (value !== void 0) return { value, done: false };
-        if (this.#ended) {
-          if (this.#error !== void 0) throw this.#error;
-          return { value: void 0, done: true };
-        }
-        return await new Promise((resolve8, reject) => {
-          this.#waiters.push({ resolve: resolve8, reject });
-        });
-      }
-    };
-  }
-};
-
-// ../../packages/bridge-core/src/runtime/managed-process.ts
-function safeChildProcessId(child) {
-  const pid = child.pid;
-  if (pid === void 0 || !Number.isSafeInteger(pid) || pid <= 1 || pid === process.pid) {
-    return void 0;
-  }
-  return pid;
-}
-function safeDetachedProcessGroupId(child) {
-  return process.platform === "win32" ? void 0 : safeChildProcessId(child);
-}
-function isMissingProcess(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
-}
-function processGroupIsAlive(processGroupId) {
-  try {
-    process.kill(-processGroupId, 0);
-    return true;
-  } catch (error) {
-    if (isMissingProcess(error)) return false;
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "EPERM") {
-      return true;
-    }
-    throw error;
-  }
-}
-function childIsAlive(child) {
-  return child.exitCode === null && child.signalCode === null;
-}
-function signalChildProcessTree(child, signal) {
-  const pid = safeChildProcessId(child);
-  if (pid === void 0) return false;
-  try {
-    if (process.platform === "win32") {
-      if (!childIsAlive(child)) return false;
-      return child.kill(signal);
-    }
-    process.kill(-pid, signal);
-    return true;
-  } catch (error) {
-    if (isMissingProcess(error)) return false;
-    throw error;
-  }
-}
-function installEmergencyChildExitHook(child, processLike = process) {
-  let removed = false;
-  const emergencyExit = () => {
-    removed = true;
-    try {
-      signalChildProcessTree(child, "SIGKILL");
-    } catch {
-    }
-  };
-  processLike.once("exit", emergencyExit);
-  return () => {
-    if (removed) return;
-    removed = true;
-    processLike.off("exit", emergencyExit);
-  };
-}
-async function waitForProcessTreeExit(child, processGroupId, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (processGroupId === void 0 ? childIsAlive(child) : processGroupIsAlive(processGroupId)) {
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) return false;
-    await new Promise((resolve8) => {
-      setTimeout(resolve8, Math.min(25, remaining));
-    });
-  }
-  return true;
-}
-async function terminateChildProcessTree(child, killGraceMs = 3e3) {
-  const processGroupId = safeDetachedProcessGroupId(child);
-  if (processGroupId === void 0 && !childIsAlive(child)) return;
-  const sendSignal = (signal) => {
-    signalChildProcessTree(child, signal);
-  };
-  sendSignal("SIGTERM");
-  if (await waitForProcessTreeExit(
-    child,
-    processGroupId,
-    Math.max(0, killGraceMs)
-  )) {
-    return;
-  }
-  sendSignal("SIGKILL");
-  await waitForProcessTreeExit(
-    child,
-    processGroupId,
-    Math.min(Math.max(0, killGraceMs), 1e3)
-  );
-}
-
-// ../../packages/bridge-core/src/agents/codex-adapter.ts
-var execFileAsync = promisify(execFile);
-var INHERITED_ENVIRONMENT = [
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var INHERITED_ENVIRONMENT2 = [
   "PATH",
   "HOME",
   "USER",
@@ -354,15 +725,15 @@ var INHERITED_ENVIRONMENT = [
   "COMSPEC",
   "PATHEXT"
 ];
-function processEnv(overrides) {
+function processEnv2(overrides) {
   const environment = {};
-  for (const key of INHERITED_ENVIRONMENT) {
+  for (const key of INHERITED_ENVIRONMENT2) {
     const value = process.env[key];
     if (value !== void 0) environment[key] = value;
   }
   return { ...environment, ...overrides };
 }
-function splitLines(chunk, previous, onLine) {
+function splitLines2(chunk, previous, onLine) {
   const combined = previous + chunk.toString();
   const lines = combined.split(/\r?\n/);
   const remainder = lines.pop() ?? "";
@@ -382,18 +753,24 @@ var CodexAdapter = class {
   id = "codex";
   #executable;
   #killGraceMs;
+  #model;
+  #profile;
+  #reasoningEffort;
   #rtkExecutable;
   #directExecMcpScript;
   #rtkVersion;
   constructor(options = {}) {
     this.#executable = options.executable ?? "codex";
     this.#killGraceMs = options.killGraceMs ?? 2e3;
+    this.#model = options.model;
+    this.#profile = options.profile;
+    this.#reasoningEffort = options.reasoningEffort;
     this.#rtkExecutable = options.rtkExecutable ?? "rtk";
     this.#directExecMcpScript = options.directExecMcpScript === false ? void 0 : options.directExecMcpScript ?? defaultDirectExecMcpScript();
   }
   #probeRtk(environment) {
     if (this.#rtkExecutable === false) return Promise.resolve(void 0);
-    this.#rtkVersion ??= execFileAsync(this.#rtkExecutable, ["--version"], {
+    this.#rtkVersion ??= execFileAsync2(this.#rtkExecutable, ["--version"], {
       encoding: "utf8",
       env: environment,
       timeout: 1e3,
@@ -436,9 +813,16 @@ ${guidance}
       `mcp_servers.visual_remote_exec.args=${JSON.stringify(serverArgs)}`
     ];
   }
+  #modelConfig() {
+    return [
+      ...this.#profile === void 0 ? [] : ["--profile", this.#profile],
+      ...this.#model === void 0 ? [] : ["--model", this.#model],
+      ...this.#reasoningEffort === void 0 ? [] : ["-c", `model_reasoning_effort=${JSON.stringify(this.#reasoningEffort)}`]
+    ];
+  }
   async probe() {
     return await new Promise((resolve8) => {
-      const child = spawn(this.#executable, ["--version"], {
+      const child = spawn2(this.#executable, ["--version"], {
         stdio: ["ignore", "pipe", "ignore"],
         shell: false
       });
@@ -471,6 +855,7 @@ ${guidance}
       "workspace-write",
       "-C",
       input.workspaceRoot,
+      ...this.#modelConfig(),
       ...this.#directExecConfig(input),
       "-"
     ];
@@ -489,6 +874,7 @@ ${guidance}
       "workspace-write",
       "-C",
       input.workspaceRoot,
+      ...this.#modelConfig(),
       ...this.#directExecConfig(input),
       "resume",
       input.sessionId,
@@ -498,9 +884,9 @@ ${guidance}
   }
   async *#execute(input, signal, args) {
     const queue = new AsyncQueue();
-    const environment = processEnv(input.environment);
+    const environment = processEnv2(input.environment);
     const prompt = await this.#runtimePrompt(input, environment);
-    const child = spawn(this.#executable, args, {
+    const child = spawn2(this.#executable, args, {
       cwd: input.workspaceRoot,
       env: environment,
       detached: process.platform !== "win32",
@@ -532,12 +918,12 @@ ${guidance}
     signal.addEventListener("abort", abort, { once: true });
     if (signal.aborted) abort();
     child.stdout.on("data", (chunk) => {
-      stdoutRemainder = splitLines(chunk, stdoutRemainder, (line) => {
+      stdoutRemainder = splitLines2(chunk, stdoutRemainder, (line) => {
         for (const event of parseCodexJsonLine(line, input.workspaceRoot)) queue.push(event);
       });
     });
     child.stderr.on("data", (chunk) => {
-      stderrRemainder = splitLines(chunk, stderrRemainder, (line) => {
+      stderrRemainder = splitLines2(chunk, stderrRemainder, (line) => {
         if (line.trim()) queue.push({ type: "warning", text: line });
       });
     });
@@ -615,6 +1001,7 @@ import { ZodError } from "zod";
 import { z } from "zod";
 var servicePortSchema = z.number().int().min(10001).max(65535);
 var commandSchema = z.array(z.string().min(1)).min(1);
+var environmentVariableSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "Expected an environment variable name");
 var readySchema = z.object({
   path: z.string().startsWith("/").default("/"),
   timeoutMs: z.number().int().positive().default(6e4)
@@ -643,9 +1030,38 @@ var visualDevConfigSchema = z.object({
   }).strict(),
   agent: z.object({
     adapter: z.enum(["codex", "claude", "opencode"]),
+    model: z.string().trim().min(1).optional(),
+    reasoningEffort: z.enum(["minimal", "low", "medium", "high", "xhigh", "max"]).optional(),
+    profile: z.string().trim().regex(
+      /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/,
+      "Expected a Codex profile name"
+    ).optional(),
+    inheritEnv: z.array(environmentVariableSchema).default([]),
     maxRunMs: z.number().int().positive(),
     resumeMode: z.enum(["auto", "new"]).default("auto")
-  }).strict(),
+  }).strict().superRefine((agent, context) => {
+    if (agent.adapter === "claude" && agent.reasoningEffort === "minimal") {
+      context.addIssue({
+        code: "custom",
+        path: ["reasoningEffort"],
+        message: "minimal reasoning effort is only supported by the Codex adapter"
+      });
+    }
+    if (agent.adapter === "codex" && agent.reasoningEffort === "max") {
+      context.addIssue({
+        code: "custom",
+        path: ["reasoningEffort"],
+        message: "max reasoning effort is only supported by the Claude adapter"
+      });
+    }
+    if (agent.adapter !== "codex" && agent.profile !== void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["profile"],
+        message: "agent.profile is only supported by the Codex adapter"
+      });
+    }
+  }),
   queue: z.object({
     maxPending: z.number().int().positive()
   }).strict(),
@@ -689,6 +1105,7 @@ function createDefaultConfig(projectId) {
     },
     agent: {
       adapter: "codex",
+      inheritEnv: [],
       maxRunMs: 9e5,
       resumeMode: "auto"
     },
@@ -761,17 +1178,17 @@ function mergeConfigValues(base, override) {
   }
   return merged;
 }
-async function readYamlMapping(filePath, required) {
+async function readYamlMapping(filePath2, required) {
   let source;
   try {
-    source = await readFile(filePath, "utf8");
+    source = await readFile(filePath2, "utf8");
   } catch (error) {
     if (!required && typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
       return void 0;
     }
-    throw new VisualDevConfigError(`Unable to read config: ${filePath}`, {
+    throw new VisualDevConfigError(`Unable to read config: ${filePath2}`, {
       cause: error,
-      filePath
+      filePath: filePath2
     });
   }
   try {
@@ -784,9 +1201,9 @@ async function readYamlMapping(filePath, required) {
     }
     return value;
   } catch (error) {
-    throw new VisualDevConfigError(`Invalid YAML in ${filePath}`, {
+    throw new VisualDevConfigError(`Invalid YAML in ${filePath2}`, {
       cause: error,
-      filePath
+      filePath: filePath2
     });
   }
 }
@@ -925,10 +1342,10 @@ var RevertConflictError = class extends RepositorySafetyError {
 };
 
 // ../../packages/bridge-core/src/git/git-command.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 async function runGit(args, options) {
   return await new Promise((resolve8, reject) => {
-    const child = spawn2("git", [...args], {
+    const child = spawn3("git", [...args], {
       cwd: options.cwd,
       env: { ...process.env, ...options.env ?? {} },
       shell: false,
@@ -1997,7 +2414,7 @@ import { relative as relative5, resolve as resolve6, sep as sep5 } from "node:pa
 // ../../packages/bridge-core/src/source/path-normalizer.ts
 import { access, readFile as readFile3, realpath as realpath6 } from "node:fs/promises";
 import { isAbsolute as isAbsolute3, relative as relative4, resolve as resolve5, sep as sep4 } from "node:path";
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 function toPosix(value) {
   return value.split(sep4).join("/").replaceAll("\\", "/");
 }
@@ -2032,7 +2449,7 @@ function isWithin2(root, candidate) {
 }
 async function gitFiles(repoRoot) {
   return await new Promise((resolvePromise, reject) => {
-    const child = spawn3(
+    const child = spawn4(
       "git",
       ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
       {
@@ -2102,8 +2519,8 @@ async function normalizeSourceLocation(input, repoRootInput) {
       candidates: matches.slice(0, 20)
     };
   }
-  const filePath = matches[0];
-  const absolutePath = resolve5(repoRoot, filePath);
+  const filePath2 = matches[0];
+  const absolutePath = resolve5(repoRoot, filePath2);
   const canonical = await realpath6(absolutePath);
   if (!isWithin2(repoRoot, canonical)) {
     return { input, confidence: "unknown", candidates: [] };
@@ -2111,7 +2528,7 @@ async function normalizeSourceLocation(input, repoRootInput) {
   const lineNumber = await boundedLine(canonical, input.lineNumber);
   return {
     input,
-    filePath,
+    filePath: filePath2,
     absolutePath: canonical,
     ...lineNumber === void 0 ? {} : { lineNumber },
     ...input.columnNumber === void 0 ? {} : { columnNumber: input.columnNumber },
@@ -2616,6 +3033,7 @@ var TaskService = class {
     return publicTask(accepted);
   }
   async revert(id) {
+    if (this.#closed) throw new TaskServiceError("SERVICE_CLOSED", "Task service is closed");
     if (this.#activeTaskId || this.#recovering || this.#recoveryQueue.length > 0) {
       throw new TaskServiceError(
         "WRITER_BUSY",
@@ -2631,12 +3049,19 @@ var TaskService = class {
     if (!latest || latest.id !== id) {
       throw new TaskServiceError("NOT_LATEST_TASK", "Only the latest completed task can be reverted");
     }
-    await this.#git.revert(id, task.beforeRef, task.afterRef);
-    const reverted = this.#transition(id, "reverted", {
-      completedAt: this.#now().toISOString()
-    });
-    this.#emit("task.reverted", { task: publicTask(reverted) }, id);
-    return publicTask(reverted);
+    this.#activeTaskId = id;
+    try {
+      await this.#git.revert(id, task.beforeRef, task.afterRef);
+      const reverted = this.#transition(id, "reverted", {
+        completedAt: this.#now().toISOString()
+      });
+      this.#emit("task.reverted", { task: publicTask(reverted) }, id);
+      return publicTask(reverted);
+    } finally {
+      this.#activeTaskId = void 0;
+      if (!this.#closed) void this.#drain();
+      this.#resolveIdleIfNeeded();
+    }
   }
   async waitForIdle() {
     if (!this.#activeTaskId && this.#queue.length === 0 && this.#recoveryQueue.length === 0 && !this.#recovering && !this.#draining) {
@@ -2647,7 +3072,7 @@ var TaskService = class {
   async close() {
     if (this.#closed) return;
     this.#closed = true;
-    if (this.#activeTaskId && !this.#recovering) {
+    if (this.#activeTaskId && this.#activeAbort) {
       this.#cancelRequested.add(this.#activeTaskId);
       this.#activeAbort?.abort(new AgentCanceledError("Task service is closing"));
     }
@@ -2712,9 +3137,12 @@ var TaskService = class {
       if (!task.beforeRef) {
         throw new Error("Interrupted task is missing its before snapshot");
       }
-      const after = await this.#git.createSnapshot(taskId, "after");
-      this.#store.updateTask(taskId, { afterRef: after.ref });
-      const diff = await this.#git.diff(task.beforeRef, after.ref);
+      let afterRef = task.afterRef;
+      if (!afterRef) {
+        afterRef = (await this.#git.createSnapshot(taskId, "after")).ref;
+        this.#store.updateTask(taskId, { afterRef });
+      }
+      const diff = await this.#git.diff(task.beforeRef, afterRef);
       this.#store.updateTask(taskId, {
         diffText: diff.text,
         changedFiles: diff.files
@@ -2786,7 +3214,7 @@ var TaskService = class {
     }
   }
   async #drain() {
-    if (this.#draining || this.#closed || this.#recovering || this.#recoveryQueue.length > 0) {
+    if (this.#draining || this.#activeTaskId || this.#closed || this.#recovering || this.#recoveryQueue.length > 0) {
       return;
     }
     this.#draining = true;
@@ -3039,11 +3467,11 @@ var TaskService = class {
     for (const target of result.selection.targets) {
       const sanitize = async (location) => {
         try {
-          const filePath = await this.#git.pathPolicy.assertFilesystemPathAllowed(
+          const filePath2 = await this.#git.pathPolicy.assertFilesystemPathAllowed(
             location.filePath,
             false
           );
-          return { ...location, filePath };
+          return { ...location, filePath: filePath2 };
         } catch {
           return void 0;
         }
@@ -3255,7 +3683,7 @@ var BrowserSessionManager = class {
 };
 
 // ../../packages/bridge-core/src/verification/commands.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 var MAX_OUTPUT_CHARS = 8e3;
 var KILL_GRACE_MS = 250;
 function appendOutput(current, chunk) {
@@ -3269,7 +3697,7 @@ async function runVerificationCommand(configured, cwd, signal) {
   }
   const startedAt = Date.now();
   return await new Promise((resolveResult, rejectResult) => {
-    const child = spawn4(executable, arguments_, {
+    const child = spawn5(executable, arguments_, {
       cwd,
       detached: process.platform !== "win32",
       shell: false,
@@ -3844,15 +4272,40 @@ ${output}` : ""}`
 }
 
 // ../../packages/bridge-core/src/bridge/default-control-service.ts
+function createAgentAdapter(agent) {
+  if (agent.adapter === "claude") {
+    if (agent.reasoningEffort === "minimal") {
+      throw new Error("Claude does not support minimal reasoning effort");
+    }
+    return new ClaudeAdapter({
+      ...agent.model === void 0 ? {} : { model: agent.model },
+      ...agent.reasoningEffort === void 0 ? {} : { reasoningEffort: agent.reasoningEffort }
+    });
+  }
+  if (agent.adapter === "codex") {
+    if (agent.reasoningEffort === "max") {
+      throw new Error("Codex does not support max reasoning effort");
+    }
+    return new CodexAdapter({
+      ...agent.model === void 0 ? {} : { model: agent.model },
+      ...agent.reasoningEffort === void 0 ? {} : { reasoningEffort: agent.reasoningEffort },
+      ...agent.profile === void 0 ? {} : { profile: agent.profile }
+    });
+  }
+  throw new Error(`Agent adapter ${agent.adapter} is not implemented in this build`);
+}
+function inheritedAgentEnvironment(names, environment) {
+  return Object.fromEntries(
+    names.flatMap((name) => {
+      const value = environment[name];
+      return value === void 0 ? [] : [[name, value]];
+    })
+  );
+}
 async function createDefaultControlService(context, environment = process.env) {
   const loaded = await loadVisualDevConfig(context.repoRoot, {
     ...context.configRoot === void 0 ? {} : { configRoot: context.configRoot }
   });
-  if (loaded.config.agent.adapter !== "codex") {
-    throw new Error(
-      `Agent adapter ${loaded.config.agent.adapter} is not implemented in this MVP build`
-    );
-  }
   const git = await GitTransactionManager.open(context.repoRoot, {
     allowed: rebaseWorkspacePatterns(
       context.repoRoot,
@@ -3871,13 +4324,16 @@ async function createDefaultControlService(context, environment = process.env) {
     projectId: context.projectId,
     workspaceRoot: context.workspaceRoot,
     upstreamUrl: context.upstreamUrl,
-    adapter: new CodexAdapter(),
+    adapter: createAgentAdapter(loaded.config.agent),
     store,
     git,
     maxRunMs: loaded.config.agent.maxRunMs,
     maxPending: loaded.config.queue.maxPending,
     resumeMode: loaded.config.agent.resumeMode,
-    environment: {}
+    environment: inheritedAgentEnvironment(
+      loaded.config.agent.inheritEnv,
+      environment
+    )
   });
   const controlService = createTaskControlService({
     taskService,
@@ -4208,10 +4664,10 @@ async function acquireWorktreeLock(repositoryRoot, options = {}) {
 }
 
 // ../../packages/bridge-core/src/runtime/repository.ts
-import { execFile as execFile2 } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
 import { realpath as realpath9 } from "node:fs/promises";
-import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile2);
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3 = promisify3(execFile3);
 var GitWorktreeNotFoundError = class extends Error {
   constructor(cwd, options = {}) {
     super(
@@ -4223,7 +4679,7 @@ var GitWorktreeNotFoundError = class extends Error {
 };
 async function discoverGitWorktreeRoot(cwd = process.cwd()) {
   try {
-    const { stdout } = await execFileAsync2(
+    const { stdout } = await execFileAsync3(
       "git",
       ["-C", cwd, "rev-parse", "--show-toplevel"],
       {
@@ -5253,7 +5709,7 @@ async function startBridgeCore(options, dependencies) {
   try {
     lock = options.lock ?? await acquireWorktreeLock(loadedConfig.repoRoot, { environment });
     const host = options.host ?? loadedConfig.config.gateway.host;
-    const configuredPublicUrl = options.publicUrl ?? loadedConfig.config.gateway.publicUrl;
+    const configuredPublicUrl = options.publicUrl ?? loadedConfig.config.gateway.publicUrl ?? options.fallbackPublicUrl;
     const publicUrl = configuredPublicUrl === void 0 ? void 0 : normalizePublicUrl(configuredPublicUrl);
     const gatewayPort = await findAvailablePort(startPort(loadedConfig, options.listen), host);
     const token = generatePairingToken();
@@ -5271,6 +5727,13 @@ async function startBridgeCore(options, dependencies) {
     controlService = await resolveControlService(dependencies, controlContext);
     const allowedOrigins = new Set(loadedConfig.config.security.allowedOrigins);
     if (publicUrl !== void 0) allowedOrigins.add(new URL(publicUrl).origin);
+    if (options.fallbackLoopbackOrigins === true && options.publicUrl === void 0 && loadedConfig.config.gateway.publicUrl === void 0 && loadedConfig.config.security.allowedOrigins.length === 0 && publicUrl !== void 0) {
+      const loopbackUrl = new URL(publicUrl);
+      if (loopbackUrl.hostname === "localhost" || loopbackUrl.hostname === "127.0.0.1") {
+        loopbackUrl.hostname = loopbackUrl.hostname === "localhost" ? "127.0.0.1" : "localhost";
+        allowedOrigins.add(loopbackUrl.origin);
+      }
+    }
     gateway = createGatewayServer({
       upstream: options.upstreamUrl,
       pairingToken: token,
@@ -5373,7 +5836,9 @@ async function startAttachBridge(options, dependencies = {}) {
       upstreamUrl: normalizeUpstream(options.upstream),
       ...options.listen === void 0 ? {} : { listen: options.listen },
       ...options.host === void 0 ? {} : { host: options.host },
-      ...options.publicUrl === void 0 ? {} : { publicUrl: options.publicUrl }
+      ...options.publicUrl === void 0 ? {} : { publicUrl: options.publicUrl },
+      ...options.fallbackPublicUrl === void 0 ? {} : { fallbackPublicUrl: options.fallbackPublicUrl },
+      ...options.fallbackLoopbackOrigins === void 0 ? {} : { fallbackLoopbackOrigins: options.fallbackLoopbackOrigins }
     },
     dependencies
   );
@@ -5387,6 +5852,49 @@ async function startAttachBridge(options, dependencies = {}) {
 }
 
 // src/vite.ts
+var bridgesKey = /* @__PURE__ */ Symbol.for("visual-remote.vite.bridges");
+var bridgeState = globalThis;
+var bridges = bridgeState[bridgesKey] ??= /* @__PURE__ */ new Map();
+var restartsKey = /* @__PURE__ */ Symbol.for("visual-remote.vite.restarts");
+var restartState = globalThis;
+var restarts = restartState[restartsKey] ??= new AsyncLocalStorage();
+async function acquireBridge(options, config) {
+  const root = projectRoot(config, options.cwd);
+  let shared = bridges.get(root);
+  if (shared?.closing !== void 0) {
+    await shared.closing;
+    return acquireBridge(options, config);
+  }
+  if (shared === void 0) {
+    shared = { bridge: startOrReuseBridge(options, config), users: 0 };
+    bridges.set(root, shared);
+  }
+  const entry = shared;
+  entry.users += 1;
+  let releasePromise;
+  const release = () => {
+    releasePromise ??= (async () => {
+      entry.users -= 1;
+      if (entry.users !== 0) return;
+      entry.closing = (async () => {
+        try {
+          const bridge = await entry.bridge.catch(() => void 0);
+          await bridge?.ownedBridge?.close();
+        } finally {
+          bridges.delete(root);
+        }
+      })();
+      await entry.closing;
+    })();
+    return releasePromise;
+  };
+  try {
+    return { bridge: await entry.bridge, release };
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
 function projectRoot(config, configuredRoot) {
   if (configuredRoot !== void 0) return resolve7(configuredRoot);
   return resolve7(process.cwd(), typeof config.root === "string" ? config.root : ".");
@@ -5424,32 +5932,11 @@ async function startOrReuseBridge(options, config) {
   }
 }
 function visualRemote(options = {}) {
-  let bridgePromise;
   let pairingUrlAnnounced = false;
-  const closeBridge = async () => {
-    if (bridgePromise === void 0) return;
-    const bridge = await bridgePromise.catch(() => void 0);
-    await bridge?.ownedBridge?.close();
-  };
   return {
     name: "visual-remote",
     apply: "serve",
     enforce: "pre",
-    async config(config) {
-      bridgePromise ??= startOrReuseBridge(options, config);
-      const bridge = await bridgePromise;
-      bridge.ownedBridge?.gateway.server.unref();
-      return {
-        server: {
-          proxy: {
-            "/_visual": {
-              target: bridge.gatewayUrl,
-              ws: true
-            }
-          }
-        }
-      };
-    },
     transformIndexHtml: {
       order: "pre",
       handler(html) {
@@ -5465,21 +5952,48 @@ function visualRemote(options = {}) {
         ];
       }
     },
-    configureServer(server) {
-      if (!pairingUrlAnnounced && bridgePromise !== void 0) {
-        pairingUrlAnnounced = true;
-        void bridgePromise.then((bridge) => {
-          server.config.logger.info(
-            bridge.openUrl === void 0 ? `[visual-remote] Reusing Bridge: ${bridge.gatewayUrl}` : `[visual-remote] Pair: ${bridge.openUrl}`
-          );
+    async configureServer(server) {
+      const candidate = { config: server.config, close: server.close };
+      restarts.getStore()?.push(candidate);
+      const restart = server.restart;
+      server.restart = (forceOptimize) => {
+        const candidates = [];
+        return restarts.run(candidates, async () => {
+          try {
+            return await restart(forceOptimize);
+          } finally {
+            for (const replacement of candidates) {
+              if (replacement.config !== server.config) await replacement.close();
+            }
+          }
         });
-      }
+      };
+      const serverLease = await acquireBridge(options, server.config);
+      const close = server.close;
+      server.close = async () => {
+        try {
+          await close();
+        } finally {
+          await serverLease.release();
+        }
+      };
+      candidate.close = server.close;
       server.httpServer?.once("close", () => {
-        void closeBridge();
+        void serverLease.release();
       });
-    },
-    async closeBundle() {
-      await closeBridge();
+      const { bridge } = serverLease;
+      bridge.ownedBridge?.gateway.server.unref();
+      server.config.server.proxy ??= {};
+      server.config.server.proxy["/_visual"] = {
+        target: bridge.gatewayUrl,
+        ws: true
+      };
+      if (!pairingUrlAnnounced) {
+        pairingUrlAnnounced = true;
+        server.config.logger.info(
+          bridge.openUrl === void 0 ? `[visual-remote] Reusing Bridge: ${bridge.gatewayUrl}` : `[visual-remote] Pair: ${bridge.openUrl}`
+        );
+      }
     }
   };
 }