replicas-engine 0.1.579 → 0.1.581

package/dist/src/index.js

@@ -3311,14 +3311,23 @@ function chatHistoryPageParamsFromQuery(query2) {
     beforeTurn: parse(query2.beforeTurn)
   };
 }
+function getChatHistoryPageWindow(totalItems, limit, before) {
+  const endIndex = Math.min(before ?? totalItems, totalItems);
+  return { startIndex: Math.max(0, endIndex - Math.max(1, limit)), endIndex };
+}
 function paginateChatHistory(full, params) {
   if (params.limit === void 0) return { ...full, totalEvents: full.events.length };
-  const limit = Math.max(1, params.limit);
-  const eventsEnd = Math.min(params.beforeEvent ?? full.events.length, full.events.length);
-  const eventsStartIndex = Math.max(0, eventsEnd - limit);
+  const { startIndex: eventsStartIndex, endIndex: eventsEnd } = getChatHistoryPageWindow(
+    full.events.length,
+    params.limit,
+    params.beforeEvent
+  );
   const turns = full.codexAspTranscript?.turns;
-  const turnsEnd = turns ? Math.min(params.beforeTurn ?? turns.length, turns.length) : 0;
-  const turnsStartIndex = Math.max(0, turnsEnd - limit);
+  const { startIndex: turnsStartIndex, endIndex: turnsEnd } = getChatHistoryPageWindow(
+    turns?.length ?? 0,
+    params.limit,
+    params.beforeTurn
+  );
   const codexAspTranscript = full.codexAspTranscript && turns && (turnsStartIndex > 0 || turnsEnd < turns.length) ? { ...full.codexAspTranscript, turns: turns.slice(turnsStartIndex, turnsEnd) } : full.codexAspTranscript;
   return {
     ...full,
@@ -9406,13 +9415,14 @@ function isNotFoundError(error) {
 }
 
 // src/managers/codex-asp/codex-history-file.ts
-import { appendFile as appendFile2, readFile as readFile9 } from "fs/promises";
+import { appendFile as appendFile2, open, readFile as readFile9 } from "fs/promises";
 var CodexHistoryFile = class {
   constructor(filePath) {
     this.filePath = filePath;
   }
   filePath;
   writeLock = new AsyncLock();
+  eventLineIndex = null;
   /** Best-effort ordered append; failures must not disrupt the turn. */
   append(event) {
     void this.writeLock.run(
@@ -9435,6 +9445,88 @@ var CodexHistoryFile = class {
       return { events: [], transcript: null, transcriptsByThreadId: /* @__PURE__ */ new Map() };
     }
   }
+  async loadEventsPage(page) {
+    if (page.limit === void 0) {
+      const history2 = await this.load();
+      return { events: history2.events, eventsStartIndex: 0, totalEvents: history2.events.length };
+    }
+    let file;
+    try {
+      file = await open(this.filePath, "r");
+    } catch (error) {
+      if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+        console.error("[CodexHistoryFile] Failed to open history file:", error);
+      }
+      return { events: [], eventsStartIndex: 0, totalEvents: 0 };
+    }
+    try {
+      const stats = await file.stat();
+      let index = this.eventLineIndex;
+      if (!index || index.size !== stats.size || index.mtimeMs !== stats.mtimeMs) {
+        const starts = stats.size > 0 ? [0] : [];
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        let position = 0;
+        while (position < stats.size) {
+          const { bytesRead: bytesRead2 } = await file.read(
+            buffer,
+            0,
+            Math.min(buffer.length, stats.size - position),
+            position
+          );
+          if (bytesRead2 === 0) break;
+          for (let offset = 0; offset < bytesRead2; offset += 1) {
+            const next = position + offset + 1;
+            if (buffer[offset] === 10 && next < stats.size) starts.push(next);
+          }
+          position += bytesRead2;
+        }
+        index = { size: stats.size, mtimeMs: stats.mtimeMs, starts };
+        this.eventLineIndex = index;
+      }
+      const totalEvents2 = index.starts.length;
+      const { startIndex: eventsStartIndex2, endIndex: eventsEnd2 } = getChatHistoryPageWindow(
+        totalEvents2,
+        page.limit,
+        page.beforeEvent
+      );
+      const startByte = index.starts[eventsStartIndex2] ?? index.size;
+      const endByte = index.starts[eventsEnd2] ?? index.size;
+      const content = Buffer.allocUnsafe(endByte - startByte);
+      let bytesRead = 0;
+      while (bytesRead < content.length) {
+        const result = await file.read(
+          content,
+          bytesRead,
+          content.length - bytesRead,
+          startByte + bytesRead
+        );
+        if (result.bytesRead === 0) break;
+        bytesRead += result.bytesRead;
+      }
+      if (bytesRead === content.length) {
+        const parsed = parseAgentEventJsonlWithCodexAspTranscript(content.toString("utf-8"));
+        if (!parsed.transcript && parsed.events.length === eventsEnd2 - eventsStartIndex2) {
+          return { events: parsed.events, eventsStartIndex: eventsStartIndex2, totalEvents: totalEvents2 };
+        }
+      }
+    } catch (error) {
+      console.error("[CodexHistoryFile] Failed to load history page:", error);
+    } finally {
+      await file.close();
+    }
+    const history = await this.load();
+    const totalEvents = history.events.length;
+    const { startIndex: eventsStartIndex, endIndex: eventsEnd } = getChatHistoryPageWindow(
+      totalEvents,
+      page.limit,
+      page.beforeEvent
+    );
+    return {
+      events: history.events.slice(eventsStartIndex, eventsEnd),
+      eventsStartIndex,
+      totalEvents
+    };
+  }
 };
 
 // src/managers/claude-activity.ts
@@ -10563,13 +10655,13 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     }
     return null;
   }
