visual-remote 0.3.1 → 0.3.2

package/apps/cli/dist/index.js

@@ -971,27 +971,595 @@ 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 as spawn2 } from "node:child_process";
+import { promisify } from "node:util";
+
+// ../../packages/bridge-core/src/runtime/managed-process.ts
+import { spawn } from "node:child_process";
+function replacePortPlaceholder(value, port) {
+  return value.replaceAll("{upstreamPort}", String(port));
+}
+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((resolve9) => {
+      setTimeout(resolve9, 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)
+  );
+}
+async function startManagedProcess(options) {
+  const [executable, ...rawArguments] = options.command;
+  if (executable === void 0) {
+    throw new Error("Managed dev command is empty");
+  }
+  const detached = process.platform !== "win32";
+  const child = spawn(
+    replacePortPlaceholder(executable, options.upstreamPort),
+    rawArguments.map((argument) => replacePortPlaceholder(argument, options.upstreamPort)),
+    {
+      cwd: options.cwd,
+      env: {
+        ...options.environment ?? process.env,
+        HOST: "0.0.0.0",
+        PORT: String(options.upstreamPort)
+      },
+      detached,
+      stdio: [
+        "inherit",
+        options.stdout === void 0 ? "inherit" : "pipe",
+        options.stderr === void 0 ? "inherit" : "pipe"
+      ],
+      windowsHide: true
+    }
+  );
+  const removeEmergencyExitHook = installEmergencyChildExitHook(child);
+  const exit = new Promise(
+    (resolve9) => {
+      child.once("exit", (code, signal) => {
+        resolve9({ code, signal });
+      });
+    }
+  );
+  if (child.stdout !== null && options.stdout !== void 0) {
+    child.stdout.pipe(options.stdout, { end: false });
+  }
+  if (child.stderr !== null && options.stderr !== void 0) {
+    child.stderr.pipe(options.stderr, { end: false });
+  }
+  try {
+    await new Promise((resolve9, reject) => {
+      child.once("spawn", resolve9);
+      child.once("error", reject);
+    });
+  } catch (error) {
+    removeEmergencyExitHook();
+    throw error;
+  }
+  let stopPromise;
+  return {
+    child,
+    exit,
+    stop() {
+      stopPromise ??= terminateChildProcessTree(
+        child,
+        options.killGraceMs
+      ).finally(removeEmergencyExitHook);
+      return stopPromise;
+    }
+  };
+}
+
+// ../../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((resolve9, reject) => {
+          this.#waiters.push({ resolve: resolve9, 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((resolve9) => {
+      const child = spawn2(this.#executable, ["--version"], {
+        stdio: ["ignore", "pipe", "ignore"],
+        shell: false
+      });
+      let output2 = "";
+      child.stdout?.on("data", (chunk) => {
+        output2 += chunk.toString();
+      });
+      child.once("error", () => {
+        resolve9({ available: false, supportsResume: true, structuredOutput: true });
+      });
+      child.once("close", (code) => {
+        const match = output2.match(/(\d+\.\d+\.\d+(?:[-+][^\s]+)?)/);
+        const capabilities = {
+          available: code === 0,
+          supportsResume: true,
+          structuredOutput: true
+        };
+        if (match?.[1]) capabilities.version = match[1];
+        resolve9(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 = spawn2(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)];
 }
@@ -1005,28 +1573,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 },
@@ -1036,311 +1604,113 @@ function directExecResults(item, defaultCwd) {
     }];
   });
 }
