@codexhost/cli-linux-arm64 0.10.1 → 0.11.0

package/app/desktop-controller.mjs

@@ -1,6 +1,6 @@
 // packages/desktop-control/src/production-controller.ts
 import { readFile } from "node:fs/promises";
-import path from "node:path";
+import path2 from "node:path";
 
 // packages/desktop-control/src/controller-attachment-server.ts
 import { createServer } from "node:net";
@@ -87,7 +87,106 @@ async function startControllerAttachmentServer(options) {
   };
 }
 
+// packages/desktop-control/src/controller-status.ts
+import { randomBytes } from "node:crypto";
+import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+var DESKTOP_CONTROLLER_STATUS_FILE = "desktop-controller-v1.json";
+var ERROR_MAX_LENGTH = 1e3;
+function defaultControllerStatusPath(environment = process.env) {
+  const dataDirectory = environment.CODEXHOST_DATA_DIR ? path.resolve(environment.CODEXHOST_DATA_DIR) : path.join(os.homedir(), ".codexhost");
+  return path.join(dataDirectory, "diagnostics", DESKTOP_CONTROLLER_STATUS_FILE);
+}
+function errorMessage(error) {
+  const parts = [];
+  let current = error;
+  for (let depth = 0; depth < 4 && current !== void 0; depth += 1) {
+    parts.push(current instanceof Error ? current.message : String(current));
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  return parts.join(": ").slice(0, ERROR_MAX_LENGTH) || "Renderer installation failed";
+}
+function createRendererStatusReporter(publish, now = Date.now, pid = process.pid) {
+  const startedAt = now();
+  let current;
+  const update = (next) => {
+    if (current && current.state === next.state && current.error === next.error && current.failures === next.failures) {
+      return;
+    }
+    current = { ...next, updatedAt: now() };
+    publish({ schemaVersion: 1, pid, startedAt, renderer: current });
+  };
+  return {
+    installing() {
+      update({
+        state: "installing",
+        error: current?.error ?? null,
+        failures: current?.failures ?? 0,
+        lastError: current?.lastError ?? null,
+        lastFailedAt: current?.lastFailedAt ?? null,
+        lastInstalledAt: current?.lastInstalledAt ?? null
+      });
+    },
+    installed() {
+      if (current?.state === "installed") return;
+      update({
+        state: "installed",
+        error: null,
+        failures: current?.failures ?? 0,
+        lastError: current?.lastError ?? null,
+        lastFailedAt: current?.lastFailedAt ?? null,
+        lastInstalledAt: now()
+      });
+    },
+    failed(error) {
+      const message = errorMessage(error);
+      update({
+        state: "unavailable",
+        error: message,
+        failures: (current?.failures ?? 0) + 1,
+        lastError: message,
+        lastFailedAt: now(),
+        lastInstalledAt: current?.lastInstalledAt ?? null
+      });
+    }
+  };
+}
+async function writeControllerStatusFile(filePath, document) {
+  const directory = path.dirname(filePath);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const temporaryPath = path.join(
+    directory,
+    `.${path.basename(filePath)}.${randomBytes(6).toString("hex")}.tmp`
+  );
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(document)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true });
+    throw error;
+  }
+}
+function createControllerStatusPublisher(filePath = defaultControllerStatusPath()) {
+  let queue = Promise.resolve();
+  return (document) => {
+    queue = queue.then(() => writeControllerStatusFile(filePath, document)).catch(() => void 0);
+  };
+}
+
 // packages/desktop-control/src/cdp-client.ts
