@makerbi/remodex 2.0.1 → 2.3.0

package/src/codex-desktop-refresher.js

@@ -24,6 +24,12 @@ const NEW_THREAD_DEEP_LINK = "codex://threads/new";
 class CodexDesktopRefresher {
   constructor({
     enabled = true,
+    // When desktop IPC live sync streams conversation content, the refresher's
+    // only remaining job is navigation: bring Codex to the phone-driven thread
+    // when a phone message starts. Mid-run and completion refreshes are content
+    // reload workarounds from the pre-IPC era and would repeatedly deep-link
+    // and steal focus, so navigation-only mode drops them.
+    navigationOnly = false,
     debounceMs = DEFAULT_DEBOUNCE_MS,
     refreshCommand = "",
     bundleId = DEFAULT_BUNDLE_ID,
@@ -40,6 +46,7 @@ class CodexDesktopRefresher {
     customRefreshFailureThreshold = DEFAULT_CUSTOM_REFRESH_FAILURE_THRESHOLD,
   } = {}) {
     this.enabled = enabled;
+    this.navigationOnly = navigationOnly;
     this.debounceMs = debounceMs;
     this.refreshCommand = refreshCommand;
     this.bundleId = bundleId;
@@ -82,8 +89,8 @@ class CodexDesktopRefresher {
     this.unavailableLogged = false;
   }
 
-  handleInbound(rawMessage) {
-    const parsed = safeParseJSON(rawMessage);
+  handleInbound(rawMessage, parsedMessage = null) {
+    const parsed = parsedMessage ?? safeParseJSON(rawMessage);
     if (!parsed) {
       return;
     }
@@ -117,8 +124,8 @@ class CodexDesktopRefresher {
     }
   }
 
-  handleOutbound(rawMessage) {
-    const parsed = safeParseJSON(rawMessage);
+  handleOutbound(rawMessage, parsedMessage = null) {
+    const parsed = parsedMessage ?? safeParseJSON(rawMessage);
     if (!parsed) {
       return;
     }
@@ -126,6 +133,9 @@ class CodexDesktopRefresher {
     const method = parsed.method;
     if (method === "turn/completed") {
       this.clearFallbackTimer();
+      if (this.navigationOnly) {
+        return;
+      }
       const turnId = extractTurnId(parsed);
       if (turnId && turnId === this.lastTurnIdRefreshed) {
         this.log(`refresh skipped (debounced): completion already refreshed for ${turnId}`);
@@ -317,6 +327,10 @@ class CodexDesktopRefresher {
       this.bundleId,
       this.appPath,
       targetUrl || "",
+      // Navigation-only mode must never launch Codex from closed: content
+      // already syncs over IPC live sync, so a deep link while the app is
+      // down would only cold-start it to show a thread nobody asked to see.
+      this.navigationOnly ? "0" : "1",
     ]);
   }
 
@@ -372,7 +386,7 @@ class CodexDesktopRefresher {
 
   // Keeps one lightweight rollout watcher alive for the current Remodex-controlled thread.
   ensureWatcher(threadId) {
-    if (!this.canRefresh() || !threadId) {
+    if (this.navigationOnly || !this.canRefresh() || !threadId) {
       return;
     }
 
@@ -558,12 +572,19 @@ function readBridgeConfig({
     env
   );
   const explicitRefreshEnabled = readOptionalBooleanEnv(["REMODEX_REFRESH_ENABLED"], env);
+  const explicitDesktopIpcLiveSyncEnabled = readOptionalBooleanEnv(["REMODEX_DESKTOP_IPC_LIVE_SYNC"], env);
   const explicitKeepMacAwakeEnabled = readOptionalBooleanEnv(["REMODEX_KEEP_MAC_AWAKE"], env);
   const persistedKeepMacAwakeEnabled = typeof daemonConfig.keepMacAwakeEnabled === "boolean"
     ? daemonConfig.keepMacAwakeEnabled
     : null;
-  // Desktop refresh is opt-in for now because Codex.app still lacks true live updates.
-  const defaultRefreshEnabled = false;
+  // The deep-link refresh workaround stays opt-in; local IPC live sync is the primary desktop path.
+  // Once opted in, the persisted choice must survive restarts: `remodex restart`
+  // rewrites daemon-config.json from this computed config, so ignoring the
+  // persisted flag silently disabled the refresher on every restart.
+  const persistedRefreshEnabled = typeof daemonConfig.refreshEnabled === "boolean"
+    ? daemonConfig.refreshEnabled
+    : null;
+  const defaultRefreshEnabled = persistedRefreshEnabled == null ? false : persistedRefreshEnabled;
   return {
     relayUrl,
     relayAccessToken,
@@ -588,6 +609,13 @@ function readBridgeConfig({
       : explicitKeepMacAwakeEnabled,
     codexEndpoint,
     desktopIpcSocketPath: readFirstDefinedEnv(["REMODEX_DESKTOP_IPC_SOCKET"], "", env),
+    desktopIpcLiveSyncEnabled: explicitDesktopIpcLiveSyncEnabled == null
+      ? true
+      : explicitDesktopIpcLiveSyncEnabled,
+    desktopIpcSnapshotDebounceMs: parseIntegerEnv(
+      readFirstDefinedEnv(["REMODEX_DESKTOP_IPC_SNAPSHOT_DEBOUNCE_MS"], "75", env),
+      75
+    ),
     refreshCommand,
     codexBundleId: readFirstDefinedEnv(["REMODEX_CODEX_BUNDLE_ID"], DEFAULT_BUNDLE_ID, env),
     codexAppPath: DEFAULT_APP_PATH,

package/src/cursor-acp-client.js

@@ -0,0 +1,242 @@
+// FILE: cursor-acp-client.js
+// Purpose: Small JSON-RPC stdio client for Cursor's `cursor-agent acp` server.
+// Layer: Bridge runtime provider transport
+// Exports: createCursorAcpClient
+// Depends on: child_process
+
+const { spawn } = require("child_process");
+
+const DEFAULT_ACP_REQUEST_TIMEOUT_MS = 30_000;
+
+function createCursorAcpClient({
+  command = "cursor-agent",
+  args = ["acp"],
+  cwd = process.cwd(),
+  env = process.env,
+  spawnImpl = spawn,
+  requestTimeoutMs = DEFAULT_ACP_REQUEST_TIMEOUT_MS,
+  onNotification = null,
+  onRequest = null,
+} = {}) {
+  return new CursorAcpClient({
+    args,
+    command,
+    cwd,
+    env,
+    onNotification,
+    onRequest,
+    requestTimeoutMs,
+    spawnImpl,
+  });
+}
+
+class CursorAcpClient {
+  constructor({
+    command,
+    args,
+    cwd,
+    env,
+    spawnImpl,
+    requestTimeoutMs,
+    onNotification,
+    onRequest,
+  }) {
+    this.command = command;
+    this.args = args;
+    this.cwd = cwd;
+    this.env = env;
+    this.spawn = spawnImpl;
+    this.requestTimeoutMs = requestTimeoutMs;
+    this.onNotification = onNotification;
+    this.onRequest = onRequest;
+    this.child = null;
+    this.nextRequestId = 1;
+    this.pendingRequests = new Map();
+    this.stdoutBuffer = "";
+    this.stderr = "";
+    this.closed = false;
+  }
+
+  start() {
+    if (this.child) {
+      return;
+    }
+
+    this.child = this.spawn(this.command, this.args, {
+      cwd: this.cwd,
+      env: this.env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.child.stdout?.setEncoding?.("utf8");
+    this.child.stderr?.setEncoding?.("utf8");
+
+    this.child.stdout?.on("data", (chunk) => this.handleStdout(chunk));
+    this.child.stderr?.on("data", (chunk) => {
+      this.stderr = truncateTail(`${this.stderr}${chunk}`, 4_000);
+    });
+    this.child.on("error", (error) => this.failAll(error));
+    this.child.on("close", (code, signal) => {
+      this.closed = true;
+      this.failAll(new Error(`Cursor ACP exited with code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}.`));
+    });
+  }
+
+  request(method, params = {}, timeoutMs = this.requestTimeoutMs) {
+    this.start();
+    const id = this.nextRequestId;
+    this.nextRequestId += 1;
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Cursor ACP request timed out: ${method}`));
+      }, timeoutMs);
+
+      this.pendingRequests.set(id, {
+        method,
+        reject,
+        resolve,
+        timeout,
+      });
+      try {
+        this.writeFrame({ jsonrpc: "2.0", id, method, params });
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingRequests.delete(id);
+        reject(error);
+      }
+    });
+  }
+
+  notify(method, params = {}) {
+    this.start();
+    this.writeFrame({ jsonrpc: "2.0", method, params });
+  }
+
+  respond(id, result) {
+    this.writeFrame({ jsonrpc: "2.0", id, result });
+  }
+
+  rejectRequest(id, code, message) {
+    this.writeFrame({
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code,
+        message,
+      },
+    });
+  }
+
+  kill(signal = "SIGTERM") {
+    for (const waiter of this.pendingRequests.values()) {
+      clearTimeout(waiter.timeout);
+      waiter.reject(new Error("Cursor ACP client stopped."));
+    }
+    this.pendingRequests.clear();
+    try {
+      this.child?.kill(signal);
+    } catch {
+      // Ignore shutdown races; the process may already have exited.
+    }
+  }
+
+  writeFrame(frame) {
+    if (this.closed || !this.child?.stdin?.writable) {
+      throw new Error("Cursor ACP stdin is not writable.");
+    }
+    this.child.stdin.write(`${JSON.stringify(frame)}\n`);
+  }
+
+  handleStdout(chunk) {
+    this.stdoutBuffer += String(chunk);
+    for (;;) {
+      const newlineIndex = this.stdoutBuffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        return;
+      }
+      const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+      if (line) {
+        this.handleFrame(line);
+      }
+    }
+  }
+
+  handleFrame(line) {
+    const frame = safeParseJSON(line);
+    if (!frame || typeof frame !== "object") {
+      return;
+    }
+
+    if (frame.id != null && !frame.method) {
+      this.handleResponse(frame);
+      return;
+    }
+
+    if (frame.id != null && frame.method) {
+      this.handleRequest(frame);
+      return;
+    }
+
+    if (frame.method) {
+      this.onNotification?.(frame);
+    }
+  }
+
+  handleResponse(frame) {
+    const waiter = this.pendingRequests.get(frame.id);
+    if (!waiter) {
+      return;
+    }
+
+    this.pendingRequests.delete(frame.id);
+    clearTimeout(waiter.timeout);
+    if (frame.error) {
+      const error = new Error(frame.error.message || `Cursor ACP request failed: ${waiter.method}`);
+      error.code = frame.error.code;
+      error.data = frame.error.data;
+      waiter.reject(error);
+      return;
+    }
+    waiter.resolve(frame.result ?? null);
+  }
+
+  handleRequest(frame) {
+    Promise.resolve()
+      .then(() => this.onRequest?.(frame))
+      .then((result) => {
+        if (result !== undefined) {
+          this.respond(frame.id, result);
+        }
+      })
+      .catch((error) => {
+        this.rejectRequest(frame.id, error?.code || -32603, error?.message || "Cursor ACP client request failed.");
+      });
+  }
+
+  failAll(error) {
+    for (const waiter of this.pendingRequests.values()) {
+      clearTimeout(waiter.timeout);
+      waiter.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+}
+
+function safeParseJSON(rawValue) {
+  try {
+    return JSON.parse(String(rawValue || ""));
+  } catch {
+    return null;
+  }
+}
+
+function truncateTail(value, maxChars) {
+  const text = String(value || "");
+  return text.length <= maxChars ? text : text.slice(-maxChars);
+}
+
+module.exports = {
+  createCursorAcpClient,
+};

package/src/cursor-models.js

@@ -0,0 +1,134 @@
+// FILE: cursor-models.js
+// Purpose: Converts Cursor ACP model config options into Remodex model/list entries.
+// Layer: Bridge runtime provider helper
+// Exports: Cursor provider constants plus ACP model parsing helpers.
+// Depends on: ./runtime-provider-models
+
+const {
+  CURSOR_PROVIDER_ID,
+  buildRuntimeModelOption,
+} = require("./runtime-provider-models");
+
+const DEFAULT_CURSOR_MODEL = "composer-2.5";
+
+function parseCursorModelsFromSessionResult(sessionResult = {}) {
+  const modelConfig = readModelConfigOption(sessionResult.configOptions);
+  if (!modelConfig) {
+    return [buildCursorModelOption(DEFAULT_CURSOR_MODEL, { name: "Composer 2.5" }, true)].filter(Boolean);
+  }
+
+  const currentValue = readString(modelConfig.currentValue);
+  const options = flattenModelOptions(modelConfig.options);
+  const seen = new Set();
+  const models = [];
+
+  for (const option of options) {
+    const modelId = readString(option.value || option.modelId || option.id);
+    if (!modelId || seen.has(modelId)) {
+      continue;
+    }
+    seen.add(modelId);
+    const model = buildCursorModelOption(modelId, option, modelId === currentValue);
+    if (model) {
+      models.push(model);
+    }
+  }
+
+  return models.length
+    ? models
+    : [buildCursorModelOption(currentValue || DEFAULT_CURSOR_MODEL, { name: "Cursor" }, true)].filter(Boolean);
+}
+
+function readModelConfigOption(configOptions) {
+  const options = Array.isArray(configOptions) ? configOptions : [];
+  return options.find((option) => {
+    const category = readString(option?.category).toLowerCase();
+    const id = readString(option?.id).toLowerCase();
+    return category === "model" || id === "model";
+  }) || null;
+}
+
+function flattenModelOptions(options) {
+  if (!Array.isArray(options)) {
+    return [];
+  }
+
+  const flattened = [];
+  for (const option of options) {
+    if (Array.isArray(option?.options)) {
+      flattened.push(...flattenModelOptions(option.options));
+    } else if (option && typeof option === "object") {
+      flattened.push(option);
+    }
+  }
+  return flattened;
+}
+
+function buildCursorModelOption(modelReference, option = {}, isDefault = false) {
+  const normalizedReference = normalizeCursorModelReference(modelReference);
+  if (!normalizedReference) {
+    return null;
+  }
+
+  return buildRuntimeModelOption({
+    provider: CURSOR_PROVIDER_ID,
+    id: normalizedReference,
+    model: normalizedReference,
+    displayName: readString(option.name) || displayNameForCursorModel(normalizedReference),
+    description: readString(option.description) || `Cursor ACP model (${normalizedReference})`,
+    isDefault,
+    supportsFastMode: false,
+    supportedReasoningEfforts: [],
+    defaultReasoningEffort: null,
+  });
+}
+
+function normalizeCursorModelReference(value) {
+  const normalized = readString(value);
+  if (!normalized || normalized.startsWith("{") || normalized.startsWith("[")) {
+    return "";
+  }
+  if (!/^[A-Za-z0-9._:-]+(?:\[[^\]\r\n]*\])?$/.test(normalized)) {
+    return "";
+  }
+  return normalized;
+}
+
+function displayNameForCursorModel(modelReference) {
+  const normalized = normalizeCursorModelReference(modelReference);
+  const base = normalized.split("[")[0] || normalized;
+  const lowered = base.toLowerCase();
+
+  if (lowered === "default") {
+    return "Auto";
+  }
+  if (lowered.startsWith("gpt-")) {
+    return `GPT-${base.slice(4)}`;
+  }
+  return base
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map(titleCase)
+    .join(" ");
+}
+
+function titleCase(value) {
+  if (!value) {
+    return "";
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+module.exports = {
+  CURSOR_PROVIDER_ID,
+  DEFAULT_CURSOR_MODEL,
+  buildCursorModelOption,
+  displayNameForCursorModel,
+  normalizeCursorModelReference,
+  parseCursorModelsFromSessionResult,
+  readModelConfigOption,
+};