@makerbi/remodex 3.1.0 → 3.3.0

package/src/desktop-ipc-shared.js

@@ -26,14 +26,15 @@ const DESKTOP_IPC_METHOD_VERSIONS = new Map([
   ["thread-stream-following-status-requested", 1],
   ["thread-archived", 2],
   ["thread-unarchived", 1],
-  ["thread-read-state-changed", 2],
+  ["thread-owner-discovery", 1],
+  ["thread-read-state-changed", 3],
   ["thread-queued-followups-changed", 1],
-  ["thread-follower-start-turn", 1],
+  ["thread-follower-start-turn", 2],
   ["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", 3],
+  ["thread-follower-interrupt-turn", 4],
   ["thread-follower-set-model-and-reasoning", 1],
   ["thread-follower-set-collaboration-mode", 1],
   ["thread-follower-edit-last-user-turn", 2],
@@ -582,6 +583,38 @@ function buildCompleteThreadReadParams(threadId) {
   };
 }
 
+// Desktop 26.903 scopes read receipts to the authenticated identity and runtime.
+// Only the local stdio runtime is owned by this bridge; never broadcast tokens.
+function buildThreadReadStateContext(authStatus, hostId = "local") {
+  if (!authStatus || hostId !== "local") {
+    return null;
+  }
+  let identity;
+  if (authStatus.authMethod === "chatgpt" || authStatus.authMethod === "chatgptAuthTokens") {
+    try {
+      const payload = JSON.parse(Buffer.from(
+        readString(authStatus.authToken).split(".")[1] || "", "base64url"
+      ).toString("utf8"));
+      const auth = payload["https://api.openai.com/auth"];
+      const accountId = readString(auth?.chatgpt_account_id ?? auth?.account_id);
+      const userId = readString(auth?.user_id ?? auth?.chatgpt_user_id);
+      if (!accountId || !userId) {
+        return null;
+      }
+      identity = { kind: "chatgpt", accountId, userId };
+    } catch {
+      return null;
+    }
+  } else {
+    if (authStatus.authMethod == null && authStatus.requiresOpenaiAuth !== false) {
+      return null;
+    }
+    identity = { kind: "execution-storage", authMode: authStatus.authMethod ?? "none" };
+  }
+  const hostHash = createHash("sha256").update(JSON.stringify(["local", hostId, null])).digest("hex");
+  return { identity, executionHostKey: `${hostId}:${hostHash}` };
+}
+
 function resolveIpcSocketPathCandidates() {
   if (process.platform === "win32") {
     return ["\\\\.\\pipe\\codex-ipc"];
@@ -666,6 +699,7 @@ function responseItemMessageText(payload) {
 }
 
 module.exports = {
+  buildThreadReadStateContext,
   CLIENT_STATUS_CHANGED,
   buildCompleteThreadReadParams,
   buildIpcRequestEnvelope,

package/src/git-handler.js

@@ -69,9 +69,6 @@ function handleGitRequest(rawMessage, sendResponse, options = {}) {
   handleGitMethod(method, params, methodOptions)
     .then((result) => {
       sendResponse(JSON.stringify({ id, result }));
-      if (method === "thread/name/set") {
-        options.onThreadNameSet?.(result);
-      }
     })
     .catch((err) => {
       const errorCode = err.errorCode || "git_error";
@@ -96,7 +93,7 @@ async function handleGitMethod(method, params, options = {}) {
     return threadGenerateTitle(params, options);
   }
   if (method === "thread/name/set") {
-    return threadNameSet(params);
+    return threadNameSet(params, options);
   }
 
   const cwd = await resolveGitCwd(params);
@@ -153,8 +150,9 @@ async function handleGitMethod(method, params, options = {}) {
   }
 }
 
-// Owns mobile thread renames locally so they do not fall through to unsupported Codex RPC.
-function threadNameSet(params) {
+// Normalize mobile aliases, then persist through the same catalog RPC as Desktop.
+// The app-server emits thread/name/updated to the phone and live IPC owner.
+async function threadNameSet(params, { sendCodexRequest } = {}) {
   const threadId = normalizeNonEmptyLine(params.threadId || params.thread_id || params.conversationId || params.conversation_id);
   const name = normalizeNonEmptyLine(params.name || params.threadName || params.thread_name || params.title);
   if (!threadId) {
@@ -164,6 +162,11 @@ function threadNameSet(params) {
     throw gitError("missing_thread_name", "A thread name is required.");
   }
 
+  if (typeof sendCodexRequest !== "function") {
+    throw gitError("thread_rename_unavailable", "The local Codex connection is unavailable.");
+  }
+  await sendCodexRequest("thread/name/set", { threadId, name });
+
   return { threadId, thread_id: threadId, name, title: name };
 }
 
@@ -184,9 +187,8 @@ async function gitStatus(cwd) {
   const localOnlyCommitCount = await countLocalOnlyCommits(cwd, { detached: snapshot.detached }).catch(() => 0);
   const state = computeState(dirty, ahead, behind, snapshot.detached, noUpstream);
   const canPush = hasPushRemote && hasHeadCommit && (ahead > 0 || noUpstream) && !snapshot.detached;
-  const diff = await repoDiffTotals(cwd, {
+  const diff = await repoDiffTotals(snapshot.repoRoot || cwd, {
     tracking: snapshot.tracking,
-    fileLines: snapshot.fileLines,
   }).catch(() => ({ additions: 0, deletions: 0, binaryFiles: 0 }));
 
   return {
@@ -267,17 +269,14 @@ async function gitInit(cwd) {
 // ─── Git Diff ─────────────────────────────────────────────────
 
 async function gitDiff(cwd) {
+  cwd = await resolveRepoRoot(cwd);
   const porcelain = await git(cwd, "status", "--porcelain=v1", "-b");
   const lines = porcelain.trim().split("\n").filter(Boolean);
   const branchLine = lines[0] || "";
-  const fileLines = lines.slice(1);
   const tracking = parseTrackingFromStatus(branchLine);
   const baseRef = await resolveRepoDiffBase(cwd, tracking);
   const trackedPatch = await gitDiffAgainstBase(cwd, baseRef);
-  const untrackedPaths = fileLines
-    .filter((line) => line.startsWith("?? "))
-    .map((line) => line.substring(3).trim())
-    .filter(Boolean);
+  const untrackedPaths = await repoUntrackedPaths(cwd);
   const untrackedPatch = await diffPatchForUntrackedFiles(cwd, untrackedPaths);
   const patch = [trackedPatch.trim(), untrackedPatch.trim()].filter(Boolean).join("\n\n").trim();
   return { patch };
@@ -2349,10 +2348,7 @@ function scopedLocalCheckoutPath(checkoutRootPath, projectRelativePath) {
 async function repoDiffTotals(cwd, context) {
   const baseRef = await resolveRepoDiffBase(cwd, context.tracking);
   const trackedTotals = await diffTotalsAgainstBase(cwd, baseRef);
-  const untrackedPaths = context.fileLines
-    .filter((line) => line.startsWith("?? "))
-    .map((line) => line.substring(3).trim())
-    .filter(Boolean);
+  const untrackedPaths = await repoUntrackedPaths(cwd);
   const untrackedTotals = await diffTotalsForUntrackedFiles(cwd, untrackedPaths);
 
   return {
@@ -2362,6 +2358,13 @@ async function repoDiffTotals(cwd, context) {
   };
 }
 
+// Porcelain collapses new directories and quotes filenames. Ask Git for the
+// individual paths so the summary and Changes patch include every new file.
+async function repoUntrackedPaths(repoRoot) {
+  const output = await git(repoRoot, "ls-files", "--others", "--exclude-standard", "-z");
+  return output.split("\0").filter(Boolean);
+}
+
 // Uses upstream when available; otherwise falls back to commits not yet present on any remote.
 async function resolveRepoDiffBase(cwd, tracking) {
   if (!(await refExists(cwd, "HEAD"))) {

package/src/rollout-live-mirror.js

@@ -205,10 +205,9 @@ function createThreadRolloutLiveMirror({
 
     try {
       const currentTime = now();
-      const suppressedBeforeScan = isSuppressed();
+      const suppressedBeforeScan = isSuppressed({ probeFallbackActivity: true });
       if (suppressedBeforeScan) {
         if (!wasSuppressed) {
-          rolloutPath = null;
           lastSize = 0;
           partialLine = "";
           didBootstrap = false;
@@ -218,7 +217,6 @@ function createThreadRolloutLiveMirror({
         return;
       }
       if (wasSuppressed) {
-        rolloutPath = null;
         lastSize = 0;
         partialLine = "";
         didBootstrap = false;
@@ -251,7 +249,8 @@ function createThreadRolloutLiveMirror({
         fallbackActivityAt: Number(rolloutStat.mtimeMs) || 0,
       });
       if (suppressed) {
-        rolloutPath = null;
+        // Keep the resolved path so quiet Desktop work needs only a stat on
+        // later probes, without repeatedly searching the sessions directory.
         lastSize = 0;
         partialLine = "";
         didBootstrap = false;

package/src/runtime-provider-router.js

@@ -76,7 +76,11 @@ function createRuntimeProviderRouter({
 
     if (method === "model/list") {
       respondAsync(parsed, sendResponse, async () => {
-        const codexResult = await sendCodexRequest("model/list", stripProviderFields(parsed.params || {}));
+        const codexResult = await sendCodexRequest(
+          "model/list",
+          stripProviderFields(parsed.params || {}),
+          String(parsed.id)
+        );
         const providerModels = await listProviderModels(runtimeProviders);
         return mergeModelListResult(codexResult, providerModels);
       });
@@ -85,7 +89,11 @@ function createRuntimeProviderRouter({
 
     if (method === "thread/list") {
       respondAsync(parsed, sendResponse, async () => {
-        const codexResult = await sendCodexRequest("thread/list", stripProviderFields(parsed.params || {}));
+        const codexResult = await sendCodexRequest(
+          "thread/list",
+          stripProviderFields(parsed.params || {}),
+          String(parsed.id)
+        );
         const providerThreads = hasCursor(parsed.params)
           ? []
           : await listProviderThreads(runtimeProviders, parsed.params || {});