-function normalizedUsage(record) {
-  const result = asRecord(record.result);
-  const usage = asRecord(record.usage) ?? (result ? asRecord(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;
-  const cachedInputTokens = usage.cached_input_tokens ?? usage.cachedInputTokens;
-  if (typeof inputTokens !== "number" || typeof outputTokens !== "number") {
-    return void 0;
-  }
-  return {
-    type: "usage",
-    inputTokens,
-    outputTokens,
-    ...typeof cachedInputTokens === "number" ? { cachedInputTokens } : {}
-  };
-}
-function parseCodexJsonLine(line, defaultCwd = "") {
-  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 type = asText(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 usage = normalizedUsage(record);
-    return [
-      ...events,
-      ...usage === void 0 ? [] : [usage],
-      summary ? { type: "complete", summary } : { type: "complete" }
-    ];
-  }
-  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";
-    return [...events, { type: "error", text }];
-  }
-  const item = asRecord(record.item);
-  if (type === "item.started" && item) {
-    const itemType = asText(item.type) ?? "item";
-    const directExec = isDirectExecItem(item);
-    const summary = directExec ? directExecSummary(item) : asText(item.command) ?? asText(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";
-    if (itemType === "agent_message") {
-      const text = asText(item.text) ?? asText(item.message);
-      return text ? [...events, { type: "message", text }] : events;
-    }
-    if (itemType === "command_execution") {
-      const command = asText(item.command);
-      if (command) {
-        events.push({
-          type: "command",
-          command,
-          cwd: asText(item.cwd) ?? defaultCwd
-        });
-      }
-    }
-    const directResults = isDirectExecItem(item) ? directExecResults(item, defaultCwd) : [];
-    for (const result of directResults) {
-      events.push({
-        type: "command",
-        command: result.command,
-        cwd: result.cwd,
-        ...result.exitCode === void 0 ? {} : { exitCode: result.exitCode },
-        ...result.durationMs === void 0 ? {} : { durationMs: result.durationMs },
-        ...result.usedRtk === void 0 ? {} : { usedRtk: result.usedRtk },
-        ...result.timedOut === void 0 ? {} : { timedOut: result.timedOut },
-        ...result.truncated === void 0 ? {} : { truncated: result.truncated }
-      });
-    }
-    for (const path of itemFiles(item)) events.push({ type: "file_hint", path });
-    const exitCode = typeof item.exit_code === "number" ? item.exit_code : void 0;
-    events.push({
-      type: "tool_end",
-      name: isDirectExecItem(item) ? "direct_exec" : itemType,
-      ok: directResults.length > 0 ? directResults.every((result) => result.ok) : exitCode === void 0 || exitCode === 0
-    });
-    return events;
-  }
-  const message = asText(record.message);
-  if (message) events.push({ type: "message", text: message });
-  return events;
-}
-
-// ../../packages/bridge-core/src/agents/codex-adapter.ts
-import { execFile, spawn as spawn2 } from "node:child_process";
-import { existsSync } from "node:fs";
-import { fileURLToPath as fileURLToPath2 } 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((resolve9, reject) => {
-          this.#waiters.push({ resolve: resolve9, reject });
-        });
-      }
-    };
-  }
-};
-
-// ../../packages/bridge-core/src/runtime/managed-process.ts
-import { spawn } from "node:child_process";
-function replacePortPlaceholder(value, port) {
-  return value.replaceAll("{upstreamPort}", String(port));
-}
-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 normalizedUsage(record) {
+  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;
+  const cachedInputTokens = usage.cached_input_tokens ?? usage.cachedInputTokens;
+  if (typeof inputTokens !== "number" || typeof outputTokens !== "number") {
+    return void 0;
   }
-}
-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);
+  return {
+    type: "usage",
+    inputTokens,
+    outputTokens,
+    ...typeof cachedInputTokens === "number" ? { cachedInputTokens } : {}
   };
 }
-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((resolve9) => {
-      setTimeout(resolve9, Math.min(25, remaining));
-    });
+function parseCodexJsonLine(line, defaultCwd = "") {
+  const trimmed = line.trim();
+  if (!trimmed) return [];
+  let value;
+  try {
+    value = JSON.parse(trimmed);
+  } catch {
+    return [{ type: "warning", text: trimmed }];
   }
-  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;
+  const record = asRecord2(value);
+  if (!record) return [{ type: "message", text: trimmed }];
+  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 = asRecord2(record.result);
+    const summary = asText2(record.summary) ?? (result ? asText2(result.summary) : void 0);
+    const usage = normalizedUsage(record);
+    return [
+      ...events,
+      ...usage === void 0 ? [] : [usage],
+      summary ? { type: "complete", summary } : { type: "complete" }
+    ];
   }
