@genee/omp-opsx-addon 0.3.0 → 0.5.0

package/lib/usage-poller.ts

@@ -299,8 +299,12 @@ function seedUnconfirmedFromDisk(): void {
     }
 }
 
-/** Read the realtime cache file, tolerating missing/partial fields. */
-function readRealtimeDisk(): RealtimeFile | null {
+/**
+ * Parse the realtime cache file, tolerating missing/partial fields. RAW read:
+ * shape normalization (legacy per-session → global) only — no provider-id
+ * key canonicalization; callers decide when to canonicalize.
+ */
+function parseRealtimeDisk(): RealtimeFile | null {
     try {
         const file = resolveRealtimeFile();
         if (!existsSync(file)) return null;
@@ -320,8 +324,20 @@ function readRealtimeDisk(): RealtimeFile | null {
     }
 }
 
-/** Read the fetch cache file, tolerating missing/partial fields. */
-function readFetchDisk(): FetchFile | null {
+/**
+ * Read the realtime cache file, tolerating missing/partial fields. Old
+ * provider ids (`ArkCodingPlan` / `arkcodingplan`) are canonicalized into
+ * `ark-coding-plan` before returning, so every consumer (render, dirty
+ * signal, locked delta re-read) sees a single canonical column.
+ */
+function readRealtimeDisk(): RealtimeFile | null {
+    const disk = parseRealtimeDisk();
+    if (disk) canonicalizeRealtime(disk);
+    return disk;
+}
+
+/** Parse the fetch cache file, tolerating missing/partial fields. RAW read: no provider-id canonicalization. */
+function parseFetchDisk(): FetchFile | null {
     try {
         const file = resolveFetchFile();
         if (!existsSync(file)) return null;
@@ -336,6 +352,122 @@ function readFetchDisk(): FetchFile | null {
     }
 }
 
+/** Read the fetch cache file, tolerating missing/partial fields. Old provider ids are canonicalized. */
+function readFetchDisk(): FetchFile | null {
+    const fetch = parseFetchDisk();
+    if (fetch) canonicalizeFetch(fetch);
+    return fetch;
+}
+
+// ── provider-id canonicalization (legacy → canonical) ──────────────
+// The old npm package wrote `arkcodingplan` (mixed-case `ArkCodingPlan` in
+// models.yml); the runtime canonical id is `ark-coding-plan`. Every read path
+// normalizes disk keys onto the canonical id so a provider never surfaces as
+// two columns, and the locked write-back helpers converge the file itself.
+// All helpers are pure + idempotent: once an old key is merged and deleted,
+// the canonical key already holds the accumulated value, so a repeat pass
+// changes nothing and reports `changed === false`.
+
+/** Merge `totals` keys whose canonical form differs into that canonical key (bucket fields SUM), deleting the old keys. Returns whether anything changed. */
+function canonicalizeTotalsKeys(totals: Record<string, UsageBucket>): boolean {
+    let changed = false;
+    for (const key of Object.keys(totals)) {
+        const canonical = canonicalizeProvider(key);
+        if (canonical === key) continue;
+        changed = true;
+        const prev = normalizeBucket(totals[canonical]);
+        const src = normalizeBucket(totals[key]);
+        totals[canonical] = {
+            total: prev.total + src.total,
+            input: prev.input + src.input,
+            output: prev.output + src.output,
+        };
+        delete totals[key];
+    }
+    return changed;
+}
+
+/**
+ * Merge per-second provider keys onto their canonical form (disk shape
+ * `{sec: {provider: tokens}}`), summing tokens within the same second and
+ * deleting the old keys. Called BEFORE `transposeSeconds`, so
+ * `readRealtimeDisk` and `getSessionUsagePerSecond` share the same shape.
+ * Returns whether anything changed.
+ */
+function canonicalizeSecondsKeys(seconds: Record<string, Record<string, number>>): boolean {
+    let changed = false;
+    for (const sec of Object.keys(seconds)) {
+        const secMap = seconds[sec];
+        for (const key of Object.keys(secMap)) {
+            const canonical = canonicalizeProvider(key);
+            if (canonical === key) continue;
+            changed = true;
+            secMap[canonical] = (secMap[canonical] ?? 0) + secMap[key];
+            delete secMap[key];
+        }
+    }
+    return changed;
+}
+
+/**
+ * Merge `fetchedByProvider` keys onto their canonical form, keeping the
+ * NEWEST timestamp (freshness signal — max, never summed). Returns whether
+ * anything changed.
+ */
+function canonicalizeFetchedByProviderKeys(map: Record<string, number>): boolean {
+    let changed = false;
+    for (const key of Object.keys(map)) {
+        const canonical = canonicalizeProvider(key);
+        if (canonical === key) continue;
+        changed = true;
+        map[canonical] = Math.max(map[canonical] ?? 0, map[key]);
+        delete map[key];
+    }
+    return changed;
+}
+
+/**
+ * Rewrite `reports[].provider` onto its canonical form. When several reports
+ * collapse onto the same canonical provider (old-package + new-runtime
+ * copies), keep the LAST one — matching `mergeReports`' incoming-wins
+ * semantics (reports are never accumulated across providers). Returns whether
+ * anything changed.
+ */
+function canonicalizeReports(reports: UsageReport[]): boolean {
+    let changed = false;
+    for (const r of reports) {
+        const canonical = canonicalizeProvider(r.provider);
+        if (canonical !== r.provider) {
+            r.provider = canonical;
+            changed = true;
+        }
+    }
+    const seen = new Set<string>();
+    for (let i = reports.length - 1; i >= 0; i--) {
+        if (!seen.has(reports[i].provider)) {
+            seen.add(reports[i].provider);
+        } else {
+            reports.splice(i, 1);
+            changed = true;
+        }
+    }
+    return changed;
+}
+
+/** Canonicalize a whole realtime disk object in place; returns whether anything changed. */
+function canonicalizeRealtime(disk: RealtimeFile): boolean {
+    let changed = canonicalizeTotalsKeys(disk.totals ?? {});
+    changed = canonicalizeSecondsKeys(disk.seconds ?? {}) || changed;
+    return changed;
+}
+
+/** Canonicalize a whole fetch disk object in place; returns whether anything changed. */
+function canonicalizeFetch(fetch: FetchFile): boolean {
+    let changed = canonicalizeFetchedByProviderKeys(fetch.fetchedByProvider ?? {});
+    changed = canonicalizeReports(fetch.reports) || changed;
+    return changed;
+}
+
 /**
  * Per-session snapshot of what THIS process last wrote to the realtime file —
  * the delta baseline. On flush we add `current - lastFlushed` to the file's
@@ -438,6 +570,57 @@ function writeFetchPayload(fetch: {
     return writePayloadLocked(resolveFetchFile(), () => JSON.stringify(fetch, null, 2));
 }
 
+/**
+ * Locked atomic replace of `file` with the payload `payload()` produces —
+ * unless `payload()` returns null, in which case NOTHING is written (no
+ * tmp+rename) and the lock is simply released. Returns true when a write
+ * landed, false when the payload was null or the write failed. `payload()`
+ * runs INSIDE the lock, so the write/no-write decision can be based on a
+ * lock-consistent disk re-read (read-modify-write).
+ */
+function writePayloadLockedIfChanged(file: string, payload: () => string | null): boolean {
+    const release = acquireWriteLock(file);
+    try {
+        const body = payload();
+        if (body === null) return false;
+        ensureDir(dirname(file));
+        const tmp = `${file}.tmp-${process.pid}-${writeSeq++}`;
+        writeFileSync(tmp, body, 'utf-8');
+        renameSync(tmp, file);
+        return true;
+    } catch {
+        return false;
+    } finally {
+        release();
+    }
+}
+
+/**
+ * Convergence write for the REALTIME file: under the lock, re-read the file,
+ * canonicalize old provider ids, and write back ONLY while a legacy key is
+ * still present. Once converged the canonical keys are unchanged → payload
+ * returns null → no write (no per-tick write amplification). The in-lock
+ * re-read means the write reflects the LATEST disk state, so a concurrent
+ * session's incremental write (serialized by the same lock) is never
+ * overwritten with a stale snapshot.
+ */
+function writeRealtimeCanonicalized(): boolean {
+    return writePayloadLockedIfChanged(resolveRealtimeFile(), () => {
+        const disk = parseRealtimeDisk();
+        if (!disk) return null;
+        return canonicalizeRealtime(disk) ? JSON.stringify(disk, null, 2) : null;
+    });
+}
+
+/** Convergence write for the FETCH file — see {@link writeRealtimeCanonicalized}. */
+function writeFetchCanonicalized(): boolean {
+    return writePayloadLockedIfChanged(resolveFetchFile(), () => {
+        const fetch = parseFetchDisk();
+        if (!fetch) return null;
+        return canonicalizeFetch(fetch) ? JSON.stringify(fetch, null, 2) : null;
+    });
+}
+
 /**
  * Realtime write path: under the lock, re-read the file (the LATEST global
  * aggregates), add this process's per-provider deltas onto the corresponding
@@ -496,9 +679,13 @@ function aggregateLegacySessionUsage(
     const disk: RealtimeFile = { totals: {}, seconds: {} };
     for (const entry of Object.values(sessionUsage ?? {})) {
         for (const [provider, raw] of Object.entries(entry?.perProvider ?? {})) {
+            // Old npm-package ids (`arkcodingplan`) canonicalize here so the
+            // one-time migration never lands legacy keys on disk (this
+            // aggregation is written directly by `migrateLegacyCache`).
+            const canonical = canonicalizeProvider(provider);
             const bucket = normalizeBucket(raw);
-            const prev = normalizeBucket(disk.totals[provider]);
-            disk.totals[provider] = {
+            const prev = normalizeBucket(disk.totals[canonical]);
+            disk.totals[canonical] = {
                 total: prev.total + bucket.total,
                 input: prev.input + bucket.input,
                 output: prev.output + bucket.output,
@@ -506,7 +693,7 @@ function aggregateLegacySessionUsage(
             const seconds = typeof raw === 'object' && raw !== null ? (raw as ProviderUsageTotals).seconds : undefined;
             for (const [sec, n] of Object.entries(seconds ?? {})) {
                 const secMap = (disk.seconds[sec] ??= {});
-                secMap[provider] = (secMap[provider] ?? 0) + n;
+                secMap[canonical] = (secMap[canonical] ?? 0) + n;
             }
         }
     }
@@ -555,6 +742,14 @@ function migrateLegacyCache(): void {
  * global `fetchedAt` when the cache file predates per-provider tracking.
  */
 function syncFromDisk(loggedInProviders?: ReadonlySet<string>): void {
+    // Convergence: normalize legacy provider ids on disk. Under the lock we
+    // re-read each file and write back ONLY while an old key is still present
+    // (idempotent — once converged, later ticks write nothing). The in-lock
+    // re-read guarantees the write reflects the latest disk state, so a
+    // concurrent session's locked incremental write is never overwritten by a
+    // stale snapshot.
+    writeRealtimeCanonicalized();
+    writeFetchCanonicalized();
     // Consumption signal (→ markDirty) reads the REALTIME file's GLOBAL totals:
     // any provider whose aggregate grew since the last sync marks dirty.
     const realtime = readRealtimeDisk();
@@ -1064,6 +1259,9 @@ export function getSessionUsageTotals(): Record<string, UsageBucket> {
             return usageReadCache.totals;
         }
         const disk = JSON.parse(readFileSync(file, 'utf-8')) as RealtimeFile;
+        // Old provider ids merge into `ark-coding-plan` before caching, so the
+        // consumption waveform (index.ts render source) never sees legacy keys.
+        canonicalizeTotalsKeys(disk.totals ?? {});
         const totals: Record<string, UsageBucket> = {};
         for (const [p, raw] of Object.entries(disk.totals ?? {})) totals[p] = normalizeBucket(raw);
         usageReadCache = { ino: st.ino, mtimeMs: st.mtimeMs, size: st.size, totals };
@@ -1097,6 +1295,9 @@ export function getSessionUsagePerSecond(windowSecs = 60): Record<string, Record
             return filterSeconds(perSecondReadCache.perSecond, cutoff);
         }
         const disk = JSON.parse(readFileSync(file, 'utf-8')) as RealtimeFile;
+        // Canonicalize on the DISK shape ({sec: {provider}}), before
+        // transpose — same helper and shape as `readRealtimeDisk`.
+        canonicalizeSecondsKeys((disk.seconds ?? {}) as Record<string, Record<string, number>>);
         const perSecond = transposeSeconds((disk.seconds ?? {}) as Record<string, Record<string, number>>, cutoff);
         perSecondReadCache = { ino: st.ino, mtimeMs: st.mtimeMs, size: st.size, perSecond };
         return perSecond;

package/lib/usage-redis-multiproc.worker.ts

@@ -32,7 +32,11 @@ _setRealtimeFileForTest(realtimeFile);
 _setFetchFileForTest(join(dirname(realtimeFile), 'fetch.json'));
 _setLegacyCacheFileForTest(join(dirname(realtimeFile), 'legacy.json'));
 const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
-const provider = `provider-${sessionId}`;
+// Canonical (lowercase) provider id: the poller's read path normalizes every
+// disk key through `canonicalizeProvider`, so a mixed-case id would be folded
+// to lowercase in the file while the raw-case id flowed to the Redis mirrors —
+// breaking the file==redis consistency this test asserts.
+const provider = `provider-${sessionId.toLowerCase()}`;
 // Frozen seconds in the recent past: reconcile covers them while the worker is
 // alive; the test asserts file == redis on exactly these keys.
 const baseSec = Math.floor(Date.now() / 1000) - 10;