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

package/README.md

@@ -7,7 +7,7 @@ Run Pi and Claude Code as first-class external harnesses inside Codex Desktop.
 ## Install
 
 ```bash
-npm install -g @karlorz/codexhost-cli@0.13.3-5
+npm install -g @karlorz/codexhost-cli@0.13.3-6
 ```
 
 Do not install this package directly. npm selects it through the optional dependencies of `@karlorz/codexhost-cli`.

package/app/codexhost-distribution.json

@@ -1 +1 @@
-{"schemaVersion":1,"version":"0.13.3-5","distribution":"npm","target":"windows-arm64"}
+{"schemaVersion":1,"version":"0.13.3-6","distribution":"npm","target":"windows-arm64"}

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 path19 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/update-manager/dist/runtime-metadata.js
@@ -1663,10 +1663,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path20) {
+  if (!path20)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path20.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(path20, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path20);
     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, path20 = []) => {
     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 }, [...path20, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path20, ...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, path20 = []) => {
     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 }, [...path20, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path18, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path20, ...issue2.path]);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path20, ...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 path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path20) {
     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 path20 = ref.slice(1).split("/").filter(Boolean);
+  if (path20.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path20[0] === defsKey) {
+    const key = path20[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",
@@ -16816,6 +16817,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);
 
@@ -17164,6 +17212,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,
@@ -17311,7 +17361,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);
@@ -17389,22 +17439,22 @@ 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] };
+      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 path18 from "node:path";
 
 // packages/console-server/src/page.ts
 import { readFile as readFile8 } from "node:fs/promises";
@@ -17454,6 +17504,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";
@@ -17862,6 +17955,135 @@ 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";
+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);
+}
+async function readLiveVoiceInjectState(dataDirectory2, 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"));
+    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(dataDirectory2, inject, routes) {
+  if (!routes) {
+    try {
+      const saved = JSON.parse(await readFile9(injectPath(dataDirectory2), "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`);
+  try {
+    await writeFile4(
+      temporaryPath,
+      `${JSON.stringify({ version: 1, inject, ...routes ? { routes } : {} }, null, 2)}
+`,
+      {
+        mode: 384,
+        flag: "wx"
+      }
+    );
+    await rename3(temporaryPath, injectPath(dataDirectory2));
+  } finally {
+    await rm5(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";
+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 readFile10(path17.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 +18139,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 +18256,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 +18295,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 +18336,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);
@@ -18168,6 +18486,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 +18630,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(path18.dirname(entryPath2))];
   const parts = [];
   for (const file2 of files) {
     const metadata = await stat4(file2).catch(() => null);
@@ -18362,7 +18733,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 = path19.dirname(entryPath);
 function usage() {
   console.error(
     "usage: console-server open [--no-browser] | console-server ensure | console-server serve | console-server update"