@makerbi/remodex 2.0.0 → 2.3.0

package/src/rollout-turn-semantics.js

@@ -0,0 +1,20 @@
+// FILE: rollout-turn-semantics.js
+// Purpose: Shared desktop rollout turn-lifecycle semantics for the live mirror
+// and the JSONL history fallback, so both agree on what ends a run.
+
+// Any of these event_msg types ends a desktop run; task_complete is not the only
+// terminal outcome (Stop on desktop writes turn_aborted, fatal failures write error).
+const TERMINAL_TASK_EVENT_TYPES = new Set(["task_complete", "turn_aborted", "error"]);
+
+// Desktop interleaves parallel turns in one rollout file. A terminal event only
+// closes the tracked turn when it targets that turn, carries no explicit id, or
+// nothing is tracked; a sibling turn's terminal event must leave the tracked
+// run open.
+function terminalEventClosesTrackedTurn(eventTurnId, trackedTurnId) {
+  return !eventTurnId || !trackedTurnId || eventTurnId === trackedTurnId;
+}
+
+module.exports = {
+  TERMINAL_TASK_EVENT_TYPES,
+  terminalEventClosesTrackedTurn,
+};

package/src/runtime-provider-models.js

@@ -0,0 +1,164 @@
+// FILE: runtime-provider-models.js
+// Purpose: Normalizes provider-aware model/thread metadata shared by local runtime providers.
+// Layer: Bridge runtime provider helper
+// Exports: provider constants plus model/provider parsing helpers.
+// Depends on: none
+
+const CODEX_PROVIDER_ID = "codex";
+const CURSOR_PROVIDER_ID = "cursor";
+const OPENCODE_PROVIDER_ID = "opencode";
+
+const PROVIDER_FIELD_KEYS = [
+  "modelProvider",
+  "model_provider",
+  "provider",
+  "runtimeProvider",
+  "runtime_provider",
+  "harness",
+];
+
+function normalizeRuntimeProvider(value) {
+  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+  switch (normalized) {
+    case "":
+      return CODEX_PROVIDER_ID;
+    case "cursor-agent":
+    case "cursor_cli":
+    case "cursor-cli":
+      return CURSOR_PROVIDER_ID;
+    case "open-code":
+    case "open_code":
+      return OPENCODE_PROVIDER_ID;
+    case "claude-code":
+    case "claudecode":
+      return "claude";
+    default:
+      return normalized;
+  }
+}
+
+function readModelProvider(value = {}) {
+  if (!value || typeof value !== "object") {
+    return CODEX_PROVIDER_ID;
+  }
+
+  return normalizeRuntimeProvider(
+    value.modelProvider
+      || value.model_provider
+      || value.provider
+      || value.runtimeProvider
+      || value.runtime_provider
+      || value.harness
+      || value.collaborationMode?.settings?.modelProvider
+      || value.collaborationMode?.settings?.model_provider
+      || value.collaborationMode?.settings?.provider
+      || value.collaboration_mode?.settings?.modelProvider
+      || value.collaboration_mode?.settings?.model_provider
+      || value.collaboration_mode?.settings?.provider
+  );
+}
+
+function hasExplicitProviderField(value = {}) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  return hasOwnProviderField(value)
+    || hasOwnProviderField(value.collaborationMode?.settings)
+    || hasOwnProviderField(value.collaboration_mode?.settings);
+}
+
+function isCodexProvider(value) {
+  return normalizeRuntimeProvider(value) === CODEX_PROVIDER_ID;
+}
+
+function isCursorProvider(value) {
+  return normalizeRuntimeProvider(value) === CURSOR_PROVIDER_ID;
+}
+
+function isOpenCodeProvider(value) {
+  return normalizeRuntimeProvider(value) === OPENCODE_PROVIDER_ID;
+}
+
+function buildRuntimeModelOption({
+  provider,
+  id,
+  model = id,
+  displayName,
+  description = "",
+  isDefault = false,
+  supportsFastMode = false,
+  supportedReasoningEfforts = [],
+  defaultReasoningEffort = null,
+}) {
+  const normalizedProvider = normalizeRuntimeProvider(provider);
+  const normalizedId = readString(id || model);
+  const normalizedModel = readString(model || id);
+  if (!normalizedProvider || !normalizedId || !normalizedModel) {
+    return null;
+  }
+
+  return {
+    id: normalizedId,
+    model: normalizedModel,
+    modelProvider: normalizedProvider,
+    provider: normalizedProvider,
+    displayName: readString(displayName) || normalizedModel,
+    description: readString(description),
+    isDefault,
+    supportsFastMode,
+    supportedReasoningEfforts,
+    defaultReasoningEffort,
+  };
+}
+
+function stripProviderFields(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return value;
+  }
+
+  const clone = { ...value };
+  for (const key of PROVIDER_FIELD_KEYS) {
+    delete clone[key];
+  }
+
+  if (clone.collaborationMode?.settings) {
+    clone.collaborationMode = {
+      ...clone.collaborationMode,
+      settings: stripProviderFields(clone.collaborationMode.settings),
+    };
+  }
+  if (clone.collaboration_mode?.settings) {
+    clone.collaboration_mode = {
+      ...clone.collaboration_mode,
+      settings: stripProviderFields(clone.collaboration_mode.settings),
+    };
+  }
+  return clone;
+}
+
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+function hasOwnProviderField(value = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return PROVIDER_FIELD_KEYS.some((key) => Object.prototype.hasOwnProperty.call(value, key));
+}
+
+module.exports = {
+  CODEX_PROVIDER_ID,
+  CURSOR_PROVIDER_ID,
+  OPENCODE_PROVIDER_ID,
+  PROVIDER_FIELD_KEYS,
+  buildRuntimeModelOption,
+  hasExplicitProviderField,
+  isCodexProvider,
+  isCursorProvider,
+  isOpenCodeProvider,
+  normalizeRuntimeProvider,
+  readModelProvider,
+  stripProviderFields,
+};