+function cdpExceptionMessage(details, fallback) {
+  const exception = details.exception;
+  if (isRecord(exception) && typeof exception.description === "string" && exception.description) {
+    return exception.description;
+  }
+  return typeof details.text === "string" && details.text ? details.text : fallback;
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -244,8 +343,7 @@ var CdpClient = class _CdpClient {
     });
     if (!isRecord(response)) throw new Error("Runtime.evaluate returned an invalid result");
     if (isRecord(response.exceptionDetails)) {
-      const text = typeof response.exceptionDetails.text === "string" ? response.exceptionDetails.text : "Renderer evaluation failed";
-      throw new Error(text);
+      throw new Error(cdpExceptionMessage(response.exceptionDetails, "Renderer evaluation failed"));
     }
     if (!isRecord(response.result) || !("value" in response.result)) {
       throw new Error("Runtime.evaluate did not return a value");
@@ -298,14 +396,25 @@ var CdpClient = class _CdpClient {
 
 // packages/desktop-control/src/renderer-react-ownership.ts
 function committedReactAncestors(value) {
-  const MAX_VISITED_FIBERS = 2e4;
+  const MAX_VISITED_FIBERS = 2e5;
   const fiber = (value2) => typeof value2 === "object" && value2 !== null ? value2 : null;
+  const exhausted = () => {
+    const target = globalThis;
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function")
+      target.dispatchEvent(
+        new CustomEvent("codexhost:react-fiber-walk-limit", {
+          detail: { limit: MAX_VISITED_FIBERS }
+        })
+      );
+    return [];
+  };
   const first = fiber(value);
   if (!first) return [];
   const previous = [];
   const seen = /* @__PURE__ */ new Set();
   for (let node = first; node; node = fiber(node.return)) {
-    if (seen.has(node) || seen.size >= MAX_VISITED_FIBERS) return [];
+    if (seen.has(node)) return [];
+    if (seen.size >= MAX_VISITED_FIBERS) return exhausted();
     seen.add(node);
     previous.push(node);
   }
@@ -313,8 +422,30 @@ function committedReactAncestors(value) {
   if (!rootState || !("current" in rootState)) return previous;
   const current = fiber(rootState.current);
   if (!current) return [];
-  const stack = [{ node: current, parent: null }];
   const alternate = fiber(first.alternate);
+  const path3 = [current];
+  seen.clear();
+  seen.add(current);
+  for (let index = previous.length - 2; index >= 0; index -= 1) {
+    const expected = previous[index];
+    const expectedAlternate = fiber(expected?.alternate);
+    let child = fiber(path3.at(-1)?.child);
+    let matched = false;
+    while (child && !seen.has(child) && seen.size < MAX_VISITED_FIBERS) {
+      seen.add(child);
+      if (child === expected || child === expectedAlternate) {
+        matched = true;
+        break;
+      }
+      child = fiber(child.sibling);
+    }
+    if (!matched || !child) break;
+    path3.push(child);
+  }
+  if (path3.length === previous.length && (path3.at(-1) === first || path3.at(-1) === alternate)) {
+    return path3.reverse();
+  }
+  const stack = [{ node: current, parent: null }];
   seen.clear();
   while (stack.length > 0 && seen.size < MAX_VISITED_FIBERS) {
     const entry = stack.pop();
@@ -332,7 +463,7 @@ function committedReactAncestors(value) {
     const child = fiber(entry.node.child);
     if (child) stack.push({ node: child, parent: entry });
   }
-  return [];
+  return stack.length > 0 ? exhausted() : [];
 }
 
 // packages/desktop-control/src/renderer-host-response-ownership.ts
@@ -1253,8 +1384,9 @@ async function evaluateSource(renderer, source) {
   });
   if (!isRecord2(response)) throw new Error("Renderer source evaluation returned an invalid result");
   if (isRecord2(response.exceptionDetails)) {
-    const text = typeof response.exceptionDetails.text === "string" ? response.exceptionDetails.text : "Renderer source evaluation failed";
-    throw new Error(text);
+    throw new Error(
+      cdpExceptionMessage(response.exceptionDetails, "Renderer source evaluation failed")
+    );
   }
 }
 async function readBinding(renderer) {
@@ -1454,6 +1586,7 @@ var defaultDependencies = {
     process.stdout.write(`${serializeDesktopControllerReadiness(readiness)}
 `);
   },
+  publishStatus: createControllerStatusPublisher(),
   sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
   monitorIntervalMs: 500
 };
@@ -1485,8 +1618,8 @@ function parseDesktopControllerArguments(arguments_) {
     if (argument === "--renderer") {
       if (rendererPath !== void 0) throw new Error("--renderer may only be provided once");
       if (!value) throw new Error("--renderer requires a value");
-      if (!path.isAbsolute(value)) throw new Error("--renderer must be an absolute path");
-      rendererPath = path.normalize(value);
+      if (!path2.isAbsolute(value)) throw new Error("--renderer must be an absolute path");
+      rendererPath = path2.normalize(value);
       index += 1;
       continue;
     }
@@ -1568,15 +1701,22 @@ async function runDesktopController(options, signal, dependencies = defaultDepen
   let session;
   let nextRecoveryAt = 0;
   let recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
-  const recordRecoveryFailure = () => {
+  const status = createRendererStatusReporter(
+    (document) => dependencies.publishStatus?.(document),
+    now
+  );
+  const recordRecoveryFailure = (error) => {
     nextRecoveryAt = now() + recoveryDelayMs;
     recoveryDelayMs = Math.min(recoveryDelayMs * 2, RECOVERY_RETRY_MAX_MS);
+    status.failed(error);
   };
   const recordRecoverySuccess = () => {
     nextRecoveryAt = 0;
     recoveryDelayMs = RECOVERY_RETRY_INITIAL_MS;
+    status.installed();
   };
   const createSession = async () => {
+    status.installing();
     startupTrace("reading Renderer bundle");
     const rendererSource = await dependencies.readRenderer(options.rendererPath);
     if (rendererSource.trim().length === 0) throw new Error("production Renderer Bundle is empty");
@@ -1619,7 +1759,7 @@ ${rendererSource}`,
   } catch (error) {
     startupTrace("initial Renderer Session unavailable", error);
     session = void 0;
-    recordRecoveryFailure();
+    recordRecoveryFailure(error);
   }
   let operation = Promise.resolve(void 0);
   const useSession = (callback) => {
@@ -1646,7 +1786,7 @@ ${rendererSource}`,
       return current;
     } catch (error) {
       resetSession();
-      recordRecoveryFailure();
+      recordRecoveryFailure(error);
       throw error;
     }
   };