@makerbi/remodex 1.4.0 → 1.5.0

package/src/desktop-handler.js

@@ -20,6 +20,8 @@ const DEFAULT_APP_BOOT_WAIT_MS = 1_200;
 const DEFAULT_THREAD_MATERIALIZE_WAIT_MS = 4_000;
 const DEFAULT_THREAD_MATERIALIZE_POLL_MS = 250;
 const DEFAULT_WAKE_DISPLAY_DURATION_SECONDS = 30;
+const WINDOWS_BOUNCE_URL = "codex://settings";
+const DESKTOP_THREAD_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,255}$/;
 
 function handleDesktopRequest(rawMessage, sendResponse, options = {}) {
   let parsed;
@@ -71,16 +73,39 @@ async function handleDesktopMethod(method, params, options = {}) {
   const threadMaterializeWaitMs = options.threadMaterializeWaitMs ?? DEFAULT_THREAD_MATERIALIZE_WAIT_MS;
   const threadMaterializePollMs = options.threadMaterializePollMs ?? DEFAULT_THREAD_MATERIALIZE_POLL_MS;
 
-  if (platform !== "darwin") {
-    throw desktopError(
-      "unsupported_platform",
-      "Mac handoff is only available when the bridge is running on macOS."
-    );
-  }
-
   switch (method) {
+    case "desktop/continueOnDesktop":
+      if (platform !== "darwin" && platform !== "win32") {
+        throw desktopError(
+          "unsupported_platform",
+          "Desktop handoff is only available when the bridge is running on macOS or Windows."
+        );
+      }
+
+      return continueOnDesktop(params, {
+        platform,
+        bundleId,
+        appPath,
+        executor,
+        env,
+        fsModule,
+        isAppRunning,
+        sleepFn,
+        appBootWaitMs,
+        relaunchWaitMs,
+        threadMaterializeWaitMs,
+        threadMaterializePollMs,
+      });
     case "desktop/continueOnMac":
-      return continueOnMac(params, {
+      if (platform !== "darwin") {
+        throw desktopError(
+          "unsupported_platform",
+          "Mac handoff is only available when the bridge is running on macOS."
+        );
+      }
+
+      return continueOnDesktop(params, {
+        platform,
         bundleId,
         appPath,
         executor,
@@ -106,10 +131,11 @@ async function handleDesktopMethod(method, params, options = {}) {
   }
 }
 
-// Waits for fresh phone-authored chats to materialize locally before deep-linking them on Mac.
-async function continueOnMac(
+// Waits for fresh phone-authored chats to materialize locally before deep-linking them on desktop.
+async function continueOnDesktop(
   params,
   {
+    platform,
     bundleId,
     appPath,
     executor,
@@ -125,11 +151,53 @@ async function continueOnMac(
 ) {
   const threadId = resolveThreadId(params);
   if (!threadId) {
-    throw desktopError("missing_thread_id", "A thread id is required to continue on Mac.");
+    throw desktopError("missing_thread_id", "A thread id is required to continue on desktop.");
+  }
+  if (!isValidDesktopThreadId(threadId)) {
+    throw desktopError("invalid_thread_id", "The requested desktop thread id is not valid.");
   }
 
   const targetUrl = `codex://threads/${threadId}`;
   const desktopKnown = isThreadLikelyKnownOnDesktop(threadId, { env, fsModule });
+
+  if (platform === "win32") {
+    try {
+      if (desktopKnown) {
+        await refreshWindowsCodex(targetUrl, {
+          executor,
+          env,
+          sleepFn,
+          settleMs: relaunchWaitMs,
+        });
+      } else {
+        await openWindowsDeepLink(WINDOWS_BOUNCE_URL, { executor, env });
+        await sleepFn(appBootWaitMs);
+        await waitForThreadMaterialization(threadId, {
+          env,
+          fsModule,
+          sleepFn,
+          timeoutMs: threadMaterializeWaitMs,
+          pollMs: threadMaterializePollMs,
+        });
+        await openWindowsDeepLink(targetUrl, { executor, env });
+      }
+    } catch (error) {
+      throw desktopError(
+        "handoff_failed",
+        "Could not open Codex on this PC.",
+        error
+      );
+    }
+
+    return {
+      success: true,
+      relaunched: false,
+      targetUrl,
+      threadId,
+      desktopKnown,
+    };
+  }
+
   const appRunning = typeof isAppRunning === "function"
     ? await isAppRunning(appPath)
     : await detectRunningCodexApp(appPath, executor);
@@ -311,6 +379,11 @@ function resolveThreadId(params) {
   return "";
 }
 
+// Keeps desktop deep links to a single safe route segment before handing them to OS launchers.
+function isValidDesktopThreadId(threadId) {
+  return typeof threadId === "string" && DESKTOP_THREAD_ID_PATTERN.test(threadId);
+}
+
 function desktopError(errorCode, userMessage, cause = null) {
   const error = new Error(userMessage);
   error.errorCode = errorCode;
@@ -372,6 +445,22 @@ async function openCodexApp({ bundleId, appPath, executor }) {
   }
 }
 
+async function openWindowsDeepLink(targetUrl, { executor, env }) {
+  await executor(env?.SystemRoot ? path.join(env.SystemRoot, "System32", "rundll32.exe") : "rundll32.exe", [
+    "url.dll,FileProtocolHandler",
+    targetUrl,
+  ], {
+    timeout: HANDOFF_TIMEOUT_MS,
+    windowsHide: true,
+  });
+}
+
+async function refreshWindowsCodex(targetUrl, { executor, env, sleepFn, settleMs }) {
+  await openWindowsDeepLink(WINDOWS_BOUNCE_URL, { executor, env });
+  await sleepFn(settleMs);
+  await openWindowsDeepLink(targetUrl, { executor, env });
+}
+
 // Gives the desktop a short window to materialize the requested thread before the final deep link.
 async function openWhenThreadReady(
   threadId,

package/src/desktop-ipc-action-follower.js

@@ -77,7 +77,6 @@ function createDesktopIpcActionFollower({
 
     activeThreadIds.add(threadId);
     ipc.ensureConnected();
-    recoverThreadBaseline(threadId);
     return false;
   }
 
@@ -111,6 +110,19 @@ function createDesktopIpcActionFollower({
     const nextState = applyConversationStateChange(previousState, params.change);
     if (!nextState) {
       if (isPatchChange(params.change)) {
+        const emptyState = createEmptyConversationState();
+        const speculativeState = applyConversationStateChange(emptyState, params.change);
+        const speculativeActions = projectPendingDesktopActions(threadId, speculativeState);
+        if (speculativeActions.length > 0) {
+          rawStatesByThreadId.set(threadId, speculativeState);
+          syncProjectedActions(threadId, speculativeActions);
+          return;
+        }
+
+        if (typeof readConversationState !== "function") {
+          return;
+        }
+
         queueThreadChange(threadId, params.change);
         recoverThreadBaseline(threadId);
       }
@@ -219,8 +231,7 @@ function createDesktopIpcActionFollower({
   }
 
   function recoverThreadBaseline(threadId) {
-    if (typeof readConversationState !== "function"
-      || recoveringThreadIds.has(threadId)
+    if (recoveringThreadIds.has(threadId)
       || rawStatesByThreadId.has(threadId)) {
       return;
     }
@@ -230,27 +241,39 @@ function createDesktopIpcActionFollower({
       .then(() => readConversationState(threadId))
       .then((baselineState) => {
         if (!baselineState || typeof baselineState !== "object") {
+          recoverThreadBaselineFromQueuedChanges(threadId, null);
           return;
         }
 
-        let nextState = cloneJSON(baselineState);
-        const queuedChanges = queuedChangesByThreadId.get(threadId) || [];
-        queuedChangesByThreadId.delete(threadId);
-        for (const change of queuedChanges) {
-          nextState = applyConversationStateChange(nextState, change) || nextState;
-        }
-
-        rawStatesByThreadId.set(threadId, nextState);
-        syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
+        recoverThreadBaselineFromQueuedChanges(threadId, baselineState);
       })
       .catch((error) => {
         console.warn(`${logPrefix} desktop IPC baseline recovery failed for ${threadId}: ${error.message}`);
+        recoverThreadBaselineFromQueuedChanges(threadId, null);
       })
       .finally(() => {
         recoveringThreadIds.delete(threadId);
       });
   }
 
+  function recoverThreadBaselineFromQueuedChanges(threadId, baselineState) {
+    const queuedChanges = queuedChangesByThreadId.get(threadId) || [];
+    if (queuedChanges.length === 0) {
+      return;
+    }
+
+    queuedChangesByThreadId.delete(threadId);
+    let nextState = baselineState && typeof baselineState === "object"
+      ? cloneJSON(baselineState)
+      : createEmptyConversationState();
+    for (const change of queuedChanges) {
+      nextState = applyConversationStateChange(nextState, change) || nextState;
+    }
+
+    rawStatesByThreadId.set(threadId, nextState);
+    syncProjectedActions(threadId, projectPendingDesktopActions(threadId, nextState));
+  }
+
   return {
     observeInbound,
     stopAll,
@@ -555,6 +578,13 @@ function seedConversationStateFromThreadRead(response) {
   };
 }
 
+function createEmptyConversationState() {
+  return {
+    turns: [],
+    requests: [],
+  };
+}
+
 function applyImmerPatch(target, patch) {
   const patchPath = Array.isArray(patch?.path) ? patch.path : [];
   const op = readString(patch?.op).toLowerCase();

package/src/git-handler.js

@@ -13,6 +13,8 @@ const { promisify } = require("util");
 
 const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT_MS = 30_000;
+/** Node defaults maxBuffer to 1 MiB; large repo diffs exceed it ("stdout maxBuffer length exceeded"). */
+const GIT_EXEC_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
 const GIT_DRAFT_TIMEOUT_MS = 120_000;
 const GITHUB_CLI_TIMEOUT_MS = 120_000;
 const GIT_DRAFT_PATCH_MAX_BYTES = 80_000;
@@ -49,7 +51,20 @@ function handleGitRequest(rawMessage, sendResponse, options = {}) {
   const id = parsed.id;
   const params = parsed.params || {};
 
-  handleGitMethod(method, params, options)
+  // Lets long-running git flows push interim progress events to the phone.
+  const sendNotification = (notificationMethod, notificationParams) => {
+    if (typeof notificationMethod !== "string" || !notificationMethod) {
+      return;
+    }
+    sendResponse(JSON.stringify({
+      method: notificationMethod,
+      params: notificationParams ?? {},
+    }));
+  };
+
+  const methodOptions = { ...options, sendNotification };
+
+  handleGitMethod(method, params, methodOptions)
     .then((result) => {
       sendResponse(JSON.stringify({ id, result }));
       if (method === "thread/name/set") {
@@ -977,8 +992,26 @@ async function gitRunStackedAction(cwd, params, options = {}) {
   const wantsCommit = action === "commit" || action === "commit_push" || action === "commit_push_pr";
   const wantsPr = action === "create_pr" || action === "commit_push_pr";
 
+  // Emits phase progress events on the same wire used by JSON-RPC responses
+  // so the iOS toast can reflect the live step (commit/push/PR) of a stacked action.
+  const progressId = typeof params.progressId === "string" && params.progressId.trim()
+    ? params.progressId.trim()
+    : null;
+  const emitPhase = (phase, status) => {
+    if (!progressId || typeof options.sendNotification !== "function") {
+      return;
+    }
+    options.sendNotification("git/stackedAction/progress", {
+      progressId,
+      phase,
+      status,
+    });
+  };
+
   if (params.featureBranch === true) {
+    emitPhase("branch", "started");
     await gitCreateFeatureBranch(cwd, params);
+    emitPhase("branch", "completed");
   }
 
   const branch = await currentBranchName(cwd);
@@ -1004,6 +1037,7 @@ async function gitRunStackedAction(cwd, params, options = {}) {
   if (wantsCommit) {
     const statusBeforeCommit = await gitStatus(cwd);
     if (statusBeforeCommit.dirty) {
+      emitPhase("commit", "started");
       const commitResult = await gitCommit(cwd, {
         message: params.commitMessage || params.message,
       });
@@ -1013,10 +1047,12 @@ async function gitRunStackedAction(cwd, params, options = {}) {
         commitSha: commitResult.hash,
         subject: firstCommitMessageLine(params.commitMessage || params.message),
       };
+      emitPhase("commit", "completed");
     } else if (action === "commit") {
       throw gitError("nothing_to_commit", "Nothing to commit.");
     } else {
       result.commit = { status: "skipped_clean" };
+      emitPhase("commit", "skipped");
     }
   }
 
@@ -1037,17 +1073,21 @@ async function gitRunStackedAction(cwd, params, options = {}) {
     if (statusBeforePush.dirty) {
       throw gitError("dirty_worktree", "Commit or stash local changes before pushing.");
     }
+    emitPhase("push", "started");
     result.push = {
       state: "pushed",
       ...(await gitPush(cwd)),
     };
+    emitPhase("push", "completed");
   }
 
   if (wantsPr) {
+    emitPhase("createPR", "started");
     result.pr = await gitCreatePullRequest(cwd, {
       ...params,
       pushBeforeCreate: false,
     }, options);
+    emitPhase("createPR", "completed");
   }
 
   result.status = await gitStatus(cwd);
@@ -2387,7 +2427,7 @@ async function gitDiffNoIndexNumstat(cwd, filePath) {
     const { stdout } = await execFileAsync(
       "git",
       ["diff", "--no-index", "--numstat", "--", "/dev/null", filePath],
-      { cwd, timeout: GIT_TIMEOUT_MS }
+      { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_EXEC_MAX_BUFFER_BYTES }
     );
     return stdout;
   } catch (err) {
@@ -2413,7 +2453,7 @@ async function gitDiffNoIndexPatch(cwd, filePath) {
     const { stdout } = await execFileAsync(
       "git",
       ["diff", "--no-index", "--binary", "--", "/dev/null", filePath],
-      { cwd, timeout: GIT_TIMEOUT_MS }
+      { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_EXEC_MAX_BUFFER_BYTES }
     );
     return stdout;
   } catch (err) {
@@ -2428,7 +2468,11 @@ async function gitDiffNoIndexPatch(cwd, filePath) {
 // ─── Helpers ──────────────────────────────────────────────────
 
 function git(cwd, ...args) {
-  return execFileAsync("git", args, { cwd, timeout: GIT_TIMEOUT_MS })
+  return execFileAsync("git", args, {
+    cwd,
+    timeout: GIT_TIMEOUT_MS,
+    maxBuffer: GIT_EXEC_MAX_BUFFER_BYTES,
+  })
     .then(({ stdout }) => stdout)
     .catch((err) => {
       const msg = (err.stderr || err.message || "").trim();

package/src/macos-launch-agent.js

@@ -33,8 +33,8 @@ const DEFAULT_PAIRING_WAIT_TIMEOUT_MS = 10_000;
 const DEFAULT_PAIRING_WAIT_INTERVAL_MS = 200;
 
 // Runs the bridge inside launchd while keeping QR rendering in the foreground CLI command.
-function runMacOSBridgeService({ env = process.env } = {}) {
-  assertDarwinPlatform();
+function runMacOSBridgeService({ env = process.env, platform = process.platform } = {}) {
+  assertDarwinPlatform(platform);
   const config = readDaemonConfig({ env });
   if (!config?.relayUrl) {
     const message = "No relay URL configured for the macOS bridge service.";