sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/codexQuotaWatcher.js

@@ -0,0 +1,363 @@
+import * as fs from 'fs';
+import { getActiveCodexAccount, resolveActiveCodexAccount } from './codexProfiles';
+import { quotaFromCodexRateLimits, resolveCodexQuotaFromLocalSources } from './codexQuota';
+import { readQuotaSnapshot, writeQuotaSnapshot } from './quotaSnapshots';
+import { appendQuotaHistorySample } from './quotaHistory';
+import { CodexProvider } from './providers/codex';
+import { onAccountsChanged } from './accountChanges';
+const DEFAULT_DISCOVERY_POLL_INTERVAL_MS = 30_000;
+const DEFAULT_LOCAL_SCAN_CACHE_MS = 5 * 60_000;
+function accountEmail(account) {
+    return account?.email ?? account?.metadata?.email;
+}
+function enrichQuotaState(state, account) {
+    return {
+        ...state,
+        runtimeProvider: 'codex',
+        providerId: 'codex',
+        accountLabel: account?.label,
+        accountDetail: accountEmail(account),
+    };
+}
+function makeUnavailableState(account, error = 'Run a Codex session to view rate limits') {
+    return {
+        runtimeProvider: 'codex',
+        fiveHour: { utilization: 0, resetsAt: '' },
+        sevenDay: { utilization: 0, resetsAt: '' },
+        available: false,
+        error,
+        providerId: 'codex',
+        accountLabel: account?.label,
+        accountDetail: accountEmail(account),
+        fiveHourLabel: 'Primary',
+        sevenDayLabel: 'Secondary',
+    };
+}
+/**
+ * Watches the active Codex rollout for quota snapshots and falls back to the
+ * latest account-scoped cache when no live rate limits are present.
+ */
+export class CodexQuotaWatcher {
+    workspacePath;
+    discoveryPollIntervalMs;
+    providerFactory;
+    getActiveAccount;
+    readSnapshot;
+    writeSnapshot;
+    watchFile;
+    maxTailBytes;
+    maxSessionFiles;
+    localScanCacheMs;
+    now;
+    workspaceId;
+    appendHistorySample;
+    subscribeAccountsChanged;
+    listeners = [];
+    discoveryTimer;
+    provider = null;
+    reader = null;
+    fileWatcher = null;
+    sessionPath = null;
+    lastEmissionKey = null;
+    lastLocalScanAt = Number.NEGATIVE_INFINITY;
+    lastLocalScanState = null;
+    running = false;
+    accountSubscription = null;
+    constructor(workspacePath, options = {}) {
+        this.workspacePath = workspacePath;
+        this.discoveryPollIntervalMs =
+            options.discoveryPollIntervalMs ?? DEFAULT_DISCOVERY_POLL_INTERVAL_MS;
+        this.providerFactory = options.providerFactory ?? (() => new CodexProvider());
+        // Self-heal the registry pointer to the live login before reading it, so the
+        // history key (account.id) and the display label track the currently
+        // logged-in account even after a native `codex login`. Overridable for tests.
+        this.getActiveAccount =
+            options.getActiveAccount ??
+                (() => {
+                    resolveActiveCodexAccount();
+                    return getActiveCodexAccount();
+                });
+        this.readSnapshot = options.readSnapshot ?? readQuotaSnapshot;
+        this.writeSnapshot = options.writeSnapshot ?? writeQuotaSnapshot;
+        this.watchFile = options.watchFile ?? fs.watch;
+        this.maxTailBytes = options.maxTailBytes;
+        this.maxSessionFiles = options.maxSessionFiles;
+        this.localScanCacheMs = options.localScanCacheMs ?? DEFAULT_LOCAL_SCAN_CACHE_MS;
+        this.now = options.now ?? Date.now;
+        this.workspaceId = options.workspaceId;
+        this.appendHistorySample = options.appendHistorySample ?? appendQuotaHistorySample;
+        this.subscribeAccountsChanged = options.subscribeAccountsChanged ?? onAccountsChanged;
+    }
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.accountSubscription ??= this.subscribeAccountsChanged(() => this.handleAccountsChanged());
+        this.handleAccountsChanged();
+    }
+    stop() {
+        if (!this.running)
+            return;
+        this.running = false;
+        if (this.discoveryTimer) {
+            clearInterval(this.discoveryTimer);
+            this.discoveryTimer = undefined;
+        }
+        this.accountSubscription?.dispose();
+        this.accountSubscription = null;
+        this.teardownActiveSession();
+    }
+    dispose() {
+        this.stop();
+        this.listeners.splice(0, this.listeners.length);
+    }
+    onUpdate(cb) {
+        this.listeners.push(cb);
+        return {
+            dispose: () => {
+                const index = this.listeners.indexOf(cb);
+                if (index >= 0)
+                    this.listeners.splice(index, 1);
+            },
+        };
+    }
+    onQuotaUpdate(cb) {
+        return this.onUpdate(cb);
+    }
+    refresh() {
+        this.handleAccountsChanged();
+    }
+    handleAccountsChanged() {
+        if (!this.running)
+            return;
+        const account = this.safeGetActiveAccount();
+        if (!account) {
+            if (this.discoveryTimer) {
+                clearInterval(this.discoveryTimer);
+                this.discoveryTimer = undefined;
+            }
+            this.teardownActiveSession();
+            this.emitState(makeUnavailableState(null, 'No Codex account configured'));
+            return;
+        }
+        if (!this.discoveryTimer) {
+            this.discoveryTimer = setInterval(() => {
+                this.refreshActiveSession();
+            }, this.discoveryPollIntervalMs);
+            this.discoveryTimer.unref?.();
+        }
+        this.refreshActiveSession(account);
+    }
+    refreshActiveSession(account = this.safeGetActiveAccount()) {
+        if (!account) {
+            this.handleAccountsChanged();
+            return;
+        }
+        const provider = this.getProvider();
+        const nextSessionPath = provider.findActiveSession(this.workspacePath);
+        if (!nextSessionPath) {
+            this.teardownActiveSession();
+            this.emitCachedOrUnavailable(account);
+            return;
+        }
+        if (nextSessionPath !== this.sessionPath || this.reader == null) {
+            this.attachToSession(nextSessionPath);
+            return;
+        }
+        this.ingestSessionUpdate('readNew', account);
+    }
+    attachToSession(nextSessionPath) {
+        this.teardownActiveSession();
+        this.provider = this.providerFactory();
+        this.reader = this.provider.createReader(nextSessionPath);
+        this.sessionPath = nextSessionPath;
+        this.ingestSessionUpdate('readAll');
+        try {
+            this.fileWatcher = this.watchFile(nextSessionPath, (eventType) => {
+                if (!this.running)
+                    return;
+                if (eventType === 'change') {
+                    this.ingestSessionUpdate('readNew');
+                    return;
+                }
+                this.refreshActiveSession();
+            });
+            if (typeof this.fileWatcher.on === 'function') {
+                this.fileWatcher.on('error', () => {
+                    try {
+                        this.fileWatcher?.close();
+                    }
+                    catch {
+                        // Discovery polling remains active.
+                    }
+                    this.fileWatcher = null;
+                });
+            }
+        }
+        catch {
+            this.emitCachedOrUnavailable();
+        }
+    }
+    ingestSessionUpdate(mode, knownAccount) {
+        const account = knownAccount ?? this.safeGetActiveAccount();
+        if (!account) {
+            this.handleAccountsChanged();
+            return;
+        }
+        if (!this.provider || !this.reader) {
+            this.emitCachedOrUnavailable(account);
+            return;
+        }
+        if (!this.reader.exists()) {
+            this.refreshActiveSession();
+            return;
+        }
+        if (mode === 'readAll') {
+            this.reader.readAll();
+        }
+        else {
+            this.reader.readNew();
+        }
+        const liveQuota = quotaFromCodexRateLimits(this.provider.getLastRateLimits(), 'session');
+        if (!liveQuota) {
+            this.emitCachedOrUnavailable(account);
+            return;
+        }
+        const cached = this.readSnapshot('codex', account.id);
+        const liveQuotaWithResetCredits = {
+            ...liveQuota,
+            resetCredits: liveQuota.resetCredits ?? cached?.resetCredits,
+        };
+        this.writeSnapshot('codex', account.id, liveQuotaWithResetCredits);
+        if (this.workspaceId) {
+            const sample = {
+                timestamp: liveQuotaWithResetCredits.capturedAt ?? new Date().toISOString(),
+                runtimeProvider: 'codex',
+                providerId: account.id,
+                workspaceId: this.workspaceId,
+                fiveHour: {
+                    utilization: liveQuotaWithResetCredits.fiveHour.utilization,
+                    resetsAt: liveQuotaWithResetCredits.fiveHour.resetsAt,
+                },
+                sevenDay: {
+                    utilization: liveQuotaWithResetCredits.sevenDay.utilization,
+                    resetsAt: liveQuotaWithResetCredits.sevenDay.resetsAt,
+                },
+                available: liveQuotaWithResetCredits.available,
+                error: liveQuotaWithResetCredits.error,
+                source: liveQuotaWithResetCredits.source,
+                stale: liveQuotaWithResetCredits.stale,
+            };
+            try {
+                const result = this.appendHistorySample(sample);
+                if (result && typeof result.catch === 'function') {
+                    result.catch(() => {
+                        // History append must never break the live emission path.
+                    });
+                }
+            }
+            catch {
+                // Synchronous errors swallowed for the same reason.
+            }
+        }
+        this.emitState(enrichQuotaState({
+            ...liveQuotaWithResetCredits,
+            runtimeProvider: 'codex',
+            providerId: 'codex',
+        }, account));
+    }
+    emitCachedOrUnavailable(knownAccount) {
+        const account = knownAccount ?? this.safeGetActiveAccount();
+        if (!account) {
+            this.emitState(makeUnavailableState(null, 'No Codex account configured'));
+            return;
+        }
+        const scanNow = this.now();
+        if (scanNow - this.lastLocalScanAt < this.localScanCacheMs) {
+            if (this.lastLocalScanState) {
+                this.emitState(this.lastLocalScanState);
+                return;
+            }
+        }
+        else {
+            let localProvider = null;
+            this.lastLocalScanAt = scanNow;
+            this.lastLocalScanState = null;
+            try {
+                localProvider = this.providerFactory();
+                this.lastLocalScanState = resolveCodexQuotaFromLocalSources({
+                    workspacePath: this.workspacePath,
+                    activeAccount: account,
+                    readSnapshot: this.readSnapshot,
+                    writeSnapshot: this.writeSnapshot,
+                    provider: localProvider,
+                    maxTailBytes: this.maxTailBytes,
+                    maxSessionFiles: this.maxSessionFiles,
+                });
+                if (this.lastLocalScanState) {
+                    this.emitState(this.lastLocalScanState);
+                    return;
+                }
+            }
+            catch {
+                // Fall through to account-scoped cache or unavailable state.
+            }
+            finally {
+                localProvider?.dispose();
+            }
+        }
+        const cached = this.readSnapshot('codex', account.id);
+        if (cached) {
+            this.emitState(enrichQuotaState({
+                ...cached,
+                runtimeProvider: 'codex',
+                providerId: 'codex',
+                source: 'cache',
+                stale: true,
+                fiveHourLabel: cached.fiveHourLabel ?? 'Primary',
+                sevenDayLabel: cached.sevenDayLabel ?? 'Secondary',
+            }, account));
+            return;
+        }
+        this.emitState(makeUnavailableState(account));
+    }
+    emitState(state) {
+        const nextKey = JSON.stringify(state);
+        if (this.lastEmissionKey === nextKey)
+            return;
+        this.lastEmissionKey = nextKey;
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                // Listener failures should not stop session watching.
+            }
+        }
+    }
+    getProvider() {
+        if (!this.provider) {
+            this.provider = this.providerFactory();
+        }
+        return this.provider;
+    }
+    safeGetActiveAccount() {
+        try {
+            return this.getActiveAccount();
+        }
+        catch {
+            return null;
+        }
+    }
+    teardownActiveSession() {
+        if (this.fileWatcher) {
+            this.fileWatcher.close();
+            this.fileWatcher = null;
+        }
+        this.reader?.flush();
+        this.reader = null;
+        this.provider?.dispose();
+        this.provider = null;
+        this.sessionPath = null;
+    }
+}

