@makerbi/remodex 2.4.0 → 2.5.6

package/src/macos-launch-agent.js

@@ -1,7 +1,7 @@
 // FILE: macos-launch-agent.js
-// Purpose: Owns macOS-only launchd install/start/stop/status helpers for the background Remodex bridge.
+// Purpose: Owns macOS-only launchd install/start/stop/uninstall/status helpers for the background Remodex bridge.
 // Layer: CLI helper
-// Exports: start/stop/status helpers plus the launchd service runner used by `remodex up`.
+// Exports: start/stop/uninstall/status helpers plus the launchd service runner used by `remodex up`.
 // Depends on: child_process, fs, os, path, ./bridge, ./daemon-state, ./codex-desktop-refresher, ./qr, ./secure-device-state
 
 const { execFileSync } = require("child_process");
@@ -33,6 +33,23 @@ const SERVICE_LABEL = "com.remodex.bridge";
 const DEFAULT_PAIRING_WAIT_TIMEOUT_MS = 10_000;
 const DEFAULT_PAIRING_WAIT_INTERVAL_MS = 200;
 
+// If the saved Node binary or CLI entrypoint disappears (npm uninstall, deleted
+// checkout), exit 0 so launchd's KeepAlive.SuccessfulExit=false stops rescheduling
+// the job; `exec` keeps genuine daemon failures non-zero so they still restart.
+const LAUNCH_AGENT_GUARD_SCRIPT = 'if [ ! -x "$1" ] || [ ! -f "$2" ]; then exit 0; fi; exec "$1" "$2" run-service';
+
+// Keeps the guard script constant: the installed paths are shell positionals, never interpolated source.
+function buildLaunchAgentProgramArguments({ nodePath, cliPath }) {
+  return [
+    "/bin/sh",
+    "-c",
+    LAUNCH_AGENT_GUARD_SCRIPT,
+    SERVICE_LABEL,
+    nodePath,
+    cliPath,
+  ];
+}
+
 // Runs the bridge inside launchd while keeping QR rendering in the foreground CLI command.
 function runMacOSBridgeService({ env = process.env, platform = process.platform } = {}) {
   assertDarwinPlatform(platform);
@@ -123,17 +140,19 @@ async function startMacOSBridgeService({
   };
 }
 
-// Restarts the installed LaunchAgent without rewriting relay config, useful during local bridge development.
+// Restarts the installed LaunchAgent without rewriting relay config, regenerating the plist so
+// legacy launch definitions pick up the current Node/CLI paths and launch policy.
 async function restartMacOSBridgeService({
   env = process.env,
   platform = process.platform,
   fsImpl = fs,
   execFileSyncImpl = execFileSync,
   osImpl = os,
+  nodePath = process.execPath,
+  cliPath = path.resolve(__dirname, "..", "bin", "remodex.js"),
   waitForPairing = false,
   pairingTimeoutMs = DEFAULT_PAIRING_WAIT_TIMEOUT_MS,
   pairingPollIntervalMs = DEFAULT_PAIRING_WAIT_INTERVAL_MS,
-  ...startOptions
 } = {}) {
   assertDarwinPlatform(platform);
   const plistPath = resolveLaunchAgentPlistPath({ env, osImpl });
@@ -144,10 +163,11 @@ async function restartMacOSBridgeService({
       fsImpl,
       execFileSyncImpl,
       osImpl,
+      nodePath,
+      cliPath,
       waitForPairing,
       pairingTimeoutMs,
       pairingPollIntervalMs,
-      ...startOptions,
     });
   }
 
@@ -156,7 +176,16 @@ async function restartMacOSBridgeService({
     clearPairingSession({ env, fsImpl });
   }
 
-  kickstartLaunchAgent({
+  ensureRemodexStateDir({ env, fsImpl, osImpl });
+  ensureRemodexLogsDir({ env, fsImpl, osImpl });
+  writeLaunchAgentPlist({
+    env,
+    fsImpl,
+    osImpl,
+    nodePath,
+    cliPath,
+  });
+  restartLaunchAgent({
     env,
     execFileSyncImpl,
     plistPath,
@@ -204,6 +233,31 @@ function stopMacOSBridgeService({
   clearBridgeStatus({ env, fsImpl });
 }
 
+// Removes launchd ownership of the bridge (unload + plist) while preserving daemon config,
+// logs, device trust, and pairing identity for a future reinstall.
+function uninstallMacOSBridgeService({
+  env = process.env,
+  platform = process.platform,
+  execFileSyncImpl = execFileSync,
+  fsImpl = fs,
+  osImpl = os,
+  processImpl = process,
+} = {}) {
+  assertDarwinPlatform(platform);
+  const plistPath = resolveLaunchAgentPlistPath({ env, osImpl });
+  const removed = fsImpl.existsSync(plistPath);
+  // Stop first: a real bootout failure throws here and leaves the plist on disk.
+  stopMacOSBridgeService({
+    env,
+    platform,
+    execFileSyncImpl,
+    fsImpl,
+    processImpl,
+  });
+  fsImpl.rmSync(plistPath, { force: true });
+  return { plistPath, removed };
+}
+
 // Revokes pairing immediately on macOS by stopping the daemon before rotating identity/trust state.
 function resetMacOSBridgePairing({
   env = process.env,
@@ -374,9 +428,9 @@ function buildLaunchAgentPlist({
   <string>${escapeXml(SERVICE_LABEL)}</string>
   <key>ProgramArguments</key>
   <array>
-    <string>${escapeXml(nodePath)}</string>
-    <string>${escapeXml(cliPath)}</string>
-    <string>run-service</string>
+${buildLaunchAgentProgramArguments({ nodePath, cliPath })
+    .map((argument) => `    <string>${escapeXml(argument)}</string>`)
+    .join("\n")}
   </array>
   <key>RunAtLoad</key>
   <true/>
@@ -455,31 +509,6 @@ function restartLaunchAgent({
   ], { stdio: ["ignore", "ignore", "pipe"] });
 }
 
-function kickstartLaunchAgent({
-  env = process.env,
-  execFileSyncImpl = execFileSync,
-  plistPath,
-} = {}) {
-  try {
-    execFileSyncImpl("launchctl", [
-      "kickstart",
-      "-k",
-      launchAgentLabelDomain(env),
-    ], { stdio: ["ignore", "ignore", "pipe"] });
-  } catch {
-    execFileSyncImpl("launchctl", [
-      "bootstrap",
-      launchAgentDomain(env),
-      plistPath,
-    ], { stdio: ["ignore", "ignore", "pipe"] });
-    execFileSyncImpl("launchctl", [
-      "kickstart",
-      "-k",
-      launchAgentLabelDomain(env),
-    ], { stdio: ["ignore", "ignore", "pipe"] });
-  }
-}
-
 function bootoutLaunchAgent({
   env = process.env,
   execFileSyncImpl = execFileSync,
@@ -675,6 +704,7 @@ function shortFingerprint(value) {
 module.exports = {
   buildTrustedDeviceSummary,
   buildLaunchAgentPlist,
+  buildLaunchAgentProgramArguments,
   getMacOSBridgeServiceStatus,
   mergeBridgeStatusForDaemon,
   printMacOSBridgePairingQr,
@@ -685,4 +715,5 @@ module.exports = {
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
+  uninstallMacOSBridgeService,
 };

package/src/rollout-live-mirror.js

@@ -13,6 +13,10 @@ const {
 } = require("./rollout-watch");
 const { resolveCodexGeneratedImagesRoot } = require("./codex-home");
 const { buildApplyPatchFileChangeItem } = require("./apply-patch-changes");
+const {
+  expandExecWrapperToolCall,
+  isOrchestrationWaitCall,
+} = require("./codex-tool-wrapper");
 const {
   TERMINAL_TASK_EVENT_TYPES,
   terminalEventClosesTrackedTurn,
@@ -56,6 +60,8 @@ function createRolloutLiveMirrorController({
   now = () => Date.now(),
   setIntervalFn = setInterval,
   clearIntervalFn = clearInterval,
+  setImmediateFn = setImmediate,
+  clearImmediateFn = clearImmediate,
   pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
   lookupTimeoutMs = DEFAULT_LOOKUP_TIMEOUT_MS,
   idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS,
@@ -110,6 +116,8 @@ function createRolloutLiveMirrorController({
       now,
       setIntervalFn,
       clearIntervalFn,
+      setImmediateFn,
+      clearImmediateFn,
       pollIntervalMs,
       lookupTimeoutMs,
       idleTimeoutMs,
@@ -157,6 +165,8 @@ function createThreadRolloutLiveMirror({
   now,
   setIntervalFn,
   clearIntervalFn,
+  setImmediateFn,
+  clearImmediateFn,
   pollIntervalMs,
   lookupTimeoutMs,
   idleTimeoutMs,
@@ -166,6 +176,7 @@ function createThreadRolloutLiveMirror({
   onStop = () => {},
 }) {
   const startedAt = now();
+  let lookupStartedAt = startedAt;
   const state = createMirrorState(threadId);
 
   let isStopped = false;
@@ -182,7 +193,10 @@ function createThreadRolloutLiveMirror({
   let wasSuppressed = false;
 
   const intervalId = setIntervalFn(tick, pollIntervalMs);
-  tick();
+  let initialTickId = setImmediateFn(() => {
+    initialTickId = null;
+    tick();
+  });
 
   function tick() {
     if (isStopped) {
@@ -191,9 +205,30 @@ function createThreadRolloutLiveMirror({
 
     try {
       const currentTime = now();
+      const suppressedBeforeScan = isSuppressed();
+      if (suppressedBeforeScan) {
+        if (!wasSuppressed) {
+          rolloutPath = null;
+          lastSize = 0;
+          partialLine = "";
+          didBootstrap = false;
+          resetRunState(state);
+        }
+        wasSuppressed = true;
+        return;
+      }
+      if (wasSuppressed) {
+        rolloutPath = null;
+        lastSize = 0;
+        partialLine = "";
+        didBootstrap = false;
+        resetRunState(state);
+        lookupStartedAt = currentTime;
+        wasSuppressed = false;
+      }
 
       if (!rolloutPath) {
-        if (currentTime - startedAt >= lookupTimeoutMs) {
+        if (currentTime - lookupStartedAt >= lookupTimeoutMs) {
           stop();
           return;
         }
@@ -209,20 +244,21 @@ function createThreadRolloutLiveMirror({
 
       const rolloutStat = fsModule.statSync(rolloutPath);
       const fileSize = rolloutStat.size;
-      // While another live source streams this thread the tail keeps consuming
-      // rollout lines with its emissions muted. Compare per-thread activity so
-      // a quiet Desktop turn stays owned, while newer rollout growth can recover
-      // from a stale connected snapshot.
+      // Re-check ownership with the rollout's activity time before bootstrapping.
+      // If another source owns the thread, leave the file untouched until that
+      // ownership expires.
       const suppressed = isSuppressed({
         fallbackActivityAt: Number(rolloutStat.mtimeMs) || 0,
       });
-      if (wasSuppressed && !suppressed && didBootstrap) {
+      if (suppressed) {
+        rolloutPath = null;
         lastSize = 0;
         partialLine = "";
         didBootstrap = false;
         resetRunState(state);
+        wasSuppressed = true;
+        return;
       }
-      wasSuppressed = suppressed;
       if (!didBootstrap) {
         didBootstrap = true;
         bootstrapFromExistingRollout({
@@ -354,6 +390,10 @@ function createThreadRolloutLiveMirror({
     // final partial-line flush must never leak the poll interval.
     isStopped = true;
     clearIntervalFn(intervalId);
+    if (initialTickId != null) {
+      clearImmediateFn(initialTickId);
+      initialTickId = null;
+    }
     if (partialLine) {
       const flushLine = partialLine;
       partialLine = "";
@@ -369,8 +409,8 @@ function createThreadRolloutLiveMirror({
   // Only a healthy, actively-tailed run with a real id counts: synthetic ids
   // are not actionable app-server turn ids, and suppressed/awaiting states
   // mean the mirror does not actually know what is running. While another live
-  // source owns the thread the tail keeps parsing with its emissions muted, so
-  // reporting that turn id would resurrect exactly the state the bridge muted.
+  // source owns the thread the mirror has no parsed file state, so reporting a
+  // turn id would resurrect exactly the state the bridge muted.
   function getActiveTurnId() {
     if (
       isStopped
@@ -950,6 +990,7 @@ function synthesizeNotificationsFromRolloutEntry(entry, state, { nowMs = Date.no
       state.commandCalls.clear();
       state.applyPatchCalls.clear();
       state.emittedPatchApplyEndCalls.clear();
+      state.wrappedExecCallIdsByOuterId.clear();
 
       const startedParams = {
         threadId: state.threadId,
@@ -1081,12 +1122,12 @@ function synthesizeNotificationsFromRolloutEntry(entry, state, { nowMs = Date.no
   }
 
   if (itemType === "functioncall") {
-    notifications.push(...toolStartNotifications(state, payload));
+    notifications.push(...projectedToolStartNotifications(state, payload));
     return notifications;
   }
 
   if (itemType === "customtoolcall") {
-    notifications.push(...customToolStartNotifications(state, payload));
+    notifications.push(...projectedToolStartNotifications(state, payload));
     return notifications;
   }
 
@@ -1326,6 +1367,29 @@ function extractResponseItemMessageText(payload) {
   return responseItemMessageText(payload);
 }
 
+function projectedToolStartNotifications(state, payload) {
+  if (isOrchestrationWaitCall(payload)) {
+    return [];
+  }
+
+  const projectedPayloads = expandExecWrapperToolCall(payload);
+  const outerCallId = projectedPayloads[0]?.remodexWrappedExecCallId;
+  if (outerCallId && projectedPayloads.length > 1) {
+    state.wrappedExecCallIdsByOuterId.set(
+      outerCallId,
+      projectedPayloads.map((projectedPayload) => (
+        readString(projectedPayload.call_id) || readString(projectedPayload.callId)
+      )).filter(Boolean)
+    );
+  }
+
+  return projectedPayloads.flatMap((projectedPayload) => (
+    normalizeRolloutItemType(projectedPayload.type) === "customtoolcall"
+      ? customToolStartNotifications(state, projectedPayload)
+      : toolStartNotifications(state, projectedPayload)
+  ));
+}
+
 function toolStartNotifications(state, payload) {
   if (!state.activeTurnId) {
     return [];
@@ -1383,6 +1447,7 @@ function toolStartNotifications(state, payload) {
     toolName,
     command: resolveToolCommand(toolName, argumentsObject),
     cwd: resolveToolWorkingDirectory(argumentsObject, state),
+    wrappedExecCall: Boolean(payload.remodexWrappedExecCallId),
   });
 
   if (isCommandToolName(toolName)) {
@@ -1461,6 +1526,7 @@ function customToolStartNotifications(state, payload) {
       toolName,
       command: toolName,
       cwd: readString(state.sessionMeta?.cwd) || "",
+      wrappedExecCall: Boolean(payload.remodexWrappedExecCallId),
     });
   }
 
@@ -1544,8 +1610,28 @@ function toolOutputNotifications(state, payload) {
     return [];
   }
 
+  const wrappedCallIds = state.wrappedExecCallIdsByOuterId.get(callId);
+  if (Array.isArray(wrappedCallIds) && wrappedCallIds.length > 0) {
+    state.wrappedExecCallIdsByOuterId.delete(callId);
+    const outputRecipientId = wrappedCallIds.find((nestedCallId) => (
+      isCommandToolName(state.commandCalls.get(nestedCallId)?.toolName)
+    )) || wrappedCallIds[0];
+    return wrappedCallIds.flatMap((nestedCallId) => toolOutputNotifications(state, {
+      ...payload,
+      call_id: nestedCallId,
+      callId: nestedCallId,
+      output: nestedCallId === outputRecipientId ? payload.output : "",
+    }));
+  }
+
   const toolCall = state.commandCalls.get(callId);
   if (!toolCall) {
+    if (state.applyPatchCalls.has(callId)) {
+      return patchApplyEndNotifications(state, {
+        ...payload,
+        status: readString(payload.status) || "completed",
+      });
+    }
     return [];
   }
 
@@ -1561,7 +1647,8 @@ function toolOutputNotifications(state, payload) {
     return notifications;
   }
 
-  const output = readString(payload.output);
+  const rawOutput = extractToolOutputText(payload.output);
+  const output = toolCall.wrappedExecCall ? stripExecOutputEnvelope(rawOutput) : rawOutput;
   const notifications = [...ensureThinkingNotifications(state)];
   if (output) {
     notifications.push(createNotification("codex/event/exec_command_output_delta", {
@@ -1587,6 +1674,38 @@ function toolOutputNotifications(state, payload) {
   return notifications;
 }
 
+function extractToolOutputText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(extractToolOutputText).join("");
+  }
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+
+  for (const key of ["text", "output_text", "outputText"]) {
+    if (typeof value[key] === "string") {
+      return value[key];
+    }
+  }
+  for (const key of ["content", "output", "result"]) {
+    const text = extractToolOutputText(value[key]);
+    if (text) {
+      return text;
+    }
+  }
+  return "";
+}
+
+function stripExecOutputEnvelope(output) {
+  return readString(output).replace(
+    /^Script [^\n]*\nWall time [^\n]*\nOutput:\n?/,
+    ""
+  );
+}
+
 function imageGenerationNotifications(state, payload, { preferCallId = false } = {}) {
   if (!state.activeTurnId) {
     return [];
@@ -1759,6 +1878,7 @@ function createMirrorState(threadId) {
     commandCalls: new Map(),
     applyPatchCalls: new Map(),
     emittedPatchApplyEndCalls: new Set(),
+    wrappedExecCallIdsByOuterId: new Map(),
     emittedAgentMessageKeys: new Set(),
     agentMessageOccurrencesByBaseKey: new Map(),
     pendingEventAgentMessageOccurrencesByBaseKey: new Map(),
@@ -2091,6 +2211,7 @@ function resetRunState(state) {
   state.commandCalls.clear();
   state.applyPatchCalls.clear();
   state.emittedPatchApplyEndCalls.clear();
+  state.wrappedExecCallIdsByOuterId.clear();
   state.emittedAgentMessageKeys.clear();
   state.agentMessageOccurrencesByBaseKey.clear();
   state.pendingEventAgentMessageOccurrencesByBaseKey.clear();