remcodex 0.1.0-beta.7 → 0.1.0-beta.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RemCodex contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,45 +1,104 @@
-# RemCodex
+# 🚀 RemCodex
 
-> Control Codex from anywhere. Even on your phone.
+> Remote control for Codex.  
+> From your browser and phone.
 
-RemCodex is a local-first web UI for running, reviewing, approving, and resuming Codex sessions from your browser.
+Run Codex on one machine.  
+Monitor, approve, and control the same session from another.
 
-It is built for the real workflow: long-running sessions, mobile check-ins, approval prompts, imported rollout history, and timeline-style execution flow.
+🌐 https://remcodex.com
 
-- Watch live Codex runs without staying in the terminal
-- Approve sensitive actions from a cleaner UI
-- Pick up the same session again after refresh, sleep, or reconnect
+> Not a remote desktop. Not a proxy.  
+> A local-first way to control Codex away from the terminal.
 
-## Status
+![RemCodex hero cover](docs/assets/hero-cover.png)
 
-This project is currently a **beta / developer preview**.
+---
 
-It is already usable for local and internal workflows, but it is not yet packaged as a one-click desktop app.
+## ✨ What is RemCodex?
 
-## Why People Use It
+RemCodex is **remote control for Codex**.
 
-Codex is powerful in the terminal, but many real workflows need a better control surface:
+It lets you start Codex on one machine, then keep the same session visible,
+interruptible, and controllable from another.
 
-- checking progress from your phone
-- watching a long run without babysitting a terminal window
-- approving writes from a cleaner interface
-- reopening a session after refresh, sleep, or reconnect
-- reviewing imported rollout history next to native sessions
+- 👀 See what the AI is doing — in real time
+- ✅ Approve or reject actions before execution
+- ⏹ Interrupt or stop at any moment
+- 📱 Access your session from any device
+- 🔄 Sessions don’t break — they resume
 
-RemCodex turns Codex's event stream into a browser-based workspace that is easier to follow, easier to resume, and easier to operate.
+> One session. Any device.
 
-## What It Does
+---
 
-- Run Codex sessions from a browser
-- View sessions in a single-page workspace with a sidebar and execution timeline
-- Follow streaming assistant output, commands, patches, and approvals
-- Approve or reject file-system actions from the UI
-- Import existing Codex rollout sessions from `~/.codex/sessions/...`
-- Keep imported sessions in sync while they are still active
-- Resume stale sessions after the page comes back from background
-- Work well on desktop and on mobile
+## 🎬 A real workflow
 
-## Screenshots
+You start a long Codex session on your machine.
+
+Then you leave your desk.
+
+On your phone:
+
+- you see progress in real time
+- you receive an approval request
+- you approve it
+
+The session continues instantly.
+
+> Everything else can disconnect — your session won’t.
+
+---
+
+## 🔥 Why RemCodex exists
+
+AI coding agents are powerful.  
+But today, they run like a black box.
+
+You either:
+
+- trust everything blindly
+- or sit in front of your terminal watching it
+
+RemCodex fixes that.
+
+> AI is no longer a black box.
+
+---
+
+## ⚡ What it does
+
+- Real-time execution timeline (messages, commands, approvals)
+- Human-in-the-loop command approval
+- Multi-device access to the same live session
+- Resume after refresh, sleep, or reconnect
+- Browser-based UI — **no extra client required**
+- Works with Codex CLI
+
+> No extra client install. Just open a browser.  
+> Your code never leaves your machine.
+
+---
+
+## 🚀 Quick start
+
+```bash
+npx remcodex
+```
+
+Then open:
+
+http://127.0.0.1:18840
+
+Access from another device:
+
+http://<your-ip>:18840
+
+> Runs entirely on your local machine. No cloud, no data upload.
+
+---
+
+## 🖥 Screenshots
 
 ![RemCodex desktop workspace](docs/assets/hero-desktop.png)
 
@@ -55,249 +114,203 @@ RemCodex turns Codex's event stream into a browser-based workspace that is easie
 
 ![RemCodex imported Codex session](docs/assets/imported-session.png)
 
-> Bring imported Codex rollouts into the same workspace and keep them easy to review.
+> Bring imported Codex rollouts into the same workspace.
+
+---
 
