hacklab 0.0.2 → 0.3.1

package/dist/sync.js

@@ -0,0 +1,805 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { loadConfig } from './config.js';
+import { dim } from './ui.js';
+export const LOGIN_EXPIRED_MESSAGE = 'login expired. run hacklab login again';
+const HOURLY_WINDOW_DAYS = 90;
+const modelAccumulator = new Map();
+const hourlyAccumulator = new Map();
+const _cursorScanStatus = {
+    value: { source: 'none' },
+};
+function buildApiUrl(session, path) {
+    return `${session.appUrl.replace(/\/$/, '')}${path}`;
+}
+function isLoopbackAppUrl(value) {
+    try {
+        const url = new URL(value);
+        return (url.hostname === 'localhost' ||
+            url.hostname === '127.0.0.1' ||
+            url.hostname === '::1');
+    }
+    catch {
+        return false;
+    }
+}
+function getCauseMessage(err) {
+    if (!(err instanceof Error))
+        return null;
+    const cause = err.cause;
+    if (cause instanceof Error)
+        return cause.message;
+    if (typeof cause === 'object' && cause !== null && 'message' in cause) {
+        const message = cause.message;
+        return typeof message === 'string' ? message : null;
+    }
+    return err.message === 'fetch failed' ? null : err.message;
+}
+function formatFetchFailure(session, err) {
+    const app = session.appUrl.replace(/\/$/, '');
+    const cause = getCauseMessage(err);
+    const details = cause ? ` (${cause})` : '';
+    if (isLoopbackAppUrl(app)) {
+        return `could not reach ${app}${details}. start the web app or run ${dim(`HACKLAB_APP_URL=https://staging.hacklab.so hacklab login`)}`;
+    }
+    return `could not reach ${app}${details}. check ${dim('HACKLAB_APP_URL')} or run ${dim('hacklab login')} again`;
+}
+export async function fetchApi(session, path, init) {
+    try {
+        return await fetch(buildApiUrl(session, path), init);
+    }
+    catch (err) {
+        throw new Error(formatFetchFailure(session, err));
+    }
+}
+export async function checkSession(session) {
+    let res;
+    try {
+        res = await fetchApi(session, '/api/xp', {
+            headers: { Authorization: `Bearer ${session.token}` },
+        });
+    }
+    catch (err) {
+        return {
+            status: 'failed',
+            message: err instanceof Error ? err.message : String(err),
+        };
+    }
+    if (res.status === 401)
+        return { status: 'unauthorized' };
+    if (res.status === 404) {
+        const contentType = res.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json'))
+            return { status: 'ok' };
+        return {
+            status: 'failed',
+            message: `Hacklab API not found at ${session.appUrl.replace(/\/$/, '')}. check ${dim('HACKLAB_APP_URL')} or run ${dim('hacklab login')} again`,
+        };
+    }
+    if (res.status >= 500) {
+        return {
+            status: 'failed',
+            message: `Hacklab API failed at ${session.appUrl.replace(/\/$/, '')} (${res.status}). try again later`,
+        };
+    }
+    return { status: 'ok' };
+}
+function hourlyCutoff() {
+    const d = new Date();
+    d.setUTCDate(d.getUTCDate() - HOURLY_WINDOW_DAYS);
+    return d.toISOString().slice(0, 10);
+}
+function addHourly(date, hour, tool, model, tokens, cutoff, messages = 1) {
+    if (date < cutoff)
+        return;
+    const key = `${date}|${hour}|${tool}|${model ?? ''}`;
+    const existing = hourlyAccumulator.get(key);
+    if (existing) {
+        existing.tokens += tokens;
+        existing.messages += messages;
+    }
+    else {
+        hourlyAccumulator.set(key, { tokens, messages });
+    }
+}
+function flushHourly() {
+    const out = [];
+    for (const [key, { tokens, messages }] of hourlyAccumulator.entries()) {
+        const [date, hourStr, tool, model] = key.split('|');
+        if (!date || hourStr === undefined || !tool)
+            continue;
+        out.push({
+            date,
+            hour: Number(hourStr),
+            tool,
+            model: model || undefined,
+            tokens,
+            messages,
+        });
+    }
+    return out;
+}
+function addToDaily(map, date, model, tokens, messages) {
+    const key = `${date}|${model}`;
+    const existing = map.get(key);
+    if (existing) {
+        existing.tokens += tokens;
+        existing.messages += messages;
+    }
+    else {
+        map.set(key, { tokens, messages });
+    }
+}
+function dailyMapToEntries(map, tool) {
+    return Array.from(map.entries()).map(([key, { tokens, messages }]) => {
+        const [date, model] = key.split('|');
+        return {
+            date: date ?? '',
+            tool,
+            tokens,
+            messages,
+            model: model || undefined,
+        };
+    });
+}
+function toDateStr(ts) {
+    const v = typeof ts === 'string' && /^\d+$/.test(ts) ? Number(ts) : ts;
+    const d = new Date(v);
+    return d.toISOString().slice(0, 10);
+}
+export function formatTokens(n) {
+    if (n >= 1_000_000_000)
+        return `${(n / 1_000_000_000).toFixed(1)}B`;
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(0)}K`;
+    return String(n);
+}
+export function formatBytes(n) {
+    if (n >= 1_073_741_824)
+        return `${(n / 1_073_741_824).toFixed(1)}GB`;
+    if (n >= 1_048_576)
+        return `${(n / 1_048_576).toFixed(1)}MB`;
+    if (n >= 1_024)
+        return `${(n / 1_024).toFixed(0)}KB`;
+    return `${n}B`;
+}
+async function findFiles(dir, ext) {
+    const results = [];
+    async function walk(current) {
+        try {
+            const entries = await readdir(current, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = join(current, entry.name);
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                }
+                else if (entry.name.endsWith(ext)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // skip unreadable directories
+        }
+    }
+    await walk(dir);
+    return results;
+}
+async function scanClaudeCode() {
+    const claudeDir = join(homedir(), '.claude', 'projects');
+    try {
+        await stat(claudeDir);
+    }
+    catch {
+        return [];
+    }
+    const files = await findFiles(claudeDir, '.jsonl');
+    const dailyByModel = new Map();
+    const cutoff = hourlyCutoff();
+    for (const filePath of files) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            for (const line of content.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    const usage = parsed.message?.usage ?? parsed.usage ?? null;
+                    if (!usage)
+                        continue;
+                    const tokens = (usage.input_tokens ?? 0) +
+                        (usage.output_tokens ?? 0) +
+                        (usage.cache_creation_input_tokens ?? 0) +
+                        (usage.cache_read_input_tokens ?? 0);
+                    if (tokens <= 0)
+                        continue;
+                    let date;
+                    let hour = null;
+                    if (parsed.timestamp) {
+                        const d = new Date(typeof parsed.timestamp === 'string' &&
+                            /^\d+$/.test(parsed.timestamp)
+                            ? Number(parsed.timestamp)
+                            : parsed.timestamp);
+                        date = toDateStr(d);
+                        hour = d.getHours();
+                    }
+                    else {
+                        const s = await stat(filePath);
+                        date = toDateStr(s.mtime);
+                    }
+                    const model = parsed.message?.model ?? '';
+                    addToDaily(dailyByModel, date, model, tokens, 1);
+                    if (model) {
+                        modelAccumulator.set(model, (modelAccumulator.get(model) ?? 0) + tokens);
+                    }
+                    if (hour !== null) {
+                        addHourly(date, hour, 'claude_code', model, tokens, cutoff, 1);
+                    }
+                }
+                catch {
+                    // skip malformed lines
+                }
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return dailyMapToEntries(dailyByModel, 'claude_code');
+}
+async function scanCodex() {
+    const codexDir = join(homedir(), '.codex', 'sessions');
+    try {
+        await stat(codexDir);
+    }
+    catch {
+        return [];
+    }
+    const files = await findFiles(codexDir, '.jsonl');
+    const dailyByModel = new Map();
+    for (const filePath of files) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            const relPath = filePath.slice(codexDir.length + 1);
+            const parts = relPath.split('/');
+            let date;
+            if (parts.length >= 3) {
+                date = `${parts[0]}-${parts[1]?.padStart(2, '0')}-${parts[2]?.padStart(2, '0')}`;
+            }
+            else {
+                const s = await stat(filePath);
+                date = toDateStr(s.mtime);
+            }
+            let maxTotal = 0;
+            let fileModel = '';
+            for (const line of content.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    if (parsed.payload?.model)
+                        fileModel = parsed.payload.model;
+                    const usage = parsed.payload?.info?.total_token_usage;
+                    if (usage) {
+                        const t = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
+                        if (t > maxTotal)
+                            maxTotal = t;
+                    }
+                }
+                catch {
+                    // skip
+                }
+            }
+            if (maxTotal > 0) {
+                addToDaily(dailyByModel, date, fileModel, maxTotal, 1);
+                if (fileModel) {
+                    modelAccumulator.set(fileModel, (modelAccumulator.get(fileModel) ?? 0) + maxTotal);
+                }
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    return dailyMapToEntries(dailyByModel, 'codex');
+}
+async function scanHermes() {
+    const dbPath = join(homedir(), '.hermes', 'state.db');
+    try {
+        await stat(dbPath);
+    }
+    catch {
+        return [];
+    }
+    const { execSync } = await import('node:child_process');
+    const dailyByModel = new Map();
+    const cutoff = hourlyCutoff();
+    try {
+        const raw = execSync(`sqlite3 -readonly "${dbPath}" "select s.id, coalesce(s.model,'') as model, s.started_at, s.input_tokens, s.output_tokens, s.cache_read_tokens, s.cache_write_tokens, s.reasoning_tokens, coalesce((select count(*) from messages m where m.session_id = s.id and m.role = 'assistant'), 0) as msg_count from sessions s"`, { encoding: 'utf8', timeout: 10000 }).trim();
+        if (!raw)
+            return [];
+        for (const row of raw.split('\n')) {
+            const [_id, model, startedAt, inputTokens, outputTokens, cacheRead, cacheWrite, reasoning, msgCount,] = row.split('|');
+            const tokens = (Number.parseInt(inputTokens ?? '0', 10) || 0) +
+                (Number.parseInt(outputTokens ?? '0', 10) || 0) +
+                (Number.parseInt(cacheRead ?? '0', 10) || 0) +
+                (Number.parseInt(cacheWrite ?? '0', 10) || 0) +
+                (Number.parseInt(reasoning ?? '0', 10) || 0);
+            if (tokens <= 0)
+                continue;
+            const tsSec = Number.parseFloat(startedAt ?? '0');
+            if (!Number.isFinite(tsSec) || tsSec <= 0)
+                continue;
+            const tsMs = Math.round(tsSec * 1000);
+            const d = new Date(tsMs);
+            const date = toDateStr(d);
+            const hour = d.getHours();
+            const m = (model ?? '').trim();
+            const messages = Number.parseInt(msgCount ?? '0', 10) || 1;
+            addToDaily(dailyByModel, date, m, tokens, messages);
+            if (m) {
+                modelAccumulator.set(m, (modelAccumulator.get(m) ?? 0) + tokens);
+            }
+            addHourly(date, hour, 'hermes', m, tokens, cutoff, messages);
+        }
+    }
+    catch {
+        return [];
+    }
+    return dailyMapToEntries(dailyByModel, 'hermes');
+}
+async function scanOpenclaw() {
+    const agentsDir = join(homedir(), '.openclaw', 'agents');
+    try {
+        await stat(agentsDir);
+    }
+    catch {
+        return [];
+    }
+    const sessionFiles = [];
+    try {
+        const agentIds = await readdir(agentsDir, { withFileTypes: true });
+        for (const entry of agentIds) {
+            if (!entry.isDirectory())
+                continue;
+            const sessionsSubdir = join(agentsDir, entry.name, 'sessions');
+            const discovered = await findFiles(sessionsSubdir, '.jsonl');
+            sessionFiles.push(...discovered);
+        }
+    }
+    catch {
+        return [];
+    }
+    if (sessionFiles.length === 0)
+        return [];
+    const dailyByModel = new Map();
+    const cutoff = hourlyCutoff();
+    for (const filePath of sessionFiles) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            let fileFallbackDate = null;
+            for (const line of content.split('\n')) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const parsed = JSON.parse(line);
+                    const usage = parsed.usage ??
+                        parsed.tokenUsage ??
+                        parsed.message?.usage ??
+                        parsed.response?.usage ??
+                        null;
+                    if (!usage || typeof usage !== 'object')
+                        continue;
+                    const tokens = (usage.total ??
+                        (usage.input ?? usage.inputTokens ?? 0) +
+                            (usage.output ?? usage.outputTokens ?? 0) +
+                            (usage.cacheRead ?? usage.cacheReadTokens ?? 0) +
+                            (usage.cacheWrite ?? usage.cacheWriteTokens ?? 0));
+                    if (!tokens || tokens <= 0)
+                        continue;
+                    let date;
+                    let hour = null;
+                    const ts = parsed.timestamp ?? parsed.t ?? parsed.time ?? null;
+                    if (ts) {
+                        const tsMs = typeof ts === 'string' && /^\d+$/.test(ts) ? Number(ts) : ts;
+                        const d = new Date(tsMs);
+                        if (!Number.isNaN(d.getTime())) {
+                            date = toDateStr(d);
+                            hour = d.getHours();
+                        }
+                        else {
+                            if (!fileFallbackDate) {
+                                const s = await stat(filePath);
+                                fileFallbackDate = toDateStr(s.mtime);
+                            }
+                            date = fileFallbackDate;
+                        }
+                    }
+                    else {
+                        if (!fileFallbackDate) {
+                            const s = await stat(filePath);
+                            fileFallbackDate = toDateStr(s.mtime);
+                        }
+                        date = fileFallbackDate;
+                    }
+                    const model = parsed.model ?? parsed.response?.model ?? '';
+                    addToDaily(dailyByModel, date, model, tokens, 1);
+                    if (model) {
+                        modelAccumulator.set(model, (modelAccumulator.get(model) ?? 0) + tokens);
+                    }
+                    if (hour !== null) {
+                        addHourly(date, hour, 'openclaw', model, tokens, cutoff, 1);
+                    }
+                }
+                catch {
+                    // skip malformed lines
+                }
+            }
+        }
+        catch {
+            // skip unreadable files
+        }
+    }
+    return dailyMapToEntries(dailyByModel, 'openclaw');
+}
+async function scanCursorLocal() {
+    const dbPath = join(homedir(), '.cursor', 'ai-tracking', 'ai-code-tracking.db');
+    try {
+        await stat(dbPath);
+    }
+    catch {
+        return { entries: [], stats: null };
+    }
+    const { execSync } = await import('node:child_process');
+    try {
+        const raw = execSync(`sqlite3 "${dbPath}" "select commitHash, linesAdded, linesDeleted, composerLinesAdded, composerLinesDeleted, humanLinesAdded, humanLinesDeleted, v2AiPercentage from scored_commits;"`, { encoding: 'utf8', timeout: 10000 }).trim();
+        if (!raw)
+            return { entries: [], stats: null };
+        const rows = raw.split('\n');
+        let totalTokens = 0;
+        let totalAiLines = 0;
+        let totalHumanLines = 0;
+        let aiPctSum = 0;
+        for (const row of rows) {
+            const [, , , composerAdded, composerDeleted, humanAdded, , aiPct] = row.split('|');
+            const aiLines = (parseInt(composerAdded ?? '0', 10) || 0) +
+                (parseInt(composerDeleted ?? '0', 10) || 0);
+            totalAiLines += parseInt(composerAdded ?? '0', 10) || 0;
+            totalHumanLines += parseInt(humanAdded ?? '0', 10) || 0;
+            aiPctSum += parseFloat(aiPct ?? '0') || 0;
+            totalTokens += aiLines * 30;
+        }
+        let models = [];
+        try {
+            const modelRaw = execSync(`sqlite3 "${dbPath}" "select model, count(*) from ai_code_hashes where model is not null and model != '' group by model order by count(*) desc;"`, { encoding: 'utf8', timeout: 5000 }).trim();
+            if (modelRaw) {
+                models = modelRaw.split('\n').map((line) => {
+                    const [model, count] = line.split('|');
+                    return { model: model ?? '', uses: parseInt(count ?? '0', 10) || 0 };
+                });
+            }
+        }
+        catch {
+            // optional
+        }
+        const entries = totalTokens > 0
+            ? [{ date: toDateStr(new Date()), tool: 'cursor', tokens: totalTokens }]
+            : [];
+        return {
+            entries,
+            stats: {
+                totalCommits: rows.length,
+                aiLinesAdded: totalAiLines,
+                humanLinesAdded: totalHumanLines,
+                avgAiPercent: rows.length > 0 ? Math.round((aiPctSum / rows.length) * 10) / 10 : 0,
+                models,
+            },
+        };
+    }
+    catch {
+        return { entries: [], stats: null };
+    }
+}
+async function scanCursorApi() {
+    const config = await loadConfig();
+    if (!config.cursorApiKey) {
+        _cursorScanStatus.value = { source: 'none' };
+        return [];
+    }
+    const email = config.cursorEmail;
+    const now = Date.now();
+    const fiveYearsMs = 5 * 365 * 24 * 60 * 60 * 1000;
+    const startDate = now - fiveYearsMs;
+    const endDate = now;
+    const dailyByModel = new Map();
+    const cursorCutoff = hourlyCutoff();
+    let page = 1;
+    let hasMore = true;
+    let retries = 0;
+    const MAX_RETRIES = 3;
+    let eventsProcessed = 0;
+    let partialReason = null;
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+    while (hasMore) {
+        const body = {
+            startDate,
+            endDate,
+            page,
+            pageSize: 100,
+        };
+        if (email)
+            body.email = email;
+        let res;
+        try {
+            res = await fetch('https://api.cursor.com/teams/filtered-usage-events', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${config.cursorApiKey}`,
+                },
+                body: JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            partialReason = `network: ${err instanceof Error ? err.message : 'unknown'}`;
+            break;
+        }
+        if (!res.ok) {
+            if (res.status === 429 && retries < MAX_RETRIES) {
+                const waitMs = 2000 * 2 ** retries;
+                await sleep(waitMs);
+                retries++;
+                continue;
+            }
+            if (res.status === 401 || res.status === 403) {
+                if (eventsProcessed === 0) {
+                    _cursorScanStatus.value = {
+                        source: 'api-failed',
+                        reason: `auth ${res.status} — check CURSOR_API_KEY`,
+                    };
+                    return [];
+                }
+                partialReason = `auth ${res.status} mid-scan`;
+                break;
+            }
+            partialReason = `HTTP ${res.status}`;
+            break;
+        }
+        retries = 0;
+        let data;
+        try {
+            data = await res.json();
+        }
+        catch {
+            partialReason = 'invalid json';
+            break;
+        }
+        const events = data.usageEvents ?? [];
+        for (const event of events) {
+            if (!event.isTokenBasedCall)
+                continue;
+            const tu = event.tokenUsage ??
+                event;
+            const tokens = (tu.inputTokens ?? 0) +
+                (tu.outputTokens ?? 0) +
+                (tu.cacheWriteTokens ?? 0) +
+                (tu.cacheReadTokens ?? 0);
+            if (tokens > 0 && event.timestamp) {
+                const rawTs = event.timestamp;
+                const tsMs = typeof rawTs === 'string' && /^\d+$/.test(rawTs)
+                    ? Number(rawTs)
+                    : rawTs;
+                const eventDate = new Date(tsMs);
+                const date = toDateStr(eventDate);
+                const hour = eventDate.getHours();
+                const model = event.model ?? '';
+                addToDaily(dailyByModel, date, model, tokens, 1);
+                if (model) {
+                    modelAccumulator.set(model, (modelAccumulator.get(model) ?? 0) + tokens);
+                }
+                addHourly(date, hour, 'cursor', model, tokens, cursorCutoff, 1);
+                eventsProcessed++;
+            }
+        }
+        hasMore = data.pagination?.hasNextPage ?? false;
+        page++;
+        if (page > 500) {
+            partialReason = 'pagination cap (500 pages)';
+            break;
+        }
+    }
+    _cursorScanStatus.value = partialReason
+        ? { source: 'api-partial', events: eventsProcessed, reason: partialReason }
+        : { source: 'api', events: eventsProcessed };
+    return dailyMapToEntries(dailyByModel, 'cursor');
+}
+async function scanOpenCode() {
+    const openCodeDir = join(homedir(), '.local', 'share', 'opencode');
+    try {
+        await stat(openCodeDir);
+    }
+    catch {
+        return [];
+    }
+    const cutoff = hourlyCutoff();
+    const dailyByModel = new Map();
+    // Schema: data column is JSON with shape:
+    //   { role, modelID, time: { created: ms }, tokens: { input, output, reasoning, cache: { read, write } } }
+    const dbPath = join(openCodeDir, 'opencode.db');
+    try {
+        await stat(dbPath);
+        const { execSync } = await import('node:child_process');
+        const raw = execSync(`sqlite3 -readonly "${dbPath}" "SELECT json_extract(data,'$.time.created'), coalesce(json_extract(data,'$.modelID'),''), coalesce(json_extract(data,'$.tokens.input'),0), coalesce(json_extract(data,'$.tokens.output'),0), coalesce(json_extract(data,'$.tokens.cache.read'),0), coalesce(json_extract(data,'$.tokens.cache.write'),0), coalesce(json_extract(data,'$.tokens.reasoning'),0) FROM message WHERE json_extract(data,'$.role')='assistant'"`, { encoding: 'utf8', timeout: 15000, stdio: 'pipe' }).trim();
+        if (raw) {
+            for (const row of raw.split('\n')) {
+                const [timeStr, model, inputStr, outputStr, cacheReadStr, cacheWriteStr, reasoningStr,] = row.split('|');
+                const tokens = (Number.parseInt(inputStr ?? '0', 10) || 0) +
+                    (Number.parseInt(outputStr ?? '0', 10) || 0) +
+                    (Number.parseInt(cacheReadStr ?? '0', 10) || 0) +
+                    (Number.parseInt(cacheWriteStr ?? '0', 10) || 0) +
+                    (Number.parseInt(reasoningStr ?? '0', 10) || 0);
+                if (tokens <= 0)
+                    continue;
+                const tsMs = Number(timeStr ?? '0'); // already milliseconds
+                if (!Number.isFinite(tsMs) || tsMs <= 0)
+                    continue;
+                const d = new Date(tsMs);
+                const date = toDateStr(d);
+                const hour = d.getHours();
+                const m = (model ?? '').trim();
+                addToDaily(dailyByModel, date, m, tokens, 1);
+                if (m)
+                    modelAccumulator.set(m, (modelAccumulator.get(m) ?? 0) + tokens);
+                addHourly(date, hour, 'opencode', m, tokens, cutoff, 1);
+            }
+            if (dailyByModel.size > 0) {
+                return dailyMapToEntries(dailyByModel, 'opencode');
+            }
+        }
+    }
+    catch {
+        // DB unavailable; fall through to JSON files
+    }
+    // Fallback: scan ~/.local/share/opencode/storage/message/{sessionID}/msg_*.json
+    const messageDir = join(openCodeDir, 'storage', 'message');
+    try {
+        await stat(messageDir);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const sessionDirs = await readdir(messageDir, { withFileTypes: true });
+        for (const sessionEntry of sessionDirs) {
+            if (!sessionEntry.isDirectory())
+                continue;
+            const msgFiles = await findFiles(join(messageDir, sessionEntry.name), '.json');
+            for (const filePath of msgFiles) {
+                try {
+                    const parsed = JSON.parse(await readFile(filePath, 'utf8'));
+                    if (parsed.role !== 'assistant')
+                        continue;
+                    const t = parsed.tokens;
+                    if (!t || typeof t !== 'object')
+                        continue;
+                    const tokens = (t.input ?? 0) +
+                        (t.output ?? 0) +
+                        (t.cache?.read ?? 0) +
+                        (t.cache?.write ?? 0) +
+                        (t.reasoning ?? 0);
+                    if (tokens <= 0)
+                        continue;
+                    const tsMs = parsed.time?.created ?? 0;
+                    let date;
+                    let hour = null;
+                    if (tsMs > 0) {
+                        const d = new Date(tsMs);
+                        date = toDateStr(d);
+                        hour = d.getHours();
+                    }
+                    else {
+                        date = toDateStr((await stat(filePath)).mtime);
+                    }
+                    const model = String(parsed.modelID ?? '');
+                    addToDaily(dailyByModel, date, model, tokens, 1);
+                    if (model)
+                        modelAccumulator.set(model, (modelAccumulator.get(model) ?? 0) + tokens);
+                    if (hour !== null)
+                        addHourly(date, hour, 'opencode', model, tokens, cutoff, 1);
+                }
+                catch {
+                    // skip malformed files
+                }
+            }
+        }
+    }
+    catch {
+        // skip
+    }
+    return dailyMapToEntries(dailyByModel, 'opencode');
+}
+export async function runSync(session) {
+    modelAccumulator.clear();
+    hourlyAccumulator.clear();
+    _cursorScanStatus.value = { source: 'none' };
+    const [claudeEntries, codexEntries, cursorApiEntries, cursorLocal, openclawEntries, hermesEntries, opencodeEntries,] = await Promise.all([
+        scanClaudeCode(),
+        scanCodex(),
+        scanCursorApi(),
+        scanCursorLocal(),
+        scanOpenclaw(),
+        scanHermes(),
+        scanOpenCode(),
+    ]);
+    const cursorEntries = cursorApiEntries.length > 0 ? cursorApiEntries : cursorLocal.entries;
+    const claudeTotal = claudeEntries.reduce((s, e) => s + e.tokens, 0);
+    const codexTotal = codexEntries.reduce((s, e) => s + e.tokens, 0);
+    const cursorTotal = cursorEntries.reduce((s, e) => s + e.tokens, 0);
+    const openclawTotal = openclawEntries.reduce((s, e) => s + e.tokens, 0);
+    const hermesTotal = hermesEntries.reduce((s, e) => s + e.tokens, 0);
+    const opencodeTotal = opencodeEntries.reduce((s, e) => s + e.tokens, 0);
+    const allEntries = [
+        ...claudeEntries,
+        ...codexEntries,
+        ...cursorEntries,
+        ...openclawEntries,
+        ...hermesEntries,
+        ...opencodeEntries,
+    ];
+    const messagesTotal = allEntries.reduce((s, e) => s + (e.messages ?? 0), 0);
+    const modelTotals = {};
+    for (const [name, tokens] of modelAccumulator.entries()) {
+        if (tokens > 0)
+            modelTotals[name] = tokens;
+    }
+    const hourlyTotals = flushHourly();
+    const res = await fetchApi(session, '/api/claim/sync', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${session.token}`,
+        },
+        body: JSON.stringify({
+            dailyTotals: allEntries,
+            toolTotals: {
+                claude_code: claudeTotal,
+                codex: codexTotal,
+                cursor: cursorTotal,
+                openclaw: openclawTotal,
+                hermes: hermesTotal,
+                opencode: opencodeTotal,
+            },
+            modelTotals,
+            hourlyTotals,
+        }),
+    });
+    if (res.status === 401) {
+        throw new Error(LOGIN_EXPIRED_MESSAGE);
+    }
+    if (!res.ok) {
+        const data = await res.json().catch(() => null);
+        throw new Error(data?.error ??
+            `sync failed (${res.status})`);
+    }
+    const result = await res.json();
+    return {
+        claudeTotal,
+        codexTotal,
+        cursorTotal,
+        openclawTotal,
+        hermesTotal,
+        opencodeTotal,
+        messagesTotal,
+        allEntries,
+        cursorStats: cursorLocal.stats,
+        result,
+        models: Array.from(modelAccumulator.entries())
+            .map(([name, tokens]) => ({ name, tokens }))
+            .sort((a, b) => b.tokens - a.tokens),
+        cursorScanStatus: _cursorScanStatus.value,
+    };
+}
+//# sourceMappingURL=sync.js.map