@swarmify/agents-cli 1.13.4 → 1.14.0

package/dist/lib/session/discover.js

@@ -1,1315 +0,0 @@
-/**
- * Session discovery across Claude, Codex, Gemini, OpenCode, and OpenClaw.
- *
- * Performs incremental scans: each agent's session files are stat'd and compared
- * to a scan-stamp ledger in SQLite. Only files whose mtime or size changed since
- * the last run are re-parsed. All metadata is upserted into the sessions DB so
- * subsequent queries are served entirely from the cache.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import * as crypto from 'crypto';
-import * as readline from 'readline';
-import { execSync } from 'child_process';
-import { AGENTS, getCliVersion } from '../agents.js';
-import { getConfigSymlinkVersion } from '../shims.js';
-import { SESSION_AGENTS } from './types.js';
-import { extractSessionTopic } from './prompt.js';
-import { getDB, getScanStampByPath, getScanStampsForPaths, recordScans, syncLabels, upsertSessionsBatch, querySessions, countSessions, ftsSearch, } from './db.js';
-const HOME = os.homedir();
-const AGENTS_DIR = path.join(HOME, '.agents');
-/** How long OpenClaw channel/cron snapshots stay valid before we re-shell-out. */
-const OPENCLAW_TTL_MS = 60_000;
-let cachedOpenClawWorkspaces = null;
-const cachedAgentVersions = new Map();
-/**
- * Discover sessions. Scans only files whose (mtime, size) have changed since
- * the last run; everything else is served from the SQLite cache.
- */
-export async function discoverSessions(options) {
-    // Touch the DB so the schema is ready and connection is cached for this run.
-    getDB();
-    const agents = options?.agent ? [options.agent] : SESSION_AGENTS;
-    const onProgress = options?.onProgress;
-    // Incrementally re-scan changed files across all selected agents in parallel.
-    await Promise.all(agents.map(agent => {
-        switch (agent) {
-            case 'claude': return scanClaudeIncremental(onProgress);
-            case 'codex': return scanCodexIncremental(onProgress);
-            case 'gemini': return scanGeminiIncremental(onProgress);
-            case 'opencode': return scanOpenCodeIncremental();
-            case 'openclaw': return scanOpenClawIncremental();
-        }
-    }));
-    const sessions = querySessions(buildQueryOptions(options, agents, { includeLimit: true }));
-    return sessions;
-}
-/**
- * Count sessions in scope without running an incremental scan. Assumes the DB
- * is already fresh (typically true because `discoverSessions` ran first this
- * turn). Uses the exact same filter shape as the discover query.
- */
-export function countSessionsInScope(options) {
-    const agents = options.agent ? [options.agent] : SESSION_AGENTS;
-    return countSessions(buildQueryOptions(options, agents, { includeLimit: false }));
-}
-/** Translate DiscoverOptions into the QueryOptions shape expected by the DB layer. */
-function buildQueryOptions(options, agents, opts) {
-    const projectQuery = options?.project?.trim();
-    const sinceMs = options?.since ? parseTimeFilter(options.since) : undefined;
-    const untilMs = options?.until ? new Date(options.until).getTime() : undefined;
-    let cwdFilter;
-    let cwdPrefixFilter;
-    if (options?.cwdPrefix) {
-        cwdPrefixFilter = normalizeCwd(options.cwdPrefix);
-    }
-    else if (!options?.all && !projectQuery) {
-        cwdFilter = normalizeCwd(options?.cwd || process.cwd());
-    }
-    return {
-        agent: options?.agent,
-        agents: options?.agent ? undefined : agents,
-        version: options?.version,
-        cwd: cwdFilter,
-        cwdPrefix: cwdPrefixFilter,
-        project: projectQuery,
-        sinceMs,
-        untilMs: Number.isFinite(untilMs) ? untilMs : undefined,
-        limit: opts.includeLimit ? (options?.limit ?? 50) : undefined,
-        excludeTeamOrigin: options?.excludeTeamOrigin,
-        onlyTeamOrigin: options?.onlyTeamOrigin,
-    };
-}
-/** Resolve and canonicalize a working directory path (follows symlinks). */
-function normalizeCwd(cwd) {
-    if (!cwd)
-        return '';
-    const resolved = path.resolve(cwd);
-    return safeRealpathSync(resolved) || resolved;
-}
-/**
- * Resolve a session by full or short ID. Accepts a pre-loaded session list
- * (fast path from discoverSessions) and falls back to a DB lookup for the
- * "I only know the id" case.
- */
-export function resolveSessionById(sessions, idQuery) {
-    const query = idQuery.toLowerCase();
-    const exact = sessions.filter(s => s.id.toLowerCase() === query || s.shortId.toLowerCase() === query);
-    if (exact.length > 0)
-        return exact;
-    return sessions.filter(s => s.id.toLowerCase().startsWith(query) || s.shortId.toLowerCase().startsWith(query));
-}
-// ---------------------------------------------------------------------------
-// Content-index search (FTS5-backed)
-// ---------------------------------------------------------------------------
-/**
- * Run an FTS5 search over the DB and intersect with the given session list,
- * preserving the existing SessionMeta[] contract so sessions.ts is unchanged.
- */
-export function searchContentIndex(sessions, query) {
-    if (!query.trim())
-        return new Map();
-    const hits = ftsSearch(query);
-    if (hits.length === 0)
-        return new Map();
-    const byId = new Map(sessions.map(s => [s.id, s]));
-    const result = new Map();
-    for (const hit of hits) {
-        const session = byId.get(hit.sessionId);
-        if (!session)
-            continue;
-        result.set(hit.sessionId, {
-            ...session,
-            _matchedTerms: hit.matchedTerms,
-            _bm25Score: hit.score,
-        });
-    }
-    return result;
-}
-// ---------------------------------------------------------------------------
-// Incremental scan orchestration
-// ---------------------------------------------------------------------------
-/**
- * For a list of files, stat each, compare to the DB ledger, and return only
- * the ones that need rescanning. One bulk DB query for the whole list.
- */
-function filterChangedFiles(filePaths) {
-    const ledger = getScanStampsForPaths(filePaths);
-    const out = [];
-    for (const filePath of filePaths) {
-        const stat = safeStatSync(filePath);
-        if (!stat)
-            continue;
-        const scan = {
-            fileMtimeMs: Math.floor(stat.mtimeMs),
-            fileSize: stat.size,
-        };
-        const prev = ledger.get(filePath);
-        if (prev && prev.fileMtimeMs === scan.fileMtimeMs && prev.fileSize === scan.fileSize) {
-            continue;
-        }
-        out.push({ filePath, scan });
-    }
-    return out;
-}
-// ---------------------------------------------------------------------------
-// Multi-version directory scanning
-// ---------------------------------------------------------------------------
-/**
- * Collect all directories to scan for an agent's sessions. Deduplicates by
- * realpath to avoid double-counting symlinked version homes.
- */
-export function getAgentSessionDirs(agent, subdir) {
-    const resolved = new Set();
-    const dirs = [];
-    function addDir(dir) {
-        if (!fs.existsSync(dir))
-            return;
-        const real = safeRealpathSync(dir);
-        const key = real || dir;
-        if (resolved.has(key))
-            return;
-        resolved.add(key);
-        dirs.push(dir);
-    }
-    addDir(path.join(HOME, `.${agent}`, subdir));
-    const versionsBase = path.join(AGENTS_DIR, 'versions', agent);
-    if (fs.existsSync(versionsBase)) {
-        try {
-            for (const version of fs.readdirSync(versionsBase)) {
-                addDir(path.join(versionsBase, version, 'home', `.${agent}`, subdir));
-            }
-        }
-        catch { /* dir unreadable */ }
-    }
-    const backupsBase = path.join(AGENTS_DIR, 'backups', agent);
-    if (fs.existsSync(backupsBase)) {
-        try {
-            for (const ts of fs.readdirSync(backupsBase)) {
-                addDir(path.join(backupsBase, ts, subdir));
-            }
-        }
-        catch { /* dir unreadable */ }
-    }
-    return dirs;
-}
-// ---------------------------------------------------------------------------
-// Claude account info
-// ---------------------------------------------------------------------------
-let cachedClaudeAccount;
-/** Read the Claude OAuth account email from .claude.json across all version homes. */
-function getClaudeAccount() {
-    if (cachedClaudeAccount !== undefined)
-        return cachedClaudeAccount || undefined;
-    // Claude's active config lives at $CLAUDE_CONFIG_DIR/.claude.json; for our shim
-    // that's <version>/home/.claude/.claude.json. The home-level .claude.json is a
-    // legacy path used when Claude runs without CLAUDE_CONFIG_DIR set.
-    const candidates = [
-        path.join(HOME, '.claude', '.claude.json'),
-        path.join(HOME, '.claude.json'),
-    ];
-    const versionsBase = path.join(AGENTS_DIR, 'versions', 'claude');
-    if (fs.existsSync(versionsBase)) {
-        try {
-            for (const version of fs.readdirSync(versionsBase)) {
-                candidates.push(path.join(versionsBase, version, 'home', '.claude', '.claude.json'));
-                candidates.push(path.join(versionsBase, version, 'home', '.claude.json'));
-            }
-        }
-        catch { /* versions dir unreadable */ }
-    }
-    for (const candidate of candidates) {
-        try {
-            if (!fs.existsSync(candidate))
-                continue;
-            const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-            const name = data.oauthAccount?.emailAddress || data.oauthAccount?.displayName;
-            if (name) {
-                cachedClaudeAccount = name;
-                return name;
-            }
-        }
-        catch { /* auth file unreadable or malformed */ }
-    }
-    cachedClaudeAccount = '';
-    return undefined;
-}
-// ---------------------------------------------------------------------------
-// Claude
-// ---------------------------------------------------------------------------
-/**
- * Build a map of Claude sessionId -> user-given label from ~/.claude/sessions/*.json.
- * Each JSON has shape { pid, sessionId, cwd, startedAt, name?, ... }. The
- * `name` field only exists if the user ran /rename in that session.
- * For sessionId collisions (re-resume of the same session), prefer the most
- * recent startedAt.
- */
-function buildClaudeLabelMap() {
-    const map = new Map();
-    const dir = path.join(HOME, '.claude', 'sessions');
-    if (!fs.existsSync(dir))
-        return new Map();
-    let files;
-    try {
-        files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
-    }
-    catch {
-        return new Map();
-    }
-    for (const f of files) {
-        try {
-            const data = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
-            if (typeof data.sessionId !== 'string')
-                continue;
-            const name = typeof data.name === 'string' && data.name.trim() ? data.name.trim() : null;
-            const startedAt = typeof data.startedAt === 'number' ? data.startedAt : 0;
-            const existing = map.get(data.sessionId);
-            if (!existing || startedAt > existing.startedAt) {
-                map.set(data.sessionId, { label: name, startedAt });
-            }
-        }
-        catch { /* unreadable session metadata file */ }
-    }
-    const out = new Map();
-    for (const [sid, { label }] of map)
-        out.set(sid, label);
-    return out;
-}
-/** Incrementally re-scan changed Claude session files and upsert into the DB. */
-async function scanClaudeIncremental(onProgress) {
-    const account = getClaudeAccount();
-    const labelMap = buildClaudeLabelMap();
-    const filePaths = [];
-    const seen = new Set();
-    for (const projectsDir of getAgentSessionDirs('claude', 'projects')) {
-        let projectDirs;
-        try {
-            projectDirs = fs.readdirSync(projectsDir);
-        }
-        catch {
-            continue;
-        }
-        for (const dirName of projectDirs) {
-            const dirPath = path.join(projectsDir, dirName);
-            const stat = safeStatSync(dirPath);
-            if (!stat?.isDirectory())
-                continue;
-            let files;
-            try {
-                files = fs.readdirSync(dirPath).filter(f => f.endsWith('.jsonl'));
-            }
-            catch {
-                continue;
-            }
-            for (const file of files) {
-                const sessionId = file.replace('.jsonl', '');
-                if (seen.has(sessionId))
-                    continue;
-                seen.add(sessionId);
-                filePaths.push(path.join(dirPath, file));
-            }
-        }
-    }
-    const changed = filterChangedFiles(filePaths);
-    if (changed.length > 0) {
-        onProgress?.({ agent: 'claude', parsed: 0, total: changed.length });
-        const entries = [];
-        const touched = [];
-        let parsed = 0;
-        for (const { filePath, scan } of changed) {
-            try {
-                const sessionId = path.basename(filePath).replace('.jsonl', '');
-                const label = labelMap.get(sessionId) ?? undefined;
-                const result = await readClaudeMeta(filePath, sessionId, account, label);
-                if (result) {
-                    entries.push({ meta: result.meta, content: result.content, scan });
-                }
-                else {
-                    touched.push({ filePath, scan });
-                }
-            }
-            catch {
-                touched.push({ filePath, scan });
-            }
-            parsed++;
-            onProgress?.({ agent: 'claude', parsed, total: changed.length });
-        }
-        upsertSessionsBatch(entries);
-        recordScans(touched);
-    }
-    // Pick up /rename changes on sessions whose JSONL didn't change.
-    // Only bother for sessions we actually have a Claude row for.
-    if (labelMap.size > 0)
-        syncLabels(labelMap);
-}
-/** Stream-parse a single Claude JSONL file to extract session metadata. */
-async function readClaudeMeta(filePath, sessionId, account, label) {
-    const scan = await scanClaudeSession(filePath);
-    const isTeamOrigin = scan.entrypoint === 'sdk-cli';
-    let meta;
-    if (scan.timestamp) {
-        const cwd = normalizeCwd(scan.cwd || '');
-        meta = {
-            id: sessionId,
-            shortId: sessionId.slice(0, 8),
-            agent: 'claude',
-            timestamp: scan.timestamp,
-            project: cwd ? path.basename(cwd) : undefined,
-            cwd,
-            filePath,
-            gitBranch: scan.gitBranch,
-            version: scan.version,
-            account,
-            topic: scan.topic,
-            label,
-            messageCount: scan.messageCount,
-            tokenCount: scan.tokenCount,
-            isTeamOrigin,
-        };
-    }
-    else {
-        const stat = safeStatSync(filePath);
-        meta = {
-            id: sessionId,
-            shortId: sessionId.slice(0, 8),
-            agent: 'claude',
-            timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
-            filePath,
-            account,
-            label,
-            messageCount: scan.messageCount,
-            tokenCount: scan.tokenCount,
-            topic: scan.topic,
-            isTeamOrigin,
-        };
-    }
-    return { meta, content: scan.contentText || '' };
-}
-// ---------------------------------------------------------------------------
-// Codex account info
-// ---------------------------------------------------------------------------
-let cachedCodexAccount;
-/** Extract the Codex account email from the JWT id_token in auth.json. */
-function getCodexAccount() {
-    if (cachedCodexAccount !== undefined)
-        return cachedCodexAccount || undefined;
-    const candidates = [path.join(HOME, '.codex', 'auth.json')];
-    const versionsBase = path.join(AGENTS_DIR, 'versions', 'codex');
-    if (fs.existsSync(versionsBase)) {
-        try {
-            for (const version of fs.readdirSync(versionsBase)) {
-                candidates.push(path.join(versionsBase, version, 'home', '.codex', 'auth.json'));
-            }
-        }
-        catch { /* versions dir unreadable */ }
-    }
-    for (const candidate of candidates) {
-        try {
-            if (!fs.existsSync(candidate))
-                continue;
-            const data = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-            const idToken = data.tokens?.id_token;
-            if (idToken) {
-                const parts = idToken.split('.');
-                if (parts.length >= 2) {
-                    const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf-8'));
-                    if (payload.email) {
-                        cachedCodexAccount = payload.email;
-                        return payload.email;
-                    }
-                }
-            }
-        }
-        catch { /* auth file or JWT malformed */ }
-    }
-    cachedCodexAccount = '';
-    return undefined;
-}
-// ---------------------------------------------------------------------------
-// Codex
-// ---------------------------------------------------------------------------
-/** Incrementally re-scan changed Codex session files and upsert into the DB. */
-async function scanCodexIncremental(onProgress) {
-    const account = getCodexAccount();
-    const currentVersion = await getCurrentAgentVersion('codex');
-    const filePaths = [];
-    for (const sessionsDir of getAgentSessionDirs('codex', 'sessions')) {
-        // High limit: we only stat files here, parsing is gated by ledger match.
-        for (const fp of walkForFiles(sessionsDir, '.jsonl', 100_000)) {
-            filePaths.push(fp);
-        }
-    }
-    const changed = filterChangedFiles(filePaths);
-    if (changed.length === 0)
-        return;
-    onProgress?.({ agent: 'codex', parsed: 0, total: changed.length });
-    const entries = [];
-    const touched = [];
-    const seen = new Set();
-    let parsed = 0;
-    for (const { filePath, scan } of changed) {
-        try {
-            const result = await readCodexMeta(filePath, account, currentVersion);
-            if (result && !seen.has(result.meta.id)) {
-                seen.add(result.meta.id);
-                entries.push({ meta: result.meta, content: result.content, scan });
-            }
-            else {
-                touched.push({ filePath, scan });
-            }
-        }
-        catch {
-            touched.push({ filePath, scan });
-        }
-        parsed++;
-        onProgress?.({ agent: 'codex', parsed, total: changed.length });
-    }
-    upsertSessionsBatch(entries);
-    recordScans(touched);
-}
-/** Stream-parse a single Codex JSONL file to extract session metadata. */
-async function readCodexMeta(filePath, account, currentVersion) {
-    const scan = await scanCodexSession(filePath);
-    const sessionId = scan.sessionId || '';
-    if (!sessionId)
-        return null;
-    const cwd = normalizeCwd(scan.cwd || '');
-    const meta = {
-        id: sessionId,
-        shortId: sessionId.slice(0, 8),
-        agent: 'codex',
-        timestamp: scan.timestamp || new Date().toISOString(),
-        project: cwd ? path.basename(cwd) : undefined,
-        cwd,
-        filePath,
-        gitBranch: scan.gitBranch,
-        version: resolveSessionVersion('codex', filePath, scan.version, currentVersion),
-        topic: scan.topic,
-        messageCount: scan.messageCount,
-        tokenCount: scan.tokenCount,
-        account,
-    };
-    return { meta, content: scan.contentText || '' };
-}
-// ---------------------------------------------------------------------------
-// Gemini
-// ---------------------------------------------------------------------------
-/** Incrementally re-scan changed Gemini session files and upsert into the DB. */
-async function scanGeminiIncremental(onProgress) {
-    const currentVersion = await getCurrentAgentVersion('gemini');
-    const projectMap = buildGeminiProjectMap();
-    const filePaths = [];
-    for (const tmpDir of getAgentSessionDirs('gemini', 'tmp')) {
-        let hashDirs;
-        try {
-            hashDirs = fs.readdirSync(tmpDir);
-        }
-        catch {
-            continue;
-        }
-        for (const hashDir of hashDirs) {
-            const chatsDir = path.join(tmpDir, hashDir, 'chats');
-            if (!fs.existsSync(chatsDir))
-                continue;
-            let chatFiles;
-            try {
-                chatFiles = fs.readdirSync(chatsDir).filter(f => f.endsWith('.json'));
-            }
-            catch {
-                continue;
-            }
-            for (const file of chatFiles) {
-                filePaths.push({ filePath: path.join(chatsDir, file), hashDir });
-            }
-        }
-    }
-    const changedPaths = filterChangedFiles(filePaths.map(f => f.filePath));
-    const changedByPath = new Map(changedPaths.map(c => [c.filePath, c.scan]));
-    if (changedByPath.size === 0)
-        return;
-    onProgress?.({ agent: 'gemini', parsed: 0, total: changedByPath.size });
-    const entries = [];
-    const touched = [];
-    const seen = new Set();
-    let parsed = 0;
-    for (const { filePath, hashDir } of filePaths) {
-        const scan = changedByPath.get(filePath);
-        if (!scan)
-            continue;
-        try {
-            const result = readGeminiMeta(filePath, hashDir, projectMap, currentVersion);
-            if (result && !seen.has(result.meta.id)) {
-                seen.add(result.meta.id);
-                entries.push({ meta: result.meta, content: result.content, scan });
-            }
-            else {
-                // Gemini file without a sessionId — record scan so we don't re-parse it next run.
-                touched.push({ filePath, scan });
-            }
-        }
-        catch {
-            touched.push({ filePath, scan });
-        }
-        parsed++;
-        onProgress?.({ agent: 'gemini', parsed, total: changedByPath.size });
-    }
-    upsertSessionsBatch(entries);
-    recordScans(touched);
-}
-/** Parse a single Gemini JSON session file to extract session metadata. */
-function readGeminiMeta(filePath, hashDir, projectMap, currentVersion) {
-    let session;
-    try {
-        session = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-    const sessionId = typeof session.sessionId === 'string' ? session.sessionId : '';
-    const startTime = typeof session.startTime === 'string' ? session.startTime : '';
-    const projectHash = typeof session.projectHash === 'string' ? session.projectHash : '';
-    const embeddedVersion = typeof session.version === 'string'
-        ? session.version
-        : typeof session.cliVersion === 'string'
-            ? session.cliVersion
-            : undefined;
-    if (!sessionId)
-        return null;
-    const projectInfo = projectMap.get(projectHash || hashDir);
-    const project = projectInfo?.name || hashDir.slice(0, 12);
-    const cwd = projectInfo?.path ? normalizeCwd(projectInfo.path) : undefined;
-    const stat = safeStatSync(filePath);
-    const messages = Array.isArray(session.messages) ? session.messages : [];
-    let topic;
-    let messageCount = 0;
-    let tokenCount = 0;
-    let sawTokenCount = false;
-    const userTexts = [];
-    for (const message of messages) {
-        if (message.type === 'user') {
-            const text = extractGeminiMessageText(message.content);
-            if (text) {
-                messageCount++;
-                userTexts.push(text);
-                if (!topic)
-                    topic = extractSessionTopic(text);
-            }
-        }
-        else if (message.type === 'gemini') {
-            if (extractGeminiMessageText(message.content)) {
-                messageCount++;
-            }
-        }
-        const total = getGeminiTokenCount(message.tokens);
-        if (total !== null) {
-            tokenCount += total;
-            sawTokenCount = true;
-        }
-    }
-    const meta = {
-        id: sessionId,
-        shortId: sessionId.slice(0, 8),
-        agent: 'gemini',
-        timestamp: startTime || (stat ? stat.mtime.toISOString() : new Date().toISOString()),
-        project,
-        cwd,
-        filePath,
-        version: resolveSessionVersion('gemini', filePath, embeddedVersion, currentVersion),
-        topic,
-        messageCount,
-        tokenCount: sawTokenCount ? tokenCount : undefined,
-    };
-    return { meta, content: userTexts.join('\n') };
-}
-/** Build a hash-to-project mapping from Gemini's projects.json and history directories. */
-function buildGeminiProjectMap() {
-    const map = new Map();
-    const projectsJsonPath = path.join(HOME, '.gemini', 'projects.json');
-    if (fs.existsSync(projectsJsonPath)) {
-        try {
-            const data = JSON.parse(fs.readFileSync(projectsJsonPath, 'utf-8'));
-            const projects = data.projects;
-            if (typeof projects === 'object' && projects !== null) {
-                if (Array.isArray(projects)) {
-                    for (const p of projects) {
-                        if (typeof p === 'string') {
-                            const hash = sha256(p);
-                            map.set(hash, { name: path.basename(p), path: p });
-                            map.set(p, { name: path.basename(p), path: p });
-                        }
-                    }
-                }
-                else {
-                    for (const [p, name] of Object.entries(projects)) {
-                        const hash = sha256(p);
-                        map.set(hash, { name: String(name), path: p });
-                    }
-                }
-            }
-        }
-        catch { /* projects.json missing or malformed */ }
-    }
-    const historyDir = path.join(HOME, '.gemini', 'history');
-    if (fs.existsSync(historyDir)) {
-        try {
-            for (const name of fs.readdirSync(historyDir)) {
-                const rootFile = path.join(historyDir, name, '.project_root');
-                if (fs.existsSync(rootFile)) {
-                    try {
-                        const projectPath = fs.readFileSync(rootFile, 'utf-8').trim();
-                        if (projectPath) {
-                            const hash = sha256(projectPath);
-                            map.set(hash, { name, path: projectPath });
-                        }
-                    }
-                    catch { /* history entry unreadable */ }
-                }
-            }
-        }
-        catch { /* history entry unreadable */ }
-    }
-    return map;
-}
-// ---------------------------------------------------------------------------
-// OpenCode
-// ---------------------------------------------------------------------------
-const OPENCODE_DB = path.join(HOME, '.local', 'share', 'opencode', 'opencode.db');
-let cachedOpenCodeAccount;
-/** Query the active OpenCode account email from its SQLite database. */
-function getOpenCodeAccount() {
-    if (cachedOpenCodeAccount !== undefined)
-        return cachedOpenCodeAccount || undefined;
-    try {
-        if (fs.existsSync(OPENCODE_DB)) {
-            const out = execSync(`sqlite3 "${OPENCODE_DB}" "SELECT email FROM control_account WHERE active=1 LIMIT 1;"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-            if (out) {
-                cachedOpenCodeAccount = out;
-                return out;
-            }
-        }
-    }
-    catch { /* sqlite3 unavailable or DB locked */ }
-    cachedOpenCodeAccount = '';
-    return undefined;
-}
-/** Scan OpenCode sessions from its SQLite database when the DB file has changed. */
-async function scanOpenCodeIncremental() {
-    if (!fs.existsSync(OPENCODE_DB))
-        return;
-    const stat = safeStatSync(OPENCODE_DB);
-    if (!stat)
-        return;
-    // OpenCode is one big DB; we use its mtime/size as the ledger for the
-    // entire fleet of OpenCode sessions.
-    const currentScan = {
-        fileMtimeMs: Math.floor(stat.mtimeMs),
-        fileSize: stat.size,
-    };
-    const prev = getScanStampByPath(OPENCODE_DB);
-    if (prev && prev.fileMtimeMs === currentScan.fileMtimeMs && prev.fileSize === currentScan.fileSize) {
-        return;
-    }
-    const account = getOpenCodeAccount();
-    const currentVersion = await getCurrentAgentVersion('opencode');
-    try {
-        const query = `
-      SELECT
-        s.id,
-        s.title,
-        s.directory,
-        s.version,
-        s.time_created,
-        COALESCE(stats.message_count, 0),
-        stats.token_count,
-        COALESCE(stats.has_token_data, 0)
-      FROM session s
-      LEFT JOIN (
-        SELECT
-          session_id,
-          COUNT(*) AS message_count,
-          SUM(
-            COALESCE(json_extract(data, '$.tokens.input'), 0) +
-            COALESCE(json_extract(data, '$.tokens.output'), 0) +
-            COALESCE(json_extract(data, '$.tokens.reasoning'), 0) +
-            COALESCE(json_extract(data, '$.tokens.cache.read'), 0) +
-            COALESCE(json_extract(data, '$.tokens.cache.write'), 0)
-          ) AS token_count,
-          MAX(CASE WHEN json_type(data, '$.tokens') IS NOT NULL THEN 1 ELSE 0 END) AS has_token_data
-        FROM message
-        GROUP BY session_id
-      ) stats ON stats.session_id = s.id
-      WHERE s.parent_id IS NULL
-      ORDER BY time_created DESC
-      LIMIT 1000;
-    `.replace(/\n/g, ' ');
-        const out = execSync(`sqlite3 -separator '|||' "${OPENCODE_DB}"`, { encoding: 'utf-8', input: query, stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000 });
-        const entries = [];
-        for (const line of out.split('\n')) {
-            if (!line.trim())
-                continue;
-            const [id, title, directory, version, timeCreatedStr, messageCountStr, tokenCountStr, hasTokenDataStr] = line.split('|||');
-            if (!id)
-                continue;
-            const timeCreated = parseInt(timeCreatedStr, 10);
-            const messageCount = parseInt(messageCountStr, 10);
-            const tokenCount = parseInt(tokenCountStr, 10);
-            const hasTokenData = hasTokenDataStr === '1';
-            const timestamp = isNaN(timeCreated) ? new Date().toISOString() : new Date(timeCreated).toISOString();
-            const topic = title || undefined;
-            const meta = {
-                id,
-                shortId: id.replace(/^ses_/, '').slice(0, 8),
-                agent: 'opencode',
-                timestamp,
-                project: directory ? path.basename(directory) : undefined,
-                cwd: directory ? normalizeCwd(directory) : undefined,
-                filePath: `${OPENCODE_DB}#${id}`,
-                version: resolveSessionVersion('opencode', OPENCODE_DB, version || undefined, currentVersion),
-                account,
-                topic,
-                messageCount: Number.isNaN(messageCount) ? undefined : messageCount,
-                tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
-            };
-            entries.push({ meta, content: topic || '', scan: currentScan });
-        }
-        upsertSessionsBatch(entries);
-        // Stamp the OpenCode DB itself so we can short-circuit on the next run.
-        recordScans([{ filePath: OPENCODE_DB, scan: currentScan }]);
-    }
-    catch (err) {
-        if (process.stderr.isTTY) {
-            console.error(`Warning: Could not query OpenCode sessions: ${err.message}`);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// OpenClaw
-// ---------------------------------------------------------------------------
-/** Scan active OpenClaw channels and cron jobs via the openclaw CLI. */
-async function scanOpenClawIncremental() {
-    // Check if openclaw is installed — silently skip if not.
-    try {
-        execSync('which openclaw', { stdio: 'ignore' });
-    }
-    catch {
-        return;
-    }
-    // TTL cache: skip subprocess calls if we scanned recently. Stored in the
-    // meta table so we skip even when no channels/cron exist to produce rows.
-    const db = getDB();
-    const row = db.prepare(`SELECT value FROM meta WHERE key = 'openclaw_last_scan_ms'`).get();
-    const lastScanMs = row ? parseInt(row.value, 10) : 0;
-    if (lastScanMs && Date.now() - lastScanMs < OPENCLAW_TTL_MS) {
-        return;
-    }
-    const currentVersion = await getCurrentAgentVersion('openclaw');
-    const now = Date.now();
-    const scan = { fileMtimeMs: now, fileSize: 0 };
-    const entries = [];
-    try {
-        const output = execSync('openclaw channels status', {
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        for (const line of output.split('\n')) {
-            const match = line.match(/^-\s+\w+\s+(\S+)\s+\((\w+)\):\s*(.+)/);
-            if (!match)
-                continue;
-            const [, agentId, name, statusStr] = match;
-            if (!statusStr.includes('running'))
-                continue;
-            entries.push({
-                meta: {
-                    id: `openclaw-${agentId}`,
-                    shortId: agentId.slice(0, 8),
-                    agent: 'openclaw',
-                    timestamp: new Date().toISOString(),
-                    project: name,
-                    cwd: getOpenClawSessionCwd(agentId),
-                    version: currentVersion,
-                    filePath: '',
-                },
-                content: `${name} ${agentId}`,
-                scan,
-            });
-        }
-    }
-    catch {
-        /* channels command failed */
-    }
-    try {
-        const output = execSync('openclaw cron list', {
-            encoding: 'utf-8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        });
-        const lines = output.split('\n');
-        for (let i = 1; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (!line)
-                continue;
-            const headMatch = line.match(/^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s+(\S+)/);
-            if (!headMatch)
-                continue;
-            const jobId = headMatch[1];
-            const jobName = headMatch[2];
-            const rest = line.slice(headMatch[0].length).trim();
-            const cols = rest.split(/\s{2,}/);
-            const agentId = cols[4] || '';
-            entries.push({
-                meta: {
-                    id: `openclaw-cron-${jobId}`,
-                    shortId: jobId.slice(0, 8),
-                    agent: 'openclaw',
-                    timestamp: new Date().toISOString(),
-                    project: `${jobName} (${agentId || 'unknown'})`,
-                    cwd: getOpenClawSessionCwd(agentId),
-                    version: currentVersion,
-                    filePath: '',
-                },
-                content: `${jobName} ${agentId}`,
-                scan,
-            });
-        }
-    }
-    catch {
-        /* cron command failed */
-    }
-    upsertSessionsBatch(entries);
-    db.prepare(`INSERT OR REPLACE INTO meta (key, value) VALUES ('openclaw_last_scan_ms', ?)`).run(String(Date.now()));
-}
-/** Stream a Claude JSONL file and extract scan-level metadata (timestamp, cwd, topic, tokens). */
-async function scanClaudeSession(filePath) {
-    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let timestamp;
-    let cwd;
-    let gitBranch;
-    let version;
-    let topic;
-    let entrypoint;
-    let messageCount = 0;
-    let tokenCount = 0;
-    let sawTokenCount = false;
-    const seenAssistantIds = new Set();
-    const userTexts = [];
-    try {
-        for await (const line of rl) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            // entrypoint ships on the first envelope event (attachment/user/assistant)
-            // and is the clean structural signal for "was this a team spawn?"
-            if (!entrypoint && typeof parsed.entrypoint === 'string') {
-                entrypoint = parsed.entrypoint;
-            }
-            if (!timestamp && (parsed.type === 'user' || parsed.type === 'assistant') && parsed.timestamp) {
-                timestamp = parsed.timestamp;
-                cwd = parsed.cwd || '';
-                gitBranch = parsed.gitBranch || undefined;
-                version = parsed.version || undefined;
-            }
-            if (parsed.type === 'user') {
-                const text = extractClaudeUserText(parsed);
-                if (text) {
-                    messageCount++;
-                    userTexts.push(text);
-                    if (!topic)
-                        topic = extractSessionTopic(text);
-                }
-                continue;
-            }
-            if (parsed.type !== 'assistant')
-                continue;
-            const assistantId = typeof parsed.message?.id === 'string'
-                ? parsed.message.id
-                : typeof parsed.uuid === 'string'
-                    ? parsed.uuid
-                    : undefined;
-            const logicalId = assistantId || `${parsed.timestamp || ''}:${seenAssistantIds.size}`;
-            if (seenAssistantIds.has(logicalId))
-                continue;
-            seenAssistantIds.add(logicalId);
-            messageCount++;
-            const usage = getClaudeUsageTotal(parsed.message?.usage || parsed.usage);
-            if (usage !== null) {
-                tokenCount += usage;
-                sawTokenCount = true;
-            }
-        }
-    }
-    finally {
-        rl.close();
-        stream.destroy();
-    }
-    return {
-        timestamp,
-        cwd,
-        gitBranch,
-        version,
-        topic,
-        entrypoint,
-        messageCount,
-        tokenCount: sawTokenCount ? tokenCount : undefined,
-        contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
-    };
-}
-/** Stream a Codex JSONL file and extract scan-level metadata (session ID, cwd, topic, tokens). */
-async function scanCodexSession(filePath) {
-    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
-    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-    let sessionId;
-    let timestamp;
-    let cwd;
-    let gitBranch;
-    let version;
-    let topic;
-    let messageCount = 0;
-    let tokenCount;
-    const userTexts = [];
-    try {
-        for await (const line of rl) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (parsed.type === 'session_meta') {
-                const payload = parsed.payload || {};
-                sessionId = payload.id || sessionId;
-                timestamp = payload.timestamp || parsed.timestamp || timestamp;
-                cwd = payload.cwd || cwd;
-                gitBranch = payload.git?.branch || gitBranch;
-                version = payload.cli_version || payload.version || version;
-                continue;
-            }
-            if (parsed.type === 'response_item' && parsed.payload?.type === 'message') {
-                const role = parsed.payload.role === 'user' || parsed.payload.role === 'developer'
-                    ? 'user'
-                    : 'assistant';
-                const text = extractCodexMessageText(parsed.payload.content, role);
-                if (!text)
-                    continue;
-                messageCount++;
-                if (role === 'user') {
-                    userTexts.push(text);
-                    if (!topic)
-                        topic = extractSessionTopic(text);
-                }
-                continue;
-            }
-            if (parsed.type === 'event_msg' && parsed.payload?.type === 'token_count') {
-                const total = getCodexTokenCount(parsed.payload.info?.total_token_usage);
-                if (total !== null)
-                    tokenCount = total;
-            }
-        }
-    }
-    finally {
-        rl.close();
-        stream.destroy();
-    }
-    return {
-        sessionId,
-        timestamp,
-        cwd,
-        gitBranch,
-        version,
-        topic,
-        messageCount,
-        tokenCount,
-        contentText: userTexts.length > 0 ? userTexts.join('\n') : undefined,
-    };
-}
-/** Resolve the working directory for an OpenClaw agent from its workspace config. */
-function getOpenClawSessionCwd(agentId) {
-    const workspace = agentId ? getOpenClawWorkspaceMap().get(agentId) : undefined;
-    if (workspace)
-        return workspace;
-    const configDir = AGENTS.openclaw.configDir;
-    return safeRealpathSync(configDir) || configDir;
-}
-/** Build a cached map of OpenClaw agent ID to workspace path from openclaw.json. */
-function getOpenClawWorkspaceMap() {
-    if (cachedOpenClawWorkspaces)
-        return cachedOpenClawWorkspaces;
-    const workspaces = new Map();
-    const configPath = path.join(AGENTS.openclaw.configDir, 'openclaw.json');
-    if (!fs.existsSync(configPath)) {
-        cachedOpenClawWorkspaces = workspaces;
-        return workspaces;
-    }
-    try {
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        for (const agent of config.agents?.list || []) {
-            if (!agent.id || !agent.workspace)
-                continue;
-            workspaces.set(agent.id, safeRealpathSync(agent.workspace) || agent.workspace);
-        }
-    }
-    catch {
-        // Ignore invalid OpenClaw config and fall back to ~/.openclaw.
-    }
-    cachedOpenClawWorkspaces = workspaces;
-    return workspaces;
-}
-// ---------------------------------------------------------------------------
-// Utilities
-// ---------------------------------------------------------------------------
-/** Read up to maxLines non-empty lines from the beginning of a file. */
-export function readFirstLines(filePath, maxLines) {
-    return new Promise((resolve) => {
-        const lines = [];
-        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
-        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-        rl.on('line', (line) => {
-            if (line.trim()) {
-                lines.push(line);
-            }
-            if (lines.length >= maxLines) {
-                rl.close();
-                stream.destroy();
-            }
-        });
-        rl.on('close', () => resolve(lines));
-        rl.on('error', () => resolve(lines));
-    });
-}
-/**
- * Walk a directory recursively for files with a given extension.
- */
-export function walkForFiles(dir, ext, limit) {
-    const results = [];
-    function walk(d, depth) {
-        if (depth > 5)
-            return;
-        let entries;
-        try {
-            entries = fs.readdirSync(d);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = path.join(d, entry);
-            const stat = safeStatSync(full);
-            if (!stat)
-                continue;
-            if (stat.isDirectory()) {
-                walk(full, depth + 1);
-            }
-            else if (entry.endsWith(ext)) {
-                results.push({ path: full, mtime: stat.mtimeMs });
-            }
-        }
-    }
-    walk(dir, 0);
-    results.sort((a, b) => b.mtime - a.mtime);
-    return results.slice(0, limit).map(r => r.path);
-}
-/** Compute the SHA-256 hex digest of a string. */
-function sha256(input) {
-    return crypto.createHash('sha256').update(input).digest('hex');
-}
-/** Stat a path, returning null on any error. */
-function safeStatSync(p) {
-    try {
-        return fs.statSync(p);
-    }
-    catch {
-        return null;
-    }
-}
-/** Resolve a path to its real path, returning null on any error. */
-function safeRealpathSync(p) {
-    try {
-        return fs.realpathSync(p);
-    }
-    catch {
-        return null;
-    }
-}
-/** Extract meaningful user text from a Claude JSONL user event, skipping meta and local-command messages. */
-function extractClaudeUserText(parsed) {
-    if (parsed.isMeta === true)
-        return undefined;
-    const content = parsed.message?.content;
-    if (typeof content === 'string') {
-        const text = content.trim();
-        return isLocalCommandMessage(text) ? undefined : text || undefined;
-    }
-    if (!Array.isArray(content))
-        return undefined;
-    const text = content
-        .filter((block) => block.type === 'text')
-        .map((block) => String(block.text || '').trim())
-        .find((value) => value && !value.startsWith('[Request interrupted'));
-    if (!text || isLocalCommandMessage(text))
-        return undefined;
-    return text;
-}
-/** Check whether a message is a local-command wrapper rather than real user input. */
-function isLocalCommandMessage(text) {
-    return /<local-command-caveat>|<bash-(input|stdout|stderr)>/i.test(text);
-}
-/** Sum all token usage fields from a Claude assistant message's usage object. */
-function getClaudeUsageTotal(usage) {
-    if (!usage || typeof usage !== 'object')
-        return null;
-    return sumKnownNumbers([
-        usage.input_tokens,
-        usage.output_tokens,
-        usage.cache_creation_input_tokens,
-        usage.cache_read_input_tokens,
-    ]);
-}
-/** Extract text from Codex message content blocks, filtering out system instructions for user messages. */
-function extractCodexMessageText(contentBlocks, role) {
-    if (!Array.isArray(contentBlocks))
-        return undefined;
-    const matches = role === 'user'
-        ? contentBlocks.filter((block) => block.type === 'input_text')
-        : contentBlocks.filter((block) => block.type === 'output_text');
-    const text = matches
-        .map((block) => String(block.text || '').trim())
-        .find((value) => {
-        if (!value)
-            return false;
-        if (role === 'user' && (value.length >= 2000 || value.includes('<permissions instructions>') || value.startsWith('# AGENTS.md instructions'))) {
-            return false;
-        }
-        return true;
-    });
-    return text || undefined;
-}
-/** Trim and normalize a version string, returning undefined for empty values. */
-function normalizeVersion(version) {
-    const trimmed = version?.trim();
-    return trimmed ? trimmed : undefined;
-}
-/** Extract the version number from a managed ~/.agents/versions/<agent>/<version>/... path. */
-function extractVersionFromManagedPath(agent, sourcePath) {
-    if (!sourcePath)
-        return undefined;
-    const candidates = [sourcePath, safeRealpathSync(sourcePath) || ''];
-    const marker = `/.agents/versions/${agent}/`;
-    for (const candidate of candidates) {
-        if (!candidate)
-            continue;
-        const normalized = candidate.split(path.sep).join('/');
-        const start = normalized.indexOf(marker);
-        if (start === -1)
-            continue;
-        const version = normalized.slice(start + marker.length).split('/')[0];
-        if (version)
-            return version;
-    }
-    return undefined;
-}
-/** Resolve the current version of an agent CLI (symlink version or live CLI output, cached). */
-async function getCurrentAgentVersion(agent) {
-    const cached = cachedAgentVersions.get(agent);
-    if (cached)
-        return cached;
-    const promise = (async () => {
-        const symlinkVersion = normalizeVersion(getConfigSymlinkVersion(agent));
-        if (symlinkVersion)
-            return symlinkVersion;
-        return normalizeVersion(await getCliVersion(agent));
-    })();
-    cachedAgentVersions.set(agent, promise);
-    return promise;
-}
-/** Resolve a session's version: embedded in file > extracted from managed path > current CLI version. */
-function resolveSessionVersion(agent, sourcePath, embeddedVersion, currentVersion) {
-    return normalizeVersion(embeddedVersion)
-        || extractVersionFromManagedPath(agent, sourcePath)
-        || normalizeVersion(currentVersion);
-}
-/** Sum all token usage fields from a Codex total_token_usage object. */
-function getCodexTokenCount(totalTokenUsage) {
-    if (!totalTokenUsage || typeof totalTokenUsage !== 'object')
-        return null;
-    return sumKnownNumbers([
-        totalTokenUsage.input_tokens,
-        totalTokenUsage.cached_input_tokens,
-        totalTokenUsage.output_tokens,
-        totalTokenUsage.reasoning_output_tokens,
-    ]);
-}
-/** Extract text from a Gemini message content field (string or array of parts). */
-function extractGeminiMessageText(content) {
-    if (typeof content === 'string')
-        return content.trim();
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            if (typeof part === 'string')
-                return part;
-            if (typeof part?.text === 'string')
-                return part.text;
-            return '';
-        })
-            .join('\n')
-            .trim();
-    }
-    return '';
-}
-/** Extract the total token count from a Gemini message's tokens object. */
-function getGeminiTokenCount(tokens) {
-    if (!tokens || typeof tokens !== 'object')
-        return null;
-    if (typeof tokens.total === 'number')
-        return tokens.total;
-    return sumKnownNumbers([
-        tokens.input,
-        tokens.output,
-        tokens.cached,
-        tokens.thoughts,
-        tokens.tool,
-    ]);
-}
-/** Sum all numeric values in an array, returning null if none are valid numbers. */
-function sumKnownNumbers(values) {
-    let total = 0;
-    let found = false;
-    for (const value of values) {
-        if (typeof value !== 'number' || Number.isNaN(value))
-            continue;
-        total += value;
-        found = true;
-    }
-    return found ? total : null;
-}
-// ---------------------------------------------------------------------------
-// Time range parsing
-// ---------------------------------------------------------------------------
-/** Parse a time filter string (relative like '7d' or ISO timestamp) into epoch milliseconds. */
-export function parseTimeFilter(input) {
-    const relativeMatch = input.match(/^(\d+)([mhdw])$/i);
-    if (relativeMatch) {
-        const value = parseInt(relativeMatch[1], 10);
-        const unit = relativeMatch[2].toLowerCase();
-        if (unit === 'm')
-            return Date.now() - value * 60_000;
-        if (unit === 'h')
-            return Date.now() - value * 3_600_000;
-        if (unit === 'd')
-            return Date.now() - value * 86_400_000;
-        if (unit === 'w')
-            return Date.now() - value * 7 * 86_400_000;
-    }
-    const ts = new Date(input).getTime();
-    return Number.isNaN(ts) ? 0 : ts;
-}
-//# sourceMappingURL=discover.js.map