-## Who It Is For
+## 🧠 What it actually is
 
-- developers who already use Codex locally
-- people who want a browser-based control surface instead of raw terminal watching
-- teams who want to review or monitor runs from another device on the same network
-- anyone who wants approvals, timeline view, and imported rollout history in one place
+RemCodex is a **browser-based workspace for Codex sessions**.
 
-## Screens It Aims To Replace
+It is built for real workflows:
 
-- terminal-only session watching
-- ad-hoc mobile remote desktop checks
-- raw log scrolling for approvals and command progress
-- fragmented session history between local and imported rollouts
+- long-running sessions
+- mobile check-ins
+- approval prompts
+- imported rollout history
+- timeline-style execution flow
 
-## Current Product Shape
+Instead of raw terminal logs, you get a structured, visual timeline you can follow and control.
+
+---
+
+## 🧩 Current product shape
 
 - Single-page workspace UI
 - Left sidebar for session navigation
-- Right-side timeline / execution flow for the active session
-- Fixed composer at the bottom
+- Right-side execution timeline
+- Fixed input composer
 - Semantic timeline rendering for:
-  - user messages
-  - assistant commentary / final messages
-  - thinking
-  - commands
-  - patches
-  - approvals
-  - system events
+    - user messages
+    - assistant output
+    - thinking
+    - commands
+    - patches
+    - approvals
+    - system events
 
-## Tech Stack
+---
 
-- Backend: Node.js + TypeScript + Express + WebSocket
-- Database: SQLite via `better-sqlite3`
-- Terminal/runtime integration: `node-pty` + Codex app-server
-- Frontend: zero-build static web app (`web/`)
-- Markdown rendering: `markdown-it`
+## ⚙️ Key behaviors
 
-## Requirements
+### Approvals
 
-Before running this project, you should have:
+- Writes inside working area → auto allowed
+- Writes outside → require approval
+- `Allow once` / `Allow for this turn` supported
+- Approval history stays visible in timeline
 
-- Node.js installed
-- Codex CLI installed and already working locally
-- A machine where this app can access your local Codex data and working directories
+---
 
-This project is currently developed primarily around a local macOS workflow.
+### Timeline
 
-## Quick Start
+- Semantic rendering (not raw logs)
+- Commands grouped into readable activity blocks
+- Running / failed states clearly visible
+- Smooth streaming + recovery after refresh
 
-For the current developer preview, the recommended local install path is:
+---
 
-```bash
-npm install
-npm run build
-npm link
-remcodex start
-```
+### Imported sessions
 
-Then open:
+- Import from `~/.codex/sessions/...`
+- Keep syncing if still active
+- Unified view with native sessions
+
+---
 
-```text
-http://127.0.0.1:3000
+## 🧠 Architecture
+
+```
+Codex CLI → Event stream → Semantic layer → Timeline → Web UI
 ```
 
-If you want to make it reachable from your phone, expose the local machine on your LAN and open the same URL with your host IP.
+---
 
-## Local CLI
+## ⚙️ Requirements
 
-RemCodex already ships with a local CLI entrypoint, even though the npm package is not published yet.
+- Node.js
+- Codex CLI (already working locally)
 
-If you do not want to run `npm link`, you can call the built CLI directly:
+---
 
-```bash
-node dist/server/src/cli.js start --no-open
-```
+## ⚙️ Configuration
 
-Useful commands:
+Default port: **18840**
 
 ```bash
-node dist/server/src/cli.js doctor
-node dist/server/src/cli.js start --no-open
-node dist/server/src/cli.js version
+PORT=18841 npx remcodex
 ```
 
-Use a specific database:
+---
 
-```bash
-node dist/server/src/cli.js start --db ~/.remcodex/remcodex-demo.db --no-open
-node dist/server/src/cli.js doctor --db ~/.remcodex/remcodex-demo.db
-```
+## 📦 Install FAQ
+
+### Why does `npx remcodex` hang on Linux?
+
+First install may compile native deps:
 
-Planned install target after the npm package is published:
+- `better-sqlite3`
+- `node-pty`
+
+Make sure you have:
+
+- `python3`
+- `make`
+- `g++`
+
+---
+
+### Debug install issues
 
 ```bash
