@karlorz/codexhost-cli-win32-arm64 0.13.3-5 → 0.13.3-7

package/app/console-server.mjs

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // packages/console-server/src/main.ts
-import path17 from "node:path";
+import path21 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/update-manager/dist/runtime-metadata.js
@@ -891,7 +891,7 @@ function createBackgroundUpdateManager(dependencies = {}) {
 }
 
 // packages/console-server/src/harnesses.ts
-import path10 from "node:path";
+import path12 from "node:path";
 
 // packages/harness-plugin-files/dist/discovery.js
 import { readdir as readdir2, realpath as realpath2 } from "node:fs/promises";
@@ -1663,10 +1663,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path22) {
+  if (!path22)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path22.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -2075,11 +2075,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path22, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path22);
     return iss;
   });
 }
@@ -2226,16 +2226,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path18 = []) => {
+  const processError = (error52, path22 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -2262,17 +2262,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path18 = []) => {
+  const processError = (error52, path22 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path18, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path22, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2304,8 +2304,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path22 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path22) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14997,13 +14997,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path22 = ref.slice(1).split("/").filter(Boolean);
+  if (path22.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path22[0] === defsKey) {
+    const key = path22[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15709,6 +15709,7 @@ var consoleOpenResultSchema = external_exports.strictObject({
   url: external_exports.string().max(2048).regex(/^http:\/\/(?:127\.0\.0\.1|localhost):\d{1,5}\/(?:\?.*)?$/u)
 });
 var CONSOLE_HOST_METHODS = Object.freeze([
+  "codexhost/voice/gateway-status",
   "codexhost/console/remote-connections",
   "codexhost/runtime/status",
   "codexhost/remote/ssh-setup",
@@ -15719,6 +15720,8 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/installation",
   "codexhost/harness/launch-settings/get",
   "codexhost/harness/launch-settings/set",
+  "codexhost/harness/grok-computer-use/get",
+  "codexhost/harness/grok-computer-use/set",
   "codexhost/harness/web-ui/open",
   "codexhost/harness/accounts/sources",
   "codexhost/harness/accounts/list",
@@ -16250,7 +16253,9 @@ var harnessInspectionSchema = external_exports.union([
 var harnessInspectParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
   cwd: nonBlankTextSchema2.max(16384).optional(),
-  refresh: external_exports.boolean().optional()
+  refresh: external_exports.boolean().optional(),
+  /** `availability` asks only whether the Harness can run; see `InspectHarnessInput.purpose`. */
+  purpose: external_exports.literal("availability").optional()
 }).strict();
 var harnessWebUiOpenParamsSchema = external_exports.object({
   harnessId: harnessIdSchema
@@ -16424,6 +16429,26 @@ var harnessLaunchSettingsSchema = external_exports.object({
   restartRequired: external_exports.boolean()
 }).strict();
 
+// packages/shared-contracts/dist/grok-computer-use.js
+var grokComputerUseGetSchema = external_exports.object({}).strict();
+var grokComputerUseSetSchema = external_exports.object({
+  enabled: external_exports.boolean().optional(),
+  browser: external_exports.boolean().optional()
+}).strict().refine((value) => value.enabled !== void 0 || value.browser !== void 0, {
+  message: "Expected enabled or browser"
+});
+var grokComputerUseSettingsSchema = external_exports.object({
+  enabled: external_exports.boolean(),
+  available: external_exports.boolean(),
+  unavailableReason: external_exports.string().min(1).max(500).optional(),
+  browser: external_exports.boolean().optional(),
+  browserFilesPresent: external_exports.boolean().optional(),
+  browserAvailable: external_exports.boolean().optional(),
+  browserUnavailableReason: external_exports.string().min(1).max(500).optional(),
+  applyFailed: external_exports.boolean().optional(),
+  applyError: external_exports.string().min(1).max(500).optional()
+}).strict();
+
 // packages/shared-contracts/dist/harness-installation.js
 var harnessInstallationParamsSchema = external_exports.object({
   harnessId: harnessIdSchema,
@@ -16816,6 +16841,53 @@ var remoteConnectionsReplySchema = external_exports.union([
   external_exports.strictObject({ error: external_exports.strictObject({ code: external_exports.number().int(), message: external_exports.string() }) })
 ]);
 
+// packages/shared-contracts/dist/voice-settings.js
+var VOICE_GATEWAY_STATUS_METHOD = "codexhost/voice/gateway-status";
+var voiceRoutesSchema = external_exports.strictObject({
+  chatExperience: external_exports.enum(["chatgpt", "codex"]),
+  chatConnection: external_exports.enum(["desktop", "gateway"]),
+  workConnection: external_exports.enum(["desktop", "gateway"])
+});
+var DEFAULT_VOICE_ROUTES = Object.freeze({
+  chatExperience: "chatgpt",
+  chatConnection: "desktop",
+  workConnection: "gateway"
+});
+var voiceSettingsSchema = voiceRoutesSchema.extend({ inject: external_exports.boolean() });
+var voiceSettingsRequestSchema = external_exports.discriminatedUnion("operation", [
+  external_exports.strictObject({
+    operation: external_exports.literal("get"),
+    runtime: external_exports.strictObject({
+      id: external_exports.string().uuid(),
+      revision: external_exports.string().max(64),
+      activeCall: external_exports.boolean()
+    }).optional()
+  }),
+  external_exports.strictObject({ operation: external_exports.literal("migrate"), routes: voiceRoutesSchema }),
+  external_exports.strictObject({
+    operation: external_exports.literal("set"),
+    settings: voiceSettingsSchema,
+    revision: external_exports.string().max(64)
+  }),
+  external_exports.strictObject({ operation: external_exports.literal("restart"), confirm: external_exports.literal(true) })
+]);
+var voiceSettingsStateSchema = external_exports.strictObject({
+  settings: voiceSettingsSchema,
+  initialized: external_exports.boolean(),
+  revision: external_exports.string(),
+  activeInject: external_exports.boolean().nullable(),
+  envOverride: external_exports.enum(["0", "1"]).nullable(),
+  activeEnvOverride: external_exports.enum(["0", "1"]).nullable(),
+  routesActive: external_exports.boolean().nullable(),
+  activeCall: external_exports.boolean().nullable(),
+  gatewayReady: external_exports.boolean().nullable(),
+  restartAvailable: external_exports.boolean(),
+  restart: external_exports.strictObject({
+    phase: external_exports.enum(["idle", "restarting", "succeeded", "failed"]),
+    error: external_exports.string().nullable()
+  })
+});
+
 // packages/shared-contracts/dist/index.js
 var workspaceContractVersionSchema = external_exports.literal(WORKSPACE_CONTRACT_VERSION);
 
@@ -17009,23 +17081,365 @@ var HarnessLaunchSettingsStore = class {
   }
 };
 
-// packages/console-server/src/paths.ts
+// packages/harness-plugin-files/dist/grok-computer-use.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { access, mkdir as mkdir5, readFile as readFile5, rename as rename3, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
 import os2 from "node:os";
+import path10 from "node:path";
+
+// packages/harness-plugin-files/dist/grok-computer-use-lock.js
+import { mkdir as mkdir4, rm as rm4 } from "node:fs/promises";
 import path9 from "node:path";
+import { setTimeout as delay3 } from "node:timers/promises";
+async function withGrokComputerUseLock(dataDirectory3, grokHome2, operation) {
+  const locks = [
+    .../* @__PURE__ */ new Set([
+      path9.join(dataDirectory3, ".grok-computer-use.lock"),
+      path9.join(grokHome2, ".codexhost-cua.lock")
+    ])
+  ].sort();
+  const acquired = [];
+  const deadline = Date.now() + 5e3;
+  try {
+    for (const lock of locks) {
+      await mkdir4(path9.dirname(lock), { recursive: true, mode: 448 });
+      for (; ; ) {
+        try {
+          await mkdir4(lock, { mode: 448 });
+          acquired.push(lock);
+          break;
+        } catch (error51) {
+          if (error51.code !== "EEXIST")
+            throw error51;
+          if (Date.now() >= deadline)
+            throw new Error("Grok Computer Use settings are locked");
+          await delay3(25);
+        }
+      }
+    }
+    return await operation();
+  } finally {
+    for (const lock of acquired.reverse())
+      await rm4(lock, { recursive: true });
+  }
+}
+
+// packages/harness-plugin-files/dist/grok-computer-use.js
+var GROK_BROWSER_BINDING_SUPPORTED = false;
+var PREFERENCE_FILE = "grok-computer-use.json";
+var TABLE = "[mcp_servers.cua_repl]";
+var ENV_TABLE = "[mcp_servers.cua_repl.env]";
+var COMPUTER_UNAVAILABLE = "ChatGPT Desktop Computer Use files were not found. Install ChatGPT.app with Computer Use, then try again.";
+var BROWSER_FILES_UNAVAILABLE = "ChatGPT Desktop in-app browser files were not found. Update ChatGPT.app, then try again.";
+var BROWSER_UNSUPPORTED = "ChatGPT Desktop does not authorize Grok to use the in-app browser. The preference is saved as intent until Desktop supports an external Harness.";
+var APPLY_FAILED = "Could not apply Grok Computer Use settings to Grok config.";
+var GrokComputerUseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "GrokComputerUseError";
+  }
+};
+function dataDirectory(environment) {
+  return environment.CODEXHOST_DATA_DIR ? path10.resolve(environment.CODEXHOST_DATA_DIR) : path10.join(os2.homedir(), ".codexhost");
+}
+function grokHome(environment) {
+  return environment.GROK_HOME ? path10.resolve(environment.GROK_HOME) : path10.join(environment.HOME ?? os2.homedir(), ".grok");
+}
+function chatgptApp(environment, platform) {
+  if (environment.CODEXHOST_CHATGPT_APP)
+    return path10.resolve(environment.CODEXHOST_CHATGPT_APP);
+  if (platform === "darwin")
+    return "/Applications/ChatGPT.app";
+  return void 0;
+}
+async function isFile(target) {
+  try {
+    await access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isNotFound(error51) {
+  return Boolean(error51 && typeof error51 === "object" && "code" in error51 && error51.code === "ENOENT");
+}
+async function writeAtomically(file2, content) {
+  await mkdir5(path10.dirname(file2), { recursive: true, mode: 448 });
+  const temporary = `${file2}.${randomUUID3()}.tmp`;
+  try {
+    await writeFile4(temporary, content, { mode: 384, flag: "wx" });
+    await rename3(temporary, file2);
+  } finally {
+    await rm5(temporary, { force: true });
+  }
+}
+function launchPaths(environment, platform) {
+  const app = chatgptApp(environment, platform);
+  if (!app)
+    return void 0;
+  const resources = path10.join(app, "Contents", "Resources");
+  const cuaNode = path10.join(resources, "cua_node");
+  return {
+    node: path10.join(cuaNode, "bin", "node"),
+    cuaRepl: path10.join(cuaNode, "lib", "node_modules", "@oai", "cua-repl", "bin", "cua-repl.mjs"),
+    nodeRepl: path10.join(cuaNode, "bin", "node_repl"),
+    nodeModules: path10.join(cuaNode, "lib", "node_modules"),
+    codexCli: path10.join(resources, "codex-cli", "bin", "codex"),
+    skyApp: path10.join(environment.HOME ?? os2.homedir(), ".codex", "computer-use", "Codex Computer Use.app"),
+    codexHome: path10.join(environment.HOME ?? os2.homedir(), ".codex"),
+    browserDesktop: path10.join(cuaNode, "lib", "node_modules", "@oai", "browser-desktop")
+  };
+}
+async function sharedRuntimePresent(launch) {
+  const present = await Promise.all([launch.node, launch.cuaRepl, launch.nodeRepl].map(isFile));
+  return present.every(Boolean);
+}
+async function computerFilesPresent(launch) {
+  const present = await Promise.all([isFile(launch.skyApp), isFile(launch.codexCli)]);
+  return present.every(Boolean);
+}
+async function browserFilesPresent(launch) {
+  return isFile(path10.join(launch.browserDesktop, "package.json"));
+}
+async function discoverGrokComputerUseLaunch(environment = process.env, platform = process.platform) {
+  const launch = launchPaths(environment, platform);
+  if (!launch || !await sharedRuntimePresent(launch))
+    return void 0;
+  return launch;
+}
+function tableRange(text, header) {
+  const lines = text.split(/\n/);
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index] === header) {
+      start = index;
+      break;
+    }
+  }
+  if (start < 0)
+    return void 0;
+  let end = lines.length;
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.startsWith("[") && line.endsWith("]")) {
+      end = index;
+      break;
+    }
+  }
+  return { start, end };
+}
+function removeTables(text, headers) {
+  let current = text;
+  for (const header of headers) {
+    const range = tableRange(current, header);
+    if (!range)
+      continue;
+    const lines = current.split(/\n/);
+    lines.splice(range.start, range.end - range.start);
+    current = lines.join("\n");
+  }
+  return current.replace(/\n{3,}/g, "\n\n");
+}
+function cuaReplEnabledInToml(text) {
+  const range = tableRange(text, TABLE);
+  if (!range)
+    return false;
+  const body = text.split(/\n/).slice(range.start, range.end);
+  for (const line of body) {
+    if (/^enabled\s*=\s*false\b/u.test(line))
+      return false;
+    if (/^enabled\s*=\s*true\b/u.test(line))
+      return true;
+  }
+  return true;
+}
+function inferredSurfaces(text) {
+  if (!cuaReplEnabledInToml(text))
+    return { enabled: false, browser: false };
+  const range = tableRange(text, ENV_TABLE);
+  const body = range ? text.split(/\n/).slice(range.start, range.end).join("\n") : "";
+  const literal2 = /^CUA_REPL_ENABLED_SURFACES\s*=\s*(["'])([^"']*)\1\s*(?:#.*)?$/mu.exec(body);
+  if (!literal2)
+    return { enabled: true, browser: false };
+  const surfaces = new Set(literal2[2]?.split(",").map((surface) => surface.trim()));
+  return { enabled: surfaces.has("computer"), browser: surfaces.has("browser") };
+}
+function stanza(launch, state) {
+  const trusted = `${launch.codexHome}:${launch.nodeModules}`;
+  const services = {};
+  if (state.browser)
+    services.browser = "@oai/browser-desktop/service";
+  if (state.enabled)
+    services.sky = "@oai/sky/service";
+  const surfaces = [state.browser ? "browser" : "", state.enabled ? "computer" : ""].filter(Boolean).join(",");
+  const backends = state.browser ? 'BROWSER_USE_AVAILABLE_BACKENDS = "iab"\n' : "";
+  const active = state.enabled || state.browser;
+  return `${TABLE}
+command = ${JSON.stringify(launch.node)}
+args = [${JSON.stringify(launch.cuaRepl)}]
+enabled = ${active ? "true" : "false"}
+startup_timeout_sec = 120
+
+${ENV_TABLE}
+NODE_REPL_TRUSTED_SERVICES = ${JSON.stringify(JSON.stringify(services))}
+NODE_REPL_TRUSTED_CODE_PATHS = ${JSON.stringify(trusted)}
+NODE_REPL_NODE_PATH = ${JSON.stringify(launch.node)}
+CODEX_HOME = ${JSON.stringify(launch.codexHome)}
+CUA_REPL_NODE_REPL_PATH = ${JSON.stringify(launch.nodeRepl)}
+NODE_REPL_NODE_MODULE_DIRS = ${JSON.stringify(launch.nodeModules)}
+NODE_REPL_NATIVE_PIPE_CONNECT_TIMEOUT_MS = "1000"
+SKY_CUA_SERVICE_PATH = ${JSON.stringify(launch.skyApp)}
+CODEX_CLI_PATH = ${JSON.stringify(launch.codexCli)}
+${backends}CUA_REPL_ENABLED_SURFACES = ${JSON.stringify(surfaces)}
+`;
+}
+async function readPreference(environment) {
+  try {
+    const document = JSON.parse(await readFile5(path10.join(dataDirectory(environment), PREFERENCE_FILE), "utf8"));
+    return {
+      ...typeof document.enabled === "boolean" ? { enabled: document.enabled } : {},
+      ...typeof document.browser === "boolean" ? { browser: document.browser } : {},
+      ...typeof document.applyError === "string" && document.applyError ? { applyError: document.applyError } : {}
+    };
+  } catch (error51) {
+    if (isNotFound(error51))
+      return void 0;
+    throw new GrokComputerUseError("Could not read Grok Computer Use settings");
+  }
+}
+async function writePreference(environment, state) {
+  const document = {
+    ...typeof state.enabled === "boolean" ? { enabled: state.enabled } : {},
+    ...typeof state.browser === "boolean" ? { browser: state.browser } : {},
+    ...state.applyError ? { applyError: state.applyError } : {}
+  };
+  await writeAtomically(path10.join(dataDirectory(environment), PREFERENCE_FILE), `${JSON.stringify(document)}
+`);
+}
+async function readGrokConfig(environment) {
+  try {
+    return await readFile5(path10.join(grokHome(environment), "config.toml"), "utf8");
+  } catch (error51) {
+    if (isNotFound(error51))
+      return "";
+    throw new GrokComputerUseError("Could not read Grok config");
+  }
+}
+async function writeGrokConfig(environment, text) {
+  await writeAtomically(path10.join(grokHome(environment), "config.toml"), text.endsWith("\n") ? text : `${text}
+`);
+}
+async function currentState(environment, preference) {
+  const resolved = preference ?? await readPreference(environment);
+  const inferred = resolved?.enabled === void 0 ? inferredSurfaces(await readGrokConfig(environment)) : void 0;
+  return {
+    enabled: resolved?.enabled ?? inferred?.enabled ?? false,
+    browser: resolved ? resolved.browser ?? false : inferred?.browser ?? false,
+    ...resolved?.applyError ? { applyError: resolved.applyError } : {}
+  };
+}
+function settingsFrom(state, files) {
+  const bindable = files.browser && GROK_BROWSER_BINDING_SUPPORTED;
+  return {
+    enabled: state.enabled,
+    available: files.computer,
+    ...files.computer ? {} : { unavailableReason: COMPUTER_UNAVAILABLE },
+    browser: state.browser,
+    browserFilesPresent: files.browser,
+    browserAvailable: bindable,
+    ...bindable ? {} : {
+      browserUnavailableReason: files.browser ? BROWSER_UNSUPPORTED : BROWSER_FILES_UNAVAILABLE
+    },
+    ...state.applyError ? { applyFailed: true, applyError: state.applyError } : {}
+  };
+}
+async function surfaceFiles(launch) {
+  if (!launch)
+    return { computer: false, browser: false };
+  const [computer, browser] = await Promise.all([
+    computerFilesPresent(launch),
+    browserFilesPresent(launch)
+  ]);
+  return { computer, browser };
+}
+async function getGrokComputerUseSettings(environment = process.env, platform = process.platform) {
+  const launch = await discoverGrokComputerUseLaunch(environment, platform);
+  return settingsFrom(await currentState(environment), await surfaceFiles(launch));
+}
+async function writeConfigForState(state, launch, files, environment) {
+  const current = await readGrokConfig(environment);
+  const range = tableRange(current, TABLE);
+  const effective = {
+    enabled: state.enabled && files.computer,
+    browser: state.browser && files.browser && GROK_BROWSER_BINDING_SUPPORTED
+  };
+  if (!effective.enabled && !effective.browser && !range)
+    return;
+  if (!launch) {
+    if (!range)
+      return;
+    const lines = current.split(/\n/);
+    const body = lines.slice(range.start, range.end);
+    const replaced = body.map((line) => /^enabled\s*=/u.test(line) ? "enabled = false" : line);
+    if (!replaced.some((line) => /^enabled\s*=/u.test(line))) {
+      replaced.splice(1, 0, "enabled = false");
+    }
+    lines.splice(range.start, range.end - range.start, ...replaced);
+    await writeGrokConfig(environment, lines.join("\n"));
+    return;
+  }
+  const stripped = removeTables(current, [ENV_TABLE, TABLE]).replace(/\s+$/u, "\n");
+  await writeGrokConfig(environment, `${stripped.trimEnd()}
+
+${stanza(launch, effective)}`);
+}
+async function setGrokComputerUse(update, environment = process.env, platform = process.platform) {
+  return withGrokComputerUseLock(dataDirectory(environment), grokHome(environment), async () => {
+    const launch = await discoverGrokComputerUseLaunch(environment, platform);
+    const files = await surfaceFiles(launch);
+    if (update.enabled && !files.computer) {
+      throw new GrokComputerUseError(COMPUTER_UNAVAILABLE);
+    }
+    if (update.browser && !files.browser) {
+      throw new GrokComputerUseError(BROWSER_FILES_UNAVAILABLE);
+    }
+    const previous = await currentState(environment);
+    const state = {
+      enabled: update.enabled ?? previous.enabled,
+      browser: update.browser ?? previous.browser
+    };
+    try {
+      await writeConfigForState(state, launch, files, environment);
+      await writePreference(environment, state);
+    } catch (error51) {
+      await writeConfigForState(previous, launch, files, environment).catch(() => void 0);
+      const applyError = error51 instanceof GrokComputerUseError ? error51.message : APPLY_FAILED;
+      await writePreference(environment, { ...previous, applyError }).catch(() => void 0);
+      if (error51 instanceof GrokComputerUseError)
+        throw error51;
+      throw new GrokComputerUseError(APPLY_FAILED);
+    }
+    return settingsFrom(state, files);
+  });
+}
+
+// packages/console-server/src/paths.ts
+import os3 from "node:os";
+import path11 from "node:path";
 var DEFAULT_CONSOLE_PORT = 4399;
 var CONSOLE_PORT_ENV = "CODEXHOST_CONSOLE_PORT";
 var LAUNCHER_EXECUTABLE_ENV = "CODEXHOST_LAUNCHER_EXECUTABLE";
-function dataDirectory(environment = process.env) {
-  return environment.CODEXHOST_DATA_DIR ? path9.resolve(environment.CODEXHOST_DATA_DIR) : path9.join(os2.homedir(), ".codexhost");
+function dataDirectory2(environment = process.env) {
+  return environment.CODEXHOST_DATA_DIR ? path11.resolve(environment.CODEXHOST_DATA_DIR) : path11.join(os3.homedir(), ".codexhost");
 }
 function consolePaths(environment = process.env) {
-  const root = dataDirectory(environment);
+  const root = dataDirectory2(environment);
   return {
     dataDirectory: root,
-    startupRecordFile: path9.join(root, "diagnostics", "launcher-startup-v1.json"),
-    controllerStatusFile: path9.join(root, "diagnostics", "desktop-controller-v1.json"),
-    logsDirectory: path9.join(root, "logs"),
-    hostDescriptorDirectory: path9.join(root, "console", "hosts")
+    startupRecordFile: path11.join(root, "diagnostics", "launcher-startup-v1.json"),
+    controllerStatusFile: path11.join(root, "diagnostics", "desktop-controller-v1.json"),
+    logsDirectory: path11.join(root, "logs"),
+    hostDescriptorDirectory: path11.join(root, "console", "hosts")
   };
 }
 function consolePort(environment = process.env) {
@@ -17041,10 +17455,10 @@ function consolePort(environment = process.env) {
 // packages/console-server/src/harnesses.ts
 var HARNESS_PLUGIN_DIRECTORY_ENV = "CODEXHOST_PLUGIN_DIRECTORY";
 function harnessPluginRoots(appDirectory2, sourceCheckout, environment = process.env) {
-  const bundled = sourceCheckout ? path10.resolve(appDirectory2, "..", "..", "host-runtime", "dist", "plugins") : path10.join(appDirectory2, "plugins");
+  const bundled = sourceCheckout ? path12.resolve(appDirectory2, "..", "..", "host-runtime", "dist", "plugins") : path12.join(appDirectory2, "plugins");
   return [
     bundled,
-    environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path10.join(dataDirectory(environment), "plugins")
+    environment[HARNESS_PLUGIN_DIRECTORY_ENV] ?? path12.join(dataDirectory2(environment), "plugins")
   ];
 }
 var ConsoleHarnessError = class extends Error {
@@ -17078,7 +17492,8 @@ function createConsoleHarnesses(roots, environment = process.env) {
         launchCommand: manifest.launchCommand === true,
         links: manifest.links ?? null,
         icon,
-        launchPath
+        launchPath,
+        ...manifest.id === "grok" ? { computerUse: await getGrokComputerUseSettings(environment) } : {}
       });
     }
     return harnesses.sort(
@@ -17099,17 +17514,27 @@ function createConsoleHarnesses(roots, environment = process.env) {
       } catch (error51) {
         throw new ConsoleHarnessError(400, error51 instanceof Error ? error51.message : String(error51));
       }
+    },
+    async setGrokComputerUse(update) {
+      const harness2 = (await list()).find((candidate) => candidate.id === "grok");
+      if (!harness2) throw new ConsoleHarnessError(404, "Harness 'grok' is not installed");
+      try {
+        const computerUse = await setGrokComputerUse(update, environment);
+        return { ...harness2, computerUse };
+      } catch (error51) {
+        throw new ConsoleHarnessError(400, error51 instanceof Error ? error51.message : String(error51));
+      }
     }
   };
 }
 
 // packages/console-server/src/host-client.ts
-import { readdir as readdir4, readFile as readFile6, rm as rm4 } from "node:fs/promises";
-import path12 from "node:path";
+import { readdir as readdir4, readFile as readFile7, rm as rm6 } from "node:fs/promises";
+import path14 from "node:path";
 
 // packages/console-server/src/diagnostics.ts
-import { open as open4, readdir as readdir3, readFile as readFile5, stat as stat3 } from "node:fs/promises";
-import path11 from "node:path";
+import { open as open4, readdir as readdir3, readFile as readFile6, stat as stat3 } from "node:fs/promises";
+import path13 from "node:path";
 var MAX_DIAGNOSTIC_FILE_BYTES = 256 * 1024;
 var MAX_LOG_TAIL_BYTES = 256 * 1024;
 var LOG_FILE_PATTERN = /^host-runtime-\d{1,10}\.log(?:\.1)?$/u;
@@ -17117,7 +17542,7 @@ async function readBoundedJson(filePath) {
   try {
     const metadata = await stat3(filePath);
     if (!metadata.isFile() || metadata.size > MAX_DIAGNOSTIC_FILE_BYTES) return null;
-    return JSON.parse(await readFile5(filePath, "utf8"));
+    return JSON.parse(await readFile6(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -17164,6 +17589,8 @@ async function readControllerStatus(filePath) {
   return {
     pid: document.pid,
     startedAt: document.startedAt,
+    ...typeof document.voiceInjection === "boolean" ? { voiceInjection: document.voiceInjection } : {},
+    ...document.voiceEnvOverride === "0" || document.voiceEnvOverride === "1" || document.voiceEnvOverride === null ? { voiceEnvOverride: document.voiceEnvOverride } : {},
     renderer: {
       state: renderer.state,
       error: typeof renderer.error === "string" ? renderer.error : null,
@@ -17188,7 +17615,7 @@ async function listLogFiles(logsDirectory) {
   const entries = await Promise.all(
     names.filter(isLogFileName).map(async (name) => {
       try {
-        const metadata = await stat3(path11.join(logsDirectory, name));
+        const metadata = await stat3(path13.join(logsDirectory, name));
         return metadata.isFile() ? { name, size: metadata.size, modifiedAt: metadata.mtimeMs } : null;
       } catch {
         return null;
@@ -17202,7 +17629,7 @@ async function readLogTail(logsDirectory, name, maxBytes = MAX_LOG_TAIL_BYTES) {
   const limit = Math.max(1, Math.min(maxBytes, MAX_LOG_TAIL_BYTES));
   let handle;
   try {
-    handle = await open4(path11.join(logsDirectory, name), "r");
+    handle = await open4(path13.join(logsDirectory, name), "r");
   } catch {
     return null;
   }
@@ -17283,14 +17710,14 @@ async function findHost(descriptorDirectory, isAlive = processIsAlive2) {
   }
   const hosts = [];
   for (const name of names.filter((candidate) => DESCRIPTOR_PATTERN.test(candidate))) {
-    const filePath = path12.join(descriptorDirectory, name);
+    const filePath = path14.join(descriptorDirectory, name);
     try {
-      const text = await readFile6(filePath, "utf8");
+      const text = await readFile7(filePath, "utf8");
       if (text.length > DESCRIPTOR_MAX_BYTES) continue;
       const endpoint = parseDescriptor(JSON.parse(text));
       if (!endpoint) continue;
       if (isAlive(endpoint.pid)) hosts.push(endpoint);
-      else await rm4(filePath, { force: true });
+      else await rm6(filePath, { force: true });
     } catch {
       continue;
     }
@@ -17311,7 +17738,7 @@ function createConsoleHostClient(descriptorDirectory, options = {}) {
         headers: { authorization: `Bearer ${host.token}`, "content-type": "application/json" },
         body: JSON.stringify({ method, params: params ?? {} }),
         signal: AbortSignal.timeout(
-          method === "codexhost/remote/ssh-setup" ? Math.max(timeoutMs, 33e4) : timeoutMs
+          method === VOICE_GATEWAY_STATUS_METHOD ? Math.min(timeoutMs, 2e3) : method === "codexhost/remote/ssh-setup" ? Math.max(timeoutMs, 33e4) : timeoutMs
         )
       });
       const body = await response.json().catch(() => null);
@@ -17328,12 +17755,12 @@ function createConsoleHostClient(descriptorDirectory, options = {}) {
 // packages/console-server/src/installation.ts
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync } from "node:fs";
-import { readFile as readFile7 } from "node:fs/promises";
-import path13 from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import path15 from "node:path";
 async function readDistribution(appDirectory2) {
   try {
     return parseDistributionMetadata(
-      JSON.parse(await readFile7(path13.join(appDirectory2, "codexhost-distribution.json"), "utf8"))
+      JSON.parse(await readFile8(path15.join(appDirectory2, "codexhost-distribution.json"), "utf8"))
     );
   } catch (error51) {
     if (error51.code === "ENOENT") return null;
@@ -17341,17 +17768,17 @@ async function readDistribution(appDirectory2) {
   }
 }
 function installedLauncherCandidates(appDirectory2, platform = process.platform) {
-  const resourcesRoot = path13.dirname(appDirectory2);
+  const resourcesRoot = path15.dirname(appDirectory2);
   const suffix = platform === "win32" ? ".exe" : "";
-  const candidates = [path13.join(resourcesRoot, "bin", `codexhost${suffix}`)];
-  if (platform === "darwin" && path13.basename(resourcesRoot) === "Resources") {
-    candidates.unshift(path13.join(path13.dirname(resourcesRoot), "MacOS", "codexhost"));
+  const candidates = [path15.join(resourcesRoot, "bin", `codexhost${suffix}`)];
+  if (platform === "darwin" && path15.basename(resourcesRoot) === "Resources") {
+    candidates.unshift(path15.join(path15.dirname(resourcesRoot), "MacOS", "codexhost"));
   }
   return candidates;
 }
 function resolveLauncherExecutable(appDirectory2, environment = process.env, platform = process.platform, exists = existsSync) {
   const configured = environment[LAUNCHER_EXECUTABLE_ENV];
-  if (configured && path13.isAbsolute(configured) && exists(configured)) return configured;
+  if (configured && path15.isAbsolute(configured) && exists(configured)) return configured;
   return installedLauncherCandidates(appDirectory2, platform).find(exists) ?? null;
 }
 async function resolveInstallation(appDirectory2, environment = process.env) {
@@ -17389,26 +17816,26 @@ function inspectInstallation(launcherExecutable) {
     );
   });
 }
-function launchCommand(installation, environment = process.env) {
+function launchCommand(installation, environment = process.env, action = "launch") {
   if (installation.distribution?.distribution === "npm") {
     const node = environment.CODEXHOST_NPM_NODE_PATH;
     const wrapper = environment.CODEXHOST_NPM_LAUNCHER_PATH;
-    if (node && wrapper && path13.isAbsolute(node) && path13.isAbsolute(wrapper)) {
-      return { command: node, args: [wrapper] };
+    if (node && wrapper && path15.isAbsolute(node) && path15.isAbsolute(wrapper)) {
+      return { command: node, args: [wrapper, ...action === "restart" ? [action] : []] };
     }
     return null;
   }
-  return installation.launcherExecutable ? { command: installation.launcherExecutable, args: ["launch"] } : null;
+  return installation.launcherExecutable ? { command: installation.launcherExecutable, args: [action] } : null;
 }
 
 // packages/console-server/src/open.ts
 import { spawn as spawn3 } from "node:child_process";
 import { stat as stat4 } from "node:fs/promises";
-import path16 from "node:path";
+import path20 from "node:path";
 
 // packages/console-server/src/page.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import path14 from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import path16 from "node:path";
 var CONSOLE_PAGE_HTML = `<!doctype html>
 <html lang="en">
 <head>
@@ -17429,14 +17856,14 @@ var MISSING_BUNDLE_SCRIPT = `document.body.textContent = "codexhost console asse
 `;
 function consoleBundleCandidates(appDirectory2) {
   return [
-    path14.join(appDirectory2, "console-web.js"),
-    path14.resolve(appDirectory2, "..", "..", "renderer-extension", "dist", "console.js")
+    path16.join(appDirectory2, "console-web.js"),
+    path16.resolve(appDirectory2, "..", "..", "renderer-extension", "dist", "console.js")
   ];
 }
 async function loadConsoleBundle(appDirectory2) {
   for (const candidate of consoleBundleCandidates(appDirectory2)) {
     try {
-      return await readFile8(candidate, "utf8");
+      return await readFile9(candidate, "utf8");
     } catch {
       continue;
     }
@@ -17454,6 +17881,49 @@ function allowedChange(origin, consoleHeader, port) {
   return origin === void 0 || origin === `http://127.0.0.1:${port}` || origin === `http://localhost:${port}`;
 }
 
+// packages/console-server/src/restart.ts
+var ConsoleRestart = class {
+  constructor(run2, observe, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), now = Date.now, timeoutMs = 12e4) {
+    this.run = run2;
+    this.observe = observe;
+    this.sleep = sleep;
+    this.now = now;
+    this.timeoutMs = timeoutMs;
+  }
+  run;
+  observe;
+  sleep;
+  now;
+  timeoutMs;
+  status = { phase: "idle", error: null };
+  start(previous) {
+    if (this.status.phase === "restarting") throw new Error("Restart is already in progress");
+    this.status = { phase: "restarting", error: null };
+    void this.restart(previous);
+  }
+  async restart(previous) {
+    try {
+      await this.run();
+      const deadline = this.now() + this.timeoutMs;
+      while (this.now() < deadline) {
+        const current = await this.observe();
+        if (current.failure) throw new Error(current.failure);
+        if (current.launcherPid !== null && current.launcherPid !== previous.launcherPid && current.controllerPid !== null && current.controllerPid !== previous.controllerPid && current.installed) {
+          this.status = { phase: "succeeded", error: null };
+          return;
+        }
+        await this.sleep(250);
+      }
+      throw new Error("Restart timed out. Check startup diagnostics before retrying.");
+    } catch (error51) {
+      this.status = {
+        phase: "failed",
+        error: error51 instanceof Error ? error51.message : String(error51)
+      };
+    }
+  }
+};
+
 // packages/console-server/src/server.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createServer } from "node:http";
@@ -17517,14 +17987,14 @@ function readAnnouncement(fetcher = fetch) {
 }
 
 // packages/console-server/src/diagnostic-report.ts
-import os3 from "node:os";
+import os4 from "node:os";
 var ISSUE_REPOSITORY_URL = "https://github.com/karlorz/codex-host";
 var ISSUE_ERROR_CHARS = 800;
 var ISSUE_URL_MAX_LENGTH = 7e3;
 var REPORT_LOG_TAIL_BYTES = 32 * 1024;
 var REPORT_LOG_FILES = 2;
 var REPORT_STARTUP_RECORDS = 5;
-function redactHome(text, home = os3.homedir()) {
+function redactHome(text, home = os4.homedir()) {
   if (!home || home === "/" || home.length < 3) return text;
   const variants = /* @__PURE__ */ new Set([home, JSON.stringify(home).slice(1, -1)]);
   let result = text;
@@ -17540,7 +18010,7 @@ async function buildDiagnosticReport(input, readTail, now = () => /* @__PURE__ *
   return {
     schemaVersion: 1,
     generatedAt: now().toISOString(),
-    platform: { os: process.platform, arch: process.arch, release: os3.release() },
+    platform: { os: process.platform, arch: process.arch, release: os4.release() },
     codexhost: {
       version: input.distribution?.version ?? input.consoleVersion,
       distribution: input.distribution?.distribution ?? null,
@@ -17616,7 +18086,7 @@ function issueUrl(report, home) {
 }
 
 // packages/console-server/src/updates.ts
-import path15 from "node:path";
+import path17 from "node:path";
 var ERROR_MAX_LENGTH = 500;
 var ConsoleUpdateError = class extends Error {
   constructor(code, message) {
@@ -17649,13 +18119,13 @@ function installationKind(metadata) {
 }
 function absoluteEnvironmentPath(environment, name) {
   const value = environment[name];
-  if (!value || !path15.isAbsolute(value)) {
+  if (!value || !path17.isAbsolute(value)) {
     throw new ConsoleUpdateError(
       "unsupported",
       `${name} is unavailable; run 'codexhost console' from the npm command to update`
     );
   }
-  return path15.normalize(value);
+  return path17.normalize(value);
 }
 function createConsoleUpdates(options) {
   const environment = options.environment ?? process.env;
@@ -17696,13 +18166,13 @@ function createConsoleUpdates(options) {
     }
   }
   async function prepare(metadata, target, release, onPrepared) {
-    const resourcesRoot = path15.dirname(target.appDirectory);
+    const resourcesRoot = path17.dirname(target.appDirectory);
     const common = {
       version: release.version,
       launcherPid: options.processId ?? process.pid,
       launcherExecutable: options.processExecutable ?? process.execPath,
       runtimeDescriptorPath: target.runtimeDescriptorPath,
-      updaterExecutable: path15.join(
+      updaterExecutable: path17.join(
         resourcesRoot,
         "libexec",
         platform === "win32" ? "codexhost-updater.exe" : "codexhost-updater"
@@ -17737,13 +18207,13 @@ function createConsoleUpdates(options) {
     if (kind === "windows-installer") {
       return manager.prepareWindowsInstaller({ ...common, artifact, installRoot: resourcesRoot });
     }
-    const appPath = path15.dirname(path15.dirname(resourcesRoot));
+    const appPath = path17.dirname(path17.dirname(resourcesRoot));
     return manager.prepareMacOsDmg({ ...common, artifact, appPath });
   }
   return Object.freeze({
     async check(target, signal) {
       const metadata = target.distribution;
-      const runtime = metadata ? null : await readRuntimeMetadata(path15.join(target.appDirectory, "main.js"), environment).catch(
+      const runtime = metadata ? null : await readRuntimeMetadata(path17.join(target.appDirectory, "main.js"), environment).catch(
         () => null
       );
       const empty = {
@@ -17794,7 +18264,7 @@ function createConsoleUpdates(options) {
       if (!metadata) {
         throw new ConsoleUpdateError("unsupported", "A source checkout cannot update itself");
       }
-      if (!target.runtimeDescriptorPath || !path15.isAbsolute(target.runtimeDescriptorPath)) {
+      if (!target.runtimeDescriptorPath || !path17.isAbsolute(target.runtimeDescriptorPath)) {
         throw new ConsoleUpdateError("unsupported", "The Launcher runtime path is unavailable");
       }
       if (handedOff) {
@@ -17862,6 +18332,135 @@ function createConsoleUpdates(options) {
   });
 }
 
+// packages/console-server/src/live-voice-inject.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { mkdir as mkdir6, readFile as readFile10, rename as rename4, rm as rm7, writeFile as writeFile5 } from "node:fs/promises";
+import path18 from "node:path";
+var CPA_LIVE_VOICE_ENV = "CODEXHOST_CPA_LIVE_VOICE";
+var LIVE_VOICE_INJECT_FILE = "live-voice-inject-v1.json";
+function injectPath(dataDirectory3) {
+  return path18.join(dataDirectory3, LIVE_VOICE_INJECT_FILE);
+}
+async function readLiveVoiceInjectState(dataDirectory3, environment = process.env) {
+  const env = environment[CPA_LIVE_VOICE_ENV];
+  const envOverride = env === "0" || env === "1" ? env : null;
+  let inject = true;
+  try {
+    const parsed = JSON.parse(await readFile10(injectPath(dataDirectory3), "utf8"));
+    inject = parsed.version !== 1 || parsed.inject !== false;
+  } catch {
+    inject = true;
+  }
+  const savedInject = inject;
+  if (envOverride === "0") inject = false;
+  if (envOverride === "1") inject = true;
+  return { inject, savedInject, envOverride };
+}
+async function writeLiveVoiceInjectFile(dataDirectory3, inject, routes) {
+  if (!routes) {
+    try {
+      const saved = JSON.parse(await readFile10(injectPath(dataDirectory3), "utf8"));
+      if (saved?.version === 1) routes = voiceRoutesSchema.safeParse(saved.routes).data;
+    } catch {
+    }
+  }
+  await mkdir6(dataDirectory3, { recursive: true, mode: 448 });
+  const temporaryPath = path18.join(dataDirectory3, `.${LIVE_VOICE_INJECT_FILE}.${randomUUID4()}.tmp`);
+  try {
+    await writeFile5(
+      temporaryPath,
+      `${JSON.stringify({ version: 1, inject, ...routes ? { routes } : {} }, null, 2)}
+`,
+      {
+        mode: 384,
+        flag: "wx"
+      }
+    );
+    await rename4(temporaryPath, injectPath(dataDirectory3));
+  } finally {
+    await rm7(temporaryPath, { force: true });
+  }
+}
+
+// packages/console-server/src/voice-settings.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile11 } from "node:fs/promises";
+import path19 from "node:path";
+var VoiceSettingsConflict = class extends Error {
+};
+var VoiceSettingsStore = class {
+  constructor(directory) {
+    this.directory = directory;
+  }
+  directory;
+  #writes = Promise.resolve();
+  #runtime = /* @__PURE__ */ new Map();
+  async read() {
+    let document = null;
+    try {
+      document = JSON.parse(
+        await readFile11(path19.join(this.directory, LIVE_VOICE_INJECT_FILE), "utf8")
+      );
+    } catch (error51) {
+      if (!(error51 instanceof SyntaxError) && error51.code !== "ENOENT")
+        throw new Error("Could not read voice settings");
+    }
+    const routes = document?.version === 1 ? voiceRoutesSchema.safeParse(document.routes).data : void 0;
+    const settings = {
+      ...routes ?? DEFAULT_VOICE_ROUTES,
+      inject: document?.version !== 1 || document.inject !== false
+    };
+    const revision = createHash2("sha256").update(JSON.stringify({ settings, initialized: !!routes })).digest("hex");
+    const runtime = [...this.#runtime.values()].filter((entry) => Date.now() - entry.at < 12e3);
+    return {
+      settings,
+      initialized: !!routes,
+      revision,
+      activeCall: runtime.length ? runtime.some((entry) => entry.activeCall) : null,
+      routesActive: runtime.length ? runtime.every((entry) => entry.revision === revision) : null
+    };
+  }
+  report(runtime) {
+    for (const [id, entry] of this.#runtime)
+      if (Date.now() - entry.at >= 12e3) this.#runtime.delete(id);
+    if (this.#runtime.size < 32 || this.#runtime.has(runtime.id))
+      this.#runtime.set(runtime.id, { ...runtime, at: Date.now() });
+  }
+  async setInjection(inject) {
+    const operation = this.#writes.then(async () => {
+      const current = await this.read();
+      if (current.activeCall)
+        throw new VoiceSettingsConflict("End your voice call before applying changes.");
+      await writeLiveVoiceInjectFile(this.directory, inject);
+    });
+    this.#writes = operation.catch(() => void 0);
+    await operation;
+  }
+  async write(input) {
+    const operation = this.#writes.then(async () => {
+      const current = await this.read();
+      if (input.operation === "migrate" && current.initialized) return current;
+      if (input.operation === "set") {
+        if (current.activeCall)
+          throw new VoiceSettingsConflict("End your voice call before applying changes.");
+        if (input.revision !== current.revision)
+          throw new VoiceSettingsConflict(
+            "Voice settings changed in another window. Reload and try again."
+          );
+      }
+      const settings = input.operation === "set" ? input.settings : { ...current.settings, ...input.routes };
+      await writeLiveVoiceInjectFile(this.directory, settings.inject, {
+        chatExperience: settings.chatExperience,
+        chatConnection: settings.chatConnection,
+        workConnection: settings.workConnection
+      });
+      return this.read();
+    });
+    this.#writes = operation.catch(() => void 0);
+    return operation;
+  }
+};
+
 // packages/console-server/src/server.ts
 var CONSOLE_SERVICE = "codexhost-console";
 var MAX_BODY_BYTES = 16 * 1024;
@@ -17917,11 +18516,42 @@ function defaultLaunch(command2, args) {
   });
   child.unref();
 }
+function defaultRestart(command2, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command2, args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", () => reject(new Error("Could not start the installed restart command")));
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
 function startConsoleServer(options) {
   const environment = options.environment ?? process.env;
   const inspect = options.inspect ?? inspectInstallation;
   const launch = options.launch ?? defaultLaunch;
   const loadAnnouncement = options.announcement ?? readAnnouncement;
+  const voiceSettings = new VoiceSettingsStore(options.paths.dataDirectory);
+  let restartRequestedAt = 0;
+  const restart = new ConsoleRestart(
+    async () => {
+      restartRequestedAt = Date.now();
+      const command2 = launchCommand(options.installation, environment, "restart");
+      if (!command2) throw new Error("This installation cannot be restarted from the console");
+      await (options.restart ?? defaultRestart)(command2.command, command2.args);
+    },
+    async () => {
+      inspectCache = null;
+      const collected = await collect();
+      const latest = collected.startup[0];
+      return {
+        launcherPid: collected.inspectDocument?.runtime.launcherPid ?? null,
+        controllerPid: collected.controllerAlive ? collected.controller?.pid ?? null : null,
+        installed: collected.controllerAlive && collected.controller?.renderer.state === "installed",
+        failure: latest?.outcome === "failed" && latest.startedAtMs >= restartRequestedAt ? latest.error ?? "Desktop startup failed" : null
+      };
+    }
+  );
   let port = options.port;
   let inspectCache = null;
   let idleTimer;
@@ -18003,7 +18633,13 @@ function startConsoleServer(options) {
       launchAvailable: launchCommand(options.installation, environment) !== null,
       summary,
       issueUrl: reportIssueUrl,
-      hostAvailable: await options.host.available()
+      hostAvailable: await options.host.available(),
+      liveVoice: {
+        ...await readLiveVoiceInjectState(options.paths.dataDirectory, environment),
+        activeInject: collected.controllerAlive && typeof controller?.voiceInjection === "boolean" ? controller.voiceInjection : null,
+        activeEnvOverride: collected.controllerAlive ? controller?.voiceEnvOverride ?? null : null
+      },
+      restart: restart.status
     };
   }
   async function diagnosticReport(collected, withLogs = true) {
@@ -18036,7 +18672,7 @@ function startConsoleServer(options) {
     scheduleIdleExit();
     const url2 = new URL(request.url ?? "/", `http://127.0.0.1:${port}`);
     const method = request.method ?? "GET";
-    const route = `${method} ${url2.pathname}`;
+    let route = `${method} ${url2.pathname}`;
     if (route === "GET /api/health") {
       sendJson(response, 200, {
         service: CONSOLE_SERVICE,
@@ -18077,6 +18713,65 @@ function startConsoleServer(options) {
         return;
       }
     }
+    if (route === "POST /api/voice-settings") {
+      const parsed = voiceSettingsRequestSchema.safeParse(body);
+      if (!parsed.success) {
+        sendJson(response, 400, { error: "Invalid voice settings request" });
+        return;
+      }
+      const input = parsed.data;
+      if (input.operation === "restart") {
+        if ((await voiceSettings.read()).activeCall) {
+          sendJson(response, 409, { error: "End your voice call before restarting." });
+          return;
+        }
+        route = "POST /api/restart";
+      } else {
+        try {
+          if (input.operation === "get" && input.runtime) voiceSettings.report(input.runtime);
+          if (input.operation === "set") {
+            const current = await readLiveVoiceInjectState(
+              options.paths.dataDirectory,
+              environment
+            );
+            if (current.envOverride && input.settings.inject !== current.savedInject) {
+              sendJson(response, 409, {
+                error: "Voice integration is controlled by this launch environment."
+              });
+              return;
+            }
+          }
+          const saved = input.operation === "get" ? await voiceSettings.read() : await voiceSettings.write(input);
+          const collected = await collect();
+          const controller = collected.controller;
+          const injection = await readLiveVoiceInjectState(
+            options.paths.dataDirectory,
+            environment
+          );
+          let gatewayReady = null;
+          try {
+            const reply = input.operation === "get" && input.runtime ? null : await options.host.request(VOICE_GATEWAY_STATUS_METHOD, {});
+            if (reply && "result" in reply && typeof reply.result === "boolean")
+              gatewayReady = reply.result;
+          } catch {
+          }
+          sendJson(response, 200, {
+            ...saved,
+            activeInject: collected.controllerAlive && typeof controller?.voiceInjection === "boolean" ? controller.voiceInjection : null,
+            envOverride: injection.envOverride,
+            activeEnvOverride: collected.controllerAlive ? controller?.voiceEnvOverride ?? null : null,
+            gatewayReady,
+            restartAvailable: !!collected.inspectDocument?.runtime.running && !!launchCommand(options.installation, environment, "restart"),
+            restart: restart.status
+          });
+        } catch (error51) {
+          sendJson(response, error51 instanceof VoiceSettingsConflict ? 409 : 500, {
+            error: error51 instanceof VoiceSettingsConflict ? error51.message : "Could not save or read voice settings"
+          });
+        }
+        return;
+      }
+    }
     if (route === "POST /api/shutdown") {
       sendJson(response, 200, { ok: true });
       setImmediate(exit);
@@ -18151,6 +18846,22 @@ function startConsoleServer(options) {
       sendJson(response, 200, { harnesses: await options.harnesses.list() });
       return;
     }
+    if (route === "POST /api/harnesses/grok-computer-use") {
+      const parsed = grokComputerUseSetSchema.safeParse(body);
+      if (!parsed.success) {
+        sendJson(response, 400, { error: "Expected { enabled } or { browser }" });
+        return;
+      }
+      try {
+        const harness2 = await options.harnesses.setGrokComputerUse(parsed.data);
+        sendJson(response, 200, { harness: harness2 });
+      } catch (error51) {
+        sendJson(response, error51 instanceof ConsoleHarnessError ? error51.status : 500, {
+          error: error51 instanceof Error ? error51.message : String(error51)
+        });
+      }
+      return;
+    }
     if (route === "POST /api/harnesses/launch-path") {
       const id = body.id;
       const value = body.path;
@@ -18168,6 +18879,59 @@ function startConsoleServer(options) {
       }
       return;
     }
+    if (route === "GET /api/live-voice-inject") {
+      sendJson(
+        response,
+        200,
+        await readLiveVoiceInjectState(options.paths.dataDirectory, environment)
+      );
+      return;
+    }
+    if (route === "POST /api/live-voice-inject") {
+      if (typeof body.inject !== "boolean") {
+        sendJson(response, 400, { error: "Expected { inject: boolean }" });
+        return;
+      }
+      try {
+        await voiceSettings.setInjection(body.inject);
+      } catch (error51) {
+        sendJson(response, error51 instanceof VoiceSettingsConflict ? 409 : 500, {
+          error: error51 instanceof VoiceSettingsConflict ? error51.message : "Could not save voice integration"
+        });
+        return;
+      }
+      sendJson(
+        response,
+        200,
+        await readLiveVoiceInjectState(options.paths.dataDirectory, environment)
+      );
+      return;
+    }
+    if (route === "POST /api/restart") {
+      if (body.confirm !== true) {
+        sendJson(response, 400, {
+          error: "Confirm that restart may interrupt voice and running tasks"
+        });
+        return;
+      }
+      const current = await collect();
+      if (!current.inspectDocument?.runtime.running || !launchCommand(options.installation, environment, "restart")) {
+        sendJson(response, 409, { error: "No restartable managed Desktop is running" });
+        return;
+      }
+      if (restart.status.phase === "restarting") {
+        sendJson(response, 409, { error: "Restart is already in progress" });
+        return;
+      }
+      restart.start({
+        launcherPid: current.inspectDocument.runtime.launcherPid,
+        controllerPid: current.controller?.pid ?? null,
+        installed: current.controller?.renderer.state === "installed",
+        failure: null
+      });
+      sendJson(response, 202, restart.status);
+      return;
+    }
     if (route === "POST /api/launch") {
       const command2 = launchCommand(options.installation, environment);
       if (!command2) {
@@ -18259,7 +19023,7 @@ async function requestShutdown(port) {
   if (!response.ok) throw new Error(`console shutdown failed: HTTP ${response.status}`);
 }
 async function consoleBuildId(entryPath2, environment = process.env) {
-  const files = [entryPath2, ...consoleBundleCandidates(path16.dirname(entryPath2))];
+  const files = [entryPath2, ...consoleBundleCandidates(path20.dirname(entryPath2))];
   const parts = [];
   for (const file2 of files) {
     const metadata = await stat4(file2).catch(() => null);
@@ -18267,7 +19031,7 @@ async function consoleBuildId(entryPath2, environment = process.env) {
   }
   const runtime = await readRuntimeMetadata(entryPath2, environment).catch(() => null);
   if (runtime?.distribution === "development") parts.push(runtime.version);
-  return JSON.stringify([parts.join("."), dataDirectory(environment)]);
+  return JSON.stringify([parts.join("."), dataDirectory2(environment)]);
 }
 function startDetachedServer(entryPath2, environment) {
   const child = spawn3(process.execPath, [entryPath2, "serve"], {
@@ -18362,7 +19126,7 @@ async function updateFromCommand(appDirectory2, arguments_) {
 var IDLE_TIMEOUT_MS = 30 * 60 * 1e3;
 var HANDOFF_EXIT_DELAY_MS = 500;
 var entryPath = fileURLToPath(import.meta.url);
-var appDirectory = path17.dirname(entryPath);
+var appDirectory = path21.dirname(entryPath);
 function usage() {
   console.error(
     "usage: console-server open [--no-browser] | console-server ensure | console-server serve | console-server update"