ohmyvibe 0.1.3 → 0.1.4

package/.env.example

@@ -1,2 +1,2 @@
-MANAGEMENT_SERVER_URL=http://localhost:3310
-DAEMON_NAME=ohmyvibe-local
+MANAGEMENT_SERVER_URL=http://localhost:3310
+DAEMON_NAME=ohmyvibe-local

package/README.md

@@ -1,249 +1,249 @@
-# OhMyVibe
-
-这是一个 `VibeCoding` 控制台：
-
-- `daemon -> control server <- browser` 架构（daemon 主动连接管理端）
-- 每个会话独立启动一个 `codex app-server` 子进程
-- daemon 统一管理多会话、消息发送、中断、状态同步
-- 额外提供一个标准 `ACP` bridge 入口，方便后续给编辑器或其他 ACP client 接入
-- 应用侧 session 本地持久化到 `data/sessions.json`
-- 支持从 Codex 历史 `~/.codex/sessions` 恢复会话，并绑定到原始 Codex thread
-- Web 控制台为独立 React + shadcn 风格项目，浏览器只连接管理端
-
-## 为什么这样做
-
-当前官方能力里，`Codex CLI` 暴露的是 `app-server` 自动化接口，而不是原生 `ACP agent`。因此这个 MVP 采用两层桥接：
-
-1. 南向：daemon 通过 `codex app-server --listen stdio://` 控制 Codex
-2. 北向：daemon 自己暴露 `ACP` 兼容 agent，供外部 ACP client 使用
-
-这能保证现在就能正确接入 Codex，同时不把上层协议绑死在 Codex 私有接口上。
-
-## 运行
-
-要求：
-
-- Node.js 22+
-- 本机已安装并可运行 `codex`
-- `codex` 已完成登录
-
-1. 启动 Web 管理端（API + 页面）：
-
-```bash
-npm install
-npm --prefix web install
-npm --prefix web run build
-npm run web:server
-```
-
-默认监听 `http://localhost:3310`
-默认读取 `web/.env`
-
-2. 在被控机器启动 daemon，并主动连接管理端：
-
-```bash
-npm run daemon
-```
-
-daemon 不再暴露本地 HTTP API，浏览器也不应直接连接 daemon。
-默认读取根目录 `.env`
-
-可选环境变量：
-
-- `DAEMON_ID`：固定 daemon 标识
-- `DAEMON_NAME`：展示名称
-
-3. 浏览器访问管理端页面：
-
-```bash
-http://your-control-host:3310
-```
-
-开发模式（前端热更新）：
-
-```bash
-npm run web:dev
-```
-
-启动 ACP bridge：
-
-```bash
-npm run acp
-```
-
-## 使用示例
-
-### 示例 1：本机快速跑通
-
-先启动控制端：
-
-```bash
-git clone https://github.com/gaoyu06/OhMyVibe.git
-cd OhMyVibe
-npm install
-npm --prefix web install
-npm --prefix web run build
-npm run web:server
-```
-
-再在另一台机器或另一个终端启动 daemon：
-
-```bash
-cp .env.example .env
-```
-
-`.env`:
-
-```env
-MANAGEMENT_SERVER_URL=http://localhost:3310
-DAEMON_NAME=ohmyvibe-local
-```
-
-启动：
-
-```bash
-npm run daemon
-```
-
-浏览器访问：
-
-```text
-http://localhost:3310
-```
-
-### 示例 2：通过 npm 全局安装 daemon
-
-如果你只想安装被控端 daemon，可以直接安装 npm 包：
-
-```bash
-npm install -g ohmyvibe
-```
-
-然后直接连接到你的控制端：
-
-```bash
-ohmyvibe --management-server-url http://your-control-host:3310
-```
-
-也可以显式指定 daemon 名称或 id：
-
-```bash
-ohmyvibe daemon ^
-  --management-server-url http://your-control-host:3310 ^
-  --daemon-name office-win ^
-  --daemon-id office-win-01
-```
-
-说明：
-
-- 当前 npm 包主要提供 `daemon` / `acp` CLI
-- Web 控制服务端目前仍建议直接从仓库部署
-
-## 服务端部署示例
-
-### 示例 1：在 Linux 服务器部署控制端
-
-```bash
-git clone https://github.com/gaoyu06/OhMyVibe.git
-cd OhMyVibe
-npm install
-npm --prefix web install
-cp web/.env.example web/.env
-npm --prefix web run build
-npm run web:server
-```
-
-`web/.env`:
-
-```env
-PORT=3310
-VITE_CONTROL_SERVER_URL=https://your-domain.example.com
-```
-
-反向代理到 `3310` 端口后，浏览器即可访问控制台，远端 daemon 使用：
-
-```env
-MANAGEMENT_SERVER_URL=https://your-domain.example.com
-```
-
-### 示例 2：用 PM2 托管控制端
-
-```bash
-pm2 start "npm run web:server" --name ohmyvibe-control
-pm2 save
-```
-
-### 示例 3：发布前验证 npm 包
-
-```bash
-npm run build:daemon
-npm run pack:dry-run
-```
-
-## 全局安装 daemon
-
-如果你要把 daemon 作为全局命令安装，当前包已经支持：
-
-```bash
-npm install -g ohmyvibe
-```
-
-然后直接启动：
-
-```bash
-ohmyvibe --management-server-url http://localhost:3310
-```
-
-也可以显式指定 daemon 名称或 id：
-
-```bash
-ohmyvibe daemon \
-  --management-server-url http://localhost:3310 \
-  --daemon-name ohmyvibe-local \
-  --daemon-id local-1
-```
-
-如果仍然想走环境变量，也支持：
-
-- `MANAGEMENT_SERVER_URL`
-- `DAEMON_ID`
-- `DAEMON_NAME`
-
-发布前可先验证打包内容：
-
-```bash
-npm run build:daemon
-npm run pack:dry-run
-```
-
-正式发布：
-
-```bash
-npm publish --access public
-```
-
-## 现在支持的能力
-
-- 创建多个独立 Codex 会话
-- daemon 重启后恢复应用内 session 列表与 transcript
-- 给指定会话发送消息
-- 流式接收 assistant 文本增量
-- 用 `item/*` 与 `turn/*` 事件维护实时 transcript
-- 中断运行中的 turn
-- 关闭会话
-- 从 Codex 历史会话列表恢复，并继续在同一 `threadId` 上对话
-- 使用独立前端从其他设备远程管理 daemon
-- daemon 主动连接管理端，浏览器不需要直连 daemon
-
-## 后续建议
-
-- 把 `turn/interrupt`、审批、文件 diff、命令执行输出做成更细粒度 UI
-- 将 ACP session 和 web session 统一到同一后端存储
-- 为 `codex app-server` 请求/通知补完整类型约束
-
-## 参考文档
-
-- OpenAI Codex App Server: https://developers.openai.com/codex/app-server
-- OpenAI Codex CLI repo: https://github.com/openai/codex
-- ACP 协议主页: https://agentclientprotocol.com
-- ACP TypeScript SDK: https://www.npmjs.com/package/@agentclientprotocol/sdk
+# OhMyVibe
+
+这是一个 `VibeCoding` 控制台：
+
+- `daemon -> control server <- browser` 架构（daemon 主动连接管理端）
+- 每个会话独立启动一个 `codex app-server` 子进程
+- daemon 统一管理多会话、消息发送、中断、状态同步
+- 额外提供一个标准 `ACP` bridge 入口，方便后续给编辑器或其他 ACP client 接入
+- 应用侧 session 本地持久化到 `data/sessions.json`
+- 支持从 Codex 历史 `~/.codex/sessions` 恢复会话，并绑定到原始 Codex thread
+- Web 控制台为独立 React + shadcn 风格项目，浏览器只连接管理端
+
+## 为什么这样做
+
+当前官方能力里，`Codex CLI` 暴露的是 `app-server` 自动化接口，而不是原生 `ACP agent`。因此这个 MVP 采用两层桥接：
+
+1. 南向：daemon 通过 `codex app-server --listen stdio://` 控制 Codex
+2. 北向：daemon 自己暴露 `ACP` 兼容 agent，供外部 ACP client 使用
+
+这能保证现在就能正确接入 Codex，同时不把上层协议绑死在 Codex 私有接口上。
+
+## 运行
+
+要求：
+
+- Node.js 22+
+- 本机已安装并可运行 `codex`
+- `codex` 已完成登录
+
+1. 启动 Web 管理端（API + 页面）：
+
+```bash
+npm install
+npm --prefix web install
+npm --prefix web run build
+npm run web:server
+```
+
+默认监听 `http://localhost:3310`
+默认读取 `web/.env`
+
+2. 在被控机器启动 daemon，并主动连接管理端：
+
+```bash
+npm run daemon
+```
+
+daemon 不再暴露本地 HTTP API，浏览器也不应直接连接 daemon。
+默认读取根目录 `.env`
+
+可选环境变量：
+
+- `DAEMON_ID`：固定 daemon 标识
+- `DAEMON_NAME`：展示名称
+
+3. 浏览器访问管理端页面：
+
+```bash
+http://your-control-host:3310
+```
+
+开发模式（前端热更新）：
+
+```bash
+npm run web:dev
+```
+
+启动 ACP bridge：
+
+```bash
+npm run acp
+```
+
+## 使用示例
+
+### 示例 1：本机快速跑通
+
+先启动控制端：
+
+```bash
+git clone https://github.com/gaoyu06/OhMyVibe.git
+cd OhMyVibe
+npm install
+npm --prefix web install
+npm --prefix web run build
+npm run web:server
+```
+
+再在另一台机器或另一个终端启动 daemon：
+
+```bash
+cp .env.example .env
+```
+
+`.env`:
+
+```env
+MANAGEMENT_SERVER_URL=http://localhost:3310
+DAEMON_NAME=ohmyvibe-local
+```
+
+启动：
+
+```bash
+npm run daemon
+```
+
+浏览器访问：
+
+```text
+http://localhost:3310
+```
+
+### 示例 2：通过 npm 全局安装 daemon
+
+如果你只想安装被控端 daemon，可以直接安装 npm 包：
+
+```bash
+npm install -g ohmyvibe
+```
+
+然后直接连接到你的控制端：
+
+```bash
+ohmyvibe --management-server-url http://your-control-host:3310
+```
+
+也可以显式指定 daemon 名称或 id：
+
+```bash
+ohmyvibe daemon ^
+  --management-server-url http://your-control-host:3310 ^
+  --daemon-name office-win ^
+  --daemon-id office-win-01
+```
+
+说明：
+
+- 当前 npm 包主要提供 `daemon` / `acp` CLI
+- Web 控制服务端目前仍建议直接从仓库部署
+
+## 服务端部署示例
+
+### 示例 1：在 Linux 服务器部署控制端
+
+```bash
+git clone https://github.com/gaoyu06/OhMyVibe.git
+cd OhMyVibe
+npm install
+npm --prefix web install
+cp web/.env.example web/.env
+npm --prefix web run build
+npm run web:server
+```
+
+`web/.env`:
+
+```env
+PORT=3310
+VITE_CONTROL_SERVER_URL=https://your-domain.example.com
+```
+
+反向代理到 `3310` 端口后，浏览器即可访问控制台，远端 daemon 使用：
+
+```env
+MANAGEMENT_SERVER_URL=https://your-domain.example.com
+```
+
+### 示例 2：用 PM2 托管控制端
+
+```bash
+pm2 start "npm run web:server" --name ohmyvibe-control
+pm2 save
+```
+
+### 示例 3：发布前验证 npm 包
+
+```bash
+npm run build:daemon
+npm run pack:dry-run
+```
+
+## 全局安装 daemon
+
+如果你要把 daemon 作为全局命令安装，当前包已经支持：
+
+```bash
+npm install -g ohmyvibe
+```
+
+然后直接启动：
+
+```bash
+ohmyvibe --management-server-url http://localhost:3310
+```
+
+也可以显式指定 daemon 名称或 id：
+
+```bash
+ohmyvibe daemon \
+  --management-server-url http://localhost:3310 \
+  --daemon-name ohmyvibe-local \
+  --daemon-id local-1
+```
+
+如果仍然想走环境变量，也支持：
+
+- `MANAGEMENT_SERVER_URL`
+- `DAEMON_ID`
+- `DAEMON_NAME`
+
+发布前可先验证打包内容：
+
+```bash
+npm run build:daemon
+npm run pack:dry-run
+```
+
+正式发布：
+
+```bash
+npm publish --access public
+```
+
+## 现在支持的能力
+
+- 创建多个独立 Codex 会话
+- daemon 重启后恢复应用内 session 列表与 transcript
+- 给指定会话发送消息
+- 流式接收 assistant 文本增量
+- 用 `item/*` 与 `turn/*` 事件维护实时 transcript
+- 中断运行中的 turn
+- 关闭会话
+- 从 Codex 历史会话列表恢复，并继续在同一 `threadId` 上对话
+- 使用独立前端从其他设备远程管理 daemon
+- daemon 主动连接管理端，浏览器不需要直连 daemon
+
+## 后续建议
+
+- 把 `turn/interrupt`、审批、文件 diff、命令执行输出做成更细粒度 UI
+- 将 ACP session 和 web session 统一到同一后端存储
+- 为 `codex app-server` 请求/通知补完整类型约束
+
+## 参考文档
+
+- OpenAI Codex App Server: https://developers.openai.com/codex/app-server
+- OpenAI Codex CLI repo: https://github.com/openai/codex
+- ACP 协议主页: https://agentclientprotocol.com
+- ACP TypeScript SDK: https://www.npmjs.com/package/@agentclientprotocol/sdk