package/dist/esm/context/composer.js

@@ -0,0 +1,71 @@
+/**
+ * Context composer — aggregates all readers with fidelity tiers.
+ */
+import { readTasks } from '../readers/tasks';
+import { readDecisions } from '../readers/decisions';
+import { readNotes } from '../readers/notes';
+import { readHistory } from '../readers/history';
+import { readLatestHandoff } from '../readers/handoff';
+export async function composeContext(project, fidelity, provider, workspacePath) {
+    // Fetch all data in parallel
+    const [allTasks, allDecisions, allNotes, history, handoff] = await Promise.all([
+        readTasks(project),
+        readDecisions(project),
+        readNotes(project),
+        readHistory(),
+        readLatestHandoff(project),
+    ]);
+    // Get session summaries
+    const sessionFiles = workspacePath ? provider.findAllSessions(workspacePath) : [];
+    const sessionSummaries = [];
+    // Read stats for session files based on fidelity
+    const FIDELITY_SESSION_LIMIT = { full: 5, compact: 2, brief: 1 };
+    const sessionLimit = FIDELITY_SESSION_LIMIT[fidelity];
+    const sessionPaths = sessionFiles.slice(0, sessionLimit);
+    for (const sp of sessionPaths) {
+        try {
+            sessionSummaries.push(provider.readSessionStats(sp));
+        }
+        catch {
+            /* skip */
+        }
+    }
+    // Apply fidelity filtering
+    let tasks;
+    let decisions;
+    let notes;
+    let stats = null;
+    switch (fidelity) {
+        case 'full':
+            tasks = allTasks;
+            decisions = allDecisions;
+            notes = allNotes.filter((n) => n.status === 'active' || n.status === 'needs_review');
+            if (history) {
+                stats = { tokens: { ...history.allTime.tokens }, cost: history.allTime.totalCost };
+            }
+            break;
+        case 'compact':
+            tasks = allTasks.filter((t) => t.status === 'pending');
+            decisions = allDecisions.slice(0, 10);
+            notes = allNotes.filter((n) => n.status === 'active');
+            if (history) {
+                stats = { tokens: { ...history.allTime.tokens }, cost: history.allTime.totalCost };
+            }
+            break;
+        case 'brief':
+            tasks = allTasks.filter((t) => t.status === 'pending').slice(0, 3);
+            decisions = []; // Count only
+            notes = allNotes.filter((n) => n.importance === 'critical');
+            stats = null;
+            break;
+    }
+    return {
+        provider: provider.id,
+        tasks: { items: tasks, total: allTasks.length },
+        decisions: { items: decisions, total: allDecisions.length },
+        notes: { items: notes, total: allNotes.length },
+        handoff,
+        stats,
+        sessionSummaries,
+    };
+}