mac
858 lines
32 KiB
JavaScript
858 lines
32 KiB
JavaScript
// sessions.js —— 读取 / 解析 / 导出 / 备份 / 导入 Codex 会话记录。
|
||
// 直接读 ~/.codex/sessions / archived_sessions 下的 rollout-*.jsonl，不依赖数据库，跨平台。
|
||
const fs = require("fs");
|
||
const path = require("path");
|
||
const { spawnSync } = require("child_process");
|
||
const initSqlJs = require("sql.js");
|
||
const { cleanThreadTitle, cleanUserVisibleText, stripInternalThoughtBlocks, looksLikeSkillMentionTitle } = require("./title_clean");
|
||
const codexDataDir = require("./codex_data_dir");
|
||
|
||
let permanentDeleteBusy = false;
|
||
let clearAllBusy = false;
|
||
const DEFAULT_LIST_LIMIT = 500;
|
||
const ALL_LIST_LIMIT = 5000;
|
||
|
||
function paths() {
|
||
const codexHome = codexDataDir.get();
|
||
return {
|
||
codexHome,
|
||
sessionsDir: path.join(codexHome, "sessions"),
|
||
archivedSessionsDir: path.join(codexHome, "archived_sessions"),
|
||
sessionIndex: path.join(codexHome, "session_index.jsonl"),
|
||
titleCleanMarker: path.join(codexHome, ".td-title-clean-v1.json"),
|
||
};
|
||
}
|
||
|
||
function isInside(base, file) {
|
||
const rel = path.relative(path.resolve(base), path.resolve(file));
|
||
return rel && !rel.startsWith(".." + path.sep) && rel !== ".." && !path.isAbsolute(rel);
|
||
}
|
||
|
||
function sessionRoots() {
|
||
const { sessionsDir, archivedSessionsDir } = paths();
|
||
return [sessionsDir, archivedSessionsDir];
|
||
}
|
||
|
||
function sessionFileAllowed(file) {
|
||
return sessionRoots().some((root) => isInside(root, file)) &&
|
||
path.basename(file).startsWith("rollout-") && path.extname(file) === ".jsonl";
|
||
}
|
||
|
||
// 递归找出所有 rollout-*.jsonl
|
||
function findRolloutFiles(base) {
|
||
const out = [];
|
||
function walk(dir) {
|
||
let ents;
|
||
try {
|
||
ents = fs.readdirSync(dir, { withFileTypes: true });
|
||
} catch {
|
||
return;
|
||
}
|
||
for (const ent of ents) {
|
||
const full = path.join(dir, ent.name);
|
||
if (ent.isDirectory()) walk(full);
|
||
else if (ent.isFile() && ent.name.startsWith("rollout-") && ent.name.endsWith(".jsonl")) out.push(full);
|
||
}
|
||
}
|
||
walk(base);
|
||
return out;
|
||
}
|
||
|
||
// 读取 session_index.jsonl，得到 {会话id: Codex 生成的标题}
|
||
function loadIndexTitles() {
|
||
const map = {};
|
||
try {
|
||
const txt = fs.readFileSync(paths().sessionIndex, "utf-8");
|
||
for (const line of txt.split("\n")) {
|
||
if (!line.trim()) continue;
|
||
try {
|
||
const d = JSON.parse(line);
|
||
if (d.id && d.thread_name) map[d.id] = cleanThreadTitle(d.thread_name, "", 80);
|
||
} catch {}
|
||
}
|
||
} catch {}
|
||
return map;
|
||
}
|
||
|
||
// 只读文件开头一段，快速取元信息与首条用户消息（避免整读大文件）
|
||
function peekMeta(file) {
|
||
let head = "";
|
||
try {
|
||
const fd = fs.openSync(file, "r");
|
||
const buf = Buffer.alloc(262144); // 256KB：足够越过超长系统提示找到首条用户消息
|
||
const n = fs.readSync(fd, buf, 0, buf.length, 0);
|
||
fs.closeSync(fd);
|
||
head = buf.slice(0, n).toString("utf-8");
|
||
} catch {
|
||
return null;
|
||
}
|
||
const meta = { id: "", cwd: "", ts: "", source: "", threadSource: "", provider: "", title: "" };
|
||
const lines = head.split("\n");
|
||
for (const line of lines) {
|
||
if (!line.trim()) continue;
|
||
let d;
|
||
try {
|
||
d = JSON.parse(line);
|
||
} catch {
|
||
continue; // 可能是被截断的最后一行
|
||
}
|
||
const p = d.payload || {};
|
||
if (d.type === "session_meta") {
|
||
// 新版 subagent 的 session_id 指向父线程，id 才是当前子线程。
|
||
meta.id = p.id || p.session_id || "";
|
||
meta.cwd = p.cwd || "";
|
||
meta.ts = p.timestamp || d.timestamp || "";
|
||
meta.source = p.source || "";
|
||
meta.threadSource = p.thread_source || "";
|
||
meta.provider = p.model_provider || "";
|
||
} else if (d.type === "event_msg" && p.type === "user_message" && !meta.title) {
|
||
meta.title = cleanThreadTitle(p.message || "", "", 200);
|
||
}
|
||
if (meta.id && meta.title) break;
|
||
}
|
||
return meta;
|
||
}
|
||
|
||
function sqlite3Available() {
|
||
const r = spawnSync("sqlite3", ["--version"], { encoding: "utf-8" });
|
||
return !r.error && r.status === 0;
|
||
}
|
||
|
||
function runSqlite3(dbPath, sql) {
|
||
const r = spawnSync("sqlite3", ["-json", dbPath, sql], {
|
||
encoding: "utf-8",
|
||
maxBuffer: 20 * 1024 * 1024,
|
||
});
|
||
if (r.error || r.status !== 0) {
|
||
throw new Error((r.stderr || (r.error && r.error.message) || "sqlite3 执行失败").trim());
|
||
}
|
||
return r.stdout || "";
|
||
}
|
||
|
||
function quoteIdent(value) {
|
||
return "\"" + String(value || "").replace(/"/g, "\"\"") + "\"";
|
||
}
|
||
|
||
function sqliteTables(dbPath) {
|
||
try {
|
||
return JSON.parse(runSqlite3(dbPath, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';") || "[]");
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
function sqliteTableInfo(dbPath, table) {
|
||
try {
|
||
return JSON.parse(runSqlite3(dbPath, "PRAGMA table_info(" + quoteIdent(table) + ");") || "[]");
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
function sqliteForeignKeys(dbPath, table) {
|
||
try {
|
||
return JSON.parse(runSqlite3(dbPath, "PRAGMA foreign_key_list(" + quoteIdent(table) + ");") || "[]");
|
||
} catch {
|
||
return [];
|
||
}
|
||
}
|
||
|
||
function sqlJsRows(db, statement) {
|
||
const result = db.exec(statement);
|
||
if (!result.length) return [];
|
||
const columns = result[0].columns;
|
||
return result[0].values.map((values) => Object.fromEntries(columns.map((name, index) => [name, values[index]])));
|
||
}
|
||
|
||
function sqliteBufferWithCommittedWal(dbPath) {
|
||
let main = fs.readFileSync(dbPath);
|
||
const walPath = dbPath + "-wal";
|
||
if (!fs.existsSync(walPath)) return main;
|
||
const wal = fs.readFileSync(walPath);
|
||
if (wal.length < 32) return main;
|
||
const magic = wal.readUInt32BE(0);
|
||
if (magic !== 0x377f0682 && magic !== 0x377f0683) throw new Error("SQLite WAL 头无效，已停止删除");
|
||
let pageSize = wal.readUInt32BE(8);
|
||
if (pageSize === 1) pageSize = 65536;
|
||
if (!pageSize || (pageSize & (pageSize - 1)) !== 0) throw new Error("SQLite WAL 页大小无效，已停止删除");
|
||
const frameSize = 24 + pageSize;
|
||
const salt1 = wal.readUInt32BE(16);
|
||
const salt2 = wal.readUInt32BE(20);
|
||
const littleEndianChecksum = magic === 0x377f0682;
|
||
const checksum = (buffer, start, end, sums) => {
|
||
let [s1, s2] = sums;
|
||
for (let offset = start; offset < end; offset += 8) {
|
||
const a = littleEndianChecksum ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
|
||
const b = littleEndianChecksum ? buffer.readUInt32LE(offset + 4) : buffer.readUInt32BE(offset + 4);
|
||
s1 = (s1 + a + s2) >>> 0;
|
||
s2 = (s2 + b + s1) >>> 0;
|
||
}
|
||
return [s1, s2];
|
||
};
|
||
let sums = checksum(wal, 0, 24, [0, 0]);
|
||
if (sums[0] !== wal.readUInt32BE(24) || sums[1] !== wal.readUInt32BE(28)) {
|
||
throw new Error("SQLite WAL 校验失败，已停止删除");
|
||
}
|
||
let lastCommitOffset = -1;
|
||
let committedPages = 0;
|
||
for (let offset = 32; offset + frameSize <= wal.length; offset += frameSize) {
|
||
if (wal.readUInt32BE(offset + 8) !== salt1 || wal.readUInt32BE(offset + 12) !== salt2) break;
|
||
sums = checksum(wal, offset, offset + 8, sums);
|
||
sums = checksum(wal, offset + 24, offset + 24 + pageSize, sums);
|
||
if (sums[0] !== wal.readUInt32BE(offset + 16) || sums[1] !== wal.readUInt32BE(offset + 20)) break;
|
||
const dbSize = wal.readUInt32BE(offset + 4);
|
||
if (dbSize > 0) {
|
||
lastCommitOffset = offset;
|
||
committedPages = dbSize;
|
||
}
|
||
}
|
||
if (lastCommitOffset < 0) return main;
|
||
const merged = Buffer.alloc(committedPages * pageSize);
|
||
main.copy(merged, 0, 0, Math.min(main.length, merged.length));
|
||
for (let offset = 32; offset <= lastCommitOffset; offset += frameSize) {
|
||
const pageNo = wal.readUInt32BE(offset);
|
||
if (!pageNo || pageNo > committedPages) continue;
|
||
wal.copy(merged, (pageNo - 1) * pageSize, offset + 24, offset + 24 + pageSize);
|
||
}
|
||
return merged;
|
||
}
|
||
|
||
function replaceStateDb(dbPath, data) {
|
||
const tmp = dbPath + ".td-delete-" + process.pid + ".tmp";
|
||
const old = dbPath + ".td-delete-" + process.pid + ".old";
|
||
const oldWal = old + "-wal";
|
||
const oldShm = old + "-shm";
|
||
fs.rmSync(old, { force: true });
|
||
fs.rmSync(oldWal, { force: true });
|
||
fs.rmSync(oldShm, { force: true });
|
||
const fd = fs.openSync(tmp, "w");
|
||
try {
|
||
fs.writeFileSync(fd, data);
|
||
fs.fsyncSync(fd);
|
||
} finally {
|
||
fs.closeSync(fd);
|
||
}
|
||
let movedMain = false;
|
||
let movedWal = false;
|
||
let movedShm = false;
|
||
let installed = false;
|
||
try {
|
||
fs.renameSync(dbPath, old);
|
||
movedMain = true;
|
||
if (fs.existsSync(dbPath + "-wal")) { fs.renameSync(dbPath + "-wal", oldWal); movedWal = true; }
|
||
if (fs.existsSync(dbPath + "-shm")) { fs.renameSync(dbPath + "-shm", oldShm); movedShm = true; }
|
||
fs.renameSync(tmp, dbPath);
|
||
installed = true;
|
||
} catch (e) {
|
||
if (installed) { try { fs.rmSync(dbPath, { force: true }); } catch {} }
|
||
if (movedMain && fs.existsSync(old) && !fs.existsSync(dbPath)) fs.renameSync(old, dbPath);
|
||
if (movedWal && fs.existsSync(oldWal) && !fs.existsSync(dbPath + "-wal")) fs.renameSync(oldWal, dbPath + "-wal");
|
||
if (movedShm && fs.existsSync(oldShm) && !fs.existsSync(dbPath + "-shm")) fs.renameSync(oldShm, dbPath + "-shm");
|
||
throw e;
|
||
} finally {
|
||
fs.rmSync(tmp, { force: true });
|
||
}
|
||
try { fs.rmSync(old, { force: true }); } catch {}
|
||
try { fs.rmSync(oldWal, { force: true }); } catch {}
|
||
try { fs.rmSync(oldShm, { force: true }); } catch {}
|
||
}
|
||
|
||
async function deleteSessionFromStateDb(SQL, dbPath, id) {
|
||
let db;
|
||
try {
|
||
db = new SQL.Database(sqliteBufferWithCommittedWal(dbPath));
|
||
const tables = sqlJsRows(db, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'").map((row) => row.name).filter(Boolean);
|
||
if (!tables.includes("threads")) return false;
|
||
db.run("PRAGMA foreign_keys=ON");
|
||
db.run("PRAGMA secure_delete=ON");
|
||
db.run("BEGIN");
|
||
let changed = false;
|
||
for (const table of tables) {
|
||
if (table === "threads") continue;
|
||
const columns = sqlJsRows(db, "PRAGMA table_info(" + quoteIdent(table) + ")").map((row) => String(row.name || ""));
|
||
const fks = sqlJsRows(db, "PRAGMA foreign_key_list(" + quoteIdent(table) + ")");
|
||
const direct = columns.filter((name) => /(^|_)thread_id$/i.test(name));
|
||
const referencesThread = fks.filter((fk) => String(fk.table || "").toLowerCase() === "threads").map((fk) => fk.from).filter(Boolean);
|
||
for (const column of Array.from(new Set(direct.concat(referencesThread)))) {
|
||
db.run("DELETE FROM " + quoteIdent(table) + " WHERE " + quoteIdent(column) + "=?", [id]);
|
||
changed = db.getRowsModified() > 0 || changed;
|
||
}
|
||
}
|
||
db.run("DELETE FROM " + quoteIdent("threads") + " WHERE " + quoteIdent("id") + "=?", [id]);
|
||
changed = db.getRowsModified() > 0 || changed;
|
||
db.run("COMMIT");
|
||
if (changed) {
|
||
db.run("VACUUM");
|
||
const fkErrors = sqlJsRows(db, "PRAGMA foreign_key_check");
|
||
const integrity = sqlJsRows(db, "PRAGMA integrity_check");
|
||
if (fkErrors.length || !integrity.length || integrity.some((row) => String(Object.values(row)[0] || "").toLowerCase() !== "ok")) {
|
||
throw new Error("SQLite 删除后完整性校验失败，已停止替换");
|
||
}
|
||
for (const table of tables) {
|
||
const columns = sqlJsRows(db, "PRAGMA table_info(" + quoteIdent(table) + ")").map((row) => String(row.name || ""));
|
||
for (const column of columns.filter((name) => /(^|_)thread_id$/i.test(name))) {
|
||
const hit = sqlJsRows(db, "SELECT 1 AS hit FROM " + quoteIdent(table) + " WHERE " + quoteIdent(column) + "=" + sql(id) + " LIMIT 1");
|
||
if (hit.length) throw new Error("SQLite 仍有会话关联记录，已停止替换");
|
||
}
|
||
}
|
||
replaceStateDb(dbPath, Buffer.from(db.export()));
|
||
}
|
||
return changed;
|
||
} catch (e) {
|
||
if (db) try { db.run("ROLLBACK"); } catch {}
|
||
throw e;
|
||
} finally {
|
||
if (db) try { db.close(); } catch {}
|
||
}
|
||
}
|
||
|
||
function removeSessionIndexEntry(id) {
|
||
const { sessionIndex } = paths();
|
||
if (!fs.existsSync(sessionIndex)) return false;
|
||
const lines = fs.readFileSync(sessionIndex, "utf-8").split("\n");
|
||
const kept = lines.filter((line) => {
|
||
if (!line.trim()) return true;
|
||
try { return JSON.parse(line).id !== id; } catch { return true; }
|
||
});
|
||
if (kept.length === lines.length) return false;
|
||
const tmp = sessionIndex + ".td-delete-" + process.pid + ".tmp";
|
||
const old = sessionIndex + ".td-delete-" + process.pid + ".old";
|
||
fs.rmSync(old, { force: true });
|
||
const fd = fs.openSync(tmp, "w");
|
||
try {
|
||
fs.writeFileSync(fd, kept.join("\n"), "utf-8");
|
||
fs.fsyncSync(fd);
|
||
} finally {
|
||
fs.closeSync(fd);
|
||
}
|
||
try {
|
||
fs.renameSync(sessionIndex, old);
|
||
try { fs.renameSync(tmp, sessionIndex); } catch (e) { fs.renameSync(old, sessionIndex); throw e; }
|
||
try { fs.rmSync(old, { force: true }); } catch {}
|
||
} finally { fs.rmSync(tmp, { force: true }); }
|
||
return true;
|
||
}
|
||
|
||
// 永久删除一个会话：正文、归档正文、Codex 标题/状态索引一起清理。
|
||
// 只接受本机 sessions/archived_sessions 下的 rollout 文件，禁止借此 IPC 删除任意路径。
|
||
async function deleteConversation(filePath) {
|
||
if (permanentDeleteBusy) throw new Error("已有永久删除任务正在执行，请稍后重试");
|
||
permanentDeleteBusy = true;
|
||
try {
|
||
const requested = path.resolve(String(filePath || ""));
|
||
if (!sessionFileAllowed(requested) || !fs.existsSync(requested)) throw new Error("无效的会话文件");
|
||
const meta = peekMeta(requested);
|
||
if (!meta || !meta.id) throw new Error("无法识别会话 ID，已停止删除");
|
||
const files = [];
|
||
for (const root of sessionRoots()) {
|
||
for (const file of findRolloutFiles(root)) {
|
||
const m = peekMeta(file);
|
||
if (m && m.id === meta.id) files.push(file);
|
||
}
|
||
}
|
||
const { codexHome } = paths();
|
||
const stateDbs = fs.readdirSync(codexHome).filter((name) => /^state_.*\.sqlite$/.test(name));
|
||
const SQL = await initSqlJs({
|
||
locateFile: (file) => path.join(global.__BUNDLE_ROOT__ || path.join(__dirname, "..", ".."), "node_modules", "sql.js", "dist", file),
|
||
});
|
||
let stateRowsRemoved = 0;
|
||
for (const name of stateDbs) {
|
||
if (await deleteSessionFromStateDb(SQL, path.join(codexHome, name), meta.id)) stateRowsRemoved++;
|
||
}
|
||
const indexRemoved = removeSessionIndexEntry(meta.id);
|
||
for (const file of files) fs.rmSync(file, { force: true });
|
||
return { id: meta.id, cwd: meta.cwd || "", filesRemoved: files.length, indexRemoved, stateDbs: stateDbs.length, stateRowsRemoved };
|
||
} finally {
|
||
permanentDeleteBusy = false;
|
||
}
|
||
}
|
||
|
||
// 清空全部 Codex 会话：删除 rollout 正文、状态库线程关联记录、桌面侧栏目录和会话索引。
|
||
// 配置、登录态、项目、插件、自动化任务均保留；执行前由调用方保证 Codex 已完全退出。
|
||
function deleteAllThreadLinkedRows(SQL, dbPath, { requireThreads = false } = {}) {
|
||
if (!fs.existsSync(dbPath)) return { changed: false, rows: 0 };
|
||
let db;
|
||
try {
|
||
db = new SQL.Database(sqliteBufferWithCommittedWal(dbPath));
|
||
const tables = sqlJsRows(db, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
|
||
.map((row) => row.name).filter(Boolean);
|
||
if (requireThreads && !tables.includes("threads")) return { changed: false, rows: 0 };
|
||
db.run("PRAGMA foreign_keys=ON");
|
||
db.run("PRAGMA secure_delete=ON");
|
||
db.run("BEGIN");
|
||
let rows = 0;
|
||
const deferred = [];
|
||
for (const table of tables) {
|
||
// 自动化定义不是会话正文；即使它记录了 target_thread_id，也必须保留。
|
||
if (table === "automations") continue;
|
||
const columns = sqlJsRows(db, "PRAGMA table_info(" + quoteIdent(table) + ")").map((row) => String(row.name || ""));
|
||
const fks = sqlJsRows(db, "PRAGMA foreign_key_list(" + quoteIdent(table) + ")");
|
||
const linked = columns.filter((name) => /(^|_)(thread_id|parent_thread_id|child_thread_id)$/i.test(name));
|
||
const referencesThreads = fks
|
||
.filter((fk) => String(fk.table || "").toLowerCase() === "threads")
|
||
.map((fk) => String(fk.from || ""));
|
||
const targets = Array.from(new Set(linked.concat(referencesThreads))).filter(Boolean);
|
||
if (table === "threads") {
|
||
deferred.push(table);
|
||
continue;
|
||
}
|
||
for (const column of targets) {
|
||
db.run("DELETE FROM " + quoteIdent(table) + " WHERE " + quoteIdent(column) + " IS NOT NULL");
|
||
rows += db.getRowsModified();
|
||
}
|
||
}
|
||
if (tables.includes("threads")) {
|
||
db.run("DELETE FROM " + quoteIdent("threads"));
|
||
rows += db.getRowsModified();
|
||
}
|
||
db.run("COMMIT");
|
||
if (!rows) return { changed: false, rows: 0 };
|
||
db.run("VACUUM");
|
||
const fkErrors = sqlJsRows(db, "PRAGMA foreign_key_check");
|
||
const integrity = sqlJsRows(db, "PRAGMA integrity_check");
|
||
if (fkErrors.length || !integrity.length || integrity.some((row) => String(Object.values(row)[0] || "").toLowerCase() !== "ok")) {
|
||
throw new Error("SQLite 清空会话后完整性校验失败，已停止替换");
|
||
}
|
||
replaceStateDb(dbPath, Buffer.from(db.export()));
|
||
return { changed: true, rows };
|
||
} catch (e) {
|
||
if (db) try { db.run("ROLLBACK"); } catch {}
|
||
throw e;
|
||
} finally {
|
||
if (db) try { db.close(); } catch {}
|
||
}
|
||
}
|
||
|
||
function copyIfExists(source, target) {
|
||
if (!fs.existsSync(source)) return false;
|
||
fs.mkdirSync(path.dirname(target), { recursive: true });
|
||
const stat = fs.statSync(source);
|
||
if (stat.isDirectory()) {
|
||
fs.cpSync(source, target, { recursive: true, force: true });
|
||
} else {
|
||
fs.copyFileSync(source, target);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
function pruneEmptyDirs(root) {
|
||
if (!fs.existsSync(root)) return;
|
||
let entries;
|
||
try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
|
||
for (const entry of entries) {
|
||
if (entry.isDirectory()) pruneEmptyDirs(path.join(root, entry.name));
|
||
}
|
||
try {
|
||
if (!fs.readdirSync(root).length) fs.rmdirSync(root);
|
||
} catch {}
|
||
}
|
||
|
||
async function clearAllConversations() {
|
||
if (clearAllBusy) throw new Error("已有清空会话任务正在执行，请稍后重试");
|
||
clearAllBusy = true;
|
||
let backup = "";
|
||
const stagedDirs = [];
|
||
const copiedFiles = [];
|
||
try {
|
||
const { codexHome, sessionsDir, archivedSessionsDir, sessionIndex } = paths();
|
||
const rolloutFiles = sessionRoots().flatMap((root) => findRolloutFiles(root));
|
||
const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
|
||
backup = path.join(codexHome, "backups_state", "session-clear", timestamp);
|
||
fs.mkdirSync(backup, { recursive: true });
|
||
|
||
// 会话正文用同盘 rename 暂存，不复制 700+ 个大 JSONL；清空成功后保留备份，便于恢复。
|
||
for (const [name, source] of [["sessions", sessionsDir], ["archived_sessions", archivedSessionsDir]]) {
|
||
if (!fs.existsSync(source)) continue;
|
||
const target = path.join(backup, name);
|
||
fs.renameSync(source, target);
|
||
stagedDirs.push({ source, target });
|
||
fs.mkdirSync(source, { recursive: true });
|
||
}
|
||
if (fs.existsSync(sessionIndex)) {
|
||
copyIfExists(sessionIndex, path.join(backup, "session_index.jsonl"));
|
||
copiedFiles.push([sessionIndex, path.join(backup, "session_index.jsonl")]);
|
||
fs.writeFileSync(sessionIndex, "", "utf-8");
|
||
}
|
||
|
||
for (const name of fs.readdirSync(codexHome)) {
|
||
if (!/^state_.*\.sqlite(?:-(?:wal|shm))?$/.test(name)) continue;
|
||
const source = path.join(codexHome, name);
|
||
const target = path.join(backup, name);
|
||
copyIfExists(source, target);
|
||
copiedFiles.push([source, target]);
|
||
}
|
||
const catalogDb = path.join(codexHome, "sqlite", "codex-dev.db");
|
||
for (const suffix of ["", "-wal", "-shm"]) {
|
||
const source = catalogDb + suffix;
|
||
if (!fs.existsSync(source)) continue;
|
||
const target = path.join(backup, "codex-dev.db" + suffix);
|
||
copyIfExists(source, target);
|
||
copiedFiles.push([source, target]);
|
||
}
|
||
|
||
const indexLines = copiedFiles.some(([source]) => source === sessionIndex)
|
||
? fs.readFileSync(path.join(backup, "session_index.jsonl"), "utf-8").split("\n").filter((line) => line.trim()).length
|
||
: 0;
|
||
const SQL = await initSqlJs({
|
||
locateFile: (file) => path.join(global.__BUNDLE_ROOT__ || path.join(__dirname, "..", ".."), "node_modules", "sql.js", "dist", file),
|
||
});
|
||
let stateRowsRemoved = 0;
|
||
for (const name of fs.readdirSync(codexHome).filter((item) => /^state_.*\.sqlite$/.test(item))) {
|
||
const result = deleteAllThreadLinkedRows(SQL, path.join(codexHome, name), { requireThreads: true });
|
||
stateRowsRemoved += result.rows;
|
||
}
|
||
const catalog = deleteAllThreadLinkedRows(SQL, catalogDb);
|
||
return {
|
||
ok: true,
|
||
filesRemoved: rolloutFiles.length,
|
||
indexEntriesRemoved: indexLines,
|
||
stateRowsRemoved,
|
||
catalogRowsRemoved: catalog.rows,
|
||
backup,
|
||
};
|
||
} catch (error) {
|
||
// 任一 SQLite/文件步骤失败，恢复正文目录、索引和数据库备份，避免半清空状态。
|
||
for (const [source, target] of copiedFiles) {
|
||
try {
|
||
if (fs.existsSync(target)) {
|
||
fs.mkdirSync(path.dirname(source), { recursive: true });
|
||
fs.copyFileSync(target, source);
|
||
}
|
||
} catch {}
|
||
}
|
||
for (const { source, target } of stagedDirs.reverse()) {
|
||
try {
|
||
fs.rmSync(source, { recursive: true, force: true });
|
||
if (fs.existsSync(target)) fs.renameSync(target, source);
|
||
} catch {}
|
||
}
|
||
throw error;
|
||
} finally {
|
||
clearAllBusy = false;
|
||
}
|
||
}
|
||
|
||
function findConversationById(id) {
|
||
const target = String(id || "").trim();
|
||
if (!target || target.length > 160) return null;
|
||
for (const root of sessionRoots()) {
|
||
for (const file of findRolloutFiles(root)) {
|
||
const meta = peekMeta(file);
|
||
if (meta && meta.id === target) return { ...meta, path: file };
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function sql(v) {
|
||
return "'" + String(v == null ? "" : v).replace(/'/g, "''") + "'";
|
||
}
|
||
|
||
function findFallbackTitlesById() {
|
||
const map = {};
|
||
for (const root of sessionRoots()) {
|
||
for (const file of findRolloutFiles(root)) {
|
||
const m = peekMeta(file);
|
||
if (m && m.id && m.title) map[m.id] = m.title;
|
||
}
|
||
}
|
||
return map;
|
||
}
|
||
|
||
function repairStateDbTitles(fallbackTitles, log = () => {}) {
|
||
if (!sqlite3Available()) return 0;
|
||
let fixed = 0;
|
||
let files = [];
|
||
const { codexHome } = paths();
|
||
try {
|
||
files = fs.readdirSync(codexHome).filter((f) => /^state_.*\.sqlite$/.test(f));
|
||
} catch {
|
||
return 0;
|
||
}
|
||
for (const name of files) {
|
||
const dbPath = path.join(codexHome, name);
|
||
try {
|
||
const out = runSqlite3(dbPath, "SELECT id,title,first_user_message FROM threads WHERE title LIKE '[$%' OR title LIKE '$%';");
|
||
const rows = JSON.parse(out || "[]");
|
||
const updates = [];
|
||
for (const row of rows) {
|
||
const next = cleanThreadTitle(row.title, row.first_user_message || fallbackTitles[row.id] || "", 80);
|
||
if (next && next !== row.title) updates.push({ id: row.id, title: next });
|
||
}
|
||
if (!updates.length) continue;
|
||
const statements = ["BEGIN;"].concat(
|
||
updates.map((u) => `UPDATE threads SET title=${sql(u.title)} WHERE id=${sql(u.id)};`),
|
||
["COMMIT;"]
|
||
).join("\n");
|
||
runSqlite3(dbPath, statements);
|
||
fixed += updates.length;
|
||
} catch (e) {
|
||
log(`标题清洗跳过 ${name}：${e.message || e}`);
|
||
}
|
||
}
|
||
return fixed;
|
||
}
|
||
|
||
function repairSkillMentionTitles(log = () => {}) {
|
||
let raw = "";
|
||
let indexMtimeMs = 0;
|
||
const { sessionIndex, titleCleanMarker } = paths();
|
||
try {
|
||
indexMtimeMs = fs.statSync(sessionIndex).mtimeMs;
|
||
const marker = JSON.parse(fs.readFileSync(titleCleanMarker, "utf-8"));
|
||
if (marker && Number(marker.indexMtimeMs) >= indexMtimeMs) return { indexFixed: 0, dbFixed: 0, skipped: true };
|
||
} catch {}
|
||
try {
|
||
raw = fs.readFileSync(sessionIndex, "utf-8");
|
||
} catch {
|
||
return { indexFixed: 0, dbFixed: 0 };
|
||
}
|
||
const fallbackTitles = findFallbackTitlesById();
|
||
let indexFixed = 0;
|
||
const lines = raw.split("\n").map((line) => {
|
||
if (!line.trim()) return line;
|
||
try {
|
||
const d = JSON.parse(line);
|
||
if (!d || !d.id || !d.thread_name || !looksLikeSkillMentionTitle(d.thread_name)) return line;
|
||
const next = cleanThreadTitle(d.thread_name, fallbackTitles[d.id] || "", 80);
|
||
if (!next || next === d.thread_name) return line;
|
||
d.thread_name = next;
|
||
indexFixed++;
|
||
return JSON.stringify(d);
|
||
} catch {
|
||
return line;
|
||
}
|
||
});
|
||
if (indexFixed) {
|
||
const backup = sessionIndex + ".bak-title-clean-" + new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
|
||
try {
|
||
fs.copyFileSync(sessionIndex, backup);
|
||
} catch {}
|
||
fs.writeFileSync(sessionIndex, lines.join("\n"), "utf-8");
|
||
}
|
||
const dbFixed = repairStateDbTitles(fallbackTitles, log);
|
||
try {
|
||
fs.writeFileSync(titleCleanMarker, JSON.stringify({ indexMtimeMs, checkedAt: new Date().toISOString() }, null, 2), "utf-8");
|
||
} catch {}
|
||
return { indexFixed, dbFixed };
|
||
}
|
||
|
||
function normalizeListOptions(opts) {
|
||
if (typeof opts === "boolean") return { includeSubagent: opts, includeArchived: false, limit: DEFAULT_LIST_LIMIT };
|
||
const requestedLimit = Number(opts && opts.limit);
|
||
const limit = Number.isFinite(requestedLimit) && requestedLimit > 0
|
||
? Math.min(Math.floor(requestedLimit), ALL_LIST_LIMIT)
|
||
: DEFAULT_LIST_LIMIT;
|
||
return {
|
||
includeSubagent: !!(opts && opts.includeSubagent),
|
||
includeArchived: !!(opts && opts.includeArchived),
|
||
limit,
|
||
};
|
||
}
|
||
|
||
// 列出会话（默认只列当前 sessions，并排除子 agent 派生线程；全量模式会带 archived_sessions）
|
||
function listConversations(opts = {}) {
|
||
const { includeSubagent, includeArchived, limit } = normalizeListOptions(opts);
|
||
const { sessionsDir, archivedSessionsDir } = paths();
|
||
const roots = [{ dir: sessionsDir, archived: false }];
|
||
if (includeArchived) roots.push({ dir: archivedSessionsDir, archived: true });
|
||
const titles = loadIndexTitles();
|
||
const items = [];
|
||
for (const root of roots) {
|
||
const files = findRolloutFiles(root.dir);
|
||
for (const file of files) {
|
||
const m = peekMeta(file);
|
||
if (!m) continue;
|
||
if (!includeSubagent && m.threadSource === "subagent") continue;
|
||
let size = 0;
|
||
try {
|
||
size = fs.statSync(file).size;
|
||
} catch {}
|
||
items.push({
|
||
id: m.id,
|
||
title: cleanThreadTitle(titles[m.id] || "", m.title, 80) || "(无标题对话)",
|
||
project: m.cwd ? path.basename(m.cwd) : "",
|
||
cwd: m.cwd,
|
||
ts: m.ts,
|
||
source: m.source,
|
||
threadSource: m.threadSource,
|
||
provider: m.provider,
|
||
path: file,
|
||
size,
|
||
archived: root.archived,
|
||
});
|
||
}
|
||
}
|
||
items.sort((a, b) => (b.ts || "").localeCompare(a.ts || ""));
|
||
return items.slice(0, limit);
|
||
}
|
||
|
||
// 解析单个会话文件为可读消息列表
|
||
function readConversation(file) {
|
||
const messages = [];
|
||
let meta = {};
|
||
let content;
|
||
try {
|
||
content = fs.readFileSync(file, "utf-8");
|
||
} catch (e) {
|
||
return { meta, messages, error: String(e) };
|
||
}
|
||
for (const line of content.split("\n")) {
|
||
if (!line.trim()) continue;
|
||
let d;
|
||
try {
|
||
d = JSON.parse(line);
|
||
} catch {
|
||
continue;
|
||
}
|
||
const p = d.payload || {};
|
||
const ts = d.timestamp || "";
|
||
if (d.type === "session_meta") {
|
||
meta = { id: p.id || p.session_id || "", cwd: p.cwd || "", ts: p.timestamp || ts, provider: p.model_provider || "" };
|
||
} else if (d.type === "event_msg" && p.type === "user_message") {
|
||
messages.push({ role: "user", text: cleanUserVisibleText(String(p.message || "")), ts });
|
||
} else if (d.type === "event_msg" && p.type === "agent_message") {
|
||
messages.push({ role: "assistant", text: stripInternalThoughtBlocks(String(p.message || "")), ts });
|
||
} else if (d.type === "response_item" && p.type === "function_call") {
|
||
const name = p.name || "tool";
|
||
messages.push({ role: "tool", text: `调用工具：${name}`, ts, collapsed: true });
|
||
}
|
||
}
|
||
return { meta, messages };
|
||
}
|
||
|
||
// 导出为 Markdown 文本
|
||
function toMarkdown(item, conv) {
|
||
const lines = [];
|
||
lines.push(`# ${item.title || "Codex 会话记录"}`);
|
||
lines.push("");
|
||
if (item.project) lines.push(`- 项目：${item.project}`);
|
||
if (item.cwd) lines.push(`- 目录：${item.cwd}`);
|
||
if (item.ts) lines.push(`- 时间：${item.ts}`);
|
||
if (item.provider) lines.push(`- Provider：${item.provider}`);
|
||
lines.push("");
|
||
lines.push("---");
|
||
lines.push("");
|
||
for (const m of conv.messages) {
|
||
if (m.role === "user") lines.push(`## 👤 用户\n\n${m.text}\n`);
|
||
else if (m.role === "assistant") lines.push(`## 🤖 Codex\n\n${m.text}\n`);
|
||
else if (m.role === "tool") lines.push(`> 🔧 ${m.text}\n`);
|
||
}
|
||
return lines.join("\n");
|
||
}
|
||
|
||
// 备份：把 sessions/、archived_sessions/ 与索引复制到目标目录下的 codex-sessions-backup/
|
||
function backupAll(destDir, log = () => {}) {
|
||
const out = path.join(destDir, "codex-sessions-backup");
|
||
fs.mkdirSync(out, { recursive: true });
|
||
let n = 0;
|
||
const { sessionsDir, archivedSessionsDir, sessionIndex } = paths();
|
||
for (const [name, dir] of [["sessions", sessionsDir], ["archived_sessions", archivedSessionsDir]]) {
|
||
const files = findRolloutFiles(dir);
|
||
for (const f of files) {
|
||
const rel = path.relative(dir, f);
|
||
const dst = path.join(out, name, rel);
|
||
fs.mkdirSync(path.dirname(dst), { recursive: true });
|
||
fs.copyFileSync(f, dst);
|
||
n++;
|
||
}
|
||
}
|
||
if (fs.existsSync(sessionIndex)) fs.copyFileSync(sessionIndex, path.join(out, "session_index.jsonl"));
|
||
log(`已备份 ${n} 个会话文件到 ${out}`);
|
||
return { path: out, count: n };
|
||
}
|
||
|
||
function resolveImportRoot(srcDir) {
|
||
const root = path.resolve(String(srcDir || ""));
|
||
if (fs.existsSync(path.join(root, "sessions"))) return root;
|
||
const nested = path.join(root, "codex-sessions-backup");
|
||
if (fs.existsSync(path.join(nested, "sessions"))) return nested;
|
||
return root;
|
||
}
|
||
|
||
function mergeSessionIndex(srcIndex, dstIndex) {
|
||
if (!fs.existsSync(srcIndex)) return 0;
|
||
const entries = new Map();
|
||
const read = (file) => {
|
||
try {
|
||
for (const line of fs.readFileSync(file, "utf-8").split("\n")) {
|
||
if (!line.trim()) continue;
|
||
try {
|
||
const value = JSON.parse(line);
|
||
if (value && value.id) entries.set(String(value.id), value);
|
||
} catch {}
|
||
}
|
||
} catch {}
|
||
};
|
||
// 目标机器已有的重命名优先，备份只补缺失条目。
|
||
read(srcIndex);
|
||
const imported = new Map(entries);
|
||
entries.clear();
|
||
read(dstIndex);
|
||
const existing = new Map(entries);
|
||
for (const [id, value] of imported) if (!existing.has(id)) existing.set(id, value);
|
||
if (!existing.size) return 0;
|
||
fs.mkdirSync(path.dirname(dstIndex), { recursive: true });
|
||
const backup = dstIndex + ".bak-import-" + Date.now();
|
||
try { if (fs.existsSync(dstIndex)) fs.copyFileSync(dstIndex, backup); } catch {}
|
||
const tmp = dstIndex + ".tmp-import-" + process.pid;
|
||
try {
|
||
fs.writeFileSync(tmp, [...existing.values()].map((value) => JSON.stringify(value)).join("\n") + "\n", "utf-8");
|
||
try { fs.renameSync(tmp, dstIndex); }
|
||
catch {
|
||
fs.rmSync(dstIndex, { force: true });
|
||
fs.renameSync(tmp, dstIndex);
|
||
}
|
||
} finally {
|
||
try { fs.rmSync(tmp, { force: true }); } catch {}
|
||
}
|
||
return imported.size;
|
||
}
|
||
|
||
// 导入：把外部备份目录里的 rollout-*.jsonl 合并进本机 sessions/ 与 archived_sessions/（已存在则跳过）
|
||
function importSessions(srcDir, log = () => {}) {
|
||
// 支持传入 backup 根目录或其中的 sessions/ 子目录
|
||
let added = 0;
|
||
let skipped = 0;
|
||
const sourceRoot = resolveImportRoot(srcDir);
|
||
const { sessionsDir, archivedSessionsDir } = paths();
|
||
const roots = fs.existsSync(path.join(sourceRoot, "sessions"))
|
||
? [
|
||
{ base: path.join(sourceRoot, "sessions"), dest: sessionsDir },
|
||
{ base: path.join(sourceRoot, "archived_sessions"), dest: archivedSessionsDir },
|
||
]
|
||
: [{ base: sourceRoot, dest: sessionsDir }];
|
||
for (const root of roots) {
|
||
const files = findRolloutFiles(root.base);
|
||
for (const f of files) {
|
||
const rel = path.relative(root.base, f);
|
||
const dst = path.join(root.dest, rel);
|
||
if (fs.existsSync(dst)) {
|
||
skipped++;
|
||
continue;
|
||
}
|
||
fs.mkdirSync(path.dirname(dst), { recursive: true });
|
||
fs.copyFileSync(f, dst);
|
||
added++;
|
||
}
|
||
}
|
||
const indexMerged = mergeSessionIndex(path.join(sourceRoot, "session_index.jsonl"), paths().sessionIndex);
|
||
log(`导入完成：新增 ${added} 个，跳过 ${skipped} 个（已存在），合并索引 ${indexMerged} 条`);
|
||
return { added, skipped, indexMerged };
|
||
}
|
||
|
||
module.exports = {
|
||
getCodexHome: () => paths().codexHome,
|
||
getSessionsDir: () => paths().sessionsDir,
|
||
getArchivedSessionsDir: () => paths().archivedSessionsDir,
|
||
listConversations,
|
||
readConversation,
|
||
toMarkdown,
|
||
backupAll,
|
||
importSessions,
|
||
deleteConversation,
|
||
clearAllConversations,
|
||
findConversationById,
|
||
repairSkillMentionTitles,
|
||
};
|