remcodex 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/server/src/services/event-store.js

@@ -55,9 +55,24 @@ class EventStore {
         `)
             .get(id);
         const event = this.toPayload(row);
-        this.captureLatestQuota(sessionId, event);
-        this.emitter.emit(this.channel(sessionId), event);
-        return event;
+        return this.publish(event);
+    }
+    publishTransient(sessionId, input, seq) {
+        const event = {
+            id: input.id?.trim() || (0, ids_1.createId)("evt"),
+            sessionId,
+            type: input.type,
+            seq,
+            timestamp: input.timestamp?.trim() || new Date().toISOString(),
+            turnId: input.turnId ?? null,
+            messageId: input.messageId ?? null,
+            callId: input.callId ?? null,
+            requestId: input.requestId ?? null,
+            phase: input.phase ?? null,
+            stream: this.normalizeStream(input.stream),
+            payload: input.payload ?? {},
+        };
+        return this.publish(event);
     }
     list(sessionId, options = {}) {
         const safeLimit = Math.max(1, Math.min(options.limit ?? 200, 200));
@@ -241,7 +256,7 @@ class EventStore {
             this.emitter.off(channel, listener);
         };
     }
-    nextSeq(sessionId) {
+    latestSeq(sessionId) {
         const row = this.db
             .prepare(`
           SELECT COALESCE(MAX(seq), 0) AS current_seq
@@ -249,7 +264,15 @@ class EventStore {
           WHERE session_id = ?
         `)
             .get(sessionId);
-        return row.current_seq + 1;
+        return row.current_seq;
+    }
+    nextSeq(sessionId) {
+        return this.latestSeq(sessionId) + 1;
+    }
+    publish(event) {
+        this.captureLatestQuota(event.sessionId, event);
+        this.emitter.emit(this.channel(event.sessionId), event);
+        return event;
     }
     toPayload(row) {
         return {

package/dist/server/src/services/session-manager.js

@@ -9,11 +9,13 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = require("../utils/errors");
 const ids_1 = require("../utils/ids");
+const output_limits_1 = require("../utils/output-limits");
 const codex_runner_1 = require("./codex-runner");
 const codex_stream_events_1 = require("./codex-stream-events");
 function nowIso() {
     return new Date().toISOString();
 }
+const TRANSIENT_SEQ_STEP = 0.00001;
 function shouldAutotitleSession(title) {
     const normalized = String(title || "").trim();
     return (!normalized ||
@@ -288,6 +290,30 @@ class SessionManager {
         runtime.runner.stop();
         return { accepted: true };
     }
+    retryApprovalRequest(sessionId, requestId, codexLaunch) {
+        const session = this.getSessionOrThrow(sessionId);
+        const project = this.options.projectManager.getProject(session.project_id);
+        if (!project) {
+            throw new errors_1.AppError(404, "Project not found for session.");
+        }
+        const currentRunner = this.runners.get(sessionId);
+        const busyStatuses = ["starting", "running", "stopping"];
+        if (currentRunner?.runner.isAlive() && busyStatuses.includes(session.status)) {
+            throw new errors_1.AppError(409, "Session already has an active task.");
+        }
+        const pending = this.pendingApprovals.get(sessionId)?.get(requestId) ??
+            this.restorePendingApprovalFromEvents(sessionId, requestId);
+        if (!pending) {
+            throw new errors_1.AppError(404, "Approval request not found.");
+        }
+        const turnId = (0, ids_1.createId)("turn");
+        const runtimePrompt = normalizeDemoPrompt(project.path, this.buildApprovalRetryRuntimePrompt(pending));
+        this.startRunner(sessionId, project.path, runtimePrompt, turnId, this.resolveResumeThreadId(session), codexLaunch);
+        return {
+            accepted: true,
+            turnId,
+        };
+    }
     resolveApproval(sessionId, requestId, decision) {
         const runtime = this.runners.get(sessionId);
         if (!runtime?.runner.isAlive()) {
@@ -322,6 +348,7 @@ class SessionManager {
         const runtime = {
             runner,
             stopRequested: false,
+            transientSeqCursor: this.options.eventStore.latestSeq(sessionId),
             turnId,
             appTurnId: null,
             turnStarted: false,
@@ -921,6 +948,8 @@ class SessionManager {
             cwd: payload.cwd || null,
             stdout: "",
             stderr: "",
+            stdoutTruncated: false,
+            stderrTruncated: false,
             started: true,
             completed: false,
         });
@@ -947,14 +976,15 @@ class SessionManager {
         if (!current) {
             return;
         }
-        if (stream === "stderr") {
-            current.stderr += textDelta;
-        }
-        else {
-            current.stdout += textDelta;
+        const targetKey = stream === "stderr" ? "stderr" : "stdout";
+        const truncatedKey = stream === "stderr" ? "stderrTruncated" : "stdoutTruncated";
+        const capped = (0, output_limits_1.appendCappedText)(current[targetKey], textDelta);
+        current[targetKey] = capped.nextText;
+        if (capped.truncated) {
+            current[truncatedKey] = true;
         }
         runtime.activeCommandCallId = callId;
-        this.appendEvent(sessionId, {
+        this.publishTransientEvent(sessionId, runtime, {
             type: "command.output.delta",
             turnId: runtime.turnId,
             messageId: null,
@@ -989,6 +1019,11 @@ class SessionManager {
             payload: {
                 command: payload.command || current.command,
                 cwd: payload.cwd || current.cwd,
+                stdout: current.stdout || null,
+                stderr: current.stderr || null,
+                aggregatedOutput: current.stdout || current.stderr || null,
+                stdoutTruncated: current.stdoutTruncated || undefined,
+                stderrTruncated: current.stderrTruncated || undefined,
                 status: payload.status || (payload.exitCode === 0 ? "completed" : "failed"),
                 exitCode: payload.exitCode ?? null,
                 durationMs: payload.durationMs ?? null,
@@ -1194,9 +1229,18 @@ class SessionManager {
     }
     appendEvent(sessionId, input) {
         const event = this.options.eventStore.append(sessionId, input);
+        const runtime = this.runners.get(sessionId);
+        if (runtime) {
+            runtime.transientSeqCursor = Math.max(runtime.transientSeqCursor, Number(event.seq || 0));
+        }
         this.touchSession(sessionId);
         return event;
     }
+    publishTransientEvent(sessionId, runtime, input) {
+        runtime.transientSeqCursor =
+            Math.round((runtime.transientSeqCursor + TRANSIENT_SEQ_STEP) * 100000) / 100000;
+        return this.options.eventStore.publishTransient(sessionId, input, runtime.transientSeqCursor);
+    }
     touchSession(sessionId) {
         this.options.db
             .prepare(`
@@ -1368,6 +1412,35 @@ class SessionManager {
         }
         return null;
     }
+    buildApprovalRetryRuntimePrompt(approval) {
+        const commandText = this.extractApprovalCommand(approval.method, approval.params);
+        const reason = typeof approval.params.reason === "string" && approval.params.reason.trim()
+            ? approval.params.reason.trim()
+            : "";
+        if (commandText) {
+            return [
+                "Re-run the exact operation that previously requested approval.",
+                "Do not do extra exploration.",
+                "As soon as the approval prompt appears again, stop and wait for the user decision.",
+                "",
+                commandText,
+            ].join("\n");
+        }
+        if (reason) {
+            return [
+                "Re-run the exact step that previously requested approval.",
+                "Do not do extra exploration.",
+                "As soon as the approval prompt appears again, stop and wait for the user decision.",
+                "",
+                `Original approval reason: ${reason}`,
+            ].join("\n");
+        }
+        return [
+            "Re-run the exact step that previously requested approval.",
+            "Do not do extra exploration.",
+            "As soon as the approval prompt appears again, stop and wait for the user decision.",
+        ].join("\n");
+    }
     describeApprovalTitle(method) {
         if (method === "item/commandExecution/requestApproval" || method === "execCommandApproval") {
             return "Command execution requires approval";

package/dist/server/src/services/session-timeline-service.js

@@ -1,181 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionTimelineService = void 0;
-const DEFAULT_TIMELINE_LIMIT = 200;
-const MAX_TIMELINE_LIMIT = 400;
-function clampLimit(limit) {
-    const numeric = Number(limit || DEFAULT_TIMELINE_LIMIT);
-    if (!Number.isFinite(numeric) || numeric <= 0) {
-        return DEFAULT_TIMELINE_LIMIT;
-    }
-    return Math.max(1, Math.min(Math.trunc(numeric), MAX_TIMELINE_LIMIT));
-}
-function normalizeCursor(value) {
-    const numeric = Number(value || 0);
-    if (!Number.isFinite(numeric) || numeric <= 0) {
-        return 0;
-    }
-    return Math.trunc(numeric);
-}
-function cloneEvent(event) {
-    return {
-        ...event,
-        payload: event.payload && typeof event.payload === "object"
-            ? { ...event.payload }
-            : event.payload,
-    };
-}
-function appendTextDelta(currentValue, nextValue) {
-    if (!nextValue) {
-        return currentValue || "";
-    }
-    return `${currentValue || ""}${nextValue}`;
-}
-function compareEvents(left, right) {
-    if (left.seq !== right.seq) {
-        return left.seq - right.seq;
-    }
-    return String(left.id || "").localeCompare(String(right.id || ""));
-}
-function upsertTimelineEvent(items, indexById, nextEvent) {
-    const existing = indexById.get(nextEvent.id);
-    if (existing) {
-        Object.assign(existing, nextEvent);
-        return existing;
-    }
-    const cloned = cloneEvent(nextEvent);
-    items.push(cloned);
-    indexById.set(cloned.id, cloned);
-    return cloned;
-}
-function timelineAssistantDeltaId(event) {
-    return `timeline:assistant:delta:${event.messageId || event.id}`;
-}
-function timelineReasoningDeltaId(event) {
-    return `timeline:reasoning:delta:${event.messageId || event.id}`;
-}
-function timelineCommandOutputId(event) {
-    return `timeline:command:output:${event.callId || event.id}:${event.stream || "stdout"}`;
-}
-function timelinePatchOutputId(event) {
-    return `timeline:patch:output:${event.callId || event.id}`;
-}
-function aggregateSemanticTimeline(rawEvents) {
-    const items = [];
-    const indexById = new Map();
-    rawEvents.forEach((event) => {
-        switch (event.type) {
-            case "message.assistant.delta": {
-                const syntheticId = timelineAssistantDeltaId(event);
-                const existing = indexById.get(syntheticId);
-                upsertTimelineEvent(items, indexById, {
-                    ...cloneEvent(event),
-                    id: syntheticId,
-                    payload: {
-                        ...(event.payload || {}),
-                        textDelta: appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || "")),
-                    },
-                });
-                break;
-            }
-            case "reasoning.delta": {
-                const syntheticId = timelineReasoningDeltaId(event);
-                const existing = indexById.get(syntheticId);
-                const nextText = appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || ""));
-                upsertTimelineEvent(items, indexById, {
-                    ...cloneEvent(event),
-                    id: syntheticId,
-                    payload: {
-                        ...(event.payload || {}),
-                        textDelta: nextText,
-                        summary: event.payload?.summary ||
-                            existing?.payload?.summary ||
-                            nextText ||
-                            null,
-                    },
-                });
-                break;
-            }
-            case "command.output.delta": {
-                const syntheticId = timelineCommandOutputId(event);
-                const existing = indexById.get(syntheticId);
-                upsertTimelineEvent(items, indexById, {
-                    ...cloneEvent(event),
-                    id: syntheticId,
-                    payload: {
-                        ...(event.payload || {}),
-                        textDelta: appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || "")),
-                        stream: event.payload?.stream || event.stream || "stdout",
-                    },
-                });
-                break;
-            }
-            case "patch.output.delta": {
-                const syntheticId = timelinePatchOutputId(event);
-                const existing = indexById.get(syntheticId);
-                upsertTimelineEvent(items, indexById, {
-                    ...cloneEvent(event),
-                    id: syntheticId,
-                    payload: {
-                        ...(event.payload || {}),
-                        textDelta: appendTextDelta(existing?.payload?.textDelta || "", String(event.payload?.textDelta || "")),
-                    },
-                });
-                break;
-            }
-            default:
-                upsertTimelineEvent(items, indexById, event);
-                break;
-        }
-    });
-    return items.sort(compareEvents);
-}
-function paginateTimelineItems(items, options, lastSeq) {
-    const limit = clampLimit(options.limit);
-    const after = normalizeCursor(options.after);
-    const before = normalizeCursor(options.before);
-    if (before > 0) {
-        const matches = items.filter((item) => item.seq < before);
-        const hasMoreBefore = matches.length > limit;
-        const pageItems = matches.slice(Math.max(0, matches.length - limit));
-        return {
-            items: pageItems,
-            nextCursor: pageItems.at(-1)?.seq || after,
-            beforeCursor: pageItems[0]?.seq || before,
-            hasMoreBefore,
-            lastSeq,
-        };
-    }
-    if (after > 0) {
-        const pageItems = items.filter((item) => item.seq > after).slice(0, limit);
-        return {
-            items: pageItems,
-            nextCursor: pageItems.at(-1)?.seq || after,
-            beforeCursor: pageItems[0]?.seq || 0,
-            hasMoreBefore: pageItems.length > 0 ? pageItems[0].seq > 1 : items.length > 0,
-            lastSeq,
-        };
-    }
-    const hasMoreBefore = items.length > limit;
-    const pageItems = items.slice(Math.max(0, items.length - limit));
-    return {
-        items: pageItems,
-        nextCursor: pageItems.at(-1)?.seq || 0,
-        beforeCursor: pageItems[0]?.seq || 0,
-        hasMoreBefore,
-        lastSeq,
-    };
-}
 class SessionTimelineService {
     eventStore;
     constructor(eventStore) {
         this.eventStore = eventStore;
     }
     list(sessionId, options = {}) {
-        const rawEvents = this.eventStore.listAll(sessionId);
-        const lastSeq = rawEvents.at(-1)?.seq || 0;
-        const aggregatedItems = aggregateSemanticTimeline(rawEvents);
-        return paginateTimelineItems(aggregatedItems, options, lastSeq);
+        const page = this.eventStore.list(sessionId, options);
+        return {
+            ...page,
+            // The initial detail load only needs the latest observed seq so resume sync
+            // can continue from the newest page we fetched.
+            lastSeq: page.nextCursor || Math.max(0, Number(options.after || 0)),
+        };
     }
 }
 exports.SessionTimelineService = SessionTimelineService;

