@leo000001/opencode-quota-sidebar 1.0.0

package/dist/storage.js

@@ -0,0 +1,328 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { asBoolean, asNumber, debug, isRecord, swallow } from './helpers.js';
+import { discoverChunks, readDayChunk, safeWriteFile, writeDayChunk, } from './storage_chunks.js';
+import { dateKeyFromTimestamp, dateKeysInRange, dateStartFromKey, isDateKey, normalizeTimestampMs, } from './storage_dates.js';
+import { parseQuotaCache, parseSessionTitleForMigration, } from './storage_parse.js';
+import { authFilePath, chunkRootPathFromStateFile, resolveOpencodeDataDir, stateFilePath, } from './storage_paths.js';
+export { authFilePath, dateKeyFromTimestamp, normalizeTimestampMs, resolveOpencodeDataDir, stateFilePath, };
+// ─── Default config ──────────────────────────────────────────────────────────
+export const defaultConfig = {
+    sidebar: {
+        enabled: true,
+        width: 36,
+        showCost: true,
+        showQuota: true,
+    },
+    quota: {
+        refreshMs: 5 * 60 * 1000,
+        includeOpenAI: true,
+        includeCopilot: true,
+        includeAnthropic: true,
+        providers: {},
+        refreshAccessToken: false,
+        requestTimeoutMs: 8_000,
+    },
+    toast: {
+        durationMs: 12_000,
+    },
+    retentionDays: 730,
+};
+export function defaultState() {
+    return {
+        version: 2,
+        titleEnabled: true,
+        sessionDateMap: {},
+        sessions: {},
+        quotaCache: {},
+    };
+}
+// ─── Config loading ──────────────────────────────────────────────────────────
+export async function loadConfig(paths) {
+    const existing = await Promise.all(paths.map(async (filePath) => {
+        const stat = await fs.stat(filePath).catch(swallow('loadConfig:stat'));
+        if (!stat || !stat.isFile())
+            return undefined;
+        return filePath;
+    }));
+    const selected = existing.find((value) => value);
+    if (!selected)
+        return defaultConfig;
+    const parsed = await fs
+        .readFile(selected, 'utf8')
+        .then((value) => JSON.parse(value))
+        .catch(swallow('loadConfig:read'));
+    if (!isRecord(parsed))
+        return defaultConfig;
+    const sidebar = isRecord(parsed.sidebar) ? parsed.sidebar : {};
+    const quota = isRecord(parsed.quota) ? parsed.quota : {};
+    const toast = isRecord(parsed.toast) ? parsed.toast : {};
+    const providers = isRecord(quota.providers) ? quota.providers : {};
+    return {
+        sidebar: {
+            enabled: asBoolean(sidebar.enabled, defaultConfig.sidebar.enabled),
+            width: Math.max(20, Math.min(60, asNumber(sidebar.width, defaultConfig.sidebar.width))),
+            showCost: asBoolean(sidebar.showCost, defaultConfig.sidebar.showCost),
+            showQuota: asBoolean(sidebar.showQuota, defaultConfig.sidebar.showQuota),
+        },
+        quota: {
+            refreshMs: Math.max(30_000, asNumber(quota.refreshMs, defaultConfig.quota.refreshMs)),
+            includeOpenAI: asBoolean(quota.includeOpenAI, defaultConfig.quota.includeOpenAI),
+            includeCopilot: asBoolean(quota.includeCopilot, defaultConfig.quota.includeCopilot),
+            includeAnthropic: asBoolean(quota.includeAnthropic, defaultConfig.quota.includeAnthropic),
+            providers: Object.entries(providers).reduce((acc, [id, value]) => {
+                if (!isRecord(value))
+                    return acc;
+                if (typeof value.enabled === 'boolean') {
+                    acc[id] = { enabled: value.enabled };
+                }
+                return acc;
+            }, {}),
+            refreshAccessToken: asBoolean(quota.refreshAccessToken, defaultConfig.quota.refreshAccessToken),
+            requestTimeoutMs: Math.max(1000, asNumber(quota.requestTimeoutMs, defaultConfig.quota.requestTimeoutMs)),
+        },
+        toast: {
+            durationMs: Math.max(1000, asNumber(toast.durationMs, defaultConfig.toast.durationMs)),
+        },
+        retentionDays: Math.max(1, asNumber(parsed.retentionDays, defaultConfig.retentionDays)),
+    };
+}
+// ─── State loading ───────────────────────────────────────────────────────────
+/** P2: Lazy chunk loading — only load chunks for sessions in sessionDateMap. */
+async function loadVersion2State(raw, statePath) {
+    const titleEnabled = asBoolean(raw.titleEnabled, true);
+    const quotaCache = parseQuotaCache(raw.quotaCache);
+    const rootPath = chunkRootPathFromStateFile(statePath);
+    const sessionDateMapRaw = isRecord(raw.sessionDateMap)
+        ? raw.sessionDateMap
+        : {};
+    const sessionDateMap = Object.entries(sessionDateMapRaw).reduce((acc, [sessionID, value]) => {
+        if (typeof value !== 'string')
+            return acc;
+        if (!isDateKey(value))
+            return acc;
+        acc[sessionID] = value;
+        return acc;
+    }, {});
+    const explicitDateKeys = Array.from(new Set(Object.values(sessionDateMap)));
+    const discoveredDateKeys = explicitDateKeys.length
+        ? []
+        : await discoverChunks(rootPath);
+    const dateKeys = explicitDateKeys.length
+        ? explicitDateKeys
+        : discoveredDateKeys;
+    const chunks = await Promise.all(dateKeys.map(async (dateKey) => {
+        const sessions = await readDayChunk(rootPath, dateKey);
+        return [dateKey, sessions];
+    }));
+    const sessions = {};
+    for (const [dateKey, chunkSessions] of chunks) {
+        for (const [sessionID, session] of Object.entries(chunkSessions)) {
+            sessions[sessionID] = session;
+            if (!sessionDateMap[sessionID])
+                sessionDateMap[sessionID] = dateKey;
+        }
+    }
+    return {
+        version: 2,
+        titleEnabled,
+        sessionDateMap,
+        sessions,
+        quotaCache,
+    };
+}
+/**
+ * M3 fix: use session.createdAt from v1 state if available,
+ * otherwise fall back to Date.now() (unavoidable for truly missing data).
+ */
+function migrateVersion1State(raw) {
+    const titleEnabled = asBoolean(raw.titleEnabled, true);
+    const quotaCache = parseQuotaCache(raw.quotaCache);
+    const sessionsRaw = isRecord(raw.sessions) ? raw.sessions : {};
+    const sessions = {};
+    const sessionDateMap = {};
+    for (const [sessionID, value] of Object.entries(sessionsRaw)) {
+        const title = parseSessionTitleForMigration(value);
+        if (!title)
+            continue;
+        // M3: try to recover createdAt from v1 data
+        const rawCreatedAt = isRecord(value) ? asNumber(value.createdAt) : undefined;
+        const createdAt = rawCreatedAt
+            ? normalizeTimestampMs(rawCreatedAt)
+            : Date.now();
+        const dateKey = dateKeyFromTimestamp(createdAt);
+        sessions[sessionID] = {
+            ...title,
+            createdAt,
+        };
+        sessionDateMap[sessionID] = dateKey;
+    }
+    return {
+        version: 2,
+        titleEnabled,
+        sessionDateMap,
+        sessions,
+        quotaCache,
+    };
+}
+export async function loadState(statePath) {
+    const raw = await fs
+        .readFile(statePath, 'utf8')
+        .then((value) => JSON.parse(value))
+        .catch(swallow('loadState'));
+    if (!isRecord(raw))
+        return defaultState();
+    if (raw.version === 2)
+        return loadVersion2State(raw, statePath);
+    if (raw.version === 1) {
+        const migrated = migrateVersion1State(raw);
+        // Persist immediately so chunk files exist for range scans.
+        await saveState(statePath, migrated, { writeAll: true }).catch(swallow('loadState:migrate'));
+        return migrated;
+    }
+    return defaultState();
+}
+// ─── State saving ────────────────────────────────────────────────────────────
+const MAX_QUOTA_CACHE_AGE_MS = 24 * 60 * 60 * 1000;
+function pruneState(state) {
+    const now = Date.now();
+    for (const [key, value] of Object.entries(state.quotaCache)) {
+        if (now - value.checkedAt > MAX_QUOTA_CACHE_AGE_MS) {
+            delete state.quotaCache[key];
+        }
+    }
+}
+/**
+ * H1 fix: when dirtyDateKeys is empty and writeAll is not set, skip chunk writes entirely.
+ * M11 fix: only iterate sessions belonging to dirty date keys (not all sessions).
+ * M4 fix: atomic writes via safeWriteFile.
+ * P4 fix: sessionDateMap dirty flag tracked externally.
+ */
+export async function saveState(statePath, state, options) {
+    pruneState(state);
+    const rootPath = chunkRootPathFromStateFile(statePath);
+    const writeAll = options?.writeAll === true;
+    // H1 fix: if no dirty keys and not writeAll, only write the state file (no chunks)
+    const dirtySet = writeAll
+        ? undefined
+        : new Set((options?.dirtyDateKeys ?? []).filter((key) => isDateKey(key)));
+    const skipChunks = !writeAll && (!dirtySet || dirtySet.size === 0);
+    // M11 fix: only build sessionsByDate for dirty keys (or all if writeAll)
+    const sessionsByDate = {};
+    if (!skipChunks) {
+        for (const [sessionID, session] of Object.entries(state.sessions)) {
+            const normalizedCreatedAt = Number.isFinite(session.createdAt) && session.createdAt > 0
+                ? session.createdAt
+                : Date.now();
+            session.createdAt = normalizedCreatedAt;
+            const dateKey = state.sessionDateMap[sessionID] ||
+                dateKeyFromTimestamp(normalizedCreatedAt);
+            state.sessionDateMap[sessionID] = dateKey;
+            // M11: skip sessions not in dirty set
+            if (!writeAll && dirtySet && !dirtySet.has(dateKey))
+                continue;
+            const dateBucket = sessionsByDate[dateKey] || {};
+            dateBucket[sessionID] = session;
+            sessionsByDate[dateKey] = dateBucket;
+        }
+    }
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
+    await fs.mkdir(rootPath, { recursive: true });
+    // M4: atomic state file write
+    await safeWriteFile(statePath, `${JSON.stringify({
+        version: 2,
+        titleEnabled: state.titleEnabled,
+        sessionDateMap: state.sessionDateMap,
+        quotaCache: state.quotaCache,
+    }, null, 2)}\n`);
+    if (skipChunks)
+        return;
+    const keysToWrite = writeAll
+        ? Object.keys(sessionsByDate)
+        : Array.from(dirtySet ?? []);
+    await Promise.all(keysToWrite
+        .map((dateKey) => {
+        const sessions = sessionsByDate[dateKey];
+        if (!sessions)
+            return undefined;
+        return writeDayChunk(rootPath, dateKey, sessions);
+    })
+        .filter((promise) => Boolean(promise)));
+}
+// ─── Eviction (M2) ──────────────────────────────────────────────────────────
+/**
+ * M2 fix: evict sessions older than retentionDays from memory.
+ * Chunk files remain on disk for historical range scans.
+ */
+export function evictOldSessions(state, retentionDays) {
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    let evicted = 0;
+    for (const [sessionID, session] of Object.entries(state.sessions)) {
+        if (session.createdAt < cutoff) {
+            delete state.sessions[sessionID];
+            delete state.sessionDateMap[sessionID];
+            evicted++;
+        }
+    }
+    if (evicted > 0) {
+        debug(`evicted ${evicted} sessions older than ${retentionDays} days`);
+    }
+    return evicted;
+}
+// ─── Range scan (M9 fix: prefer memory, fall back to disk) ──────────────────
+/**
+ * M9 fix: scan from in-memory state first, only read disk for date keys
+ * not represented in memory.
+ */
+export async function scanSessionsByCreatedRange(statePath, startAt, endAt = Date.now(), memoryState) {
+    const rootPath = chunkRootPathFromStateFile(statePath);
+    const dateKeys = dateKeysInRange(startAt, endAt);
+    if (!dateKeys.length) {
+        return [];
+    }
+    const results = [];
+    const seenSessionIDs = new Set();
+    // First pass: collect from memory
+    if (memoryState) {
+        const dateKeySet = new Set(dateKeys);
+        for (const [sessionID, session] of Object.entries(memoryState.sessions)) {
+            const dk = memoryState.sessionDateMap[sessionID];
+            if (!dk || !dateKeySet.has(dk))
+                continue;
+            const createdAt = Number.isFinite(session.createdAt) && session.createdAt > 0
+                ? session.createdAt
+                : dateStartFromKey(dk);
+            if (createdAt >= startAt && createdAt <= endAt) {
+                results.push({ sessionID, dateKey: dk, state: session });
+                seenSessionIDs.add(sessionID);
+            }
+        }
+    }
+    // Second pass: read disk chunks for date keys that may have sessions not in memory
+    const memoryDateKeys = memoryState
+        ? new Set(Object.values(memoryState.sessionDateMap))
+        : new Set();
+    const diskDateKeys = dateKeys.filter((dk) => !memoryDateKeys.has(dk));
+    if (diskDateKeys.length > 0) {
+        const chunkEntries = await Promise.all(diskDateKeys.map(async (dateKey) => {
+            const sessions = await readDayChunk(rootPath, dateKey);
+            return Object.entries(sessions).map(([sessionID, state]) => ({
+                sessionID,
+                dateKey,
+                state,
+            }));
+        }));
+        for (const entry of chunkEntries.flat()) {
+            if (seenSessionIDs.has(entry.sessionID))
+                continue;
+            const createdAt = Number.isFinite(entry.state.createdAt) && entry.state.createdAt > 0
+                ? entry.state.createdAt
+                : dateStartFromKey(entry.dateKey);
+            if (createdAt >= startAt && createdAt <= endAt) {
+                results.push(entry);
+                seenSessionIDs.add(entry.sessionID);
+            }
+        }
+    }
+    return results;
+}

