@karlorz/codexhost-cli-win32-x64 0.13.3-6 → 0.14.0-0

package/app/console-server.mjs

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // packages/console-server/src/main.ts
-import path19 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, path20) {
-  if (!path20)
+function getElementAtPath(obj, path22) {
+  if (!path22)
     return obj;
-  return path20.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(path20, issues) {
+function prefixIssues(path22, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path20);
+    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, path20 = []) => {
+  const processError = (error52, path22 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path20, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path20, ...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, path20 = []) => {
+  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 }, [...path20, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path22, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path22, ...issue2.path]);
       } else {
-        const fullpath = [...path20, ...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 path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path20) {
+  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 path20 = ref.slice(1).split("/").filter(Boolean);
-  if (path20.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 (path20[0] === defsKey) {
-    const key = path20[1];
+  if (path22[0] === defsKey) {
+    const key = path22[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -15548,10 +15548,19 @@ var model = external_exports.string().min(1).max(512);
 var project = external_exports.string().min(1).max(4096);
 var usageStatisticsParamsSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
+  /** Display timezone for ranges, dates and hourly buckets; omitted means the Host's local zone. */
+  timeZone: external_exports.string().min(1).max(128).refine((value) => {
+    try {
+      new Intl.DateTimeFormat("en", { timeZone: value });
+      return true;
+    } catch {
+      return false;
+    }
+  }, "Unsupported usage statistics timezone").optional(),
   harness: harness.optional(),
   model: model.nullable().optional(),
   project: project.nullable().optional(),
-  /** One local date inside the range. */
+  /** One date in the query timezone inside the range. */
   date: localDate.optional()
 });
 var usageStatisticsTotalsSchema = external_exports.strictObject({
@@ -15587,7 +15596,7 @@ var usageStatisticsSessionSchema = external_exports.strictObject({
 });
 var usageStatisticsResultSchema = external_exports.strictObject({
   range: external_exports.enum(USAGE_STATISTICS_RANGES),
-  /** First local date of the range; null for all time. */
+  /** First date in the query timezone (Host local when omitted); null for all time. */
   from: localDate.nullable(),
   to: localDate,
   /** The filters these figures apply, echoed so a late answer to older filters is recognised. */
@@ -15627,7 +15636,7 @@ var usageStatisticsResultSchema = external_exports.strictObject({
   totals: usageStatisticsTotalsSchema,
   /** Each date and Harness of the range: every filter except the day. */
   daily: external_exports.array(external_exports.strictObject({ date: localDate, harness, ...totals })).max(2e5),
-  /** Local weekday (0 = Sunday) and hour, all filters applied. */
+  /** Weekday (0 = Sunday) and hour in the query timezone, all filters applied. */
   hourly: external_exports.array(external_exports.strictObject({
     weekday: external_exports.number().int().min(0).max(6),
     hour: external_exports.number().int().min(0).max(23),
@@ -15718,8 +15727,12 @@ var CONSOLE_HOST_METHODS = Object.freeze([
   "codexhost/harness/display-settings/set",
   "codexhost/harness/inspect",
   "codexhost/harness/installation",
+  "codexhost/harness/installation/start",
+  "codexhost/harness/installation/status",
   "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",
@@ -15796,7 +15809,18 @@ var threadManualCompactionStartedSchema = external_exports.strictObject({
 var nonNegativeSafeIntegerSchema = external_exports.number().int().safe().nonnegative();
 var finiteNonNegativeNumberSchema = external_exports.number().finite().nonnegative();
 var cacheHitRatePercentSchema = external_exports.number().finite().min(0).max(100);
+var indicatorTextSchema = (maximum) => harnessLocalizedTextSchema.refine((entries) => Object.values(entries).every((text) => text.length <= maximum));
+var composerIndicatorsSchema = external_exports.array(external_exports.object({
+  kind: external_exports.literal("countdown"),
+  id: external_exports.string().min(1).max(64),
+  expiresAtUnix: nonNegativeSafeIntegerSchema,
+  label: indicatorTextSchema(256).optional(),
+  tooltip: indicatorTextSchema(1024).optional()
+}).strict()).max(2).refine((entries) => new Set(entries.map(({ id }) => id)).size === entries.length, {
+  message: "Composer indicator IDs must be unique"
+});
 var threadUsageSnapshotSchema = external_exports.object({
+  composerIndicators: composerIndicatorsSchema.optional(),
   inputTokens: nonNegativeSafeIntegerSchema.optional(),
   cachedInputTokens: nonNegativeSafeIntegerSchema.optional(),
   cacheWriteInputTokens: nonNegativeSafeIntegerSchema.optional(),
@@ -16204,7 +16228,9 @@ var harnessSessionCapabilitiesSchema = external_exports.object({
   }).strict().optional(),
   autonomousTurns: external_exports.object({
     observe: external_exports.boolean()
-  }).strict().optional()
+  }).strict().optional(),
+  /** True only when `turn.steer` delivers input into the active Turn through a native primitive. */
+  steer: external_exports.boolean().optional()
 }).strict();
 var harnessConfigurationStateSchema = external_exports.object({
   effectiveModel: harnessModelRefSchema.optional(),
@@ -16251,7 +16277,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
@@ -16334,6 +16362,15 @@ var threadOwnershipListResultSchema = external_exports.object({
     seen.add(thread.threadId);
   }
 });
+var threadSteeringInspectParamsSchema = external_exports.object({
+  threadId: hostThreadIdSchema,
+  /** The text about to be steered; a Harness command always stops and restarts. */
+  text: external_exports.string().optional()
+}).strict();
+var threadSteerDeliverySchema = external_exports.enum(["activeTurn", "newTurn"]);
+var threadSteeringInspectResultSchema = external_exports.object({
+  delivery: external_exports.enum(["official", "activeTurn", "newTurn"])
+}).strict();
 
 // packages/shared-contracts/dist/harness-plugins.js
 var HARNESS_PLUGIN_MANIFEST_MAX_BYTES = 32 * 1024;
@@ -16425,6 +16462,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,
@@ -16435,6 +16492,10 @@ var harnessInstallationStateSchema = external_exports.object({
   latestVersion: external_exports.string().min(1).max(128),
   updateAvailable: external_exports.boolean(),
   canUpdate: external_exports.boolean(),
+  /** Defaults to CLI; some Harnesses ship only inside a desktop application. */
+  versionKind: external_exports.enum(["cli", "application"]).optional(),
+  /** Official download opened by the user; does not imply an automatic installation. */
+  manualUpdateUrl: external_exports.url().max(2048).refine((value) => /^https:\/\/[^/?#@]+(?:[/?#]|$)/iu.test(value), "Manual updates require a credential-free HTTPS URL").optional(),
   // Adapter-owned diagnostic text; UI uses messageCode rather than displaying it verbatim.
   message: external_exports.string().max(2048).optional(),
   messageCode: external_exports.string().min(1).max(128).optional(),
@@ -16442,6 +16503,20 @@ var harnessInstallationStateSchema = external_exports.object({
   notice: harnessLocalizedTextSchema.optional(),
   latestVersionKind: external_exports.enum(["unknown", "tracking-branch"]).optional()
 }).strict();
+var harnessInstallationTaskParamsSchema = external_exports.object({ taskId: external_exports.string().uuid() }).strict();
+var harnessInstallationTaskSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ taskId: external_exports.string().uuid(), status: external_exports.literal("running") }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("succeeded"),
+    result: harnessInstallationStateSchema
+  }).strict(),
+  external_exports.object({
+    taskId: external_exports.string().uuid(),
+    status: external_exports.literal("failed"),
+    error: external_exports.object({ code: external_exports.number().int(), message: external_exports.string().min(1).max(2048) }).strict()
+  }).strict()
+]);
 
 // packages/shared-contracts/dist/codex-accounts.js
 var accountIdSchema = external_exports.string().min(1).max(256).regex(/^[A-Za-z0-9._~-]+$/u);
@@ -17057,23 +17132,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) {
@@ -17089,10 +17506,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 {
@@ -17126,7 +17543,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(
@@ -17147,17 +17565,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;
@@ -17165,7 +17593,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;
   }
@@ -17238,7 +17666,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;
@@ -17252,7 +17680,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;
   }
@@ -17333,14 +17761,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;
     }
@@ -17378,12 +17806,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;
@@ -17391,17 +17819,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) {
@@ -17443,7 +17871,7 @@ 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)) {
+    if (node && wrapper && path15.isAbsolute(node) && path15.isAbsolute(wrapper)) {
       return { command: node, args: [wrapper, ...action === "restart" ? [action] : []] };
     }
     return null;
@@ -17454,11 +17882,11 @@ function launchCommand(installation, environment = process.env, action = "launch
 // packages/console-server/src/open.ts
 import { spawn as spawn3 } from "node:child_process";
 import { stat as stat4 } from "node:fs/promises";
-import path18 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>
@@ -17479,14 +17907,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;
     }
@@ -17610,14 +18038,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;
@@ -17633,7 +18061,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,
@@ -17709,7 +18137,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) {
@@ -17742,13 +18170,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;
@@ -17789,13 +18217,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"
@@ -17830,13 +18258,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 = {
@@ -17887,7 +18315,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) {
@@ -17956,20 +18384,20 @@ function createConsoleUpdates(options) {
 }
 
 // packages/console-server/src/live-voice-inject.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdir as mkdir4, readFile as readFile9, rename as rename3, rm as rm5, writeFile as writeFile4 } from "node:fs/promises";
-import path16 from "node:path";
+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(dataDirectory2) {
-  return path16.join(dataDirectory2, LIVE_VOICE_INJECT_FILE);
+function injectPath(dataDirectory3) {
+  return path18.join(dataDirectory3, LIVE_VOICE_INJECT_FILE);
 }
-async function readLiveVoiceInjectState(dataDirectory2, environment = process.env) {
+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 readFile9(injectPath(dataDirectory2), "utf8"));
+    const parsed = JSON.parse(await readFile10(injectPath(dataDirectory3), "utf8"));
     inject = parsed.version !== 1 || parsed.inject !== false;
   } catch {
     inject = true;
@@ -17979,18 +18407,18 @@ async function readLiveVoiceInjectState(dataDirectory2, environment = process.en
   if (envOverride === "1") inject = true;
   return { inject, savedInject, envOverride };
 }
-async function writeLiveVoiceInjectFile(dataDirectory2, inject, routes) {
+async function writeLiveVoiceInjectFile(dataDirectory3, inject, routes) {
   if (!routes) {
     try {
-      const saved = JSON.parse(await readFile9(injectPath(dataDirectory2), "utf8"));
+      const saved = JSON.parse(await readFile10(injectPath(dataDirectory3), "utf8"));
       if (saved?.version === 1) routes = voiceRoutesSchema.safeParse(saved.routes).data;
     } catch {
     }
   }
-  await mkdir4(dataDirectory2, { recursive: true, mode: 448 });
-  const temporaryPath = path16.join(dataDirectory2, `.${LIVE_VOICE_INJECT_FILE}.${randomUUID3()}.tmp`);
+  await mkdir6(dataDirectory3, { recursive: true, mode: 448 });
+  const temporaryPath = path18.join(dataDirectory3, `.${LIVE_VOICE_INJECT_FILE}.${randomUUID4()}.tmp`);
   try {
-    await writeFile4(
+    await writeFile5(
       temporaryPath,
       `${JSON.stringify({ version: 1, inject, ...routes ? { routes } : {} }, null, 2)}
 `,
@@ -17999,16 +18427,16 @@ async function writeLiveVoiceInjectFile(dataDirectory2, inject, routes) {
         flag: "wx"
       }
     );
-    await rename3(temporaryPath, injectPath(dataDirectory2));
+    await rename4(temporaryPath, injectPath(dataDirectory3));
   } finally {
-    await rm5(temporaryPath, { force: true });
+    await rm7(temporaryPath, { force: true });
   }
 }
 
 // packages/console-server/src/voice-settings.ts
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile10 } from "node:fs/promises";
-import path17 from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import path19 from "node:path";
 var VoiceSettingsConflict = class extends Error {
 };
 var VoiceSettingsStore = class {
@@ -18022,7 +18450,7 @@ var VoiceSettingsStore = class {
     let document = null;
     try {
       document = JSON.parse(
-        await readFile10(path17.join(this.directory, LIVE_VOICE_INJECT_FILE), "utf8")
+        await readFile11(path19.join(this.directory, LIVE_VOICE_INJECT_FILE), "utf8")
       );
     } catch (error51) {
       if (!(error51 instanceof SyntaxError) && error51.code !== "ENOENT")
@@ -18469,6 +18897,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;
@@ -18630,7 +19074,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(path18.dirname(entryPath2))];
+  const files = [entryPath2, ...consoleBundleCandidates(path20.dirname(entryPath2))];
   const parts = [];
   for (const file2 of files) {
     const metadata = await stat4(file2).catch(() => null);
@@ -18638,7 +19082,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"], {
@@ -18733,7 +19177,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 = path19.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"