cli-link 0.0.1

package/dist/server/store.js

@@ -0,0 +1,594 @@
+import Database from 'better-sqlite3';
+import { mkdirSync, existsSync, statSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+function cleanHistoryTitle(content) {
+    const normalized = content
+        .replace(/```[\s\S]*?```/g, ' ')
+        .replace(/`([^`]+)`/g, '$1')
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => {
+        if (!line)
+            return false;
+        if (/^#+\s*AGENTS\.md/i.test(line))
+            return false;
+        if (/^<\/?[A-Z_]+>/i.test(line))
+            return false;
+        if (/^[-*]\s*$/.test(line))
+            return false;
+        return true;
+    })
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .replace(/^#+\s*/, '')
+        .replace(/^[-*]\s+/, '')
+        .trim();
+    if (!normalized)
+        return '会话记录';
+    return normalized.length > 48 ? `${normalized.slice(0, 48).trimEnd()}...` : normalized;
+}
+function buildHistoryTitle(messages) {
+    const userMessage = messages.find(m => m.type === 'user_message' || m.type === 'user');
+    return userMessage ? cleanHistoryTitle(userMessage.content) : '会话记录';
+}
+function normalizeWorkDir(workDir) {
+    if (typeof workDir !== 'string')
+        return null;
+    const trimmed = workDir.trim();
+    if (!trimmed)
+        return null;
+    const expanded = trimmed === '~'
+        ? homedir()
+        : trimmed.startsWith('~/')
+            ? join(homedir(), trimmed.slice(2))
+            : trimmed;
+    return resolve(expanded);
+}
+function parseConfig(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function getWorkDirFromSessionConfig(raw) {
+    const config = parseConfig(raw);
+    return normalizeWorkDir(config.workDir);
+}
+function getSessionWorkDir(sessionId) {
+    const row = db.prepare(`SELECT cli_config FROM sessions WHERE id = ?`).get(sessionId);
+    return getWorkDirFromSessionConfig(row?.cli_config);
+}
+// --- Database ---
+let db;
+const DB_DIR = join(homedir(), '.agentpilot');
+const DB_PATH = join(DB_DIR, 'data.db');
+export function initDb(dbPath) {
+    const path = dbPath || DB_PATH;
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    db = new Database(path);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL DEFAULT 'idle',
+      cli_config TEXT,
+      started_at INTEGER NOT NULL,
+      last_seq INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      time TEXT NOT NULL,
+      status TEXT,
+      toolName TEXT,
+      toolDetails TEXT,
+      toolUseId TEXT,
+      toolResult TEXT,
+      permission TEXT,
+      details TEXT,
+      session_id TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS history_tasks (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      work_dir TEXT,
+      status TEXT NOT NULL,
+      title TEXT NOT NULL,
+      confirm_count INTEGER NOT NULL DEFAULT 0,
+      tool_count INTEGER NOT NULL DEFAULT 0,
+      duration TEXT,
+      start_time INTEGER NOT NULL,
+      end_time INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS workdir_history (
+      path TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      last_used_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_session_seq ON messages(session_id, seq);
+  `);
+    // Migrate: add 'details' column if it doesn't exist (for existing databases)
+    const columns = db.prepare(`PRAGMA table_info(messages)`).all();
+    if (!columns.some(c => c.name === 'details')) {
+        db.exec(`ALTER TABLE messages ADD COLUMN details TEXT`);
+        console.log('[Store] Migrated: added details column to messages table');
+    }
+    if (!columns.some(c => c.name === 'toolUseId')) {
+        db.exec(`ALTER TABLE messages ADD COLUMN toolUseId TEXT`);
+        console.log('[Store] Migrated: added toolUseId column to messages table');
+    }
+    if (!columns.some(c => c.name === 'toolResult')) {
+        db.exec(`ALTER TABLE messages ADD COLUMN toolResult TEXT`);
+        console.log('[Store] Migrated: added toolResult column to messages table');
+    }
+    const historyColumns = db.prepare(`PRAGMA table_info(history_tasks)`).all();
+    if (!historyColumns.some(c => c.name === 'work_dir')) {
+        db.exec(`ALTER TABLE history_tasks ADD COLUMN work_dir TEXT`);
+        console.log('[Store] Migrated: added work_dir column to history_tasks table');
+    }
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_history_tasks_work_dir_created ON history_tasks(work_dir, created_at DESC)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_workdir_history_last_used ON workdir_history(last_used_at DESC)`);
+    backfillHistoryTaskSummaries();
+    console.log(`[Store] Database initialized at ${path}`);
+}
+function backfillHistoryTaskSummaries() {
+    const tasks = db.prepare(`SELECT id, session_id, work_dir, title, confirm_count, tool_count
+     FROM history_tasks
+     WHERE session_id IS NOT NULL`).all();
+    if (tasks.length === 0)
+        return;
+    const firstUserMessage = db.prepare(`SELECT content FROM messages
+     WHERE session_id = ? AND type IN ('user_message', 'user') AND content != ''
+     ORDER BY seq ASC
+     LIMIT 1`);
+    const countMessages = db.prepare(`SELECT
+       SUM(CASE WHEN type IN ('confirm_request', 'confirm') THEN 1 ELSE 0 END) AS confirm_count,
+       SUM(CASE WHEN type IN ('tool_call', 'tool') THEN 1 ELSE 0 END) AS tool_count
+     FROM messages
+     WHERE session_id = ?`);
+    const updateTask = db.prepare(`UPDATE history_tasks
+     SET title = ?, confirm_count = ?, tool_count = ?, work_dir = ?
+     WHERE id = ?`);
+    const getSessionConfig = db.prepare(`SELECT cli_config FROM sessions WHERE id = ?`);
+    const backfill = db.transaction((rows) => {
+        for (const task of rows) {
+            if (!task.session_id)
+                continue;
+            let title = task.title;
+            if (!title || title === '会话记录') {
+                const userMessage = firstUserMessage.get(task.session_id);
+                title = userMessage ? cleanHistoryTitle(userMessage.content) : '会话记录';
+            }
+            const counts = countMessages.get(task.session_id);
+            const confirmCount = counts.confirm_count || 0;
+            const toolCount = counts.tool_count || 0;
+            const session = getSessionConfig.get(task.session_id);
+            const workDir = task.work_dir || getWorkDirFromSessionConfig(session?.cli_config);
+            if (title !== task.title || confirmCount !== task.confirm_count || toolCount !== task.tool_count || workDir !== task.work_dir) {
+                updateTask.run(title, confirmCount, toolCount, workDir || null, task.id);
+            }
+        }
+    });
+    backfill(tasks);
+}
+// --- Session Operations ---
+export function createSession(config) {
+    const id = randomUUID();
+    const now = Date.now();
+    // If there's an existing active session, archive it first
+    const current = getCurrentSession();
+    if (current && current.status !== 'archived') {
+        archiveSession(current.id, 'completed');
+    }
+    db.prepare(`INSERT INTO sessions (id, status, cli_config, started_at, last_seq) VALUES (?, ?, ?, ?, 0)`).run(id, 'idle', config ? JSON.stringify(config) : null, now);
+    return id;
+}
+export function getCurrentSession() {
+    const row = db.prepare(`SELECT * FROM sessions WHERE status != 'archived' ORDER BY started_at DESC LIMIT 1`).get();
+    return row || null;
+}
+export function getSessionById(sessionId) {
+    const row = db.prepare(`SELECT * FROM sessions WHERE id = ?`).get(sessionId);
+    return row || null;
+}
+export function updateSessionStatus(sessionId, status) {
+    db.prepare(`UPDATE sessions SET status = ? WHERE id = ?`).run(status, sessionId);
+}
+export function updateSessionConfig(sessionId, config) {
+    db.prepare(`UPDATE sessions SET cli_config = ? WHERE id = ?`).run(JSON.stringify(config), sessionId);
+}
+// --- Message Operations ---
+export function appendMessage(sessionId, msg) {
+    const id = msg.id || randomUUID();
+    const result = db.prepare(`INSERT INTO messages (id, type, content, time, status, toolName, toolDetails, toolUseId, toolResult, permission, details, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, msg.type, msg.content, msg.time, msg.status || null, msg.toolName || null, msg.toolDetails || null, msg.toolUseId || null, msg.toolResult || null, msg.permission ? JSON.stringify(msg.permission) : null, msg.details ? JSON.stringify(msg.details) : null, sessionId);
+    const seq = Number(result.lastInsertRowid);
+    db.prepare(`UPDATE sessions SET last_seq = ? WHERE id = ?`).run(seq, sessionId);
+    return { id, seq };
+}
+export function updateToolCallResult(sessionId, toolUseId, status, toolResult) {
+    const result = db.prepare(`UPDATE messages SET status = ?, toolResult = ? WHERE session_id = ? AND toolUseId = ? AND type = 'tool_call'`).run(status, toolResult, sessionId, toolUseId);
+    return result.changes > 0;
+}
+export function getSessionMessages(sessionId, afterSeq) {
+    if (afterSeq !== undefined && afterSeq > 0) {
+        return db.prepare(`SELECT * FROM messages WHERE session_id = ? AND seq > ? ORDER BY seq ASC`).all(sessionId, afterSeq);
+    }
+    return db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY seq ASC`).all(sessionId);
+}
+export function getRecentSessionMessages(sessionId, limit) {
+    const normalizedLimit = Math.max(1, Math.floor(limit));
+    const rows = db.prepare(`SELECT * FROM messages WHERE session_id = ? ORDER BY seq DESC LIMIT ?`).all(sessionId, normalizedLimit);
+    return rows.reverse();
+}
+export function getSessionMessagesBefore(sessionId, beforeSeq, limit) {
+    const normalizedLimit = Math.max(1, Math.floor(limit));
+    const rows = db.prepare(`SELECT * FROM messages WHERE session_id = ? AND seq < ? ORDER BY seq DESC LIMIT ?`).all(sessionId, beforeSeq, normalizedLimit);
+    return rows.reverse();
+}
+export function hasSessionMessagesBefore(sessionId, beforeSeq) {
+    const row = db.prepare(`SELECT 1 FROM messages WHERE session_id = ? AND seq < ? LIMIT 1`).get(sessionId, beforeSeq);
+    return !!row;
+}
+export function getSessionDetails(sessionId) {
+    const rows = db.prepare(`SELECT details FROM messages WHERE session_id = ? AND details IS NOT NULL AND details != ''`).all(sessionId);
+    return rows.map(row => row.details);
+}
+export function getSessionMessageById(sessionId, messageId) {
+    const row = db.prepare(`SELECT * FROM messages WHERE session_id = ? AND id = ? ORDER BY seq ASC LIMIT 1`).get(sessionId, messageId);
+    return row || null;
+}
+export function copySessionMessagesBeforeSeq(sourceSessionId, targetSessionId, beforeSeq) {
+    const messages = db.prepare(`SELECT id, type, content, time, status, toolName, toolDetails, toolUseId, toolResult, permission, details
+     FROM messages
+     WHERE session_id = ? AND seq < ?
+     ORDER BY seq ASC`).all(sourceSessionId, beforeSeq);
+    if (messages.length === 0)
+        return 0;
+    const insertStmt = db.prepare(`INSERT INTO messages (id, type, content, time, status, toolName, toolDetails, toolUseId, toolResult, permission, details, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const copyMany = db.transaction((rows) => {
+        let lastSeq = 0;
+        for (const msg of rows) {
+            const result = insertStmt.run(msg.id, msg.type, msg.content, msg.time, msg.status || null, msg.toolName || null, msg.toolDetails || null, msg.toolUseId || null, msg.toolResult || null, msg.permission || null, msg.details || null, targetSessionId);
+            lastSeq = Number(result.lastInsertRowid);
+        }
+        db.prepare(`UPDATE sessions SET last_seq = ? WHERE id = ?`).run(lastSeq, targetSessionId);
+        return lastSeq;
+    });
+    return copyMany(messages);
+}
+export function getMessageCount(sessionId) {
+    const row = db.prepare(`SELECT COUNT(*) as count FROM messages WHERE session_id = ?`).get(sessionId);
+    return row.count;
+}
+export function getLastSeq(sessionId) {
+    const row = db.prepare(`SELECT last_seq FROM sessions WHERE id = ?`).get(sessionId);
+    return row?.last_seq || 0;
+}
+// --- History Operations ---
+export function archiveSession(sessionId, status) {
+    const messages = getSessionMessages(sessionId);
+    if (messages.length === 0) {
+        // Just mark as archived, no history task
+        db.prepare(`UPDATE sessions SET status = 'archived' WHERE id = ?`).run(sessionId);
+        return null;
+    }
+    const title = buildHistoryTitle(messages);
+    const confirmCount = messages.filter(m => m.type === 'confirm_request' || m.type === 'confirm').length;
+    const toolCount = messages.filter(m => m.type === 'tool_call' || m.type === 'tool').length;
+    const workDir = getSessionWorkDir(sessionId);
+    const firstTime = messages[0]?.time;
+    const lastTime = messages[messages.length - 1]?.time;
+    let startTime = Date.now() - 60_000;
+    let endTime = Date.now();
+    if (firstTime) {
+        const s = new Date(firstTime).getTime();
+        if (!isNaN(s))
+            startTime = s;
+    }
+    if (lastTime) {
+        const e = new Date(lastTime).getTime();
+        if (!isNaN(e))
+            endTime = e;
+    }
+    let duration;
+    const diffSec = Math.round((endTime - startTime) / 1000);
+    if (diffSec > 0) {
+        const m = Math.floor(diffSec / 60);
+        const s = diffSec % 60;
+        duration = m > 0 ? `${m}m ${String(s).padStart(2, '0')}s` : `${s}s`;
+    }
+    const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    db.prepare(`INSERT INTO history_tasks (id, session_id, work_dir, status, title, confirm_count, tool_count, duration, start_time, end_time, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(taskId, sessionId, workDir, status, title, confirmCount, toolCount, duration || null, startTime, endTime, Date.now());
+    db.prepare(`UPDATE sessions SET status = 'archived' WHERE id = ?`).run(sessionId);
+    return taskId;
+}
+export function getHistoryTasks(options = {}) {
+    const limit = typeof options === 'number' ? options : options.limit ?? 50;
+    const workDir = typeof options === 'number' ? null : normalizeWorkDir(options.workDir);
+    if (workDir) {
+        return db.prepare(`SELECT * FROM history_tasks
+       WHERE work_dir = ?
+       ORDER BY created_at DESC
+       LIMIT ?`).all(workDir, limit);
+    }
+    return db.prepare(`SELECT * FROM history_tasks ORDER BY created_at DESC LIMIT ?`).all(limit);
+}
+export function getLatestCliSessionIdFromMessages(sessionId, limit = 50) {
+    const rows = db.prepare(`SELECT details FROM messages
+     WHERE session_id = ? AND details IS NOT NULL
+     ORDER BY seq DESC
+     LIMIT ?`).all(sessionId, limit);
+    for (const row of rows) {
+        if (!row.details)
+            continue;
+        try {
+            const details = JSON.parse(row.details);
+            const cliSessionId = details?.session_id;
+            if (typeof cliSessionId === 'string' && cliSessionId.length > 8) {
+                return cliSessionId;
+            }
+        }
+        catch { }
+    }
+    return undefined;
+}
+export function getHistoryTask(id, workDir) {
+    const normalizedWorkDir = normalizeWorkDir(workDir);
+    const task = normalizedWorkDir
+        ? db.prepare(`SELECT * FROM history_tasks WHERE id = ? AND work_dir = ?`).get(id, normalizedWorkDir)
+        : db.prepare(`SELECT * FROM history_tasks WHERE id = ?`).get(id);
+    if (!task)
+        return null;
+    const messages = task.session_id
+        ? getSessionMessages(task.session_id)
+        : [];
+    return { ...task, messages };
+}
+export function resumeHistoryTask(id, currentSessionId, workDir) {
+    const task = getHistoryTask(id, workDir);
+    if (!task?.session_id)
+        return null;
+    const session = getSessionById(task.session_id);
+    if (!session)
+        return null;
+    if (currentSessionId && currentSessionId !== session.id) {
+        const current = getSessionById(currentSessionId);
+        if (current && current.status !== 'archived') {
+            archiveSession(current.id, 'completed');
+        }
+    }
+    else {
+        const current = getCurrentSession();
+        if (current && current.id !== session.id && current.status !== 'archived') {
+            archiveSession(current.id, 'completed');
+        }
+    }
+    db.prepare(`DELETE FROM history_tasks WHERE id = ?`).run(id);
+    db.prepare(`UPDATE sessions SET status = 'idle' WHERE id = ?`).run(session.id);
+    return {
+        ...task,
+        session: {
+            ...session,
+            status: 'idle',
+        },
+        messages: getSessionMessages(session.id),
+    };
+}
+export function deleteHistoryTask(id, workDir) {
+    const normalizedWorkDir = normalizeWorkDir(workDir);
+    const result = normalizedWorkDir
+        ? db.prepare(`DELETE FROM history_tasks WHERE id = ? AND work_dir = ?`).run(id, normalizedWorkDir)
+        : db.prepare(`DELETE FROM history_tasks WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+export function clearHistory(workDir) {
+    const normalizedWorkDir = normalizeWorkDir(workDir);
+    if (normalizedWorkDir) {
+        db.prepare(`DELETE FROM history_tasks WHERE work_dir = ?`).run(normalizedWorkDir);
+        return;
+    }
+    db.prepare(`DELETE FROM history_tasks`).run();
+}
+export function backfillUnscopedHistoryWorkDir(workDir) {
+    const normalizedWorkDir = normalizeWorkDir(workDir);
+    if (!normalizedWorkDir)
+        return;
+    const result = db.prepare(`UPDATE history_tasks
+     SET work_dir = ?
+     WHERE work_dir IS NULL`).run(normalizedWorkDir);
+    if (result.changes > 0) {
+        console.log(`[Store] Backfilled ${result.changes} unscoped history tasks to ${normalizedWorkDir}`);
+    }
+}
+// --- Work Directory History ---
+function getWorkDirName(workDir) {
+    const base = workDir.split(/[\\/]/).filter(Boolean).pop();
+    return base || workDir;
+}
+function isReadableDirectory(workDir) {
+    try {
+        return statSync(workDir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function recordWorkDir(workDir) {
+    const normalized = normalizeWorkDir(workDir);
+    if (!normalized || !isReadableDirectory(normalized))
+        return null;
+    const now = Date.now();
+    const name = getWorkDirName(normalized);
+    db.prepare(`INSERT INTO workdir_history (path, name, last_used_at, created_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(path) DO UPDATE SET
+       name = excluded.name,
+       last_used_at = excluded.last_used_at`).run(normalized, name, now, now);
+    return {
+        path: normalized,
+        name,
+        last_used_at: now,
+        created_at: now,
+    };
+}
+export function getRecentWorkDirs(limit = 12) {
+    const normalizedLimit = Math.max(1, Math.min(50, Math.floor(limit)));
+    const rows = db.prepare(`SELECT * FROM workdir_history
+     ORDER BY last_used_at DESC
+     LIMIT ?`).all(normalizedLimit);
+    const stalePaths = [];
+    const existing = rows.filter(row => {
+        const ok = isReadableDirectory(row.path);
+        if (!ok)
+            stalePaths.push(row.path);
+        return ok;
+    });
+    if (stalePaths.length > 0) {
+        const remove = db.prepare(`DELETE FROM workdir_history WHERE path = ?`);
+        const removeMany = db.transaction((paths) => {
+            for (const stalePath of paths)
+                remove.run(stalePath);
+        });
+        removeMany(stalePaths);
+    }
+    return existing;
+}
+// --- Migration (from client localStorage) ---
+export function importLocalData(messages, historyTasks, workDir) {
+    const current = getCurrentSession();
+    const importWorkDir = normalizeWorkDir(workDir)
+        || getWorkDirFromSessionConfig(current?.cli_config)
+        || normalizeWorkDir(process.cwd());
+    // Import messages into the current session (or create one if none)
+    let sessionId;
+    if (current && current.status !== 'archived') {
+        sessionId = current.id;
+    }
+    else {
+        sessionId = createSession();
+    }
+    // Only import if current session has no messages
+    const existingCount = getMessageCount(sessionId);
+    if (existingCount === 0 && messages.length > 0) {
+        const insertStmt = db.prepare(`INSERT INTO messages (id, type, content, time, status, toolName, toolDetails, permission, session_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertMany = db.transaction((msgs) => {
+            for (const msg of msgs) {
+                insertStmt.run(String(msg.id || randomUUID()), String(msg.type || 'system'), String(msg.content || ''), String(msg.time || new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })), msg.status || null, msg.toolName || null, msg.toolDetails || null, msg.permission ? JSON.stringify(msg.permission) : null, sessionId);
+            }
+        });
+        insertMany(messages);
+        const lastSeq = getLastSeq(sessionId);
+        db.prepare(`UPDATE sessions SET last_seq = ? WHERE id = ?`).run(lastSeq, sessionId);
+    }
+    // Import history tasks
+    if (historyTasks.length > 0) {
+        const insertTaskStmt = db.prepare(`INSERT OR IGNORE INTO history_tasks (id, session_id, work_dir, status, title, confirm_count, tool_count, duration, start_time, end_time, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertTasks = db.transaction((tasks) => {
+            for (const task of tasks) {
+                insertTaskStmt.run(String(task.id || randomUUID()), null, // session_id not available for imported history
+                importWorkDir, String(task.status || 'completed'), String(task.title || '会话记录'), Number(task.confirmCount || 0), Number(task.toolCount || 0), task.duration || null, Number(task.startTime || Date.now()), Number(task.endTime || Date.now()), Number(task.endTime || Date.now()));
+            }
+        });
+        insertTasks(historyTasks);
+    }
+    console.log(`[Store] Imported ${messages.length} messages and ${historyTasks.length} history tasks`);
+}
+export function importCodexSessions(sessions) {
+    const result = {
+        scanned: sessions.length,
+        imported: 0,
+        skipped: 0,
+        failed: 0,
+        messagesImported: 0,
+        errors: [],
+    };
+    if (sessions.length === 0) {
+        return result;
+    }
+    const sessionExists = db.prepare(`SELECT 1 FROM sessions WHERE id = ? LIMIT 1`);
+    const taskExists = db.prepare(`SELECT 1 FROM history_tasks WHERE id = ? LIMIT 1`);
+    const insertSession = db.prepare(`INSERT INTO sessions (id, status, cli_config, started_at, last_seq) VALUES (?, ?, ?, ?, 0)`);
+    const insertMessage = db.prepare(`INSERT INTO messages (id, type, content, time, status, toolName, toolDetails, toolUseId, toolResult, permission, details, session_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const updateLastSeq = db.prepare(`UPDATE sessions SET last_seq = ? WHERE id = ?`);
+    const insertTask = db.prepare(`INSERT INTO history_tasks (id, session_id, work_dir, status, title, confirm_count, tool_count, duration, start_time, end_time, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const importOne = db.transaction((session) => {
+        const workDir = normalizeWorkDir(session.workDir);
+        const messages = session.messages || [];
+        const confirmCount = messages.filter(m => m.type === 'confirm_request' || m.type === 'confirm').length;
+        const toolCount = messages.filter(m => m.type === 'tool_call' || m.type === 'tool').length;
+        const startedAt = Number.isFinite(session.startedAt) && session.startedAt > 0 ? session.startedAt : Date.now();
+        const endedAt = Number.isFinite(session.endedAt) && session.endedAt > 0 ? session.endedAt : startedAt;
+        const createdAt = Number.isFinite(session.createdAt) && session.createdAt > 0 ? session.createdAt : endedAt;
+        const diffSec = Math.max(0, Math.round((endedAt - startedAt) / 1000));
+        const duration = diffSec > 0
+            ? diffSec >= 60
+                ? `${Math.floor(diffSec / 60)}m ${String(diffSec % 60).padStart(2, '0')}s`
+                : `${diffSec}s`
+            : null;
+        insertSession.run(session.sessionId, 'archived', JSON.stringify(session.cliConfig || {}), startedAt);
+        let lastSeq = 0;
+        for (const message of messages) {
+            const inserted = insertMessage.run(message.id, message.type, message.content || '', message.time || '', message.status || null, message.toolName || null, message.toolDetails || null, message.toolUseId || null, message.toolResult || null, message.permission ? JSON.stringify(message.permission) : null, message.details ? JSON.stringify(message.details) : null, session.sessionId);
+            lastSeq = Number(inserted.lastInsertRowid);
+        }
+        if (lastSeq > 0) {
+            updateLastSeq.run(lastSeq, session.sessionId);
+        }
+        insertTask.run(session.taskId, session.sessionId, workDir, session.status || 'completed', session.title || 'Codex 会话记录', confirmCount, toolCount, duration, startedAt, endedAt, createdAt);
+        return messages.length;
+    });
+    for (const session of sessions) {
+        try {
+            if (!session.sessionId || !session.taskId || session.messages.length === 0) {
+                result.skipped += 1;
+                continue;
+            }
+            if (sessionExists.get(session.sessionId) || taskExists.get(session.taskId)) {
+                result.skipped += 1;
+                continue;
+            }
+            const importedMessages = importOne(session);
+            result.imported += 1;
+            result.messagesImported += importedMessages;
+        }
+        catch (err) {
+            result.failed += 1;
+            result.errors.push(`${session.sessionId || 'unknown'}: ${err?.message || 'import failed'}`);
+        }
+    }
+    console.log(`[Store] Synced Codex history: imported=${result.imported}, skipped=${result.skipped}, failed=${result.failed}`);
+    return result;
+}
+// --- Cleanup ---
+export function closeDb() {
+    if (db) {
+        db.close();
+        console.log('[Store] Database closed');
+    }
+}