@codexhost/cli-darwin-x64 0.3.0-test.1 → 0.3.0-test.3

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 @codexhost/cli@0.3.0-test.1
+npm install -g @codexhost/cli@0.3.0-test.3
 ```
 
 Do not install this package directly. npm selects it through the optional dependencies of `@codexhost/cli`.

package/app/codexhost-distribution.json

@@ -1 +1 @@
-{"schemaVersion":1,"version":"0.3.0-test.1","distribution":"npm","target":"macos-x64"}
+{"schemaVersion":1,"version":"0.3.0-test.3","distribution":"npm","target":"macos-x64"}

package/app/desktop-controller.mjs

@@ -560,55 +560,35 @@ async function readMainProcessTitlePolicyCounters(inspector) {
 // packages/desktop-control/src/renderer-draft-prewarm-runtime.ts
 function installDraftPrewarmPolicyBridge(bridge, hostId, target, prewarmedThreadManager) {
   const existing = target.__codexhostDraftPrewarmPolicyV1;
-  if (existing?.owns?.(bridge, hostId) === true) {
+  if (existing?.owns?.length === 3 && existing.owns(bridge, hostId, prewarmedThreadManager) === true) {
     return { state: "ready", reason: "owned-request-bridge" };
   }
   existing?.dispose?.();
   const originalSend = bridge.sendRequest;
   const originalPrewarm = bridge.prewarmThreadStart;
   let selectedModel = null;
-  let clearInFlight = null;
   const isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-  const routeCollaborationMode = (method, parameters) => {
-    if (selectedModel === null || !isRecord5(parameters)) return parameters;
-    const collaborationMode = parameters.collaborationMode;
-    const settings = isRecord5(collaborationMode) ? collaborationMode.settings : null;
-    if (!isRecord5(collaborationMode) || !isRecord5(settings)) {
-      throw new Error(`Codex ${method} omitted collaborationMode.settings`);
+  const routeThreadStart = (parameters) => {
+    if (selectedModel === null || !isRecord5(parameters) || parameters.ephemeral === true) {
+      return parameters;
     }
-    return {
-      ...parameters,
-      collaborationMode: {
-        ...collaborationMode,
-        settings: { ...settings, model: selectedModel }
-      }
-    };
-  };
-  const routeThreadStart = (method, parameters) => {
-    if (selectedModel === null || !isRecord5(parameters)) return parameters;
-    const direct = method === "thread/start";
-    const wrapped = method === "prewarm-thread-start-for-host" || method === "send-cli-request-for-host";
-    if (!direct && !wrapped) return parameters;
-    const threadParams = direct ? parameters : parameters.params;
-    if (!isRecord5(threadParams) || threadParams.ephemeral === true) return parameters;
-    if (direct) return { ...threadParams, model: selectedModel };
-    return { ...parameters, params: { ...threadParams, model: selectedModel } };
+    return { ...parameters, model: selectedModel };
   };
   const routedSend = (method, parameters, options) => {
-    const routedParameters = method === "start-conversation" || method === "prewarm-conversation-for-host" ? routeCollaborationMode(method, parameters) : routeThreadStart(method, parameters);
+    const routedParameters = method === "thread/start" ? routeThreadStart(parameters) : parameters;
     return options === void 0 ? originalSend.call(bridge, method, routedParameters) : originalSend.call(bridge, method, routedParameters, options);
   };
   const routedPrewarm = (parameters, options) => {
-    const routedParameters = routeThreadStart("thread/start", parameters);
-    return options === void 0 ? originalPrewarm?.call(bridge, routedParameters) : originalPrewarm?.call(bridge, routedParameters, options);
+    const routedParameters = routeThreadStart(parameters);
+    return options === void 0 ? originalPrewarm.call(bridge, routedParameters) : originalPrewarm.call(bridge, routedParameters, options);
   };
   bridge.sendRequest = routedSend;
-  if (originalPrewarm) bridge.prewarmThreadStart = routedPrewarm;
+  bridge.prewarmThreadStart = routedPrewarm;
   const policy = Object.freeze({
     state: "ready",
     hostId,
-    owns(candidate, candidateHostId) {
-      return candidate === bridge && candidateHostId === hostId;
+    owns(candidate, candidateHostId, candidatePrewarmedThreadManager) {
+      return candidate === bridge && candidateHostId === hostId && candidatePrewarmedThreadManager === prewarmedThreadManager;
     },
     select(model) {
       if (model !== null && (typeof model !== "string" || !model.startsWith("codexhost/"))) {
@@ -619,24 +599,13 @@ function installDraftPrewarmPolicyBridge(bridge, hostId, target, prewarmedThread
       return true;
     },
     clear() {
-      if (prewarmedThreadManager?.discardAllPrewarmedThreads) {
-        prewarmedThreadManager.discardAllPrewarmedThreads();
-        return Promise.resolve();
-      }
-      if (clearInFlight === null) {
-        clearInFlight = Promise.resolve(
-          originalSend.call(bridge, "clear-prewarmed-threads-for-host", { hostId })
-        ).then(() => void 0).finally(() => {
-          clearInFlight = null;
-        });
-      }
-      return clearInFlight;
+      prewarmedThreadManager.discardAllPrewarmedThreads();
+      return Promise.resolve();
     },
     dispose() {
       if (bridge.sendRequest === routedSend) bridge.sendRequest = originalSend;
       if (bridge.prewarmThreadStart === routedPrewarm) {
-        if (originalPrewarm) bridge.prewarmThreadStart = originalPrewarm;
-        else delete bridge.prewarmThreadStart;
+        bridge.prewarmThreadStart = originalPrewarm;
       }
       selectedModel = null;
     }
@@ -685,84 +654,13 @@ async function installDraftPrewarmPolicyInRenderer(contents, findRequestManagerE
     if (candidateCount !== 1 || typeof hostId !== "string" || hostId.length === 0 || typeof manager?.objectId !== "string") {
       throw new Error("Renderer request manager is ambiguous");
     }
-    const managerFunctions = await contents.debugger.sendCommand("Runtime.getProperties", {
-      objectId: manager.objectId
-    });
-    const managerPropertyNames = new Set(
-      managerFunctions.result?.map((property) => String(property.name)) ?? []
-    );
-    let hostBridgeObjectId = managerPropertyNames.has("sendRequest") && managerPropertyNames.has("prewarmThreadStart") && managerPropertyNames.has("enqueueRequest") ? manager.objectId : void 0;
-    if (!hostBridgeObjectId) {
-      let managerSendRequestId = managerFunctions.result?.find(
-        (property) => property.name === "sendRequest"
-      )?.value?.objectId;
-      const managerPrototypeId = managerFunctions.internalProperties?.find(
-        (property) => property.name === "[[Prototype]]"
-      )?.value?.objectId;
-      if (typeof managerSendRequestId !== "string" && typeof managerPrototypeId === "string") {
-        const prototypeFunctions = await contents.debugger.sendCommand("Runtime.getProperties", {
-          objectId: managerPrototypeId,
-          ownProperties: true
-        });
-        managerSendRequestId = prototypeFunctions.result?.find(
-          (property) => property.name === "sendRequest"
-        )?.value?.objectId;
-      }
-      if (typeof managerSendRequestId !== "string") {
-        throw new Error("Renderer request manager sendRequest is unavailable");
-      }
-      const functionProperties = await contents.debugger.sendCommand("Runtime.getProperties", {
-        objectId: managerSendRequestId
-      });
-      const scopesId = functionProperties.internalProperties?.find(
-        (property) => property.name === "[[Scopes]]"
-      )?.value?.objectId;
-      const hostBridgeCandidates = [];
-      if (typeof scopesId === "string") {
-        const scopes = await contents.debugger.sendCommand("Runtime.getProperties", {
-          objectId: scopesId,
-          ownProperties: true
-        });
-        for (const scope of scopes.result ?? []) {
-          if (typeof scope.value?.objectId !== "string") continue;
-          const scopeProperties = await contents.debugger.sendCommand("Runtime.getProperties", {
-            objectId: scope.value.objectId,
-            ownProperties: true
-          });
-          for (const property of scopeProperties.result ?? []) {
-            if (property.value?.type !== "object" || typeof property.value.objectId !== "string") {
-              continue;
-            }
-            const candidateSignature = await contents.debugger.sendCommand(
-              "Runtime.callFunctionOn",
-              {
-                objectId: property.value.objectId,
-                functionDeclaration: "function(){const send=this.sendRequest;return typeof send==='function'&&Function.prototype.toString.call(send).includes('messageHandler')}",
-                returnByValue: true
-              }
-            );
-            if (candidateSignature.result?.value === true) {
-              hostBridgeCandidates.push({
-                name: String(property.name),
-                objectId: property.value.objectId
-              });
-            }
-          }
-        }
-      }
-      const hostBridge = hostBridgeCandidates[0];
-      if (hostBridgeCandidates.length !== 1 || !hostBridge) {
-        throw new Error("Renderer Host request bridge is ambiguous");
-      }
-      hostBridgeObjectId = hostBridge.objectId;
+    if (typeof prewarmedThreadManager?.objectId !== "string") {
+      throw new Error("Renderer prewarmed Thread manager is unavailable");
     }
     const installed = await contents.debugger.sendCommand("Runtime.callFunctionOn", {
-      objectId: hostBridgeObjectId,
+      objectId: manager.objectId,
       functionDeclaration: installRendererPolicyFunction,
-      arguments: [
-        { value: hostId },
-        ...typeof prewarmedThreadManager?.objectId === "string" ? [{ objectId: prewarmedThreadManager.objectId }] : []
-      ],
+      arguments: [{ value: hostId }, { objectId: prewarmedThreadManager.objectId }],
       awaitPromise: true,
       returnByValue: true
     });
@@ -825,6 +723,7 @@ var FIND_REQUEST_MANAGER_EXPRESSION = `(() => {
         typeof value.requestClient.prewarmThreadStart === 'function' &&
         typeof value.requestClient.sendRequest === 'function' &&
         typeof value.requestClient.enqueueRequest === 'function' &&
+        typeof value.prewarmedThreadManager?.discardAllPrewarmedThreads === 'function' &&
         typeof value.sendRequest === 'function'
       ) {
         managers.add(value);

package/app/host-runtime.mjs

@@ -63915,6 +63915,20 @@ function decodeThreadForkRequest(request) {
     ...optionalField(params, "serviceTier")
   };
 }
+function decodeThreadRevertRequest(request) {
+  if (request.method !== "thread/revert")
+    return null;
+  if (!isRecord26(request.params))
+    throw new Error("thread/revert params must be an object");
+  const { threadId: threadId2, beforeTurnId } = request.params;
+  if (typeof threadId2 !== "string" || threadId2.length === 0) {
+    throw new Error("thread/revert params.threadId must be non-empty text");
+  }
+  if (typeof beforeTurnId !== "string" || beforeTurnId.length === 0) {
+    throw new Error("thread/revert params.beforeTurnId must be non-empty text");
+  }
+  return { threadId: threadId2, beforeTurnId: hostTurnIdSchema.parse(beforeTurnId) };
+}
 function decodeThreadRollbackRequest(request) {
   if (request.method !== "thread/rollback")
     return null;
@@ -63957,6 +63971,9 @@ function mapExternalThreadHarnessError(error54, operation) {
       return { code: -32076, message: `External Thread ${operation} failed` };
   }
 }
+function threadRevertResult(thread) {
+  return { thread: { ...thread, turns: [] } };
+}
 function threadRollbackResult(thread) {
   return { thread };
 }
@@ -65250,12 +65267,18 @@ async function executeCurrentLastTurnRollback(input) {
   return { ok: true, thread };
 }
 async function executeExternalThreadRollback(input) {
-  const { derived, rollback, adapters, repository, runtime } = input;
+  const { derived, rollback, adapters, repository, runtime, expectedLastTurnId } = input;
   if (derived.running) {
     return { ok: false, error: { code: -32072, message: "External Thread has an active Turn" } };
   }
   const refreshError = await runtime.refresh(derived);
   if (refreshError) return { ok: false, error: refreshError };
+  if (expectedLastTurnId !== void 0 && derived.record.turnMappings.at(-1)?.hostTurnId !== expectedLastTurnId) {
+    return {
+      ok: false,
+      error: { code: -32080, message: "External Revert boundary is unavailable" }
+    };
+  }
   if (rollback.numTurns === 1 && derived.session.capabilities.history.rollbackLastTurn) {
     return executeCurrentLastTurnRollback({
       current: derived,
@@ -66209,6 +66232,7 @@ var EXPLICIT_EXTERNAL_THREAD_METHODS = /* @__PURE__ */ new Set([
   "thread/name/set",
   "thread/read",
   "thread/resume",
+  "thread/revert",
   "thread/rollback",
   "thread/turns/list",
   "thread/unarchive",
@@ -66566,6 +66590,29 @@ var AppServerHost = class {
           continue;
         }
       }
+      if (request.method === "thread/revert") {
+        const params = isRecord31(request.params) ? request.params : {};
+        const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
+        if (resolution.kind === "error") {
+          await this.#writer.json(
+            rpcError(request, resolution.error.code, resolution.error.message)
+          );
+          continue;
+        }
+        if (resolution.kind === "external") {
+          let revert;
+          try {
+            const decoded = decodeThreadRevertRequest(request);
+            if (!decoded) throw new Error("Expected thread/revert request");
+            revert = decoded;
+          } catch (error54) {
+            await this.#writer.json(rpcError(request, -32602, errorMessage4(error54)));
+            continue;
+          }
+          await this.#revertExternalThread(request, resolution.thread, revert);
+          continue;
+        }
+      }
       if (request.method === "thread/rollback") {
         const params = isRecord31(request.params) ? request.params : {};
         const resolution = typeof params.threadId === "string" ? await this.#resolveExternalThread(params.threadId) : { kind: "official" };
@@ -67527,6 +67574,28 @@ var AppServerHost = class {
       params: { thread: { ...thread, turns: [] } }
     });
   }
+  async #revertExternalThread(request, thread, revert) {
+    if (thread.record.historyMode !== "paginated") {
+      await this.#writer.json(
+        rpcError(request, -32602, "External thread/revert requires paginated history")
+      );
+      return;
+    }
+    const result = await executeExternalThreadRollback({
+      derived: thread,
+      rollback: { threadId: revert.threadId, numTurns: 1 },
+      expectedLastTurnId: revert.beforeTurnId,
+      adapters: this.#externalAdapters,
+      repository: this.#repository,
+      runtime: this.#externalRuntime
+    });
+    if (!result.ok) {
+      await this.#writer.json(rpcError(request, result.error.code, result.error.message));
+      return;
+    }
+    await this.#writer.json(rpcEnvelope(request, { result: threadRevertResult(result.thread) }));
+    await this.#writer.json({ method: "thread/reverted", params: { threadId: thread.id } });
+  }
   async #rollbackExternalThread(request, derived, rollback) {
     const result = await executeExternalThreadRollback({
       derived,
@@ -69282,10 +69351,14 @@ function installManagedProfileBlock(contents, manifest) {
     "export CODEXHOST_REMOTE_SSH_MANAGED='1'",
     ...manifest.claudeCommand ? [`export CODEXHOST_CLAUDE_COMMAND=${shellQuote(manifest.claudeCommand)}`] : []
   ];
-  const block = `${PROFILE_START}
-${environment.join("\n")}
-${PROFILE_END}
-`;
+  const block = [
+    PROFILE_START,
+    'if [ -n "${SSH_CONNECTION:-}" ] || [ -n "${SSH_CLIENT:-}" ]; then',
+    ...environment.map((entry) => `  ${entry}`),
+    "fi",
+    PROFILE_END,
+    ""
+  ].join("\n");
   if (path24.basename(manifest.profilePath) === ".bashrc") return `${block}${base}`;
   const separator = base.length > 0 && !base.endsWith("\n") ? "\n" : "";
   return `${base}${separator}${block}`;