@makerbi/remodex 3.1.0 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makerbi/remodex",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Local bridge between Codex and the Remodex mobile app. Run `remodex up` to start.",
   "repository": {
     "type": "git",

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

@@ -1865,11 +1865,9 @@ function createDesktopIpcActionFollower({
       return {
         threadId,
         method: "thread-follower-start-turn",
-        params: {
-          conversationId: threadId,
-          senderRequestId: requestId,
-          turnStartParams: params,
-        },
+        params: { conversationId: threadId },
+        senderRequestId: requestId,
+        turnStartParams: params,
       };
     }
     if (method === "turn/steer") {
@@ -1889,7 +1887,8 @@ function createDesktopIpcActionFollower({
         method: "thread-follower-interrupt-turn",
         params: {
           conversationId: threadId,
-          turnId: readString(params.turnId) || readString(params.turn_id),
+          mode: "user-stop",
+          expectedTurnId: readString(params.turnId) || readString(params.turn_id),
         },
       };
     }
@@ -1908,11 +1907,11 @@ function createDesktopIpcActionFollower({
 
   function submitDesktopFollowerRequest(route, originalMessage) {
     Promise.resolve()
-      .then(() => resolveFollowerRequestParams(route))
-      .then(async (resolvedParams) => {
+      .then(() => resolveFollowerRequest(route))
+      .then(async (resolvedRequest) => {
         if (route.method === "thread-follower-start-turn") {
           try {
-            await syncDesktopOwnerRuntimeSettings(route.threadId, resolvedParams.turnStartParams);
+            await syncDesktopOwnerRuntimeSettings(route.threadId, resolvedRequest.turnStartParams);
           } catch (error) {
             // The actual turn has not reached Desktop yet. Even if the settings
             // request timed out after being applied, continuing through the local
@@ -1921,16 +1920,16 @@ function createDesktopIpcActionFollower({
           }
         }
         return {
-          resolvedParams,
-          result: await ipc.sendRequest(route.method, resolvedParams),
+          resolvedRequest,
+          result: await ipc.sendRequest(route.method, resolvedRequest.params),
         };
       })
-      .then(({ resolvedParams, result }) => {
+      .then(({ resolvedRequest, result }) => {
         const appServerResult = appServerResultForFollowerRequest(route.method, result);
         if (route.method === "thread-follower-start-turn") {
           commitPhoneRuntimeSettings(
             route.threadId,
-            resolvedParams.turnStartParams,
+            resolvedRequest.turnStartParams,
             readTurnIdFromAppServerResult(appServerResult)
           );
         }
@@ -2026,19 +2025,34 @@ function createDesktopIpcActionFollower({
 
   // Desktop-followed turn starts must apply the same param normalization as
   // requests forwarded straight to the local app-server.
-  async function resolveFollowerRequestParams(route) {
+  async function resolveFollowerRequest(route) {
     if (route.method !== "thread-follower-start-turn") {
-      return route.params;
+      return {
+        params: route.params,
+        turnStartParams: null,
+      };
     }
 
     const normalized = await Promise.resolve(
-      normalizeTurnStartParams(cloneJSON(route.params.turnStartParams))
+      normalizeTurnStartParams(cloneJSON(route.turnStartParams))
     );
     const turnStartParams = normalized && typeof normalized === "object" && !Array.isArray(normalized)
       ? normalized
-      : route.params.turnStartParams;
+      : route.turnStartParams;
+    const request = cloneJSON(turnStartParams);
+    if (!readString(request.clientUserMessageId)) {
+      request.clientUserMessageId = route.senderRequestId;
+    }
     return {
-      ...route.params,
+      params: {
+        ...route.params,
+        turnStart: {
+          request,
+          context: {
+            inheritThreadSettings: true,
+          },
+        },
+      },
       turnStartParams,
     };
   }

package/src/desktop-ipc-conversation-adapter.js

@@ -454,14 +454,24 @@ function buildConversationStateFromThread(thread, {
     now,
   });
 
-  return {
+  const state = {
     id: threadId,
+    forkedFromId: previous?.forkedFromId || null,
     hostId,
     turns,
     requests: cloneJSON(previous?.requests || []),
     createdAt: createdAtMs,
     updatedAt: updatedAtMs,
+    recencyAt: updatedAtMs,
     title: readString(thread?.name) || previous?.title || null,
+    source: readString(thread?.source) || previous?.source || "vscode",
+    agentNickname: previous?.agentNickname || null,
+    threadSource: readString(thread?.threadSource) || previous?.threadSource || "user",
+    historyMode: previous?.historyMode || "legacy",
+    parentThreadId: previous?.parentThreadId || null,
+    mode: previous?.mode || "default",
+    threadStartKind: previous?.threadStartKind || "default",
+    modelProvider: readString(thread?.modelProvider) || previous?.modelProvider || "openai",
     latestModel,
     latestReasoningEffort: previous?.latestReasoningEffort || null,
     latestServiceTier: previous?.latestServiceTier || null,
@@ -488,7 +498,10 @@ function buildConversationStateFromThread(thread, {
     workspaceBrowserRoot: previous?.workspaceBrowserRoot || null,
     projectlessOutputDirectory: previous?.projectlessOutputDirectory || null,
     currentPermissions: cloneJSON(previous?.currentPermissions || null),
+    sessionId: readString(thread?.sessionId) || previous?.sessionId || null,
   };
+  synchronizeDesktopConversationCompatibility(state);
+  return state;
 }
 
 function mergeConversationTurnsFromThread(threadTurns, {
@@ -552,7 +565,7 @@ function createEmptyConversationState(threadId, {
   cwd = "",
 } = {}) {
   const timestamp = now();
-  return {
+  const state = {
     id: threadId,
     hostId,
     turns: [],
@@ -587,6 +600,189 @@ function createEmptyConversationState(threadId, {
     projectlessOutputDirectory: null,
     currentPermissions: null,
   };
+  synchronizeDesktopConversationCompatibility(state);
+  return state;
+}
+
+// Desktop 26.825 moved rendered history to a canonical entity graph. It still
+// accepts legacy turns during normalization, but unified-timeline selectors now
+// assume the graph and several nested collections exist. Keep the bridge's
+// mutable legacy turns for app-server event handling, and mirror them into the
+// current Desktop shape before every stream broadcast.
+function synchronizeDesktopConversationCompatibility(state) {
+  if (!state || typeof state !== "object" || Array.isArray(state)) {
+    return state;
+  }
+
+  const turns = Array.isArray(state.turns) ? state.turns : [];
+  const entries = [];
+  const entitiesByKey = {};
+  for (const turn of turns) {
+    const turnId = readString(turn?.turnId) || readString(turn?.id);
+    if (!turnId) {
+      continue;
+    }
+    turn.params = normalizeTurnParamsCompatibility(turn.params, {
+      cwd: readString(turn.params?.cwd) || readString(state.cwd),
+    });
+    turn.items = Array.isArray(turn.items) ? turn.items : [];
+    turn.hookRuns = Array.isArray(turn.hookRuns) ? turn.hookRuns : [];
+    const key = `turn:${turnId}`;
+    entries.push({ key, value: key });
+    const { id: _legacyId, ...canonicalTurn } = turn;
+    entitiesByKey[key] = {
+      ...canonicalTurn,
+      turnId,
+    };
+  }
+
+  const islandId = "tail:0";
+  state.turnHistory = {
+    kind: "canonical",
+    history: {
+      entitiesByKey,
+      generation: 0,
+      isComplete: true,
+      islands: [{
+        id: islandId,
+        entries,
+        olderBoundary: {
+          status: "exhausted",
+          boundaryId: `${islandId}:older`,
+        },
+        newerBoundary: {
+          status: "exhausted",
+          boundaryId: `${islandId}:newer`,
+        },
+      }],
+    },
+  };
+  state.turnsPagination = {
+    olderCursor: null,
+    oldestLoadedTurnId: readString(turns[0]?.turnId) || readString(turns[0]?.id) || null,
+    isLoadingOlder: false,
+    hasLoadedOldest: true,
+  };
+
+  const latestParams = [...turns]
+    .reverse()
+    .map((turn) => turn?.params)
+    .find((params) => params && typeof params === "object") || null;
+  const sandboxPolicy = normalizeSandboxPolicyCompatibility(
+    latestParams?.sandboxPolicy || state.currentPermissions?.sandboxPolicy
+  );
+  if (sandboxPolicy) {
+    const runtimeWorkspaceRoots = Array.isArray(latestParams?.runtimeWorkspaceRoots)
+      ? cloneJSON(latestParams.runtimeWorkspaceRoots)
+      : Array.isArray(state.currentPermissions?.runtimeWorkspaceRoots)
+        ? cloneJSON(state.currentPermissions.runtimeWorkspaceRoots)
+        : [];
+    state.currentPermissions = {
+      activePermissionProfile: cloneJSON(
+        latestParams?.activePermissionProfile
+          ?? state.currentPermissions?.activePermissionProfile
+          ?? permissionProfileFromId(latestParams?.permissions)
+      ),
+      approvalPolicy: latestParams?.approvalPolicy
+        ?? state.currentPermissions?.approvalPolicy
+        ?? "on-request",
+      approvalsReviewer: latestParams?.approvalsReviewer
+        ?? state.currentPermissions?.approvalsReviewer
+        ?? "user",
+      runtimeWorkspaceRoots,
+      sandboxPolicy,
+    };
+  }
+
+  state.recencyAt = Number.isFinite(state.recencyAt) ? state.recencyAt : state.updatedAt;
+  state.source ||= "vscode";
+  state.threadSource ||= "user";
+  state.historyMode ||= "legacy";
+  state.mode ||= "default";
+  state.threadStartKind ||= "default";
+  state.modelProvider ||= "openai";
+  state.latestThreadSettings = {
+    cwd: readString(latestParams?.cwd) || readString(state.cwd) || null,
+    approvalPolicy: latestParams?.approvalPolicy ?? state.currentPermissions?.approvalPolicy ?? null,
+    approvalsReviewer: latestParams?.approvalsReviewer
+      ?? state.currentPermissions?.approvalsReviewer
+      ?? null,
+    ...(sandboxPolicy ? { sandboxPolicy } : {}),
+    activePermissionProfile: cloneJSON(state.currentPermissions?.activePermissionProfile ?? null),
+    model: readString(state.latestThreadSettings?.model)
+      || readString(latestParams?.model)
+      || readString(state.latestModel)
+      || null,
+    modelProvider: readString(state.latestThreadSettings?.modelProvider)
+      || readString(state.modelProvider)
+      || "openai",
+    serviceTier: readString(state.latestThreadSettings?.serviceTier)
+      || readString(latestParams?.serviceTier)
+      || readString(state.latestServiceTier)
+      || null,
+    effort: state.latestThreadSettings?.effort
+      ?? latestParams?.effort
+      ?? state.latestReasoningEffort
+      ?? null,
+    summary: latestParams?.summary ?? state.latestThreadSettings?.summary ?? "none",
+    collaborationMode: cloneJSON(
+      state.latestThreadSettings?.collaborationMode
+        || latestParams?.collaborationMode
+        || state.latestCollaborationMode
+        || null
+    ),
+    multiAgentMode: latestParams?.multiAgentMode
+      ?? state.latestThreadSettings?.multiAgentMode
+      ?? null,
+    personality: latestParams?.personality
+      ?? state.latestThreadSettings?.personality
+      ?? null,
+  };
+  return state;
+}
+
+function normalizeTurnParamsCompatibility(params, { cwd = "" } = {}) {
+  const normalized = params && typeof params === "object" && !Array.isArray(params)
+    ? params
+    : {};
+  normalized.input = Array.isArray(normalized.input) ? normalized.input : [];
+  normalized.attachments = Array.isArray(normalized.attachments) ? normalized.attachments : [];
+  normalized.cwd = readString(normalized.cwd) || readString(cwd) || null;
+  normalized.summary ??= "none";
+  normalized.personality ??= null;
+  normalized.outputSchema ??= null;
+  normalized.collaborationMode ??= null;
+  const sandboxPolicy = normalizeSandboxPolicyCompatibility(normalized.sandboxPolicy);
+  if (sandboxPolicy) {
+    normalized.sandboxPolicy = sandboxPolicy;
+  }
+  return normalized;
+}
+
+function normalizeSandboxPolicyCompatibility(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) {
+    return null;
+  }
+  const normalized = cloneJSON(policy);
+  if (normalizeToken(normalized.type) === "workspacewrite") {
+    normalized.type = "workspaceWrite";
+    normalized.writableRoots = Array.isArray(normalized.writableRoots)
+      ? normalized.writableRoots
+      : [];
+    normalized.excludeSlashTmp = Boolean(normalized.excludeSlashTmp);
+    normalized.excludeTmpdirEnvVar = Boolean(normalized.excludeTmpdirEnvVar);
+    normalized.networkAccess = Boolean(normalized.networkAccess);
+  }
+  if (normalizeToken(normalized.type) === "readonly") {
+    normalized.type = "readOnly";
+    normalized.networkAccess = Boolean(normalized.networkAccess);
+  }
+  return normalized;
+}
+
+function permissionProfileFromId(value) {
+  const id = readString(value);
+  return id ? { id, extends: null } : null;
 }
 
 function buildConversationTurn(turn, {
@@ -596,7 +792,7 @@ function buildConversationTurn(turn, {
   now = () => Date.now(),
 } = {}) {
   const turnId = readString(turn?.id) || readString(turn?.turnId) || readString(turn?.turn_id);
-  const params = cloneJSON(previousTurn?.params || {
+  const params = normalizeTurnParamsCompatibility(cloneJSON(previousTurn?.params || {
     threadId,
     input: [],
     cwd: cwd || null,
@@ -611,7 +807,7 @@ function buildConversationTurn(turn, {
     outputSchema: null,
     collaborationMode: null,
     attachments: [],
-  });
+  }), { cwd });
   const builtTurn = {
     id: turnId,
     turnId,
@@ -678,6 +874,9 @@ function applyPendingTurnStartParams(
     ...turn.params,
     ...cloneJSON(pendingParams),
   };
+  turn.params = normalizeTurnParamsCompatibility(turn.params, {
+    cwd: readString(turn.params?.cwd) || readString(conversation?.cwd),
+  });
   normalizeTurnInitialPrompt(turn);
 }
 
@@ -1262,6 +1461,7 @@ module.exports = {
   readThreadIdFromParams,
   readTurnIdFromParams,
   readTurnIdFromTurn,
+  synchronizeDesktopConversationCompatibility,
   timestampSecondsToMs,
   upsertItem,
   upsertTurn,

package/src/desktop-ipc-live-owner.js

@@ -27,6 +27,7 @@ const {
   buildConversationStateFromThread,
   createEmptyConversationState,
   readThreadIdFromParams,
+  synchronizeDesktopConversationCompatibility,
 } = require("./desktop-ipc-conversation-adapter");
 const {
   DEFAULT_MAX_PATCH_BYTES,
@@ -94,20 +95,33 @@ const OWNER_INBOUND_METHODS = new Set([
 
 const THREAD_READ_METHODS = new Set(["thread/read", "thread/resume"]);
 
-const ALLOWED_TURN_START_PARAM_KEYS = new Set([
+// Current app-server v2 TurnStartParams fields. Desktop's adjacent turnStart.context
+// is presentation state, not part of this RPC shape, so it stays outside the request.
+const APP_SERVER_TURN_START_PARAM_KEYS = new Set([
   "threadId",
   "input",
+  "additionalContext",
   "cwd",
   "approvalPolicy",
   "approvalsReviewer",
   "sandboxPolicy",
   "model",
   "serviceTier",
+  "serviceTierForTurn",
   "effort",
   "summary",
   "personality",
   "outputSchema",
   "collaborationMode",
+  "clientUserMessageId",
+  "cyberAccessProgram",
+  "environments",
+  "multiAgentMode",
+  "permissions",
+  "responsesapiClientMetadata",
+  "runtimeWorkspaceRoots",
+  "toolOutput",
+  "turnTrigger",
 ]);
 
 function createDesktopIpcLiveOwner({
@@ -1104,6 +1118,7 @@ function createDesktopIpcLiveOwner({
       return true;
     }
     runtimeSettingsStore?.attachToConversation?.(threadId, conversationState);
+    synchronizeDesktopConversationCompatibility(conversationState);
     if (shouldDelayInitialSnapshotForHistory(threadId)) {
       return false;
     }
@@ -1367,10 +1382,7 @@ function createDesktopIpcLiveOwner({
   }
 
   async function handleFollowerStartTurn(conversationId, params) {
-    const rawTurnStartParams = params.turnStartParams
-      || params.turn_start_params
-      || params.turnStart
-      || params;
+    const rawTurnStartParams = readFollowerTurnStartParams(params);
     const codexParams = mergeFollowerRuntimeOverrides(conversationId, sanitizeTurnStartParams({
       ...rawTurnStartParams,
       threadId: conversationId,
@@ -1380,7 +1392,9 @@ function createDesktopIpcLiveOwner({
       ? normalizedParams
       : codexParams;
     markOwnedThread(conversationId);
-    const senderRequestId = params.senderRequestId || params.sender_request_id;
+    const senderRequestId = params.senderRequestId
+      || params.sender_request_id
+      || rawTurnStartParams.clientUserMessageId;
     const isKnownHeldPhoneStart = Boolean(
       requestIdKey(senderRequestId)
       && pendingTurnStartEntriesByRequestId.has(requestIdKey(senderRequestId))
@@ -1417,6 +1431,17 @@ function createDesktopIpcLiveOwner({
     }
   }
 
+  function readFollowerTurnStartParams(params) {
+    const turnStart = isPlainJSONObject(params.turnStart) ? params.turnStart : null;
+    if (isPlainJSONObject(turnStart?.request)) {
+      return turnStart.request;
+    }
+    return params.turnStartParams
+      || params.turn_start_params
+      || params.turnStart
+      || params;
+  }
+
   function mirrorFollowerUserPromptToPhone(threadId, turnStartParams, turnStartResult = null) {
     const text = visibleUserPromptFromInputEntries(turnStartParams?.input);
     if (!text) {
@@ -1461,16 +1486,50 @@ function createDesktopIpcLiveOwner({
   }
 
   async function handleFollowerInterruptTurn(conversationId, params) {
-    const turnId = readString(params.turnId)
-      || readString(params.turn_id)
-      || activeTurnIdForConversation(conversationId);
+    const requestedTurnId = readString(params.expectedTurnId)
+      || readString(params.expected_turn_id)
+      || readString(params.turnId)
+      || readString(params.turn_id);
+    const activeTurnId = activeTurnIdForConversation(conversationId);
+    if (requestedTurnId && requestedTurnId !== activeTurnId) {
+      return {
+        interruptedTurnId: null,
+        ok: true,
+      };
+    }
+
+    const goalPauseError = await pauseActiveGoalForUserStop(
+      conversationId,
+      params.mode,
+      Boolean(requestedTurnId)
+    );
+    const turnId = requestedTurnId || activeTurnId;
     if (!turnId) {
-      throw new Error("Missing turnId for follower interrupt request.");
+      return followerInterruptResult(null, goalPauseError);
     }
-    return await sendCodexRequest("turn/interrupt", {
+    await sendCodexRequest("turn/interrupt", {
       threadId: conversationId,
       turnId,
     });
+    return followerInterruptResult(turnId, goalPauseError);
+  }
+
+  async function pauseActiveGoalForUserStop(conversationId, mode, hasRequestedTurnId) {
+    if (mode !== "user-stop" || hasRequestedTurnId) {
+      return "";
+    }
+    if (conversations.get(conversationId)?.threadGoal?.status !== "active") {
+      return "";
+    }
+    try {
+      await sendCodexRequest("thread/goal/set", {
+        threadId: conversationId,
+        status: "paused",
+      });
+      return "";
+    } catch (error) {
+      return error?.message || "Failed to pause thread goal.";
+    }
   }
 
   // Desktop follower approvals only carry decision-style payloads, but app-server
@@ -1786,8 +1845,7 @@ function createDesktopIpcLiveOwner({
         return turnId;
       }
     }
-    const latestTurn = turns[turns.length - 1];
-    return readString(latestTurn?.turnId) || readString(latestTurn?.id);
+    return "";
   }
 
   return {
@@ -1881,7 +1939,7 @@ function normalizeInputEntriesForDesktop(input) {
 function sanitizeTurnStartParams(params) {
   const sanitized = {};
   for (const [key, value] of Object.entries(params || {})) {
-    if (ALLOWED_TURN_START_PARAM_KEYS.has(key)) {
+    if (APP_SERVER_TURN_START_PARAM_KEYS.has(key)) {
       sanitized[key] = value;
     }
   }
@@ -1891,6 +1949,14 @@ function sanitizeTurnStartParams(params) {
   return sanitized;
 }
 
+function followerInterruptResult(interruptedTurnId, goalPauseError) {
+  return {
+    interruptedTurnId,
+    ...(goalPauseError ? { goalPauseError } : {}),
+    ok: true,
+  };
+}
+
 function readThreadFromResponse(message) {
   const result = message?.result || message?.payload || {};
   return readThreadFromPayload(result);

package/src/desktop-ipc-shared.js

@@ -28,12 +28,12 @@ const DESKTOP_IPC_METHOD_VERSIONS = new Map([
   ["thread-unarchived", 1],
   ["thread-read-state-changed", 2],
   ["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],