-npx remcodex
+npm install -g remcodex
+remcodex doctor
+remcodex start
 ```
 
-## Development
+---
+
+### Headless mode
 
 ```bash
-npm install
-npm run dev
+npx remcodex --no-open
 ```
 
-## How It Works
-
-The app uses `codex app-server` as the primary runtime path.
+---
 
-At a high level:
+## 🔧 How it works
 
-1. Codex emits semantic events
-2. The backend stores them in SQLite
-3. The frontend reads an aggregated timeline view for initial load
-4. Live updates continue over WebSocket with catch-up after refresh
+1. Codex emits events
+2. Backend stores them (SQLite)
+3. Frontend loads timeline snapshot
+4. Live updates stream via WebSocket
 
-This gives the UI:
+Result:
 
-- smooth streaming
 - recoverable sessions
-- imported rollout support
-- a consistent execution timeline instead of raw terminal logs
+- real-time UI
+- consistent execution flow
 
-## Key Behaviors
+---
 
-### Approvals
+## 📊 Status
 
-- Writes inside the working area usually pass directly
-- Writes outside the working area trigger approval
-- `Allow once` approves only the current request
-- `Allow for this turn` expands writable roots for the active turn
-- Historical approval records stay visible in the timeline
-- Only live approvals stay actionable in the bottom approval bar
+- Beta / developer preview
+- Local-first architecture
+- No cloud dependency
 
-### Imported Codex Sessions
+---
 
-- Existing Codex rollouts can be imported from local session history
-- Imported sessions keep their own source metadata
-- Imported sessions can continue syncing after you open them
-- Native sessions are excluded from the import picker
+## 🗺 Roadmap
 
-### Timeline and Execution Flow
+**Visibility**
 
-- The UI renders semantic timeline items, not raw logs
-- Commands and patches can be grouped into lighter activity summaries
-- Running and failed commands remain visually important
-- The final thinking placeholder appears only at the end of the active flow
+- fully observable execution
+- clear action timeline
 
-## Configuration
+**Control**
 
-Supported environment variables:
+- fine-grained approvals
+- safer execution
 
-- `PORT`
-- `DATABASE_PATH`
-- `PROJECT_ROOTS`
-- `CODEX_COMMAND`
-- `CODEX_MODE`
+**Continuity**
 
-For launch screenshots or demo data, you can rebuild a clean demo database with:
+- survive refresh / sleep
+- stable long runs
 
-```bash
-DATABASE_PATH="$HOME/.remcodex/remcodex-demo.db" ~/.nvm/versions/node/v20.19.5/bin/node scripts/seed-launch-demo-data.js --clean
-```
-- `REMOTE_HOSTS`
-- `ACTIVE_REMOTE_HOST`
-
-Notes:
-
-- The default runtime mode is `app-server`
-- `exec-json` is kept only as a fallback compatibility path
-- If `PROJECT_ROOTS` is not set, the app falls back to a broad local browsing root
-
-## Project Structure
-
-```text
-server/
-  src/
-    app.ts
-    controllers/
-    db/
-    gateways/
-    services/
-    types/
-    utils/
-web/
-  index.html
-  styles.css
-  api.js
-  session-ws.js
-  app.js
-scripts/
-  fix-node-pty-helper.js
-  import-codex-rollout.js
-  reset-semantic-demo-data.js
-```
+**Access**
 
-## Main Endpoints
+- control from any device
 
-- `GET /health`
-- `GET /api/codex/mode`
-- `GET /api/codex/status`
-- `GET /api/codex/quota`
-- `GET /api/sessions`
-- `GET /api/sessions/:sessionId`
-- `GET /api/sessions/:sessionId/timeline`
-- `GET /api/sessions/:sessionId/events`
-- `POST /api/sessions`
-- `POST /api/sessions/:sessionId/messages`
-- `POST /api/sessions/:sessionId/stop`
-- `POST /api/sessions/:sessionId/approvals/:requestId`
-- `WS /ws/sessions/:sessionId`
+**Integration**
 
-## What Is Not Finished Yet
+- IDE integrations
+- optional sharing
 
-This is the honest list:
+---
 
-- no polished installer yet
-- no desktop packaging yet
-- no full automated test suite yet
-- no production-grade auth / multi-user hardening yet
-- no release pipeline yet
-
-If you are comfortable cloning a repo and running a local Node app, you can use it today.
+## 👥 Who it’s for
 
-## Roadmap
+- developers already using Codex
+- people tired of terminal-only workflows
+- anyone who wants **control, not just output**
+- multi-device workflows
 
-Near-term:
+---
 
-- improve onboarding and installation
-- ship a cleaner public README and screenshots
-- add stronger regression coverage
-- harden long-running session recovery
-- continue refining the execution timeline UI
+## ⚠️ What’s not finished yet
 
-Later:
+- no polished installer yet
+- no desktop packaging
+- no production-grade auth
+- no release pipeline
 
-- package for easier local install
-- optional sync / multi-device helpers
-- stronger sharing, auditing, and team workflows
+If you're comfortable running a local Node app —  
+you can use it today.
 
-## License
+---
 
-No license has been added yet.
+## 📄 License
 
-Until a license is added, assume this repository is **source-available for review only**, not open source for reuse.
+MIT License

package/dist/server/src/app.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PORT = void 0;
 exports.resolvePackageRoot = resolvePackageRoot;
 exports.resolveDefaultDatabasePath = resolveDefaultDatabasePath;
 exports.startRemCodexServer = startRemCodexServer;
@@ -46,9 +47,10 @@ function resolvePackageRoot(startDir = __dirname) {
 function resolveDefaultDatabasePath() {
     return node_path_1.default.join((0, node_os_1.homedir)(), ".remcodex", "remcodex.db");
 }
+exports.DEFAULT_PORT = 18840;
 function buildRemCodexServer(options = {}) {
     const repoRoot = options.repoRoot ? node_path_1.default.resolve(options.repoRoot) : resolvePackageRoot();
-    const port = options.port ?? Number.parseInt(process.env.PORT ?? "3000", 10);
+    const port = options.port ?? Number.parseInt(process.env.PORT ?? String(exports.DEFAULT_PORT), 10);
     const databasePath = options.databasePath ??
         process.env.DATABASE_PATH ??
         resolveDefaultDatabasePath();

package/dist/server/src/cli.js

@@ -169,7 +169,7 @@ async function runStart(flags) {
         printError("Install Codex first, or set CODEX_COMMAND to the correct executable.");
         return 1;
     }
-    const preferredPort = flags.port ?? Number.parseInt(process.env.PORT ?? "3000", 10);
+    const preferredPort = flags.port ?? Number.parseInt(process.env.PORT ?? String(app_1.DEFAULT_PORT), 10);
     const codexMode = process.env.CODEX_MODE === "exec-json" ? "exec-json" : "app-server";
     let started = null;
     let activePort = preferredPort;

package/dist/server/src/services/codex-rollout-sync.js

@@ -9,6 +9,7 @@ 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");
 function computeSourceRolloutHasOpenTurnFromRecords(records) {
     const openTurnIds = new Set();
     for (const record of records) {
@@ -571,22 +572,7 @@ function translateRolloutRecords(records, emitFromRecordIndex = 0) {
                     : `call_${index}`;
                 const started = commandStarts.get(callId) || null;
                 const parsed = parseExecOutput(payload.output);
-                if (parsed.outputText) {
-                    appendSemantic(index, {
-                        type: "command.output.delta",
-                        turnId: currentTurnId,
-                        messageId: null,
-                        callId,
-                        requestId: null,
-                        phase: null,
-                        stream: "stdout",
-                        payload: {
-                            stream: "stdout",
-                            textDelta: parsed.outputText,
-                        },
-                        timestamp,
-                    });
-                }
+                const cappedOutput = parsed.outputText ? (0, output_limits_1.capTextValue)(parsed.outputText) : null;
                 appendSemantic(index, {
                     type: "command.end",
                     turnId: currentTurnId,
@@ -598,6 +584,9 @@ function translateRolloutRecords(records, emitFromRecordIndex = 0) {
                     payload: {
                         command: parsed.commandLine || started?.commandPayload.command || null,
                         cwd: started?.commandPayload.cwd || null,
+                        stdout: cappedOutput?.text || null,
+                        aggregatedOutput: cappedOutput?.text || null,
+                        stdoutTruncated: cappedOutput?.truncated || undefined,
                         status: parsed.exitCode == null
                             ? "completed"
                             : parsed.exitCode === 0

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 ||
@@ -277,6 +279,17 @@ class SessionManager {
             seq: event.seq,
         };
     }
+    stopSession(sessionId) {
+        const runtime = this.runners.get(sessionId);
+        if (!runtime || !runtime.runner.isAlive()) {
+            this.setStatus(sessionId, "idle");
+            return { accepted: true };
+        }
+        runtime.stopRequested = true;
+        this.setStatus(sessionId, "stopping");
+        runtime.runner.stop();
+        return { accepted: true };
+    }
     retryApprovalRequest(sessionId, requestId, codexLaunch) {
         const session = this.getSessionOrThrow(sessionId);
         const project = this.options.projectManager.getProject(session.project_id);
@@ -301,17 +314,6 @@ class SessionManager {
             turnId,
         };
     }
-    stopSession(sessionId) {
-        const runtime = this.runners.get(sessionId);
-        if (!runtime || !runtime.runner.isAlive()) {
-            this.setStatus(sessionId, "idle");
-            return { accepted: true };
-        }
-        runtime.stopRequested = true;
-        this.setStatus(sessionId, "stopping");
-        runtime.runner.stop();
-        return { accepted: true };
-    }
     resolveApproval(sessionId, requestId, decision) {
         const runtime = this.runners.get(sessionId);
         if (!runtime?.runner.isAlive()) {
@@ -346,6 +348,7 @@ class SessionManager {
         const runtime = {
             runner,
             stopRequested: false,
+            transientSeqCursor: this.options.eventStore.latestSeq(sessionId),
             turnId,
             appTurnId: null,
             turnStarted: false,
@@ -945,6 +948,8 @@ class SessionManager {
             cwd: payload.cwd || null,
             stdout: "",
             stderr: "",
+            stdoutTruncated: false,
+            stderrTruncated: false,
             started: true,
             completed: false,
         });
@@ -971,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,
@@ -1013,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,
@@ -1218,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(`

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,8 +1,8 @@
 {
   "name": "remcodex",
-  "version": "0.1.0-beta.7",
+  "version": "0.1.0-beta.9",
   "description": "Control Codex from anywhere. Even on your phone.",
-  "license": "UNLICENSED",
+  "license": "MIT",
   "bin": {
     "remcodex": "dist/server/src/cli.js"
   },
@@ -10,8 +10,7 @@
     "dist",
     "web",
     "scripts/fix-node-pty-helper.js",
-    "README.md",
-    "docs/assets"
+    "README.md"
   ],
   "scripts": {
     "postinstall": "node scripts/fix-node-pty-helper.js",

package/web/session-timeline-reducer.js

@@ -8,11 +8,35 @@ const TURN_STATUS_PRIORITY = {
   failed: 3,
   aborted: 4,
 };
+const MAX_COMMAND_OUTPUT_CHARS = 80 * 1024;
+const MAX_PATCH_OUTPUT_CHARS = 48 * 1024;
+const OUTPUT_TRUNCATION_NOTICE = "\n\n[output truncated]\n";
 
 function createItemIndex() {
   return new Map();
 }
 
+function clampOutputText(text, maxChars = MAX_COMMAND_OUTPUT_CHARS) {
+  const safeText = String(text || "");
+  if (!safeText) {
+    return "";
+  }
+  if (safeText.endsWith(OUTPUT_TRUNCATION_NOTICE)) {
+    return safeText;
+  }
+
+  const contentLimit = Math.max(0, maxChars - OUTPUT_TRUNCATION_NOTICE.length);
+  if (safeText.length <= contentLimit) {
+    return safeText;
+  }
+
+  return `${safeText.slice(0, contentLimit)}${OUTPUT_TRUNCATION_NOTICE}`;
+}
+
+function appendClampedOutput(currentText, textDelta, maxChars = MAX_COMMAND_OUTPUT_CHARS) {
+  return clampOutputText(`${String(currentText || "")}${String(textDelta || "")}`, maxChars);
+}
+
 function nextTurnFallbackId(event) {
   return event?.turnId || `turn:${event?.id || crypto.randomUUID?.() || Date.now()}`;
 }
@@ -526,10 +550,18 @@ export function reduceTimeline(state, event) {
       const nextStdout =
         event.payload?.stream === "stderr"
           ? currentCommand?.stdout || ""
-          : appendDeltaText(currentCommand?.stdout, event.payload?.textDelta);
+          : appendClampedOutput(
+              currentCommand?.stdout,
+              event.payload?.textDelta,
+              MAX_COMMAND_OUTPUT_CHARS,
+            );
       const nextStderr =
         event.payload?.stream === "stderr"
-          ? appendDeltaText(currentCommand?.stderr, event.payload?.textDelta)
+          ? appendClampedOutput(
+              currentCommand?.stderr,
+              event.payload?.textDelta,
+              MAX_COMMAND_OUTPUT_CHARS,
+            )
           : currentCommand?.stderr || "";
       upsertCommand(state, event, turnId, {
         status: currentCommand?.status === "awaiting_approval" ? "awaiting_approval" : "running",
@@ -552,14 +584,22 @@ export function reduceTimeline(state, event) {
         status: completedStatus,
         command: event.payload?.command || state.commandsByCallId[event.callId]?.command || "",
         cwd: event.payload?.cwd || state.commandsByCallId[event.callId]?.cwd || null,
-        stdout: event.payload?.stdout || state.commandsByCallId[event.callId]?.stdout || "",
-        stderr: event.payload?.stderr || state.commandsByCallId[event.callId]?.stderr || "",
-        output:
+        stdout: clampOutputText(
+          event.payload?.stdout || state.commandsByCallId[event.callId]?.stdout || "",
+          MAX_COMMAND_OUTPUT_CHARS,
+        ),
+        stderr: clampOutputText(
+          event.payload?.stderr || state.commandsByCallId[event.callId]?.stderr || "",
+          MAX_COMMAND_OUTPUT_CHARS,
+        ),
+        output: clampOutputText(
           event.payload?.aggregatedOutput ||
-          event.payload?.formattedOutput ||
-          event.payload?.output ||
-          state.commandsByCallId[event.callId]?.output ||
-          "",
+            event.payload?.formattedOutput ||
+            event.payload?.output ||
+            state.commandsByCallId[event.callId]?.output ||
+            "",
+          MAX_COMMAND_OUTPUT_CHARS,
+        ),
         exitCode:
           event.payload?.exitCode ?? state.commandsByCallId[event.callId]?.exitCode ?? null,
         duration: event.payload?.duration || state.commandsByCallId[event.callId]?.duration || null,
@@ -583,7 +623,11 @@ export function reduceTimeline(state, event) {
       const currentPatch = state.patchesByCallId[patchId];
       upsertPatch(state, event, turnId, {
         status: currentPatch?.status || "running",
-        output: appendDeltaText(currentPatch?.output, event.payload?.textDelta),
+        output: appendClampedOutput(
+          currentPatch?.output,
+          event.payload?.textDelta,
+          MAX_PATCH_OUTPUT_CHARS,
+        ),
         outputStatus: "streaming",
       });
       setTurnStatus(turn, "running");
@@ -598,9 +642,18 @@ export function reduceTimeline(state, event) {
         status: patchStatus,
         patchText:
           event.payload?.patchText || state.patchesByCallId[event.callId]?.patchText || "",
-        output: event.payload?.output || state.patchesByCallId[event.callId]?.output || "",
-        stdout: event.payload?.stdout || state.patchesByCallId[event.callId]?.stdout || "",
-        stderr: event.payload?.stderr || state.patchesByCallId[event.callId]?.stderr || "",
+        output: clampOutputText(
+          event.payload?.output || state.patchesByCallId[event.callId]?.output || "",
+          MAX_PATCH_OUTPUT_CHARS,
+        ),
+        stdout: clampOutputText(
+          event.payload?.stdout || state.patchesByCallId[event.callId]?.stdout || "",
+          MAX_PATCH_OUTPUT_CHARS,
+        ),
+        stderr: clampOutputText(
+          event.payload?.stderr || state.patchesByCallId[event.callId]?.stderr || "",
+          MAX_PATCH_OUTPUT_CHARS,
+        ),
         changes: event.payload?.changes || state.patchesByCallId[event.callId]?.changes || {},
         success:
           event.payload?.success ?? state.patchesByCallId[event.callId]?.success ?? null,