-  async getHistory() {
+  async getHistory(page = {}) {
     await this.initialized;
     await this.historyFile.flush();
-    const history = await this.historyFile.load();
+    const history = await this.historyFile.loadEventsPage(page);
     return {
       thread_id: this.sessionId,
-      events: history.events
+      ...history
     };
   }
   partialMessageStreamKey(message) {
@@ -10896,7 +10988,7 @@ var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
 var MIN_CODEX_CLI_VERSION = "0.144.6";
 var CODEX_UPGRADE_TIMEOUT_MS = 12e4;
 var codexCliVersionEnsured = null;
-var ENGINE_PACKAGE_VERSION = "0.1.579";
+var ENGINE_PACKAGE_VERSION = "0.1.581";
 var INITIALIZE_METHOD = "initialize";
 var INITIALIZED_NOTIFICATION = "initialized";
 var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
@@ -12009,22 +12101,24 @@ var CodexAspManager = class extends CodingAgentManager {
     this.recordUserMessageEvent(request);
     return true;
   }
-  async getHistory() {
+  async getHistory(page = {}) {
     if (!this.currentThreadId) {
-      return { thread_id: null, events: [], goal: null };
+      return paginateChatHistory({ thread_id: null, events: [], goal: null }, page);
     }
-    if (this.activeTurnId && this.codexAspTranscript?.threadId === this.currentThreadId) {
-      try {
-        const host = await getCodexAspHost();
-        await this.refreshThreadGoal(host, this.currentThreadId);
-      } catch {
+    if (this.codexAspTranscript?.threadId === this.currentThreadId) {
+      if (page.beforeEvent === void 0 && page.beforeTurn === void 0) {
+        try {
+          const host = await getCodexAspHost();
+          await this.refreshThreadGoal(host, this.currentThreadId);
+        } catch {
+        }
       }
-      return {
+      return paginateChatHistory({
         thread_id: this.currentThreadId,
         events: [...this.historyEvents],
         codexAspTranscript: this.codexAspTranscript,
         goal: this.currentGoal
-      };
+      }, page);
     }
     try {
       const host = await getCodexAspHost();
@@ -12039,20 +12133,20 @@ var CodexAspManager = class extends CodingAgentManager {
       if (transcript) {
         transcript.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       }
-      return {
+      return paginateChatHistory({
         thread_id: this.currentThreadId,
         events: [...this.historyEvents],
         codexAspTranscript: transcript,
         goal: this.currentGoal
-      };
+      }, page);
     } catch {
     }
-    return {
+    return paginateChatHistory({
       thread_id: this.currentThreadId,
       events: [...this.historyEvents],
       codexAspTranscript: this.codexAspTranscript,
       goal: this.currentGoal
-    };
+    }, page);
   }
   getGoal() {
     return this.currentGoal;
@@ -13260,12 +13354,12 @@ var CursorManager = class extends CodingAgentManager {
     }
     this.agent = null;
   }
-  async getHistory() {
+  async getHistory(page = {}) {
     await this.historyFile.flush();
-    const history = await this.historyFile.load();
+    const history = await this.historyFile.loadEventsPage(page);
     return {
       thread_id: this.agent?.agentId ?? this.initialSessionId,
-      events: history.events,
+      ...history,
       goal: null
     };
   }
@@ -13822,6 +13916,7 @@ var OpencodeManager = class extends CodingAgentManager {
   nonAssistantMessageIds = /* @__PURE__ */ new Set();
   activeLinearForwarder = null;
   forwardedLinearPartKeys = /* @__PURE__ */ new Set();
+  handledAccountRateLimit = false;
   modelVariants = /* @__PURE__ */ new Map();
   handledPermissionRequestIds = /* @__PURE__ */ new Set();
   pendingPermissionRequestIds = /* @__PURE__ */ new Set();
@@ -13844,24 +13939,26 @@ var OpencodeManager = class extends CodingAgentManager {
     return this.historyFile;
   }
   async interruptActiveTurn() {
-    this.activeAbortController?.abort();
-    if (this.client && this.sessionId) {
-      try {
-        await this.client.session.abort(
-          { sessionID: this.sessionId, directory: this.workingDirectory },
-          { throwOnError: true }
-        );
-      } catch (error) {
-        console.error("[OpencodeManager] Failed to abort Opencode session:", error);
-      }
+    try {
+      await this.abortActiveTurn();
+    } catch (error) {
+      console.error("[OpencodeManager] Failed to abort Opencode session:", error);
     }
   }
-  async getHistory() {
+  async abortActiveTurn() {
+    this.activeAbortController?.abort();
+    if (!this.client || !this.sessionId) return;
+    await this.client.session.abort(
+      { sessionID: this.sessionId, directory: this.workingDirectory },
+      { throwOnError: true }
+    );
+  }
+  async getHistory(page = {}) {
     await this.historyFile.flush();
-    const history = await this.historyFile.load();
+    const history = await this.historyFile.loadEventsPage(page);
     return {
       thread_id: this.sessionId ?? this.initialSessionId,
-      events: history.events,
+      ...history,
       goal: null
     };
   }
@@ -14017,6 +14114,7 @@ var OpencodeManager = class extends CodingAgentManager {
     const controller = new AbortController();
     const linearSessionId = ENGINE_ENV.REPLICAS_LINEAR_SESSION_ID;
     const linearForwarder = new LinearEventForwarder(linearSessionId);
+    this.handledAccountRateLimit = false;
     this.activeAbortController = controller;
     this.activeLinearForwarder = linearForwarder;
     this.forwardedLinearPartKeys.clear();
@@ -14104,6 +14202,11 @@ var OpencodeManager = class extends CodingAgentManager {
       return;
     }
     if (event.type === "message.updated") this.recordOpencodeMessageRole(payload);
+    if (event.type === "session.status") {
+      this.handleAccountRateLimit(payload).catch((error) => {
+        console.error("[OpencodeManager] Failed to stop account-rate-limited turn:", error);
+      });
+    }
     if (event.type === "session.next.tool.input.ended") {
       const callId = typeof payload.callID === "string" ? payload.callID : void 0;
       if (callId && typeof payload.text === "string") {
@@ -14123,6 +14226,15 @@ var OpencodeManager = class extends CodingAgentManager {
     if (this.recordOpencodeNextPart(event.type, payload)) return;
     this.recordHistoryEvent(`opencode-${event.type}`, payload, this.historyFile);
   }
+  async handleAccountRateLimit(payload) {
+    const status = isRecord4(payload.status) ? payload.status : null;
+    const action = isRecord4(status?.action) ? status.action : null;
+    if (status?.type !== "retry" || action?.reason !== "account_rate_limit" || this.handledAccountRateLimit) return;
+    this.handledAccountRateLimit = true;
+    const message = typeof status.message === "string" ? status.message : typeof action.message === "string" ? action.message : "OpenCode Go usage limit reached.";
+    this.recordHistoryEvent("opencode-error", { message, code: "account_rate_limit" }, this.historyFile);
+    await this.abortActiveTurn();
+  }
   async respondToOpencodePermission(type, payload) {
     if (!this.client) return;
     const requestId = typeof payload.id === "string" ? payload.id : void 0;
@@ -14221,13 +14333,7 @@ var OpencodeManager = class extends CodingAgentManager {
         historyFile: this.historyFile,
         recordHistoryEvent: this.recordHistoryEvent.bind(this)
       });
-      this.activeAbortController?.abort();
-      if (this.client && this.sessionId) {
-        await this.client.session.abort(
-          { sessionID: this.sessionId, directory: this.workingDirectory },
-          { throwOnError: true }
-        );
-      }
+      await this.abortActiveTurn();
       this.handledToolCallIds.add(toolUseId);
     } finally {
       this.pendingToolCallIds.delete(toolUseId);
@@ -14423,10 +14529,10 @@ var PiManager = class extends CodingAgentManager {
     this.recordUserMessage(session, request.message);
     return true;
   }
-  async getHistory() {
+  async getHistory(page = {}) {
     await this.historyFile.flush();
-    const history = await this.historyFile.load();
-    return { thread_id: this.activeSessionFile ?? this.initialSessionId, events: history.events, goal: null };
+    const history = await this.historyFile.loadEventsPage(page);
+    return { thread_id: this.activeSessionFile ?? this.initialSessionId, ...history, goal: null };
   }
   async listSlashCommands() {
     await this.initialized;
@@ -15143,8 +15249,8 @@ var RelayManager = class {
   async interrupt() {
     return this.inner.interrupt();
   }
-  async getHistory() {
-    return this.inner.getHistory();
+  async getHistory(page = {}) {
+    return this.inner.getHistory(page);
   }
   async listSlashCommands() {
     return this.inner.listSlashCommands?.() ?? [];
@@ -16407,17 +16513,27 @@ var ChatService = class {
   async getChatHistory(chatId, page = {}) {
     const chat = this.requireChat(chatId);
     const [history, senders] = await Promise.all([
-      chat.provider.getHistory(),
+      chat.provider.getHistory(page),
       this.readSenders(chatId)
     ]);
     for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
-      if (acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript)) {
+      if (acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) || history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent))) {
         chat.acceptedUserEvents.delete(messageId);
       }
     }
+    const isLatestPage = page.beforeEvent === void 0 && page.beforeTurn === void 0;
     const queuedMessageIds = new Set(chat.provider.getQueue().map((message) => message.id));
-    const acceptedEvents = [...chat.acceptedUserEvents.entries()].filter(([messageId]) => messageId === chat.activeMessageId || !chat.hasActiveTurn && chat.pendingMessageIds[0] === messageId && !queuedMessageIds.has(messageId)).map(([, acceptedEvent]) => acceptedEvent).filter((acceptedEvent) => !acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) && !history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
+    const acceptedEvents = (isLatestPage ? [...chat.acceptedUserEvents.entries()] : []).filter(([messageId]) => messageId === chat.activeMessageId || !chat.hasActiveTurn && chat.pendingMessageIds[0] === messageId && !queuedMessageIds.has(messageId)).map(([, acceptedEvent]) => acceptedEvent).filter((acceptedEvent) => !acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) && !history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
     const events = [...history.events, ...acceptedEvents].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b));
+    if (history.eventsStartIndex !== void 0) {
+      return {
+        ...history,
+        events,
+        totalEvents: (history.totalEvents ?? history.eventsStartIndex + history.events.length) + acceptedEvents.length,
+        goal: history.goal ?? chat.provider.getGoal?.() ?? null,
+        senders
+      };
+    }
     return paginateChatHistory({
       thread_id: history.thread_id,
       events,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.579",
+  "version": "0.1.581",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",