package/dist/cli.js

@@ -1,26 +1,26 @@
 #!/usr/bin/env node
 import "dotenv/config";
 function printHelp() {
-    console.log(`OhMyVibe CLI
-
-Usage:
-  ohmyvibe [command] [options]
-
-Commands:
-  daemon        Start the managed daemon (default)
-  acp           Start the ACP bridge
-
-Options:
-  -u, --management-server-url <url>  Control server URL
-  --daemon-id <id>                   Override daemon id
-  -n, --daemon-name <name>           Override daemon display name
-  -h, --help                         Show help
-  -v, --version                      Show version
-
-Examples:
-  ohmyvibe --management-server-url http://localhost:3310
-  ohmyvibe daemon -u http://localhost:3310 -n my-daemon
-  ohmyvibe acp
+    console.log(`OhMyVibe CLI
+
+Usage:
+  ohmyvibe [command] [options]
+
+Commands:
+  daemon        Start the managed daemon (default)
+  acp           Start the ACP bridge
+
+Options:
+  -u, --management-server-url <url>  Control server URL
+  --daemon-id <id>                   Override daemon id
+  -n, --daemon-name <name>           Override daemon display name
+  -h, --help                         Show help
+  -v, --version                      Show version
+
+Examples:
+  ohmyvibe --management-server-url http://localhost:3310
+  ohmyvibe daemon -u http://localhost:3310 -n my-daemon
+  ohmyvibe acp
 `);
 }
 function printVersion() {

package/dist/daemon/managementBridge.js

@@ -1,6 +1,7 @@
 import os from "node:os";
 import { randomUUID } from "node:crypto";
 import { WebSocket } from "ws";
+import packageJson from "../../package.json" with { type: "json" };
 export class ManagementBridge {
     serverUrl;
     daemonId;
@@ -87,6 +88,7 @@ export class ManagementBridge {
             daemon: {
                 id: this.daemonId,
                 name: this.daemonName,
+                version: packageJson.version,
                 platform: process.platform,
                 cwd: process.cwd(),
                 connectedAt: new Date().toISOString(),

package/dist/daemon/sessionManager.js

@@ -12,7 +12,9 @@ export class SessionManager extends EventEmitter {
     store = new SessionStore();
     configCache;
     persistTimer;
-    persistQueued = false;
+    persistInFlight = false;
+    dirtySessionIds = new Set();
+    deletedSessionIds = new Set();
     sessionUpdateTimer;
     pendingSessionUpdates = new Map();
     constructor() {
@@ -193,12 +195,13 @@ export class SessionManager extends EventEmitter {
             sandbox: input.sandbox ?? "workspace-write",
             approvalPolicy: input.approvalPolicy ?? "never",
             transcript: [],
+            previewEntries: [],
             liveMessages: new Map(),
             liveReasoning: new Map(),
             pendingApprovals: new Map(),
         };
         this.sessions.set(sessionId, session);
-        this.persist();
+        this.persist(session);
         this.emitChange({ type: "session-created", session: this.toSummary(session) });
         const runtime = this.createRuntime(session);
         session.startupPromise = this.trackSessionStartup(session, this.startSessionInBackground(session, runtime, input));
@@ -226,12 +229,13 @@ export class SessionManager extends EventEmitter {
             approvalPolicy: input.approvalPolicy ?? "never",
             codexThreadId: input.threadId,
             transcript: [],
+            previewEntries: [],
             liveMessages: new Map(),
             liveReasoning: new Map(),
             pendingApprovals: new Map(),
         };
         this.sessions.set(session.id, session);
-        this.persist();
+        this.persist(session);
         this.emitChange({ type: "session-created", session: this.toSummary(session) });
         const runtime = this.createRuntime(session);
         session.startupPromise = this.trackSessionStartup(session, this.restoreSessionInBackground(session, runtime, input));
@@ -250,7 +254,7 @@ export class SessionManager extends EventEmitter {
         session.approvalPolicy = approvalPolicy;
         session.configDirty = session.configDirty || runtimeChanged;
         this.touch(session);
-        this.persist();
+        this.persist(session);
         this.emitChange({ type: "session-updated", session: this.toSummary(session) });
         if (session.status !== "running" && session.status !== "starting") {
             await this.runtimeFor(session).applyPendingConfig();
@@ -265,7 +269,7 @@ export class SessionManager extends EventEmitter {
         }
         session.title = nextTitle;
         this.touch(session);
-        this.persist();
+        this.persist(session);
         this.emitChange({ type: "session-updated", session: this.toSummary(session) });
         return this.getOrThrow(sessionId);
     }
@@ -287,7 +291,7 @@ export class SessionManager extends EventEmitter {
         await this.runtimeFor(session).close();
         this.sessions.delete(sessionId);
         this.runtimes.delete(sessionId);
-        this.persist();
+        this.persistDeletion(sessionId);
         this.emitChange({ type: "session-deleted", sessionId });
     }
     restorePersistedSessions() {
@@ -309,6 +313,8 @@ export class SessionManager extends EventEmitter {
                 codexSource: persisted.codexSource,
                 lastError: persisted.lastError,
                 transcript: Array.isArray(persisted.transcript) ? persisted.transcript : [],
+                previewEntries: Array.isArray(persisted.previewEntries) ? persisted.previewEntries : [],
+                previewDirty: !Array.isArray(persisted.previewEntries),
                 liveMessages: new Map(),
                 liveReasoning: new Map(),
                 pendingApprovals: new Map(),
@@ -317,26 +323,78 @@ export class SessionManager extends EventEmitter {
             this.createRuntime(session);
         }
     }
-    persist() {
-        this.persistQueued = true;
+    persist(target) {
+        if (typeof target === "string" && target) {
+            this.deletedSessionIds.delete(target);
+            this.dirtySessionIds.add(target);
+        }
+        else if (target && typeof target !== "string") {
+            this.deletedSessionIds.delete(target.id);
+            this.dirtySessionIds.add(target.id);
+        }
+        else {
+            for (const sessionId of this.sessions.keys()) {
+                this.deletedSessionIds.delete(sessionId);
+                this.dirtySessionIds.add(sessionId);
+            }
+        }
+        this.schedulePersistFlush();
+    }
+    persistDeletion(sessionId) {
+        this.dirtySessionIds.delete(sessionId);
+        this.deletedSessionIds.add(sessionId);
+        this.schedulePersistFlush();
+    }
+    schedulePersistFlush() {
         if (this.persistTimer) {
             return;
         }
-        // Streaming turns can emit many small deltas; batch disk writes so read-only
-        // APIs and other sessions are not blocked by synchronous full-store saves.
         this.persistTimer = setTimeout(() => {
             this.persistTimer = undefined;
-            if (!this.persistQueued) {
-                return;
+            void this.flushPersist();
+        }, 120);
+    }
+    async flushPersist() {
+        if (this.persistInFlight) {
+            return;
+        }
+        if (!this.dirtySessionIds.size && !this.deletedSessionIds.size) {
+            return;
+        }
+        this.persistInFlight = true;
+        const deletedSessionIds = Array.from(this.deletedSessionIds);
+        const dirtySessionIds = Array.from(this.dirtySessionIds).filter((sessionId) => !this.deletedSessionIds.has(sessionId));
+        this.deletedSessionIds.clear();
+        this.dirtySessionIds.clear();
+        try {
+            for (const sessionId of dirtySessionIds) {
+                const session = this.sessions.get(sessionId);
+                if (!session) {
+                    continue;
+                }
+                await this.store.saveSession(this.serializeSessionForStore(session));
             }
-            this.persistQueued = false;
-            this.store.save(Array.from(this.sessions.values())
-                .map((session) => this.get(session.id))
-                .filter((session) => Boolean(session)));
-            if (this.persistQueued) {
-                this.persist();
+            for (const sessionId of deletedSessionIds) {
+                await this.store.deleteSession(sessionId);
             }
-        }, 120);
+        }
+        catch {
+            for (const sessionId of dirtySessionIds) {
+                if (!this.deletedSessionIds.has(sessionId)) {
+                    this.dirtySessionIds.add(sessionId);
+                }
+            }
+            for (const sessionId of deletedSessionIds) {
+                this.deletedSessionIds.add(sessionId);
+                this.dirtySessionIds.delete(sessionId);
+            }
+        }
+        finally {
+            this.persistInFlight = false;
+            if (this.dirtySessionIds.size || this.deletedSessionIds.size) {
+                this.schedulePersistFlush();
+            }
+        }
     }
     async startSessionInBackground(session, runtime, input) {
         try {
@@ -351,7 +409,7 @@ export class SessionManager extends EventEmitter {
                 text: `Session startup failed: ${session.lastError}`,
                 status: "failed",
             });
-            this.persist();
+            this.persist(session);
             this.emitChange({ type: "session-updated", session: this.toSummary(session) });
         }
     }
@@ -368,7 +426,7 @@ export class SessionManager extends EventEmitter {
                 text: `Session restore failed: ${session.lastError}`,
                 status: "failed",
             });
-            this.persist();
+            this.persist(session);
             this.emitChange({ type: "session-updated", session: this.toSummary(session) });
         }
     }
@@ -379,8 +437,9 @@ export class SessionManager extends EventEmitter {
             ...input,
         };
         session.transcript.push(entry);
+        this.markPreviewDirty(session);
         this.touch(session);
-        this.persist();
+        this.persist(session);
         this.emitChange({ type: "session-entry", sessionId: session.id, entry });
         this.emitChange({ type: "session-updated", session: this.toSummary(session) });
         return entry;
@@ -398,9 +457,18 @@ export class SessionManager extends EventEmitter {
         }
         else {
             const existing = session.transcript[existingIndex];
-            const mergedText = existing.kind === "tool" && entry.kind === "tool" && existing.text && entry.text && existing.text !== entry.text
-                ? `${existing.text}\n\n${entry.text}`.trim()
-                : entry.text || existing.text;
+            const keepExistingReadPreview = existing.kind === "tool" &&
+                entry.kind === "tool" &&
+                this.isReadToolName(existing.meta?.name);
+            const mergedText = keepExistingReadPreview
+                ? existing.text
+                : existing.kind === "tool" &&
+                    entry.kind === "tool" &&
+                    existing.text &&
+                    entry.text &&
+                    existing.text !== entry.text
+                    ? `${existing.text}\n\n${entry.text}`.trim()
+                    : entry.text || existing.text;
             session.transcript[existingIndex] = {
                 ...existing,
                 ...entry,
@@ -412,14 +480,18 @@ export class SessionManager extends EventEmitter {
                 entry: session.transcript[existingIndex],
             };
         }
+        this.markPreviewDirty(session);
         this.touch(session);
-        this.persist();
+        this.persist(session);
         this.emitChange(event);
         this.emitChange({ type: "session-updated", session: this.toSummary(session) });
     }
     touch(session) {
         session.updatedAt = new Date().toISOString();
     }
+    markPreviewDirty(session) {
+        session.previewDirty = true;
+    }
     emitChange(event) {
         if (event.type === "session-updated") {
             this.pendingSessionUpdates.set(event.session.id, event.session);
@@ -451,8 +523,9 @@ export class SessionManager extends EventEmitter {
     }
     createRuntime(session) {
         const runtime = new SessionRuntime(session, {
-            persist: () => this.persist(),
+            persist: () => this.persist(session),
             emitChange: (event) => this.emitChange(event),
+            markPreviewDirty: (target) => this.markPreviewDirty(target),
             touch: (target) => this.touch(target),
             toSummary: (target) => this.toSummary(target),
             getDetails: (sessionId) => this.getOrThrow(sessionId),
@@ -467,7 +540,31 @@ export class SessionManager extends EventEmitter {
     runtimeFor(session) {
         return this.runtimes.get(session.id) ?? this.createRuntime(session);
     }
+    serializeSessionForStore(session) {
+        const previewEntries = this.getPreviewEntries(session);
+        return {
+            id: session.id,
+            title: session.title,
+            cwd: session.cwd,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            status: session.status,
+            origin: session.origin,
+            model: session.model,
+            reasoningEffort: session.reasoningEffort,
+            sandbox: session.sandbox,
+            approvalPolicy: session.approvalPolicy,
+            codexThreadId: session.codexThreadId,
+            codexPath: session.codexPath,
+            codexSource: session.codexSource,
+            lastError: session.lastError,
+            transcriptCount: session.transcript.length,
+            previewEntries,
+            transcript: [...session.transcript],
+        };
+    }
     toSummary(session) {
+        const previewEntries = this.getPreviewEntries(session);
         return {
             id: session.id,
             title: session.title,
@@ -485,8 +582,102 @@ export class SessionManager extends EventEmitter {
             codexSource: session.codexSource,
             lastError: session.lastError,
             transcriptCount: session.transcript.length,
+            previewEntries,
         };
     }
+    getPreviewEntries(session) {
+        if (!session.previewDirty) {
+            return session.previewEntries;
+        }
+        session.previewEntries = this.toPreviewEntries(session.transcript);
+        session.previewDirty = false;
+        return session.previewEntries;
+    }
+    toPreviewEntries(transcript) {
+        if (!transcript.length) {
+            return [];
+        }
+        const selected = [];
+        let textBudget = 520;
+        for (let index = transcript.length - 1; index >= 0; index -= 1) {
+            const entry = transcript[index];
+            if (!entry) {
+                continue;
+            }
+            const previewText = this.toPreviewText(entry);
+            if (!previewText) {
+                continue;
+            }
+            const cost = Math.max(40, previewText.length);
+            if (selected.length && textBudget - cost < 0) {
+                break;
+            }
+            selected.unshift({
+                id: entry.id,
+                kind: entry.kind,
+                previewText,
+                createdAt: entry.createdAt,
+                status: entry.status,
+            });
+            textBudget -= cost;
+            if (selected.length >= 6) {
+                break;
+            }
+        }
+        return selected;
+    }
+    toPreviewText(entry) {
+        if (entry.kind === "assistant" && entry.status === "streaming" && !entry.text.trim()) {
+            return "Thinking...";
+        }
+        if (entry.kind === "approval") {
+            const approvalKind = typeof entry.meta?.approvalKind === "string" ? entry.meta.approvalKind : "";
+            if (approvalKind) {
+                return approvalKind;
+            }
+        }
+        if (entry.kind === "tool" || entry.kind === "command" || entry.kind === "file_change") {
+            return this.lastLines(entry.text, 6) || this.entryLabel(entry);
+        }
+        const collapsed = String(entry.text || "")
+            .replace(/\s+/g, " ")
+            .trim();
+        return collapsed || this.entryLabel(entry);
+    }
+    entryLabel(entry) {
+        switch (entry.kind) {
+            case "user":
+                return "User";
+            case "assistant":
+                return entry.status === "streaming" ? "Assistant" : "Reply";
+            case "reasoning":
+                return "Thinking";
+            case "tool":
+                return "Tool";
+            case "command":
+                return "Command";
+            case "file_change":
+                return "Diff";
+            case "approval":
+                return "Approval";
+            default:
+                return "System";
+        }
+    }
+    lastLines(text, limit) {
+        const lines = String(text || "")
+            .split(/\r?\n/)
+            .map((line) => line.trimEnd())
+            .filter((line) => line.trim().length > 0);
+        return lines.slice(-limit).join("\n").trim();
+    }
+    isReadToolName(value) {
+        if (typeof value !== "string") {
+            return false;
+        }
+        const normalized = value.replace(/[\s-]+/g, "_").trim().toLowerCase();
+        return normalized === "read" || normalized === "read_file" || normalized === "readfile";
+    }
     getSessionOrThrow(sessionId) {
         const session = this.sessions.get(sessionId);
         if (!session) {

package/dist/daemon/sessionRuntime.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { CodexAppServerClient } from "./codexAppServerClient.js";
 export class SessionRuntime {
     session;
@@ -56,6 +57,7 @@ export class SessionRuntime {
                 resolvedAt: new Date().toISOString(),
                 decision,
             };
+            this.callbacks.markPreviewDirty(this.session);
         }
         this.callbacks.touch(this.session);
         this.callbacks.persist();
@@ -158,6 +160,7 @@ export class SessionRuntime {
             this.session.title = response.thread?.name || response.thread?.preview || this.session.title;
             this.session.status = this.mapThreadStatus(response.thread?.status);
             this.session.transcript = this.threadToTranscript(response.thread);
+            this.callbacks.markPreviewDirty(this.session);
             this.session.liveMessages.clear();
             this.session.liveReasoning.clear();
             this.session.pendingApprovals.clear();
@@ -315,6 +318,7 @@ export class SessionRuntime {
                     const entry = this.ensureAssistantEntry(item.id);
                     entry.status = "streaming";
                     this.trackTurnEntry(entry);
+                    this.callbacks.markPreviewDirty(this.session);
                 }
                 this.callbacks.touch(this.session);
                 this.callbacks.persist();
@@ -329,6 +333,7 @@ export class SessionRuntime {
                     entry.text += delta;
                     entry.status = "streaming";
                     this.markTurnOutput(entry);
+                    this.callbacks.markPreviewDirty(this.session);
                     this.callbacks.touch(this.session);
                     this.callbacks.persist();
                     this.callbacks.emitChange({
@@ -348,6 +353,7 @@ export class SessionRuntime {
                     entry.text += delta;
                     entry.status = "streaming";
                     this.markTurnOutput(entry);
+                    this.callbacks.markPreviewDirty(this.session);
                     this.callbacks.touch(this.session);
                     this.callbacks.persist();
                     this.callbacks.emitChange({
@@ -390,6 +396,7 @@ export class SessionRuntime {
                 this.session.liveMessages.clear();
                 this.session.liveReasoning.clear();
                 this.session.currentTurnMetrics = undefined;
+                this.callbacks.markPreviewDirty(this.session);
                 this.callbacks.touch(this.session);
                 this.callbacks.persist();
                 if (updatedEntries.length || removedEntryIds.length) {
@@ -528,7 +535,7 @@ export class SessionRuntime {
                 return {
                     id: item.id,
                     kind: "tool",
-                    text: JSON.stringify(item, null, 2),
+                    text: this.formatStructuredToolCall(item),
                     status: item.status ?? "completed",
                     createdAt,
                 };
@@ -562,8 +569,19 @@ export class SessionRuntime {
                 return { id: item.id, kind: "system", text: item.text ?? "", createdAt, status: "completed" };
             case "enteredReviewMode":
             case "exitedReviewMode":
-            case "contextCompaction":
                 return { id: item.id, kind: "system", text: JSON.stringify(item, null, 2), createdAt };
+            case "contextCompaction":
+                return {
+                    id: item.id,
+                    kind: "system",
+                    text: "Context compacted",
+                    createdAt,
+                    status: "completed",
+                    meta: {
+                        eventType: "contextCompaction",
+                        payload: item,
+                    },
+                };
             default:
                 return undefined;
         }
@@ -714,6 +732,7 @@ export class SessionRuntime {
             };
             this.session.liveMessages.set(itemId, entry);
             this.session.transcript.push(entry);
+            this.callbacks.markPreviewDirty(this.session);
             this.trackTurnEntry(entry);
             this.callbacks.persist();
             this.callbacks.emitChange({ type: "session-entry", sessionId: this.session.id, entry });
@@ -732,6 +751,7 @@ export class SessionRuntime {
             };
             this.session.liveReasoning.set(itemId, entry);
             this.session.transcript.push(entry);
+            this.callbacks.markPreviewDirty(this.session);
             this.trackTurnEntry(entry);
             this.callbacks.persist();
             this.callbacks.emitChange({ type: "session-entry", sessionId: this.session.id, entry });
@@ -811,17 +831,103 @@ export class SessionRuntime {
     }
     formatFunctionCall(item) {
         const name = item?.name || "tool";
+        if (this.isReadToolName(name)) {
+            const target = this.extractReadTarget(item?.arguments);
+            return target ? `read ${target}` : "read";
+        }
         const args = this.prettyJsonString(item?.arguments);
         return args ? `${name}\n\n${args}` : name;
     }
     formatFunctionCallOutput(item) {
+        if (this.isReadToolName(item?.name)) {
+            return "";
+        }
         return String(item?.output ?? "").trim();
     }
     formatCustomToolCall(item) {
         const name = item?.name || "custom_tool";
+        if (this.isReadToolName(name)) {
+            const target = this.extractReadTarget(item?.input);
+            return target ? `read ${target}` : "read";
+        }
         const input = typeof item?.input === "string" ? item.input : this.prettyJson(item?.input);
         return input ? `${name}\n\n${input}` : name;
     }
+    formatStructuredToolCall(item) {
+        const name = item?.name || item?.toolName || item?.tool?.name || item?.type || "tool";
+        if (this.isReadToolName(name)) {
+            const target = this.extractReadTarget(item?.arguments ?? item?.input ?? item?.params ?? item);
+            return target ? `read ${target}` : "read";
+        }
+        return JSON.stringify(item, null, 2);
+    }
+    isReadToolName(value) {
+        if (typeof value !== "string") {
+            return false;
+        }
+        const normalized = value.replace(/[\s-]+/g, "_").trim().toLowerCase();
+        return normalized === "read" || normalized === "read_file" || normalized === "readfile";
+    }
+    extractReadTarget(value) {
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return "";
+            }
+            const parsed = this.parseJsonLike(trimmed);
+            if (!parsed) {
+                const normalized = trimmed.replace(/^file:\/\//i, "").replace(/[\\/]+$/, "");
+                return path.basename(normalized) || normalized;
+            }
+            value = parsed;
+        }
+        const parsed = this.parseJsonLike(value);
+        if (!parsed || typeof parsed !== "object") {
+            return "";
+        }
+        const candidate = this.firstStringValue(parsed, [
+            "filePath",
+            "filepath",
+            "path",
+            "filename",
+            "file",
+            "target",
+            "uri",
+            "name",
+        ]);
+        if (!candidate) {
+            return "";
+        }
+        const normalized = candidate.replace(/^file:\/\//i, "").replace(/[\\/]+$/, "").trim();
+        if (!normalized) {
+            return "";
+        }
+        return path.basename(normalized) || normalized;
+    }
+    parseJsonLike(value) {
+        if (typeof value !== "string") {
+            return value;
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    firstStringValue(value, keys) {
+        for (const key of keys) {
+            const candidate = value[key];
+            if (typeof candidate === "string" && candidate.trim()) {
+                return candidate.trim();
+            }
+        }
+        return "";
+    }
     prettyJsonString(value) {
         if (typeof value !== "string" || !value.trim()) {
             return "";

package/dist/daemon/sessionStore.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
+import fsPromises from "node:fs/promises";
 import path from "node:path";
 export class SessionStore {
     legacyFilePath;
     sessionsDirPath;
+    initializationPromise;
     constructor(rootDir = process.cwd()) {
         this.legacyFilePath = path.join(rootDir, "data", "sessions.json");
         this.sessionsDirPath = path.join(rootDir, "data", "sessions");
@@ -14,30 +16,15 @@ export class SessionStore {
         }
         return this.loadLegacy();
     }
-    save(sessions) {
-        fs.mkdirSync(this.sessionsDirPath, { recursive: true });
-        const expectedFileNames = new Set();
-        for (const session of sessions) {
-            const fileName = this.sessionFileName(session.id);
-            expectedFileNames.add(fileName);
-            fs.writeFileSync(path.join(this.sessionsDirPath, fileName), JSON.stringify(session, null, 2), "utf8");
-        }
-        try {
-            for (const entry of fs.readdirSync(this.sessionsDirPath, { withFileTypes: true })) {
-                if (!entry.isFile() || !entry.name.endsWith(".json")) {
-                    continue;
-                }
-                if (!expectedFileNames.has(entry.name)) {
-                    fs.rmSync(path.join(this.sessionsDirPath, entry.name), { force: true });
-                }
-            }
-        }
-        catch {
-            // noop
-        }
-        if (fs.existsSync(this.legacyFilePath)) {
-            fs.rmSync(this.legacyFilePath, { force: true });
-        }
+    async saveSession(session) {
+        await this.ensureInitialized();
+        await fsPromises.writeFile(path.join(this.sessionsDirPath, this.sessionFileName(session.id)), JSON.stringify(session, null, 2), "utf8");
+    }
+    async deleteSession(sessionId) {
+        await this.ensureInitialized();
+        await fsPromises.rm(path.join(this.sessionsDirPath, this.sessionFileName(sessionId)), {
+            force: true,
+        });
     }
     loadFromDirectory() {
         try {
@@ -80,6 +67,19 @@ export class SessionStore {
     sessionFileName(sessionId) {
         return `${sessionId}.json`;
     }
+    ensureInitialized() {
+        if (!this.initializationPromise) {
+            const initialization = (async () => {
+                await fsPromises.mkdir(this.sessionsDirPath, { recursive: true });
+                await fsPromises.rm(this.legacyFilePath, { force: true }).catch(() => undefined);
+            })();
+            this.initializationPromise = initialization.catch((error) => {
+                this.initializationPromise = undefined;
+                throw error;
+            });
+        }
+        return this.initializationPromise;
+    }
     isSessionDetails(value) {
         if (!value || typeof value !== "object") {
             return false;

package/package.json

@@ -1,46 +1,46 @@
-{
-  "name": "ohmyvibe",
-  "version": "0.1.3",
-  "description": "VibeCoding daemon + web console MVP for orchestrating Codex sessions",
-  "bin": {
-    "ohmyvibe": "./dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    ".env.example"
-  ],
-  "main": "dist/daemon/index.js",
-  "scripts": {
-    "build": "npm run build:daemon && npm run build:web",
-    "build:daemon": "tsc -p tsconfig.json",
-    "build:web": "npm --prefix web run build",
-    "pack:dry-run": "npm pack --dry-run",
-    "daemon": "tsx src/daemon/index.ts",
-    "acp": "tsx src/acp/index.ts",
-    "dev": "tsx watch src/daemon/index.ts",
-    "web:dev": "npm --prefix web run dev",
-    "web:preview": "npm --prefix web run preview",
-    "web:server": "npm --prefix web run server",
-    "prepublishOnly": "npm run build:daemon"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "type": "module",
-  "engines": {
-    "node": ">=22"
-  },
-  "dependencies": {
-    "@agentclientprotocol/sdk": "^0.18.0",
-    "dotenv": "^17.4.1",
-    "express": "^5.2.1",
-    "ws": "^8.20.0"
-  },
-  "devDependencies": {
-    "@types/express": "^5.0.6",
-    "@types/ws": "^8.18.1",
-    "tsx": "^4.21.0",
-    "typescript": "^6.0.2"
-  }
-}
+{
+  "name": "ohmyvibe",
+  "version": "0.1.4",
+  "description": "VibeCoding daemon + web console MVP for orchestrating Codex sessions",
+  "bin": {
+    "ohmyvibe": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    ".env.example"
+  ],
+  "main": "dist/daemon/index.js",
+  "scripts": {
+    "build": "npm run build:daemon && npm run build:web",
+    "build:daemon": "tsc -p tsconfig.json",
+    "build:web": "npm --prefix web run build",
+    "pack:dry-run": "npm pack --dry-run",
+    "daemon": "tsx src/daemon/index.ts",
+    "acp": "tsx src/acp/index.ts",
+    "dev": "tsx watch src/daemon/index.ts",
+    "web:dev": "npm --prefix web run dev",
+    "web:preview": "npm --prefix web run preview",
+    "web:server": "npm --prefix web run server",
+    "prepublishOnly": "npm run build:daemon"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^0.18.0",
+    "dotenv": "^17.4.1",
+    "express": "^5.2.1",
+    "ws": "^8.20.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
+  }
+}