package/dist/server/src/utils/output-limits.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMAND_STREAM_TRUNCATION_NOTICE = exports.MAX_PERSISTED_COMMAND_STREAM_CHARS = void 0;
+exports.appendCappedText = appendCappedText;
+exports.capTextValue = capTextValue;
+exports.MAX_PERSISTED_COMMAND_STREAM_CHARS = 80 * 1024;
+exports.COMMAND_STREAM_TRUNCATION_NOTICE = "\n\n[command output truncated]\n";
+function normalizeMaxChars(maxChars, notice) {
+    const numeric = Number(maxChars || exports.MAX_PERSISTED_COMMAND_STREAM_CHARS);
+    if (!Number.isFinite(numeric) || numeric <= notice.length + 1) {
+        return exports.MAX_PERSISTED_COMMAND_STREAM_CHARS;
+    }
+    return Math.trunc(numeric);
+}
+function appendCappedText(currentText, nextDelta, options = {}) {
+    const notice = String(options.notice || exports.COMMAND_STREAM_TRUNCATION_NOTICE);
+    const safeCurrent = String(currentText || "");
+    const safeDelta = String(nextDelta || "");
+    if (!safeDelta) {
+        return {
+            nextText: safeCurrent,
+            appendedText: "",
+            truncated: false,
+        };
+    }
+    const maxChars = normalizeMaxChars(options.maxChars, notice);
+    const contentLimit = Math.max(0, maxChars - notice.length);
+    if (safeCurrent.endsWith(notice) || safeCurrent.length >= maxChars) {
+        return {
+            nextText: safeCurrent.length > maxChars ? safeCurrent.slice(0, maxChars) : safeCurrent,
+            appendedText: "",
+            truncated: true,
+        };
+    }
+    if (safeCurrent.length >= contentLimit) {
+        return {
+            nextText: `${safeCurrent.slice(0, contentLimit)}${notice}`,
+            appendedText: notice,
+            truncated: true,
+        };
+    }
+    if (safeCurrent.length + safeDelta.length <= contentLimit) {
+        return {
+            nextText: safeCurrent + safeDelta,
+            appendedText: safeDelta,
+            truncated: false,
+        };
+    }
+    const available = Math.max(0, contentLimit - safeCurrent.length);
+    const preserved = safeDelta.slice(0, available);
+    const appendedText = `${preserved}${notice}`;
+    return {
+        nextText: `${safeCurrent}${appendedText}`,
+        appendedText,
+        truncated: true,
+    };
+}
+function capTextValue(text, options = {}) {
+    const notice = String(options.notice || exports.COMMAND_STREAM_TRUNCATION_NOTICE);
+    const safeText = String(text || "");
+    const maxChars = normalizeMaxChars(options.maxChars, notice);
+    const contentLimit = Math.max(0, maxChars - notice.length);
+    if (safeText.length <= contentLimit) {
+        return {
+            text: safeText,
+            truncated: false,
+        };
+    }
+    return {
+        text: `${safeText.slice(0, contentLimit)}${notice}`,
+        truncated: true,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "remcodex",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.10",
   "description": "Control Codex from anywhere. Even on your phone.",
   "license": "MIT",
   "bin": {

package/web/api.js

@@ -138,6 +138,13 @@ export function resolveSessionApproval(sessionId, requestId, decision) {
   });
 }
 
+export function retrySessionApproval(sessionId, requestId, payload = {}) {
+  return request(`/api/sessions/${sessionId}/approvals/${encodeURIComponent(requestId)}/retry`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+  });
+}
+
 export function getHealth() {
   return request("/health");
 }