-  sendSignal("SIGKILL");
-  await waitForProcessTreeExit(
-    child,
-    processGroupId,
-    Math.min(Math.max(0, killGraceMs), 1e3)
-  );
-}
-async function startManagedProcess(options) {
-  const [executable, ...rawArguments] = options.command;
-  if (executable === void 0) {
-    throw new Error("Managed dev command is empty");
+  if (type === "turn.failed" || type === "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 detached = process.platform !== "win32";
-  const child = spawn(
-    replacePortPlaceholder(executable, options.upstreamPort),
-    rawArguments.map((argument) => replacePortPlaceholder(argument, options.upstreamPort)),
-    {
-      cwd: options.cwd,
-      env: {
-        ...options.environment ?? process.env,
-        HOST: "0.0.0.0",
-        PORT: String(options.upstreamPort)
-      },
-      detached,
-      stdio: [
-        "inherit",
-        options.stdout === void 0 ? "inherit" : "pipe",
-        options.stderr === void 0 ? "inherit" : "pipe"
-      ],
-      windowsHide: true
+  const item = asRecord2(record.item);
+  if (type === "item.started" && item) {
+    const itemType = asText2(item.type) ?? "item";
+    const directExec = isDirectExecItem(item);
+    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 = asText2(item.type) ?? "item";
+    if (itemType === "agent_message") {
+      const text = asText2(item.text) ?? asText2(item.message);
+      return text ? [...events, { type: "message", text }] : events;
     }
-  );
-  const removeEmergencyExitHook = installEmergencyChildExitHook(child);
-  const exit = new Promise(
-    (resolve9) => {
-      child.once("exit", (code, signal) => {
-        resolve9({ code, signal });
+    if (itemType === "command_execution") {
+      const command = asText2(item.command);
+      if (command) {
+        events.push({
+          type: "command",
+          command,
+          cwd: asText2(item.cwd) ?? defaultCwd
+        });
+      }
+    }
+    const directResults = isDirectExecItem(item) ? directExecResults(item, defaultCwd) : [];
+    for (const result of directResults) {
+      events.push({
+        type: "command",
+        command: result.command,
+        cwd: result.cwd,
+        ...result.exitCode === void 0 ? {} : { exitCode: result.exitCode },
+        ...result.durationMs === void 0 ? {} : { durationMs: result.durationMs },
+        ...result.usedRtk === void 0 ? {} : { usedRtk: result.usedRtk },
+        ...result.timedOut === void 0 ? {} : { timedOut: result.timedOut },
+        ...result.truncated === void 0 ? {} : { truncated: result.truncated }
       });
     }
-  );
-  if (child.stdout !== null && options.stdout !== void 0) {
-    child.stdout.pipe(options.stdout, { end: false });
-  }
-  if (child.stderr !== null && options.stderr !== void 0) {
-    child.stderr.pipe(options.stderr, { end: false });
-  }
-  try {
-    await new Promise((resolve9, reject) => {
-      child.once("spawn", resolve9);
-      child.once("error", reject);
+    for (const path of itemFiles(item)) events.push({ type: "file_hint", path });
+    const exitCode = typeof item.exit_code === "number" ? item.exit_code : void 0;
+    events.push({
+      type: "tool_end",
+      name: isDirectExecItem(item) ? "direct_exec" : itemType,
+      ok: directResults.length > 0 ? directResults.every((result) => result.ok) : exitCode === void 0 || exitCode === 0
     });
-  } catch (error) {
-    removeEmergencyExitHook();
-    throw error;
+    return events;
   }
-  let stopPromise;
-  return {
-    child,
-    exit,
-    stop() {
-      stopPromise ??= terminateChildProcessTree(
-        child,
-        options.killGraceMs
-      ).finally(removeEmergencyExitHook);
-      return stopPromise;
-    }
-  };
+  const message = asText2(record.message);
+  if (message) events.push({ type: "message", text: message });
+  return events;
 }
 
 // ../../packages/bridge-core/src/agents/codex-adapter.ts
-var execFileAsync = promisify(execFile);
-var INHERITED_ENVIRONMENT = [
+import { execFile as execFile2, spawn as spawn3 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+var INHERITED_ENVIRONMENT2 = [
   "PATH",
   "HOME",
   "USER",
@@ -1365,15 +1735,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() ?? "";
@@ -1393,18 +1763,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,
@@ -1447,9 +1823,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((resolve9) => {
-      const child = spawn2(this.#executable, ["--version"], {
+      const child = spawn3(this.#executable, ["--version"], {
         stdio: ["ignore", "pipe", "ignore"],
         shell: false
       });
@@ -1482,6 +1865,7 @@ ${guidance}
       "workspace-write",
       "-C",
       input.workspaceRoot,
+      ...this.#modelConfig(),
       ...this.#directExecConfig(input),
       "-"
     ];
@@ -1500,6 +1884,7 @@ ${guidance}
       "workspace-write",
       "-C",
       input.workspaceRoot,
+      ...this.#modelConfig(),
       ...this.#directExecConfig(input),
       "resume",
       input.sessionId,
@@ -1509,9 +1894,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 = spawn2(this.#executable, args, {
+    const child = spawn3(this.#executable, args, {
       cwd: input.workspaceRoot,
       env: environment,
       detached: process.platform !== "win32",
@@ -1543,12 +1928,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 });
       });
     });
@@ -1614,6 +1999,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)
@@ -1642,9 +2028,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(),
@@ -1688,6 +2103,7 @@ function createDefaultConfig(projectId) {
     },
     agent: {
       adapter: "codex",
+      inheritEnv: [],
       maxRunMs: 9e5,
       resumeMode: "auto"
     },
@@ -1760,17 +2176,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 {
@@ -1783,9 +2199,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
     });
   }
 }
@@ -1924,10 +2340,10 @@ var RevertConflictError = class extends RepositorySafetyError {
 };
 
 // ../../packages/bridge-core/src/git/git-command.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 async function runGit(args, options) {
   return await new Promise((resolve9, reject) => {
-    const child = spawn3("git", [...args], {
+    const child = spawn4("git", [...args], {
       cwd: options.cwd,
       env: { ...process.env, ...options.env ?? {} },
       shell: false,
@@ -2996,7 +3412,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 spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 function toPosix(value) {
   return value.split(sep4).join("/").replaceAll("\\", "/");
 }
@@ -3031,7 +3447,7 @@ function isWithin2(root, candidate) {
 }
 async function gitFiles(repoRoot) {
   return await new Promise((resolvePromise, reject) => {
-    const child = spawn4(
+    const child = spawn5(
       "git",
       ["ls-files", "--cached", "--others", "--exclude-standard", "-z"],
       {
@@ -3101,8 +3517,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: [] };
@@ -3110,7 +3526,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 },
@@ -4038,11 +4454,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;
         }
@@ -4254,7 +4670,7 @@ var BrowserSessionManager = class {
 };
 
 // ../../packages/bridge-core/src/verification/commands.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 var MAX_OUTPUT_CHARS = 8e3;
 var KILL_GRACE_MS = 250;
 function appendOutput(current, chunk) {
@@ -4268,7 +4684,7 @@ async function runVerificationCommand(configured, cwd, signal) {
   }
   const startedAt = Date.now();
   return await new Promise((resolveResult, rejectResult) => {
-    const child = spawn5(executable, arguments_, {
+    const child = spawn6(executable, arguments_, {
       cwd,
       detached: process.platform !== "win32",
       shell: false,
@@ -4843,15 +5259,40 @@ ${output2}` : ""}`
 }
 
 // ../../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,
@@ -4870,13 +5311,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,
@@ -5147,10 +5591,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(
@@ -5162,7 +5606,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"],
       {
@@ -5325,7 +5769,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();
@@ -5445,7 +5889,8 @@ 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 }
     },
     dependencies
   );
@@ -5576,9 +6021,9 @@ function formatBridgeSummary(bridge) {
 import { constants } from "node:fs";
 import { access as access2, stat as stat3 } from "node:fs/promises";
 import { delimiter, isAbsolute as isAbsolute5, join as join4, relative as relative6, resolve as resolve7 } from "node:path";
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify3 } from "node:util";
-var execFileAsync3 = promisify3(execFile3);
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync4 = promisify4(execFile4);
 async function fileExists(path) {
   try {
     await stat3(path);
@@ -5592,7 +6037,7 @@ async function fileExists(path) {
 }
 async function isIgnored(repoRoot, path) {
   try {
-    await execFileAsync3("git", ["-C", repoRoot, "check-ignore", "--quiet", "--", path], {
+    await execFileAsync4("git", ["-C", repoRoot, "check-ignore", "--quiet", "--", path], {
       windowsHide: true
     });
     return true;
@@ -5664,7 +6109,7 @@ async function runDoctor(dependencies = {}) {
       });
     }
     const adapter = loaded.config.agent.adapter;
-    const adapterSupported = adapter === "codex";
+    const adapterSupported = adapter === "codex" || adapter === "claude";
     const agentAvailable = await executableAvailable(
       adapter,
       loaded.workspaceRoot,
@@ -5675,6 +6120,34 @@ async function runDoctor(dependencies = {}) {
       status: adapterSupported && agentAvailable ? "pass" : "fail",
       message: !adapterSupported ? `${adapter} is configured but is not implemented in this build.` : agentAvailable ? `${adapter} is executable.` : `${adapter} was not found or is not executable.`
     });
+    if (loaded.config.agent.inheritEnv.length > 0) {
+      const missing = loaded.config.agent.inheritEnv.filter(
+        (name) => environment[name] === void 0
+      );
+      checks.push({
+        name: "agent-environment",
+        status: missing.length === 0 ? "pass" : "fail",
+        message: missing.length === 0 ? `${loaded.config.agent.inheritEnv.length} agent environment variable(s) are available.` : `Missing agent environment variable(s): ${missing.join(", ")}.`
+      });
+    }
+    if (adapter === "claude") {
+      const sandboxDependencies = await Promise.all(
+        ["bwrap", "socat"].map(async (executable) => ({
+          executable,
+          available: await executableAvailable(
+            executable,
+            loaded.workspaceRoot,
+            environment
+          )
+        }))
+      );
+      const missing = sandboxDependencies.filter(({ available }) => !available).map(({ executable }) => executable);
+      checks.push({
+        name: "claude-sandbox",
+        status: missing.length === 0 ? "pass" : "warning",
+        message: missing.length === 0 ? "Claude Bash sandbox dependencies are available." : `Claude Bash sandbox is unavailable without: ${missing.join(", ")}.`
+      });
+    }
     const rtkAvailable = await executableAvailable(
       "rtk",
       loaded.workspaceRoot,
@@ -5739,7 +6212,7 @@ function formatDoctorChecks(checks) {
 }
 
 // src/init.ts
-import { spawn as spawn6 } from "node:child_process";
+import { spawn as spawn7 } from "node:child_process";
 import { readFile as readFile5, mkdir as mkdir3, realpath as realpath10, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
 import { basename as basename2, dirname as dirname4, join as join5, relative as relative7 } from "node:path";
 import { stringify as stringifyYaml } from "yaml";
@@ -6059,7 +6532,7 @@ function installCommand(request) {
 async function installPackage(request) {
   const { command, args } = installCommand(request);
   await new Promise((resolvePromise, reject) => {
-    const child = spawn6(command, args, {
+    const child = spawn7(command, args, {
       cwd: request.cwd,
       env: process.env,
       stdio: "inherit",
@@ -6196,6 +6669,110 @@ function formatBridgeStatus(status) {
   return rows.join("\n");
 }
 
+// ../../package.json
+var package_default = {
+  name: "visual-remote",
+  version: "0.3.2",
+  description: "Visual bridge from a running web UI to a coding agent in its Git worktree",
+  type: "module",
+  packageManager: "pnpm@10.34.5",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/elicie/visual-remote.git"
+  },
+  homepage: "https://github.com/elicie/visual-remote#readme",
+  bugs: {
+    url: "https://github.com/elicie/visual-remote/issues"
+  },
+  files: [
+    "apps/cli/dist/index.js",
+    "apps/cli/dist/direct-exec-mcp.js",
+    "apps/cli/dist/vite.js",
+    "apps/cli/dist/next.js",
+    "apps/cli/dist/next-client.js",
+    "apps/cli/vite.d.ts",
+    "apps/cli/next.d.ts",
+    "apps/cli/next-client.d.ts",
+    "packages/overlay/dist/client.js",
+    "packages/overlay/dist/viewer.js"
+  ],
+  bin: {
+    visual: "./apps/cli/dist/index.js",
+    "visual-remote": "./apps/cli/dist/index.js"
+  },
+  exports: {
+    "./vite": {
+      types: "./apps/cli/vite.d.ts",
+      import: "./apps/cli/dist/vite.js"
+    },
+    "./next": {
+      types: "./apps/cli/next.d.ts",
+      import: "./apps/cli/dist/next.js",
+      default: "./apps/cli/dist/next.js"
+    },
+    "./next/client": {
+      types: "./apps/cli/next-client.d.ts",
+      import: "./apps/cli/dist/next-client.js",
+      default: "./apps/cli/dist/next-client.js"
+    }
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org"
+  },
+  engines: {
+    node: ">=24"
+  },
+  scripts: {
+    build: "corepack pnpm run build:overlay && corepack pnpm run build:server",
+    "build:overlay": "corepack pnpm --filter @visual-remote/overlay build",
+    "build:server": "corepack pnpm --filter @visual-remote/cli build",
+    dev: "corepack pnpm run build:overlay && tsx apps/cli/src/index.ts",
+    test: "vitest run",
+    "test:e2e": "corepack pnpm build && corepack pnpm exec playwright test --config tests/e2e/playwright.config.ts",
+    "test:watch": "vitest",
+    typecheck: "corepack pnpm -r --if-present typecheck && tsc --noEmit -p tsconfig.tests.json",
+    prepack: "corepack pnpm build"
+  },
+  dependencies: {
+    commander: "^15.0.0",
+    "http-proxy": "^1.18.1",
+    ws: "^8.21.1",
+    yaml: "^2.9.0",
+    zod: "^4.4.3"
+  },
+  peerDependencies: {
+    vite: ">=5"
+  },
+  peerDependenciesMeta: {
+    vite: {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@playwright/test": "^1.62.1",
+    "@types/http-proxy": "^1.17.17",
+    "@types/node": "^26.1.2",
+    "@types/ws": "^8.18.1",
+    "@visual-remote/bridge-core": "workspace:*",
+    "@visual-remote/cli": "workspace:*",
+    "@visual-remote/gateway": "workspace:*",
+    "@visual-remote/overlay": "workspace:*",
+    "@visual-remote/protocol": "workspace:*",
+    esbuild: "^0.28.1",
+    next: "15.5.16",
+    react: "19.1.0",
+    "react-dom": "19.1.0",
+    tsx: "^4.23.1",
+    typescript: "^7.0.2",
+    vite: "^8.1.5",
+    vitest: "^4.1.10"
+  }
+};
+
+// src/version.ts
+var VISUAL_REMOTE_VERSION = package_default.version;
+
 // src/index.ts
 function parsePort(value) {
   const port = Number(value);
@@ -6218,7 +6795,7 @@ function setExitCode(dependencies, code) {
   }
 }
 function createCli(dependencies = {}) {
-  const program = new Command().name("visual").description("Visual Remote Dev Bridge").version("0.3.1");
+  const program = new Command().name("visual").description("Visual Remote Dev Bridge").version(VISUAL_REMOTE_VERSION);
   program.command("init").description("Configure Visual Remote for the current Vite or Next.js project").action(async () => {
     const result = await initializeVisualDev(dependencies);
     output(dependencies, formatInitResult(result));
@@ -6286,6 +6863,7 @@ if (entryPath !== void 0 && isDirectEntry(entryPath)) {
   });
 }
 export {
+  VISUAL_REMOTE_VERSION,
   createCli,
   formatBridgeStatus,
   formatBridgeSummary,