@makerbi/remodex 2.4.0 → 3.1.0

package/src/desktop-ipc-shared.js

@@ -1,9 +1,10 @@
 // FILE: desktop-ipc-shared.js
-// Purpose: Shared primitives for the Codex Desktop IPC modules (framing, socket path, JSON helpers).
+// Purpose: Shared primitives for the Codex Desktop IPC modules (framing, socket path, envelopes, JSON helpers).
 // Layer: CLI helper
-// Exports: FRAME_HEADER_BYTES, MAX_FRAME_BYTES, cloneJSON, normalizeToken, readString, readText, requestIdKey, resolveDefaultIpcSocketPath, safeParseJSON, writeFrame
-// Depends on: os, path
+// Exports: CLIENT_STATUS_CHANGED, DESKTOP_IPC_METHOD_VERSIONS, FRAME_HEADER_BYTES, MAX_FRAME_BYTES, buildIpcRequestEnvelope, createFrameReader, resolveDefaultIpcSocketPath, resolveIpcSocketPathCandidates, toSocketPathResolver, writeFrame, plus JSON/text helpers
+// Depends on: crypto, fs, os, path
 
+const fs = require("fs");
 const os = require("os");
 const path = require("path");
 const { createHash } = require("crypto");
@@ -21,16 +22,18 @@ const DESKTOP_IPC_METHOD_VERSIONS = new Map([
   [CLIENT_STATUS_CHANGED, 1],
   // Desktop pins thread-stream-state-changed at version 11 and drops mismatches.
   ["thread-stream-state-changed", 11],
+  ["thread-stream-following-changed", 1],
+  ["thread-stream-following-status-requested", 1],
   ["thread-archived", 2],
   ["thread-unarchived", 1],
-  ["thread-read-state-changed", 1],
+  ["thread-read-state-changed", 2],
   ["thread-queued-followups-changed", 1],
   ["thread-follower-start-turn", 1],
   ["thread-follower-load-complete-history", 1],
   ["thread-follower-update-thread-settings", 1],
   ["thread-follower-compact-thread", 1],
   ["thread-follower-steer-turn", 1],
-  ["thread-follower-interrupt-turn", 2],
+  ["thread-follower-interrupt-turn", 3],
   ["thread-follower-set-model-and-reasoning", 1],
   ["thread-follower-set-collaboration-mode", 1],
   ["thread-follower-edit-last-user-turn", 2],
@@ -517,13 +520,121 @@ function writeFrame(socket, payload, callback) {
   socket.write(Buffer.concat([header, body]), callback);
 }
 
-function resolveDefaultIpcSocketPath() {
+// Codex moved its IPC bus into the Codex home directory; older desktop and CLI
+// builds still expose it under the temp directory. Both are in the wild, so the
+// bus is looked up in that order instead of being pinned to one location.
+// Every participant on the bus — both clients and the fallback router's per-peer
+// sockets — reads the same length-prefixed framing; only the dispatch differs.
+// `onOverflow` owns the connection, so it decides how to drop a bogus peer.
+function createFrameReader({ onFrame, onOverflow }) {
+  let buffer = Buffer.alloc(0);
+
+  return {
+    push(chunk) {
+      buffer = Buffer.concat([buffer, chunk]);
+      while (buffer.length >= FRAME_HEADER_BYTES) {
+        const frameLength = buffer.readUInt32LE(0);
+        if (frameLength > MAX_FRAME_BYTES) {
+          buffer = Buffer.alloc(0);
+          onOverflow?.();
+          return;
+        }
+        if (buffer.length < FRAME_HEADER_BYTES + frameLength) {
+          return;
+        }
+
+        const payload = buffer
+          .slice(FRAME_HEADER_BYTES, FRAME_HEADER_BYTES + frameLength)
+          .toString("utf8");
+        buffer = buffer.slice(FRAME_HEADER_BYTES + frameLength);
+        const envelope = safeParseJSON(payload);
+        if (envelope) {
+          onFrame(envelope);
+        }
+      }
+    },
+    reset() {
+      buffer = Buffer.alloc(0);
+    },
+  };
+}
+
+// Desktop validates the method version and refuses requests from an unknown
+// sender, so both clients must build this envelope the same way.
+function buildIpcRequestEnvelope({ requestId, method, params, clientId, initializing = false }) {
+  return {
+    type: "request",
+    requestId,
+    sourceClientId: initializing ? "initializing-client" : clientId || "remodex-bridge",
+    version: DESKTOP_IPC_METHOD_VERSIONS.get(method) || 1,
+    method,
+    params: params || {},
+  };
+}
+
+// Newer app-server builds omit every turn unless thread/read opts in explicitly.
+// Internal hydration callers always need a complete baseline: publishing the
+// metadata-only default as a Desktop snapshot would replace the visible history.
+function buildCompleteThreadReadParams(threadId) {
+  return {
+    threadId: readString(threadId),
+    includeTurns: true,
+  };
+}
+
+function resolveIpcSocketPathCandidates() {
   if (process.platform === "win32") {
-    return "\\\\.\\pipe\\codex-ipc";
+    return ["\\\\.\\pipe\\codex-ipc"];
   }
 
+  const configuredCodexHome = readString(process.env.CODEX_HOME);
+  const codexHome = configuredCodexHome
+    ? path.resolve(configuredCodexHome)
+    : path.join(os.homedir(), ".codex");
   const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  return path.join(os.tmpdir(), "codex-ipc", `ipc-${uid}.sock`);
+  return [
+    path.join(codexHome, "ipc", "ipc.sock"),
+    path.join(os.tmpdir(), "codex-ipc", `ipc-${uid}.sock`),
+  ];
+}
+
+// Compatibility helper for callers that need one path synchronously. Transports
+// use resolveIpcSocketPathCandidates instead because only a connection attempt
+// can distinguish a live listener from a stale socket inode.
+function resolveDefaultIpcSocketPath() {
+  const candidates = resolveIpcSocketPathCandidates();
+  for (const candidate of candidates) {
+    try {
+      if (fs.statSync(candidate).isSocket()) {
+        return candidate;
+      }
+    } catch {
+      // Missing or unreadable candidate: keep looking.
+    }
+  }
+  return candidates[0];
+}
+
+// The bus location is only known at connect time, so transports accept either a
+// fixed path or a resolver and always ask again before reconnecting.
+function toSocketPathResolver(socketPath) {
+  return typeof socketPath === "function" ? socketPath : () => socketPath;
+}
+
+// A socket inode can outlive its listener. Clients therefore need the full
+// ordered candidate list so they can try the legacy bus after a refused current
+// socket instead of mistaking file existence for liveness.
+function toSocketPathCandidatesResolver(socketPath) {
+  const resolveSocketPath = toSocketPathResolver(socketPath);
+  return () => {
+    const resolved = resolveSocketPath();
+    const candidates = Array.isArray(resolved) ? resolved : [resolved];
+    return candidates.filter((candidate, index) => (
+      typeof candidate === "string"
+      && candidate.length > 0
+      && candidates.indexOf(candidate) === index
+    ));
+  };
 }
 
 // A source-neutral alias joins the same assistant prose when rollout events
@@ -556,7 +667,10 @@ function responseItemMessageText(payload) {
 
 module.exports = {
   CLIENT_STATUS_CHANGED,
+  buildCompleteThreadReadParams,
+  buildIpcRequestEnvelope,
   buildRemodexSourceItemKey,
+  createFrameReader,
   DESKTOP_IPC_METHOD_VERSIONS,
   FRAME_HEADER_BYTES,
   MAX_FRAME_BYTES,
@@ -574,9 +688,12 @@ module.exports = {
   responseItemMessageText,
   requestIdKey,
   resolveDefaultIpcSocketPath,
+  resolveIpcSocketPathCandidates,
   safeParseJSON,
   sanitizeUserInputEntries,
   sanitizeUserRoleItem,
+  toSocketPathCandidatesResolver,
+  toSocketPathResolver,
   visibleUserPromptText,
   visibleUserPromptFromInputEntries,
   writeFrame,

package/src/git-handler.js

@@ -635,13 +635,11 @@ async function gitCreateBranch(cwd, params) {
   return { branch: name, status };
 }
 
-async function gitCreateWorktree(cwd, params) {
-  const branch = normalizeCreatedBranchName(params.name);
-  if (!branch) {
-    throw gitError("missing_branch_name", "Branch name is required.");
-  }
-  await assertValidCreatedBranchName(cwd, branch);
-
+// Resolves the shared creation context for both worktree flavors and enforces
+// the invariants they have in common: a locally available base branch, and
+// dirty changes that may only travel when the base branch is checked out.
+// `destinationLabel` only shapes the dirty-transfer error message.
+async function resolveWorktreeCreationContext(cwd, params, destinationLabel) {
   const branchResult = await gitBranches(cwd);
   const repoRoot = await resolveRepoRoot(cwd);
   const status = await gitStatus(cwd);
@@ -666,34 +664,27 @@ async function gitCreateWorktree(cwd, params) {
     const transferVerb = changeTransfer === "copy" ? "copy" : "move";
     throw gitError(
       "dirty_worktree_base_mismatch",
-      `Uncommitted changes can ${transferVerb} into a new worktree only from ${currentBranchLabel}. Switch the base branch to match or clean up local changes first.`
+      `Uncommitted changes can ${transferVerb} into ${destinationLabel} only from ${currentBranchLabel}. Switch the base branch to match or clean up local changes first.`
     );
   }
 
-  const existingWorktreePath = branchResult.worktreePathByBranch[branch];
-  if (existingWorktreePath) {
-    if (sameFilePath(existingWorktreePath, cwd)) {
-      throw gitError(
-        "branch_already_open_here",
-        `Branch '${branch}' is already open in this project.`
-      );
-    }
-
-    return {
-      branch,
-      worktreePath: existingWorktreePath,
-      alreadyExisted: true,
-    };
-  }
-
-  const branchExists = await localBranchExists(cwd, branch);
-  if (branchExists) {
-    throw gitError(
-      "branch_exists",
-      `Branch '${branch}' already exists locally. Choose another name or open that branch instead.`
-    );
-  }
+  return {
+    branchResult,
+    repoRoot,
+    projectRelativePath,
+    changeScope,
+    baseBranch,
+    changeTransfer,
+    canCarryLocalChanges,
+  };
+}
 
+// Shared creation core: allocates the managed path, carries local changes per
+// the transfer mode, runs `git worktree add`, copies manifest files, and rolls
+// everything back if any step after allocation fails. `branch` switches the
+// checkout mode (`-b branch` vs `--detach`) and scopes cleanup/error mapping.
+async function createWorktreeAtManagedPath(context, { branch = null, failureMessage }) {
+  const { repoRoot, changeScope, baseBranch, changeTransfer, canCarryLocalChanges } = context;
   const worktreeRootPath = allocateManagedWorktreePath(repoRoot);
   let handoffStashRef = null;
   let copiedLocalChangesPatch = "";
@@ -708,7 +699,8 @@ async function gitCreateWorktree(cwd, params) {
       }
     }
 
-    await git(repoRoot, "worktree", "add", "-b", branch, worktreeRootPath, baseBranch);
+    const checkoutArgs = branch ? ["-b", branch] : ["--detach"];
+    await git(repoRoot, "worktree", "add", ...checkoutArgs, worktreeRootPath, baseBranch);
     didCreateWorktree = true;
 
     if (handoffStashRef) {
@@ -717,6 +709,7 @@ async function gitCreateWorktree(cwd, params) {
     if (copiedLocalChangesPatch) {
       await applyCopiedLocalChangesToWorktree(worktreeRootPath, copiedLocalChangesPatch);
     }
+    await copyWorktreeIncludeFiles(repoRoot, worktreeRootPath);
   } catch (err) {
     if (didCreateWorktree) {
       await cleanupManagedWorktree(repoRoot, worktreeRootPath, branch);
@@ -731,102 +724,90 @@ async function gitCreateWorktree(cwd, params) {
     if (err.message?.includes("invalid reference")) {
       throw gitError("missing_base_branch", `Base branch '${baseBranch}' does not exist.`);
     }
-    if (err.message?.includes("already exists")) {
-      throw gitError("branch_exists", `Branch '${branch}' already exists.`);
-    }
-    if (err.message?.includes("already used by worktree") || err.message?.includes("already checked out at")) {
-      throw gitError(
-        "branch_in_other_worktree",
-        `Branch '${branch}' is already open in another worktree.`
-      );
+    if (branch) {
+      if (err.message?.includes("already exists")) {
+        throw gitError("branch_exists", `Branch '${branch}' already exists.`);
+      }
+      if (err.message?.includes("already used by worktree") || err.message?.includes("already checked out at")) {
+        throw gitError(
+          "branch_in_other_worktree",
+          `Branch '${branch}' is already open in another worktree.`
+        );
+      }
     }
-    throw gitError("create_worktree_failed", err.message || "Failed to create worktree.");
+    throw gitError("create_worktree_failed", err.message || failureMessage);
   }
 
-  const worktreePath = scopedWorktreePath(worktreeRootPath, projectRelativePath);
   return {
-    branch,
-    worktreePath,
-    alreadyExisted: false,
+    worktreeRootPath,
+    transferredChanges: Boolean(handoffStashRef || copiedLocalChangesPatch),
   };
 }
 
-async function gitCreateManagedWorktree(cwd, params) {
-  const branchResult = await gitBranches(cwd);
-  const repoRoot = await resolveRepoRoot(cwd);
-  const status = await gitStatus(cwd);
-  const projectRelativePath = resolveProjectRelativePath(cwd, repoRoot);
-  const changeScope = await scopedProjectChanges(repoRoot, projectRelativePath);
-  const baseBranch = resolveBaseBranchName(params.baseBranch, branchResult.defaultBranch);
-  const changeTransfer = resolveWorktreeChangeTransfer(params.changeTransfer);
-  if (!baseBranch) {
-    throw gitError("missing_base_branch", "Base branch is required.");
-  }
-  if (!(await localBranchExists(cwd, baseBranch))) {
-    throw gitError(
-      "missing_base_branch",
-      `Base branch '${baseBranch}' is not available locally. Create or check out that branch first.`
-    );
-  }
-
-  const currentBranch = typeof status.branch === "string" ? status.branch.trim() : "";
-  const canCarryLocalChanges = changeScope.dirty && !!currentBranch && currentBranch === baseBranch;
-  if (changeScope.dirty && changeTransfer !== "none" && !canCarryLocalChanges) {
-    const currentBranchLabel = currentBranch || "the current branch";
-    const transferVerb = changeTransfer === "copy" ? "copy" : "move";
-    throw gitError(
-      "dirty_worktree_base_mismatch",
-      `Uncommitted changes can ${transferVerb} into a managed worktree only from ${currentBranchLabel}. Switch the base branch to match or clean up local changes first.`
-    );
+async function gitCreateWorktree(cwd, params) {
+  const branch = normalizeCreatedBranchName(params.name);
+  if (!branch) {
+    throw gitError("missing_branch_name", "Branch name is required.");
   }
+  await assertValidCreatedBranchName(cwd, branch);
 
-  const worktreeRootPath = allocateManagedWorktreePath(repoRoot);
-  let handoffStashRef = null;
-  let copiedLocalChangesPatch = "";
-  let didCreateWorktree = false;
+  const context = await resolveWorktreeCreationContext(cwd, params, "a new worktree");
+  const { branchResult, repoRoot, projectRelativePath } = context;
 
-  try {
-    if (canCarryLocalChanges) {
-      if (changeTransfer === "copy") {
-        copiedLocalChangesPatch = await captureLocalChangesPatch(repoRoot, changeScope.pathspecArgs);
-      } else if (changeTransfer === "move") {
-        handoffStashRef = await stashChangesForWorktreeHandoff(repoRoot, changeScope.pathspecArgs);
-      }
+  const existingWorktreePath = branchResult.worktreePathByBranch[branch];
+  if (existingWorktreePath) {
+    if (sameFilePath(existingWorktreePath, cwd)) {
+      throw gitError(
+        "branch_already_open_here",
+        `Branch '${branch}' is already open in this project.`
+      );
     }
 
-    await git(repoRoot, "worktree", "add", "--detach", worktreeRootPath, baseBranch);
-    didCreateWorktree = true;
-
-    if (handoffStashRef) {
-      await applyWorktreeHandoffStash(worktreeRootPath, handoffStashRef);
-    }
-    if (copiedLocalChangesPatch) {
-      await applyCopiedLocalChangesToWorktree(worktreeRootPath, copiedLocalChangesPatch);
-    }
-  } catch (err) {
-    if (didCreateWorktree) {
-      await cleanupManagedWorktree(repoRoot, worktreeRootPath);
-    } else {
-      fs.rmSync(path.dirname(worktreeRootPath), { recursive: true, force: true });
+    // Backfill manifest files a worktree created before `.worktreeinclude`
+    // existed never received; the copy skips files the worktree already has.
+    const existingWorktreeRoot = await resolveRepoRoot(existingWorktreePath).catch(() => null);
+    if (existingWorktreeRoot) {
+      await copyWorktreeIncludeFiles(repoRoot, existingWorktreeRoot);
     }
 
-    if (handoffStashRef) {
-      await restoreWorktreeHandoffStash(repoRoot, handoffStashRef);
-    }
+    return {
+      branch,
+      worktreePath: existingWorktreePath,
+      alreadyExisted: true,
+    };
+  }
 
-    if (err.message?.includes("invalid reference")) {
-      throw gitError("missing_base_branch", `Base branch '${baseBranch}' does not exist.`);
-    }
-    throw gitError("create_worktree_failed", err.message || "Failed to create managed worktree.");
+  if (await localBranchExists(cwd, branch)) {
+    throw gitError(
+      "branch_exists",
+      `Branch '${branch}' already exists locally. Choose another name or open that branch instead.`
+    );
   }
 
-  const worktreePath = scopedWorktreePath(worktreeRootPath, projectRelativePath);
+  const { worktreeRootPath } = await createWorktreeAtManagedPath(context, {
+    branch,
+    failureMessage: "Failed to create worktree.",
+  });
+
   return {
-    worktreePath,
+    branch,
+    worktreePath: scopedWorktreePath(worktreeRootPath, projectRelativePath),
     alreadyExisted: false,
-    baseBranch,
+  };
+}
+
+async function gitCreateManagedWorktree(cwd, params) {
+  const context = await resolveWorktreeCreationContext(cwd, params, "a managed worktree");
+  const { worktreeRootPath, transferredChanges } = await createWorktreeAtManagedPath(context, {
+    failureMessage: "Failed to create managed worktree.",
+  });
+
+  return {
+    worktreePath: scopedWorktreePath(worktreeRootPath, context.projectRelativePath),
+    alreadyExisted: false,
+    baseBranch: context.baseBranch,
     headMode: "detached",
-    transferredChanges: Boolean(handoffStashRef || copiedLocalChangesPatch),
+    transferredChanges,
   };
 }
 
@@ -2005,6 +1986,106 @@ async function rollbackFailedHandoffTransfer(cwd, pathspecArgs = []) {
   }
 }
 
+// Mirrors Codex Desktop's `.worktreeinclude`: files Git leaves behind (like an
+// ignored `.env`) listed in a repository-root manifest are copied into worktrees.
+// Best effort by design — a stale manifest entry must never fail creation.
+const WORKTREE_INCLUDE_FILE = ".worktreeinclude";
+const WORKTREE_INCLUDE_MAX_FILES = 512;
+
+async function copyWorktreeIncludeFiles(repoRoot, worktreeRootPath) {
+  const manifestPath = path.join(repoRoot, WORKTREE_INCLUDE_FILE);
+  if (!fs.existsSync(manifestPath)) {
+    return;
+  }
+
+  const relativePaths = await listWorktreeIncludePaths(repoRoot, manifestPath);
+  if (relativePaths.length === 0) {
+    return;
+  }
+
+  const canonicalWorktreeRoot = await fs.promises.realpath(worktreeRootPath).catch(() => null);
+  if (!canonicalWorktreeRoot) {
+    return;
+  }
+
+  for (const relativePath of relativePaths) {
+    const sourcePath = path.resolve(repoRoot, relativePath);
+    const destinationPath = path.resolve(worktreeRootPath, relativePath);
+    // `ls-files` output is repo-relative, but keep both sides pinned to their
+    // roots so a hostile manifest entry cannot escape either tree.
+    if (!isPathContainedIn(sourcePath, repoRoot) || !isPathContainedIn(destinationPath, worktreeRootPath)) {
+      continue;
+    }
+    await copyWorktreeIncludeEntry(sourcePath, destinationPath, canonicalWorktreeRoot);
+  }
+}
+
+// Resolves the manifest to repo-relative untracked paths. The manifest uses
+// gitignore syntax, so let git itself do the matching: `--others -i
+// --exclude-from` lists every untracked file (ignored or not) that the
+// manifest patterns select, with full gitignore semantics — nested `.env`
+// matches, anchored `/foo` and `!negations` behave as documented, and a
+// malformed line cannot abort the listing the way a bad pathspec would.
+async function listWorktreeIncludePaths(repoRoot, manifestPath) {
+  let listing = "";
+  try {
+    listing = await git(
+      repoRoot,
+      "ls-files",
+      "--others",
+      "-i",
+      "-z",
+      `--exclude-from=${manifestPath}`
+    );
+  } catch (err) {
+    console.error(`[remodex] .worktreeinclude listing failed: ${err.message}`);
+    return [];
+  }
+
+  const relativePaths = listing.split("\0").filter(Boolean);
+  if (relativePaths.length > WORKTREE_INCLUDE_MAX_FILES) {
+    console.error(
+      `[remodex] .worktreeinclude matched ${relativePaths.length} files; copying only the first ${WORKTREE_INCLUDE_MAX_FILES}. Narrow the manifest patterns.`
+    );
+    relativePaths.length = WORKTREE_INCLUDE_MAX_FILES;
+  }
+  return relativePaths;
+}
+
+// Copies one manifest match into the worktree, skipping anything unsafe or
+// already present rather than failing the surrounding creation flow.
+async function copyWorktreeIncludeEntry(sourcePath, destinationPath, canonicalWorktreeRoot) {
+  try {
+    // Regular files only: copying through a symlinked source would smuggle
+    // out-of-repo content (e.g. `.env -> ~/.ssh/key`) into every worktree.
+    const sourceStats = await fs.promises.lstat(sourcePath);
+    if (!sourceStats.isFile()) {
+      return;
+    }
+    const destinationDirectory = path.dirname(destinationPath);
+    await fs.promises.mkdir(destinationDirectory, { recursive: true });
+    // Re-check containment on the real path: a checked-out symlinked parent
+    // directory would otherwise let the copy write outside the worktree.
+    const canonicalDestinationDirectory = await fs.promises.realpath(destinationDirectory);
+    if (!isPathContainedIn(canonicalDestinationDirectory, canonicalWorktreeRoot)) {
+      return;
+    }
+    // COPYFILE_EXCL keeps existing files intact: change transfer may already
+    // have carried a dirty copy, and reused worktrees keep their own state.
+    await fs.promises.copyFile(
+      sourcePath,
+      path.join(canonicalDestinationDirectory, path.basename(destinationPath)),
+      fs.constants.COPYFILE_EXCL
+    );
+  } catch {
+    // Skip unreadable or already-present entries; the worktree stays usable.
+  }
+}
+
+function isPathContainedIn(candidatePath, rootPath) {
+  return candidatePath === rootPath || candidatePath.startsWith(rootPath + path.sep);
+}
+
 async function cleanupManagedWorktree(repoRoot, worktreeRootPath, branchName = null) {
   try {
     await git(repoRoot, "worktree", "remove", "--force", worktreeRootPath);

package/src/index.js

@@ -18,6 +18,7 @@ const {
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
+  uninstallMacOSBridgeService,
 } = require("./macos-launch-agent");
 
 module.exports = {
@@ -32,6 +33,7 @@ module.exports = {
   runMacOSBridgeService,
   startMacOSBridgeService,
   stopMacOSBridgeService,
+  uninstallMacOSBridgeService,
   resetBridgePairing: resetBridgeTrustState,
   openLastActiveThread,
   watchThreadRollout,