package/dist/storage_chunks.d.ts

@@ -0,0 +1,9 @@
+import type { SessionState } from './types.js';
+export declare function readDayChunk(rootPath: string, dateKey: string): Promise<Record<string, SessionState>>;
+/**
+ * S3 fix: check for symlink before writing.
+ * M4 fix: write to temp file then rename for atomicity.
+ */
+export declare function safeWriteFile(filePath: string, content: string): Promise<void>;
+export declare function writeDayChunk(rootPath: string, dateKey: string, sessions: Record<string, SessionState>): Promise<void>;
+export declare function discoverChunks(rootPath: string): Promise<string[]>;

package/dist/storage_chunks.js

@@ -0,0 +1,147 @@
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { debug, isRecord, swallow } from './helpers.js';
+import { isDateKey } from './storage_dates.js';
+import { parseSessionState } from './storage_parse.js';
+import { chunkFilePath } from './storage_paths.js';
+/** P2: Simple LRU cache for loaded chunks. */
+class ChunkCache {
+    cache = new Map();
+    maxSize;
+    constructor(maxSize = 64) {
+        this.maxSize = maxSize;
+    }
+    get(dateKey) {
+        const entry = this.cache.get(dateKey);
+        if (!entry)
+            return undefined;
+        entry.accessedAt = Date.now();
+        return entry.sessions;
+    }
+    set(dateKey, sessions) {
+        if (this.cache.size >= this.maxSize) {
+            // Evict least recently accessed
+            let oldestKey;
+            let oldestTime = Infinity;
+            for (const [key, entry] of this.cache) {
+                if (entry.accessedAt < oldestTime) {
+                    oldestTime = entry.accessedAt;
+                    oldestKey = key;
+                }
+            }
+            if (oldestKey)
+                this.cache.delete(oldestKey);
+        }
+        this.cache.set(dateKey, { sessions, accessedAt: Date.now() });
+    }
+    invalidate(dateKey) {
+        this.cache.delete(dateKey);
+    }
+}
+const chunkCache = new ChunkCache();
+export async function readDayChunk(rootPath, dateKey) {
+    const cached = chunkCache.get(dateKey);
+    if (cached)
+        return cached;
+    const filePath = chunkFilePath(rootPath, dateKey);
+    const parsed = await fs
+        .readFile(filePath, 'utf8')
+        .then((value) => JSON.parse(value))
+        .catch(swallow('readDayChunk'));
+    if (!isRecord(parsed))
+        return {};
+    if (parsed.version !== 1)
+        return {};
+    const sessionsRaw = isRecord(parsed.sessions) ? parsed.sessions : {};
+    const sessions = Object.entries(sessionsRaw).reduce((acc, [sessionID, value]) => {
+        const parsedSession = parseSessionState(value);
+        if (!parsedSession)
+            return acc;
+        acc[sessionID] = parsedSession;
+        return acc;
+    }, {});
+    chunkCache.set(dateKey, sessions);
+    return sessions;
+}
+/**
+ * S3 fix: check for symlink before writing.
+ * M4 fix: write to temp file then rename for atomicity.
+ */
+export async function safeWriteFile(filePath, content) {
+    // S3: refuse to write through symlinks
+    const stat = await fs.lstat(filePath).catch(() => undefined);
+    if (stat?.isSymbolicLink()) {
+        const message = `refusing to write through symlink: ${filePath}`;
+        debug(message);
+        throw new Error(message);
+    }
+    // M4: atomic write via temp + rename
+    const dir = path.dirname(filePath);
+    const name = path.basename(filePath);
+    const maxAttempts = 5;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const suffix = randomBytes(4).toString('hex');
+        const tmpPath = path.join(dir, `${name}.tmp.${process.pid}.${suffix}`);
+        try {
+            await fs.writeFile(tmpPath, content, { encoding: 'utf8', flag: 'wx' });
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'EEXIST') {
+                lastError = error;
+                continue;
+            }
+            throw error;
+        }
+        try {
+            await fs.rename(tmpPath, filePath);
+            return;
+        }
+        catch (error) {
+            await fs.rm(tmpPath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    throw lastError instanceof Error
+        ? lastError
+        : new Error(`safeWriteFile failed for ${filePath}`);
+}
+export async function writeDayChunk(rootPath, dateKey, sessions) {
+    const filePath = chunkFilePath(rootPath, dateKey);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const chunk = {
+        version: 1,
+        dateKey,
+        sessions,
+    };
+    await safeWriteFile(filePath, `${JSON.stringify(chunk, null, 2)}\n`);
+    chunkCache.invalidate(dateKey);
+}
+export async function discoverChunks(rootPath) {
+    const years = await fs.readdir(rootPath).catch(() => []);
+    const dateKeys = [];
+    for (const year of years) {
+        if (!/^\d{4}$/.test(year))
+            continue;
+        const yearPath = path.join(rootPath, year);
+        const months = await fs.readdir(yearPath).catch(() => []);
+        for (const month of months) {
+            if (!/^\d{2}$/.test(month))
+                continue;
+            const monthPath = path.join(yearPath, month);
+            const days = await fs.readdir(monthPath).catch(() => []);
+            for (const dayFile of days) {
+                const match = dayFile.match(/^(\d{2})\.json$/);
+                if (!match)
+                    continue;
+                const day = match[1];
+                const key = `${year}-${month}-${day}`;
+                if (isDateKey(key))
+                    dateKeys.push(key);
+            }
+        }
+    }
+    return Array.from(new Set(dateKeys)).sort();
+}

package/dist/storage_dates.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeTimestampMs(value: unknown, fallback?: number): number;
+export declare function isDateKey(value: string): boolean;
+/**
+ * Convert a timestamp (already in ms) to a date key string.
+ * M12 fix: no double normalization — caller must pass ms.
+ */
+export declare function dateKeyFromTimestamp(timestampMs: number): string;
+export declare function dateStartFromKey(dateKey: string): number;
+export declare function dateKeysInRange(startAt: number, endAt: number): string[];

package/dist/storage_dates.js

@@ -0,0 +1,88 @@
+import { asNumber } from './helpers.js';
+export function normalizeTimestampMs(value, fallback = Date.now()) {
+    const num = asNumber(value);
+    if (num === undefined)
+        return fallback;
+    // Seconds -> ms heuristic
+    if (num > 0 && num < 1_000_000_000_000)
+        return num * 1000;
+    if (num > 0)
+        return num;
+    return fallback;
+}
+function pad2(value) {
+    return `${value}`.padStart(2, '0');
+}
+/**
+ * Extract date parts from a timestamp.
+ * M12 fix: accepts already-normalized ms timestamp — no double normalization.
+ */
+function datePartsFromMs(timestampMs) {
+    const date = new Date(timestampMs);
+    if (Number.isNaN(date.getTime())) {
+        const now = new Date();
+        return {
+            year: `${now.getFullYear()}`,
+            month: pad2(now.getMonth() + 1),
+            day: pad2(now.getDate()),
+        };
+    }
+    return {
+        year: `${date.getFullYear()}`,
+        month: pad2(date.getMonth() + 1),
+        day: pad2(date.getDate()),
+    };
+}
+export function isDateKey(value) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return false;
+    const [yearText, monthText, dayText] = value.split('-');
+    const year = Number(yearText);
+    const month = Number(monthText);
+    const day = Number(dayText);
+    if (!Number.isInteger(year))
+        return false;
+    if (!Number.isInteger(month) || month < 1 || month > 12)
+        return false;
+    if (!Number.isInteger(day) || day < 1 || day > 31)
+        return false;
+    const probe = new Date(year, month - 1, day);
+    return (probe.getFullYear() === year &&
+        probe.getMonth() === month - 1 &&
+        probe.getDate() === day);
+}
+/**
+ * Convert a timestamp (already in ms) to a date key string.
+ * M12 fix: no double normalization — caller must pass ms.
+ */
+export function dateKeyFromTimestamp(timestampMs) {
+    const { year, month, day } = datePartsFromMs(timestampMs);
+    return `${year}-${month}-${day}`;
+}
+export function dateStartFromKey(dateKey) {
+    if (!isDateKey(dateKey))
+        return 0;
+    const [yearText, monthText, dayText] = dateKey.split('-');
+    return new Date(Number(yearText), Number(monthText) - 1, Number(dayText)).getTime();
+}
+/** M7 fix: cap iteration at 400 days (~13 months). */
+const MAX_DATE_RANGE_DAYS = 400;
+export function dateKeysInRange(startAt, endAt) {
+    const startDate = new Date(startAt);
+    if (Number.isNaN(startDate.getTime()))
+        return [];
+    const endDate = new Date(endAt);
+    if (Number.isNaN(endDate.getTime()))
+        return [];
+    const cursor = new Date(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
+    const endDay = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate());
+    const keys = [];
+    let iterations = 0;
+    while (cursor.getTime() <= endDay.getTime() &&
+        iterations < MAX_DATE_RANGE_DAYS) {
+        keys.push(dateKeyFromTimestamp(cursor.getTime()));
+        cursor.setDate(cursor.getDate() + 1);
+        iterations++;
+    }
+    return keys;
+}

package/dist/storage_parse.d.ts

@@ -0,0 +1,4 @@
+import type { SessionState, SessionTitleState } from './types.js';
+export declare function parseSessionState(value: unknown): SessionState | undefined;
+export declare function parseSessionTitleForMigration(value: unknown): SessionTitleState | undefined;
+export declare function parseQuotaCache(value: unknown): Record<string, import("./types.js").QuotaSnapshot>;