package/src/runtime-provider-router.js

@@ -0,0 +1,365 @@
+// FILE: runtime-provider-router.js
+// Purpose: Routes provider-aware Remodex RPCs between Codex app-server and local runtime providers.
+// Layer: Bridge runtime routing
+// Exports: createRuntimeProviderRouter plus merge helpers used by tests.
+// Depends on: ./cursor-provider, ./opencode-provider, ./runtime-provider-models
+
+const { createCursorProvider } = require("./cursor-provider");
+const { createOpenCodeProvider } = require("./opencode-provider");
+const {
+  CODEX_PROVIDER_ID,
+  readModelProvider,
+  stripProviderFields,
+} = require("./runtime-provider-models");
+
+const ROUTABLE_THREAD_METHODS = new Set([
+  "thread/start",
+  "thread/resume",
+  "thread/read",
+  "thread/turns/list",
+  "thread/name/set",
+  "thread/archive",
+  "thread/unarchive",
+  "turn/start",
+  "turn/interrupt",
+]);
+
+function createRuntimeProviderRouter({
+  sendCodexRequest,
+  sendApplicationResponse,
+  sendRuntimeMessage,
+  providers = null,
+  projectRegistry = null,
+  logPrefix = "[remodex]",
+} = {}) {
+  const runtimeProviders = providers || [
+    createCursorProvider({
+      sendApplicationMessage: (message) => sendRuntimeProviderMessage("cursor", message),
+      logPrefix,
+    }),
+    createOpenCodeProvider({
+      sendApplicationMessage: (message) => sendRuntimeProviderMessage("opencode", message),
+      projectRegistry,
+      logPrefix,
+    }),
+  ];
+
+  function sendRuntimeProviderMessage(provider, message) {
+    if (sendRuntimeMessage) {
+      sendRuntimeMessage(provider, message);
+      return;
+    }
+    sendApplicationResponse(message);
+  }
+
+  function handleApplicationMessage(rawMessage, options = {}) {
+    const sendResponse = options.sendResponse || sendApplicationResponse;
+    const parsed = safeParseJSON(rawMessage);
+    if (!parsed) {
+      return false;
+    }
+
+    const responseProvider = runtimeProviders.find((provider) => (
+      parsed.id != null
+      && !parsed.method
+      && typeof provider.handleApplicationResponse === "function"
+      && provider.handleApplicationResponse(parsed)
+    ));
+    if (responseProvider) {
+      return true;
+    }
+
+    const method = readString(parsed.method);
+    if (!method) {
+      return false;
+    }
+
+    if (method === "model/list") {
+      respondAsync(parsed, sendResponse, async () => {
+        const codexResult = await sendCodexRequest("model/list", stripProviderFields(parsed.params || {}));
+        const providerModels = await listProviderModels(runtimeProviders);
+        return mergeModelListResult(codexResult, providerModels);
+      });
+      return true;
+    }
+
+    if (method === "thread/list") {
+      respondAsync(parsed, sendResponse, async () => {
+        const codexResult = await sendCodexRequest("thread/list", stripProviderFields(parsed.params || {}));
+        const providerThreads = hasCursor(parsed.params)
+          ? []
+          : await listProviderThreads(runtimeProviders, parsed.params || {});
+        registerThreadProjects(projectRegistry, threadsFromListResult(codexResult), {
+          source: "codex-thread-list",
+          provider: CODEX_PROVIDER_ID,
+        });
+        registerThreadProjects(projectRegistry, providerThreads, {
+          source: "provider-thread-list",
+        });
+        return mergeThreadListResult(codexResult, providerThreads);
+      });
+      return true;
+    }
+
+    if (!ROUTABLE_THREAD_METHODS.has(method)) {
+      return false;
+    }
+
+    const provider = providerForRequest(parsed, runtimeProviders);
+    if (!provider) {
+      return false;
+    }
+
+    rememberProjectFromRequest(projectRegistry, parsed, {
+      source: "provider-request",
+      provider: provider.id,
+    });
+    respondAsync(parsed, sendResponse, () => provider.handleRequest(parsed));
+    return true;
+  }
+
+  function respondAsync(request, sendResponse, resolveResult) {
+    Promise.resolve()
+      .then(resolveResult)
+      .then((result) => {
+        if (request.id != null) {
+          sendResponse(JSON.stringify({
+            id: request.id,
+            result,
+          }));
+        }
+      })
+      .catch((error) => {
+        if (request.id != null) {
+          sendResponse(createJsonRpcErrorResponse(
+            request.id,
+            error,
+            error?.errorCode || "runtime_provider_failed"
+          ));
+        }
+      });
+  }
+
+  return {
+    handleApplicationMessage,
+    providers: runtimeProviders,
+    shutdown() {
+      for (const provider of runtimeProviders) {
+        provider.shutdown?.();
+      }
+    },
+  };
+}
+
+async function listProviderModels(providers) {
+  const settled = await Promise.allSettled(providers.map((provider) => provider.listModels()));
+  return settled.flatMap((result) => (result.status === "fulfilled" ? result.value : []));
+}
+
+async function listProviderThreads(providers, params) {
+  const settled = await Promise.allSettled(providers.map((provider) => provider.listThreads(params)));
+  return settled.flatMap((result) => {
+    if (result.status !== "fulfilled") {
+      return [];
+    }
+    const payload = result.value;
+    return Array.isArray(payload?.data) ? payload.data : [];
+  });
+}
+
+function providerForRequest(request, providers) {
+  const params = request.params || {};
+  const providerFromRequest = readModelProvider(params);
+  if (providerFromRequest !== CODEX_PROVIDER_ID) {
+    return providers.find((provider) => provider.canHandleProvider?.(providerFromRequest)) || null;
+  }
+  if (hasExplicitProviderField(params)) {
+    return null;
+  }
+
+  const threadId = readThreadId(params);
+  if (!threadId) {
+    return null;
+  }
+
+  return providers.find((provider) => provider.ownsThread?.(threadId)) || null;
+}
+
+function mergeModelListResult(codexResult, providerModels) {
+  const result = codexResult && typeof codexResult === "object" ? codexResult : {};
+  const key = firstArrayKey(result, ["items", "data", "models"]) || "items";
+  const codexModels = Array.isArray(result[key]) ? result[key] : [];
+  const normalizedCodexModels = codexModels.map((model) => ({
+    ...model,
+    modelProvider: CODEX_PROVIDER_ID,
+    provider: CODEX_PROVIDER_ID,
+  }));
+
+  return {
+    ...result,
+    [key]: [
+      ...normalizedCodexModels,
+      ...providerModels,
+    ],
+  };
+}
+
+function mergeThreadListResult(codexResult, providerThreads) {
+  const result = codexResult && typeof codexResult === "object" ? codexResult : {};
+  const key = firstArrayKey(result, ["data", "items", "threads"]) || "data";
+  const codexThreads = Array.isArray(result[key]) ? result[key] : [];
+  const merged = dedupeMergedThreads(codexThreads, providerThreads).sort(compareThreadsByUpdatedAt);
+
+  return {
+    ...result,
+    [key]: merged,
+  };
+}
+
+function dedupeMergedThreads(codexThreads, providerThreads) {
+  const mergedById = new Map();
+  for (const thread of codexThreads) {
+    const threadId = readThreadIdentifier(thread);
+    if (threadId) {
+      mergedById.set(threadId, thread);
+    }
+  }
+
+  for (const thread of providerThreads) {
+    const threadId = readThreadIdentifier(thread);
+    if (!threadId) {
+      continue;
+    }
+    if (!mergedById.has(threadId) || readModelProvider(thread) !== CODEX_PROVIDER_ID) {
+      mergedById.set(threadId, thread);
+    }
+  }
+  return Array.from(mergedById.values());
+}
+
+function threadsFromListResult(result) {
+  const key = firstArrayKey(result, ["data", "items", "threads"]);
+  return key && Array.isArray(result?.[key]) ? result[key] : [];
+}
+
+function registerThreadProjects(projectRegistry, threads, metadata = {}) {
+  if (!projectRegistry || !Array.isArray(threads) || !threads.length) {
+    return;
+  }
+
+  try {
+    projectRegistry.rememberProjectsFromThreads(threads, metadata);
+  } catch {
+    // Project history is a cache; provider routing should not fail when it cannot be persisted.
+  }
+}
+
+function rememberProjectFromRequest(projectRegistry, request, metadata = {}) {
+  if (!projectRegistry) {
+    return;
+  }
+
+  const params = request?.params || {};
+  const cwd = readString(params.cwd || params.current_working_directory || params.working_directory);
+  if (!cwd) {
+    return;
+  }
+
+  try {
+    projectRegistry.rememberProjectPath(cwd, metadata);
+  } catch {
+    // Best-effort cache write; the runtime request remains authoritative.
+  }
+}
+
+function stripRuntimeProviderFieldsForCodex(rawMessage) {
+  const parsed = safeParseJSON(rawMessage);
+  if (!parsed || !parsed.params || typeof parsed.params !== "object" || Array.isArray(parsed.params)) {
+    return rawMessage;
+  }
+
+  return JSON.stringify({
+    ...parsed,
+    params: stripProviderFields(parsed.params),
+  });
+}
+
+function compareThreadsByUpdatedAt(lhs, rhs) {
+  const lhsTime = Date.parse(lhs?.updatedAt || lhs?.updated_at || lhs?.createdAt || lhs?.created_at || 0) || 0;
+  const rhsTime = Date.parse(rhs?.updatedAt || rhs?.updated_at || rhs?.createdAt || rhs?.created_at || 0) || 0;
+  return rhsTime - lhsTime;
+}
+
+function firstArrayKey(value, keys) {
+  return keys.find((key) => Array.isArray(value?.[key])) || "";
+}
+
+function hasCursor(params = {}) {
+  const cursor = params?.cursor ?? params?.nextCursor ?? params?.next_cursor;
+  return cursor != null && cursor !== "" && cursor !== false;
+}
+
+function hasExplicitProviderField(params = {}) {
+  return readModelProvider(params) !== CODEX_PROVIDER_ID
+    || providerFieldHasValue(params)
+    || providerFieldHasValue(params.collaborationMode?.settings)
+    || providerFieldHasValue(params.collaboration_mode?.settings);
+}
+
+function providerFieldHasValue(value = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+
+  return [
+    "modelProvider",
+    "model_provider",
+    "provider",
+    "runtimeProvider",
+    "runtime_provider",
+    "harness",
+  ].some((key) => readString(value[key]));
+}
+
+function readThreadId(params = {}) {
+  return readString(params.threadId || params.thread_id || params.id);
+}
+
+function readThreadIdentifier(thread = {}) {
+  return readString(thread.id || thread.threadId || thread.thread_id);
+}
+
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+function createJsonRpcErrorResponse(requestId, error, defaultErrorCode) {
+  return JSON.stringify({
+    id: requestId,
+    error: {
+      code: -32000,
+      message: error?.userMessage || error?.message || "Runtime provider request failed.",
+      data: {
+        errorCode: error?.errorCode || defaultErrorCode,
+      },
+    },
+  });
+}
+
+function safeParseJSON(rawMessage) {
+  try {
+    return JSON.parse(rawMessage);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  createRuntimeProviderRouter,
+  mergeModelListResult,
+  mergeThreadListResult,
+  providerForRequest,
+  registerThreadProjects,
+  stripRuntimeProviderFieldsForCodex,
+  threadsFromListResult,
+};

package/src/scripts/codex-refresh.applescript

@@ -1,39 +1,50 @@
 -- FILE: codex-refresh.applescript
--- Purpose: Forces a non-destructive route bounce inside Codex so the target thread remounts without killing runs.
+-- Purpose: Opens the target Codex deep link so the desktop window lands on the phone-driven thread.
 -- Layer: UI automation helper
--- Args: bundle id, app path fallback, optional target deep link
+-- Args: bundle id, app path fallback, optional target deep link, optional launch-if-closed flag ("1" default)
+-- Note: content updates stream over desktop IPC live sync, so no settings-route
+-- bounce/remount is needed anymore; that bounce caused visible page flipping.
 
 on run argv
   set bundleId to item 1 of argv
   set appPath to item 2 of argv
   set targetUrl to ""
-  set bounceUrl to "codex://settings"
+  set launchIfClosed to "1"
 
   if (count of argv) is greater than or equal to 3 then
     set targetUrl to item 3 of argv
   end if
 
-  try
-    tell application "Finder" to activate
-  end try
-
-  delay 0.12
-
-  my openCodexUrl(bundleId, appPath, bounceUrl)
-  delay 0.18
+  if (count of argv) is greater than or equal to 4 then
+    set launchIfClosed to item 4 of argv
+  end if
 
-  if targetUrl is not "" then
-    my openCodexUrl(bundleId, appPath, targetUrl)
-  else
-    my openCodexUrl(bundleId, appPath, "")
+  -- Navigation is a courtesy for an already-open Codex; cold-starting the app
+  -- just to show the phone-driven thread is disruptive and never required for
+  -- content sync (that streams over desktop IPC).
+  if launchIfClosed is "0" and not my isCodexRunning(bundleId) then
+    return
   end if
 
+  my openCodexUrl(bundleId, appPath, targetUrl)
+
   delay 0.18
   try
     tell application id bundleId to activate
   end try
 end run
 
+on isCodexRunning(bundleId)
+  try
+    -- Avoid System Events here: LaunchAgents may not have automation permission.
+    set matches to do shell script "/usr/bin/lsappinfo find bundleid=" & quoted form of bundleId
+    return matches is not ""
+  on error
+    -- Unknown running state must fail closed for navigation-only callers.
+    return false
+  end try
+end isCodexRunning
+
 on openCodexUrl(bundleId, appPath, targetUrl)
   try
     if targetUrl is not "" then