remcodex 0.1.0-beta.1 → 0.1.0-beta.11

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/dist/server/src/utils/runtime-paths.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePackageRoot = resolvePackageRoot;
+exports.resolveDefaultDatabasePath = resolveDefaultDatabasePath;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+function isPackageRoot(root) {
+    return ((0, node_fs_1.existsSync)(node_path_1.default.join(root, "package.json")) &&
+        (0, node_fs_1.existsSync)(node_path_1.default.join(root, "web", "index.html")));
+}
+function resolvePackageRoot(startDir = __dirname) {
+    let current = node_path_1.default.resolve(startDir);
+    while (true) {
+        if (isPackageRoot(current)) {
+            return current;
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return process.cwd();
+}
+function resolveDefaultDatabasePath() {
+    return node_path_1.default.join((0, node_os_1.homedir)(), ".remcodex", "remcodex.db");
+}

package/package.json

@@ -1,23 +1,31 @@
 {
   "name": "remcodex",
-  "version": "0.1.0-beta.1",
+  "version": "0.1.0-beta.11",
   "description": "Control Codex from anywhere. Even on your phone.",
-  "license": "MIT",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": "20.x"
+  },
   "bin": {
     "remcodex": "dist/server/src/cli.js"
   },
   "files": [
     "dist",
     "web",
+    "scripts/check-node-version.js",
     "scripts/fix-node-pty-helper.js",
-    "README.md"
+    "README.md",
+    "docs/assets"
   ],
   "scripts": {
+    "preinstall": "node scripts/check-node-version.js",
     "postinstall": "node scripts/fix-node-pty-helper.js",
     "dev": "tsx watch server/src/app.ts",
     "start": "tsx server/src/cli.ts --no-open",
-    "build": "tsc -p tsconfig.json",
-    "cli": "tsx server/src/cli.ts --no-open"
+    "build": "tsc -p tsconfig.json && node scripts/copy-db-assets.js",
+    "cli": "tsx server/src/cli.ts --no-open",
+    "smoke:tarball": "node scripts/smoke-test-tarball.js",
+    "smoke:start": "node scripts/smoke-start-tarball.js"
   },
   "dependencies": {
     "better-sqlite3": "^11.8.1",

package/scripts/check-node-version.js

@@ -0,0 +1,14 @@
+const supportedMajor = 20;
+const currentVersion = process.versions.node;
+const currentMajor = Number.parseInt(currentVersion.split(".")[0] || "", 10);
+
+if (currentMajor !== supportedMajor) {
+  console.error(
+    [
+      `remcodex requires Node.js ${supportedMajor}.x for the published package.`,
+      `Current Node.js: ${currentVersion}`,
+      "Switch Node versions first, then reinstall remcodex so native modules are built against the same runtime.",
+    ].join("\n"),
+  );
+  process.exit(1);
+}

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");
 }