@co0ontty/wand 1.37.0 → 1.39.1

package/dist/process-manager.d.ts

@@ -24,6 +24,18 @@ export interface ClaudeHistorySession {
     hasConversation: boolean;
     managedByWand: boolean;
 }
+/** A Codex session discovered by scanning ~/.codex/sessions/ rollout files. */
+export interface CodexHistorySession {
+    /** Codex thread id（存进 claudeSessionId 字段以复用前端/路由）。 */
+    claudeSessionId: string;
+    cwd: string;
+    firstUserMessage: string;
+    timestamp: string;
+    mtimeMs: number;
+    hasConversation: boolean;
+    managedByWand: boolean;
+    provider: "codex";
+}
 export declare class ProcessManager extends EventEmitter {
     private readonly config;
     private readonly storage;
@@ -65,6 +77,10 @@ export declare class ProcessManager extends EventEmitter {
         claudeSessionId: string;
         cwd: string;
     }[]): number;
+    private codexHistoryCache;
+    listCodexHistorySessions(): CodexHistorySession[];
+    hasCodexSessionFile(threadId: string): boolean;
+    deleteCodexHistoryFiles(threadIds: string[]): number;
     get(id: string): SessionSnapshot | null;
     getPtyTranscript(id: string): string | null;
     /**

package/dist/process-manager.js

@@ -296,6 +296,150 @@ function listAllClaudeHistorySessions() {
         return [];
     }
 }
+function getCodexSessionsDir() {
+    return path.join(os.homedir(), ".codex", "sessions");
+}
+/**
+ * codex 的 user message 里混杂了系统注入（AGENTS.md 指令、<environment_context> 等
+ * XML 包裹块），它们都以 "#" 或 "<" 开头。真正的用户输入是首条不以这两者开头的
+ * input_text。
+ */
+function isCodexSystemInjectedText(text) {
+    const trimmed = text.trimStart();
+    return trimmed.startsWith("#") || trimmed.startsWith("<");
+}
+/**
+ * Read the head of a rollout file to extract summary metadata. Codex prepends a
+ * large session_meta (full base_instructions + AGENTS.md + <environment_context>)
+ * before the first real user turn, so a small window misses it. 64KB covers the
+ * first real user message in every observed session.
+ */
+function readCodexSessionSummary(filePath) {
+    try {
+        const stats = statSync(filePath);
+        const fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(65536);
+        const bytesRead = readSync(fd, buffer, 0, 65536, 0);
+        closeSync(fd);
+        const chunk = buffer.toString("utf8", 0, bytesRead);
+        const lines = chunk.split("\n").filter((line) => line.trim().length > 0);
+        let id = "";
+        let cwd = "";
+        let timestamp = "";
+        let firstUserMessage = "";
+        let hasUser = false;
+        let hasAssistant = false;
+        for (const line of lines) {
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!timestamp && parsed.timestamp) {
+                timestamp = parsed.timestamp;
+            }
+            const payload = parsed.payload;
+            if (!payload)
+                continue;
+            if (parsed.type === "session_meta" || payload.type === "session_meta") {
+                if (!id && typeof payload.id === "string")
+                    id = payload.id;
+                if (!cwd && typeof payload.cwd === "string")
+                    cwd = payload.cwd;
+                continue;
+            }
+            if (payload.type === "message" && payload.role === "user") {
+                const text = Array.isArray(payload.content)
+                    ? payload.content
+                        .filter((b) => b?.type === "input_text" && typeof b.text === "string")
+                        .map((b) => b.text)
+                        .join("")
+                    : "";
+                if (text.trim()) {
+                    hasUser = true;
+                    if (!firstUserMessage && !isCodexSystemInjectedText(text)) {
+                        firstUserMessage = text.trim().slice(0, 120);
+                    }
+                }
+            }
+            else if (payload.type === "message" && payload.role === "assistant") {
+                hasAssistant = true;
+            }
+        }
+        if (!id)
+            return null;
+        return {
+            claudeSessionId: id,
+            cwd,
+            firstUserMessage,
+            timestamp: timestamp || new Date(stats.mtimeMs).toISOString(),
+            mtimeMs: stats.mtimeMs,
+            hasConversation: hasUser && hasAssistant,
+            managedByWand: false,
+            provider: "codex",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Recursively collect rollout-*.jsonl paths under ~/.codex/sessions/. */
+function listCodexRolloutFiles() {
+    const root = getCodexSessionsDir();
+    try {
+        return readdirSync(root, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile()
+            && entry.name.startsWith("rollout-")
+            && entry.name.endsWith(".jsonl"))
+            .map((entry) => {
+            // Node ≥ 20 dirents from a recursive read carry parentPath/path.
+            const parent = entry.parentPath
+                ?? entry.path
+                ?? root;
+            return path.join(parent, entry.name);
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/** Scan ~/.codex/sessions/ and return one entry per thread id (newest rollout wins). */
+function listAllCodexHistorySessions() {
+    const files = listCodexRolloutFiles();
+    // 同一 thread 同一天可能有多个 rollout 文件，按 thread id 去重保留 mtime 最新。
+    const byThread = new Map();
+    for (const filePath of files) {
+        const summary = readCodexSessionSummary(filePath);
+        if (!summary)
+            continue;
+        const existing = byThread.get(summary.claudeSessionId);
+        if (!existing || summary.mtimeMs > existing.mtimeMs) {
+            byThread.set(summary.claudeSessionId, summary);
+        }
+    }
+    return Array.from(byThread.values()).sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+/** Delete every rollout file belonging to the given codex thread ids. */
+function deleteCodexRolloutFiles(threadIds) {
+    if (threadIds.size === 0)
+        return 0;
+    let deleted = 0;
+    for (const filePath of listCodexRolloutFiles()) {
+        const summary = readCodexSessionSummary(filePath);
+        if (summary && threadIds.has(summary.claudeSessionId)) {
+            try {
+                unlinkSync(filePath);
+                deleted++;
+            }
+            catch {
+                // Best-effort — file may already be gone
+            }
+        }
+    }
+    return deleted;
+}
 function snapshotMessages(record) {
     return record.ptyBridge?.getMessages() ?? record.messages;
 }
@@ -898,6 +1042,41 @@ export class ProcessManager extends EventEmitter {
         }
         return deleted;
     }
+    codexHistoryCache = null;
+    listCodexHistorySessions() {
+        const now = Date.now();
+        if (this.codexHistoryCache && now < this.codexHistoryCache.expiresAt) {
+            return this.codexHistoryCache.data;
+        }
+        const allSessions = listAllCodexHistorySessions();
+        // Cross-reference with wand-managed sessions（codex 的 thread id 存在 claudeSessionId 字段）
+        const managedIds = new Set();
+        for (const record of this.sessions.values()) {
+            if (record.provider === "codex" && record.claudeSessionId) {
+                managedIds.add(record.claudeSessionId);
+            }
+        }
+        for (const session of allSessions) {
+            if (managedIds.has(session.claudeSessionId)) {
+                session.managedByWand = true;
+            }
+        }
+        this.codexHistoryCache = { data: allSessions, expiresAt: now + ProcessManager.HISTORY_CACHE_TTL_MS };
+        return allSessions;
+    }
+    hasCodexSessionFile(threadId) {
+        if (!UUID_V4_PATTERN.test(threadId))
+            return false;
+        return listAllCodexHistorySessions().some((s) => s.claudeSessionId === threadId);
+    }
+    deleteCodexHistoryFiles(threadIds) {
+        const valid = new Set(threadIds.filter((id) => UUID_V4_PATTERN.test(id)));
+        const deleted = deleteCodexRolloutFiles(valid);
+        if (valid.size > 0) {
+            this.codexHistoryCache = null;
+        }
+        return deleted;
+    }
     get(id) {
         const record = this.sessions.get(id);
         if (!record) {

package/dist/server-session-routes.js

@@ -699,6 +699,41 @@ export function registerSessionRoutes(app, processes, structured, storage, defau
             res.status(response.statusCode).json(response.payload);
         }
     });
+    app.post("/api/codex-sessions/:threadId/resume", express.json(), async (req, res) => {
+        const threadId = String(req.params.threadId || "").trim();
+        const body = req.body;
+        console.log("[WAND] POST /api/codex-sessions/:threadId/resume threadId:", threadId, "cwd:", body.cwd);
+        try {
+            if (!threadId) {
+                res.status(400).json({ error: "Codex 会话 ID 不能为空。" });
+                return;
+            }
+            const history = processes.listCodexHistorySessions().find((s) => s.claudeSessionId === threadId);
+            if (!history) {
+                res.status(400).json({ error: "对应的 Codex 历史会话不存在，无法恢复。" });
+                return;
+            }
+            const cwd = body.cwd?.trim() || history.cwd;
+            if (!cwd) {
+                res.status(400).json({ error: "无法确定工作目录 (cwd)，无法恢复。" });
+                return;
+            }
+            const newMode = normalizeMode(body.mode, defaultMode);
+            const snapshot = structured.createSession({
+                cwd,
+                mode: newMode,
+                provider: "codex",
+                runner: "codex-cli-exec",
+                worktreeEnabled: body.worktreeEnabled === true,
+                claudeSessionId: threadId,
+            });
+            onSessionCreated?.(cwd);
+            res.status(201).json({ resumedClaudeSessionId: threadId, ...snapshot });
+        }
+        catch (error) {
+            res.status(400).json({ error: getErrorMessage(error, "无法按 Codex 会话 ID 恢复会话。") });
+        }
+    });
     app.post("/api/sessions/:id/resize", (req, res) => {
         const body = req.body;
         try {
@@ -907,4 +942,79 @@ export function registerClaudeHistoryRoutes(app, processes, storage) {
             res.status(500).json({ error: getErrorMessage(error, "无法批量删除历史会话。") });
         }
     });
+    // ── Codex history（~/.codex/sessions/ 扫描，对齐 Claude 历史区） ──
+    // codex 历史的"恢复"是新建一个结构化 codex 会话并预填 thread id（存进 claudeSessionId
+    // 字段），用户发第一条消息时 buildCodexArgs 自动拼 `codex exec ... resume <thread_id>`。
+    // hidden 集合与 claude 共用（id 全局唯一，不会冲突）。
+    app.get("/api/codex-history", (_req, res) => {
+        try {
+            const sessions = processes.listCodexHistorySessions();
+            const hidden = getHiddenClaudeSessionIds(storage);
+            const filtered = hidden.size > 0
+                ? sessions.filter((s) => !hidden.has(s.claudeSessionId))
+                : sessions;
+            res.json(filtered);
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "无法扫描 Codex 历史会话。") });
+        }
+    });
+    app.delete("/api/codex-history/:threadId", (req, res) => {
+        const threadId = req.params.threadId?.trim();
+        if (!threadId) {
+            res.status(400).json({ error: "会话 ID 不能为空。" });
+            return;
+        }
+        const exists = processes.listCodexHistorySessions().some((s) => s.claudeSessionId === threadId);
+        if (exists) {
+            processes.deleteCodexHistoryFiles([threadId]);
+            removeFromHiddenClaudeSessionIds(storage, [threadId]);
+        }
+        else {
+            const hidden = getHiddenClaudeSessionIds(storage);
+            if (!hidden.has(threadId)) {
+                hidden.add(threadId);
+                saveHiddenClaudeSessionIds(storage, hidden);
+            }
+        }
+        res.json({ ok: true });
+    });
+    app.post("/api/codex-history/batch-delete", express.json(), (req, res) => {
+        const threadIds = Array.isArray(req.body?.claudeSessionIds)
+            ? req.body.claudeSessionIds.filter((value) => typeof value === "string" && value.trim().length > 0)
+            : [];
+        if (threadIds.length === 0) {
+            res.status(400).json({ error: "至少提供一个历史会话 ID。" });
+            return;
+        }
+        try {
+            const existing = new Set(processes.listCodexHistorySessions().map((s) => s.claudeSessionId));
+            const toDelete = [];
+            const toHide = [];
+            for (const id of threadIds) {
+                if (existing.has(id))
+                    toDelete.push(id);
+                else
+                    toHide.push(id);
+            }
+            const deleted = processes.deleteCodexHistoryFiles(toDelete);
+            removeFromHiddenClaudeSessionIds(storage, toDelete);
+            if (toHide.length > 0) {
+                const hidden = getHiddenClaudeSessionIds(storage);
+                let added = 0;
+                for (const id of toHide) {
+                    if (!hidden.has(id)) {
+                        hidden.add(id);
+                        added++;
+                    }
+                }
+                if (added > 0)
+                    saveHiddenClaudeSessionIds(storage, hidden);
+            }
+            res.json({ ok: true, deleted: deleted + toHide.length });
+        }
+        catch (error) {
+            res.status(500).json({ error: getErrorMessage(error, "无法批量删除历史会话。") });
+        }
+    });
 }

package/dist/structured-session-manager.d.ts

@@ -12,6 +12,13 @@ interface CreateStructuredSessionOptions {
     model?: string;
     /** 用户预设的思考深度。留空 / null 视为 off。 */
     thinkingEffort?: SessionSnapshot["thinkingEffort"];
+    /**
+     * 恢复用的初始会话 id：
+     *   - Codex：历史 thread id，首条消息即 `codex exec ... resume <id>` 续接。
+     *   - Claude：历史 session id，首条消息即 `--resume` / SDK resume 续接。
+     * 留空表示新建会话。
+     */
+    claudeSessionId?: string;
 }
 /**
  * 把任意外部输入收敛到合法的 thinkingEffort 枚举值。`null` / 非法值都视为
@@ -150,6 +157,47 @@ export declare class StructuredSessionManager {
     private normalizeToolInput;
     private normalizeToolResultContent;
     private extractCodexText;
+    /**
+     * Merge one codex `item.*` event into `turnState.blocks`.
+     *
+     * 三种 phase 行为：
+     *   - "started":   首次出现的 item，块直接 push（tool_result 走 upsert 配对）。
+     *                  text/thinking/TodoWrite 这种"靠 id 替换"的块记录到
+     *                  codexBlockIndex 里，方便后续 updated/completed 找回原位。
+     *   - "updated":   codex 重发完整 ThreadItem（不是 delta）。已记录过的块就
+     *                  替换；新块按 started 路径处理。
+     *   - "completed": 把"in_progress"卡片定型——text 同时更新 turnState.result
+     *                  以便 result fallback 不为空；tool_use ↔ tool_result 通过
+     *                  共享 id 配对到一起（包括 file_change 子项的 `${id}#i`）。
+     */
+    private applyCodexItem;
+    /**
+     * Map a codex `item.{started,updated,completed}` payload into wand's
+     * `ContentBlock[]` so the chat UI's existing tool/diff/todo cards just work.
+     *
+     * Codex `exec --json` emits 8 item.type values (see
+     * `codex-rs/exec/src/exec_events.rs`); below they're routed to whatever wand
+     * tool name reuses an existing renderer:
+     *
+     *   agent_message     → text
+     *   reasoning         → thinking
+     *   command_execution → tool_use "Bash" + tool_result
+     *   file_change       → one tool_use per file, named Edit/Write/Bash by `kind`
+     *                       (codex does NOT carry old_string/new_string in the
+     *                       exec stream, only the path list; diff card body is
+     *                       empty but the file row + status still render)
+     *   mcp_tool_call     → tool_use named "<server>__<tool>" + tool_result
+     *   web_search        → tool_use "WebSearch" + tool_result (results not in stream)
+     *   todo_list         → tool_use "TodoWrite" (replaced in place on each update)
+     *   error             → text block prefixed with ❌
+     *
+     * Returns [] when there is nothing to emit yet (e.g. agent_message at
+     * `item.started` before any text has been produced).
+     *
+     * Callers handle in-place replacement for `item.updated` via
+     * `turnState.codexBlockIndex`; tool_use ↔ tool_result pairing still goes
+     * through `upsertCodexBlock` by matching ids.
+     */
     private extractCodexItemBlock;
     private upsertCodexBlock;
     /**