npm - codexui-android - Versions diffs - 0.1.101 → 0.1.102 - Mend

codexui-android 0.1.101 → 0.1.102

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/index.html CHANGED Viewed

@@ -12,8 +12,8 @@
     <link rel="icon" type="image/png" sizes="192x192" href="/icons/pwa-192x192.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/icons/apple-touch-icon.png" />
     <title>Codex Web</title>
-    <script type="module" crossorigin src="/assets/index-DzzwK-KG.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B6Gx9sFJ.css">
+    <script type="module" crossorigin src="/assets/index-Dpl251IF.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CDFerptZ.css">
   </head>
   <body class="bg-slate-950">
     <div id="app"></div>

package/dist-cli/index.js CHANGED Viewed

@@ -6867,6 +6867,60 @@ async function writeThreadQueueState(nextState) {
   }
   await writeFile4(statePath, JSON.stringify(payload), "utf8");
 }
+function normalizeReasoningEffort(value) {
+  const allowed = ["none", "minimal", "low", "medium", "high", "xhigh"];
+  return typeof value === "string" && allowed.includes(value) ? value : "";
+}
+function normalizeCollaborationModeReasoningEffort(value) {
+  return value && value.length > 0 ? value : null;
+}
+function extractLocalImagePathFromUrl(value) {
+  if (!value) return null;
+  try {
+    const parsed = new URL(value, "http://localhost");
+    if (parsed.pathname !== "/codex-local-image") return null;
+    const path = parsed.searchParams.get("path")?.trim() ?? "";
+    return path.length > 0 ? path : null;
+  } catch {
+    return null;
+  }
+}
+function buildTextWithAttachments(prompt, files) {
+  if (files.length === 0) return prompt;
+  let prefix = "# Files mentioned by the user:\n";
+  for (const f of files) {
+    prefix += `
+## ${f.label}: ${f.path}
+`;
+  }
+  return `${prefix}
+## My request for Codex:
+${prompt}
+`;
+}
+function fileNameFromPath(pathValue) {
+  const normalized = pathValue.replace(/\\/g, "/");
+  const segments = normalized.split("/").filter(Boolean);
+  return segments.at(-1) ?? normalized;
+}
+function extractThreadIdFromNotificationParams(params) {
+  const record = asRecord5(params);
+  if (!record) return "";
+  const threadId = (typeof record.threadId === "string" ? record.threadId : "") || (typeof record.thread_id === "string" ? record.thread_id : "") || (typeof record.conversationId === "string" ? record.conversationId : "") || (typeof record.conversation_id === "string" ? record.conversation_id : "");
+  if (threadId) return threadId;
+  const thread = asRecord5(record.thread);
+  if (thread && typeof thread.id === "string") return thread.id;
+  const turn = asRecord5(record.turn);
+  if (turn) {
+    const turnThreadId = (typeof turn.threadId === "string" ? turn.threadId : "") || (typeof turn.thread_id === "string" ? turn.thread_id : "");
+    if (turnThreadId) return turnThreadId;
+  }
+  return "";
+}
+function isTurnCompletedNotification(notification) {
+  return notification.method === "turn/completed";
+}
 async function readFirstLaunchPluginsCardDismissed() {
   const statePath = getCodexGlobalStatePath();
   try {
@@ -7636,6 +7690,147 @@ var AppServerProcess = class {
     forceKillTimer.unref();
   }
 };
+var BackendQueueProcessor = class {
+  constructor(appServer) {
+    this.appServer = appServer;
+    this.processingThreadIds = /* @__PURE__ */ new Set();
+    this.unsubscribe = appServer.onNotification((notification) => {
+      if (!isTurnCompletedNotification(notification)) return;
+      const threadId = extractThreadIdFromNotificationParams(notification.params);
+      if (!threadId) return;
+      void this.processThreadQueue(threadId);
+    });
+  }
+  dispose() {
+    this.unsubscribe();
+    this.processingThreadIds.clear();
+  }
+  async processThreadQueue(threadId) {
+    if (this.processingThreadIds.has(threadId)) return;
+    this.processingThreadIds.add(threadId);
+    try {
+      const next = await this.popNextQueuedTurn(threadId);
+      if (!next) return;
+      try {
+        await this.startQueuedTurn(next);
+      } catch {
+        await this.restoreQueuedTurn(next);
+      }
+    } catch {
+    } finally {
+      this.processingThreadIds.delete(threadId);
+    }
+  }
+  async popNextQueuedTurn(threadId) {
+    const state = await readThreadQueueState();
+    const queue = state[threadId];
+    if (!queue || queue.length === 0) return null;
+    const [message, ...rest] = queue;
+    const nextState = { ...state };
+    if (rest.length > 0) {
+      nextState[threadId] = rest;
+    } else {
+      delete nextState[threadId];
+    }
+    await writeThreadQueueState(nextState);
+    return { threadId, message };
+  }
+  async restoreQueuedTurn(turn) {
+    const state = await readThreadQueueState();
+    const queue = state[turn.threadId] ?? [];
+    await writeThreadQueueState({
+      ...state,
+      [turn.threadId]: [turn.message, ...queue]
+    });
+  }
+  async resolveCollaborationModeSettings(mode) {
+    let currentConfig = null;
+    try {
+      const configPayload = asRecord5(await this.appServer.rpc("config/read", {}));
+      currentConfig = asRecord5(configPayload?.config);
+    } catch {
+      currentConfig = null;
+    }
+    const configuredModel = readNonEmptyString(currentConfig?.model);
+    if (configuredModel) {
+      return {
+        model: configuredModel,
+        reasoningEffort: normalizeCollaborationModeReasoningEffort(normalizeReasoningEffort(currentConfig?.model_reasoning_effort))
+      };
+    }
+    try {
+      const modelsPayload = asRecord5(await this.appServer.rpc("model/list", {}));
+      const models = Array.isArray(modelsPayload?.data) ? modelsPayload.data : [];
+      for (const row of models) {
+        const record = asRecord5(row);
+        const candidate = readNonEmptyString(record?.id) || readNonEmptyString(record?.model);
+        if (candidate) {
+          return {
+            model: candidate,
+            reasoningEffort: normalizeCollaborationModeReasoningEffort(normalizeReasoningEffort(currentConfig?.model_reasoning_effort))
+          };
+        }
+      }
+    } catch {
+    }
+    throw new Error(`${mode === "plan" ? "Plan" : "Default"} mode requires an available model.`);
+  }
+  async buildQueuedTurnParams(turn) {
+    const localImageAttachments = [];
+    for (const imageUrl of turn.message.imageUrls) {
+      const localImagePath = extractLocalImagePathFromUrl(imageUrl.trim());
+      if (!localImagePath) continue;
+      localImageAttachments.push({
+        label: fileNameFromPath(localImagePath),
+        path: localImagePath,
+        fsPath: localImagePath
+      });
+    }
+    const allFileAttachments = [...turn.message.fileAttachments, ...localImageAttachments];
+    const dedupedFileAttachments = allFileAttachments.filter((entry, index) => allFileAttachments.findIndex((candidate) => candidate.fsPath === entry.fsPath) === index);
+    const input = [{
+      type: "text",
+      text: buildTextWithAttachments(turn.message.text, dedupedFileAttachments)
+    }];
+    for (const imageUrl of turn.message.imageUrls) {
+      const normalizedUrl = imageUrl.trim();
+      if (!normalizedUrl) continue;
+      const localImagePath = extractLocalImagePathFromUrl(normalizedUrl);
+      if (localImagePath) {
+        input.push({ type: "localImage", path: localImagePath });
+      } else {
+        input.push({ type: "image", url: normalizedUrl, image_url: normalizedUrl });
+      }
+    }
+    for (const skill of turn.message.skills) {
+      input.push({ type: "skill", name: skill.name, path: skill.path });
+    }
+    const params = {
+      threadId: turn.threadId,
+      input
+    };
+    if (dedupedFileAttachments.length > 0) {
+      params.attachments = dedupedFileAttachments.map((f) => ({ label: f.label, path: f.path, fsPath: f.fsPath }));
+    }
+    try {
+      const settings = await this.resolveCollaborationModeSettings(turn.message.collaborationMode);
+      params.collaborationMode = {
+        mode: turn.message.collaborationMode,
+        settings: {
+          model: settings.model,
+          reasoning_effort: settings.reasoningEffort,
+          developer_instructions: null
+        }
+      };
+    } catch {
+    }
+    return params;
+  }
+  async startQueuedTurn(turn) {
+    await this.appServer.rpc("thread/resume", { threadId: turn.threadId });
+    await this.appServer.rpc("turn/start", await this.buildQueuedTurnParams(turn));
+  }
+};
 var MethodCatalog = class {
   constructor() {
     this.methodCache = null;
@@ -7738,15 +7933,18 @@ function getSharedBridgeState() {
       return existing;
     }
     existing.appServer.dispose();
+    existing.backendQueueProcessor?.dispose();
     existing.terminalManager?.dispose();
   }
   const appServer = new AppServerProcess();
   const terminalManager = new ThreadTerminalManager();
+  const backendQueueProcessor = new BackendQueueProcessor(appServer);
   const created = {
     version: SHARED_BRIDGE_VERSION,
     appServer,
     terminalManager,
     methodCatalog: new MethodCatalog(),
+    backendQueueProcessor,
     telegramBridge: new TelegramThreadBridge(appServer, {
       onChatSeen: (chatId) => {
         void rememberTelegramChatId(chatId).catch(() => {
@@ -7826,7 +8024,7 @@ async function buildThreadSearchIndex(appServer) {
   return { docsById };
 }
 function createCodexBridgeMiddleware() {
-  const { appServer, terminalManager, methodCatalog, telegramBridge } = getSharedBridgeState();
+  const { appServer, terminalManager, methodCatalog, telegramBridge, backendQueueProcessor } = getSharedBridgeState();
   let threadSearchIndex = null;
   let threadSearchIndexPromise = null;
   async function getThreadSearchIndex() {
@@ -9219,6 +9417,7 @@ data: ${JSON.stringify({ ok: true })}
     threadSearchIndex = null;
     telegramBridge.stop();
     terminalManager.dispose();
+    backendQueueProcessor.dispose();
     appServer.dispose();
   };
   middleware.subscribeNotifications = (listener) => {