ccpool-server 0.0.1 → 0.0.2

package/dist/index.js

@@ -20,7 +20,7 @@ function isValidName(name) {
 }
 
 // ../../packages/core/dist/storage/storage.js
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 var DEFAULT_GROUP_ID = "default";
 function isEmptyBatch(b) {
   return b.samples.length === 0 && b.resets.length === 0 && b.messages.length === 0 && b.markers.length === 0;
@@ -57,19 +57,42 @@ function attributeShares(samples, messages, now = Date.now(), resets = [], marke
     const capSamples = samples.filter((s) => s.cap === cap).map((s) => ({ t: Date.parse(s.capturedAt), pct: s.pct })).filter((s) => Number.isFinite(s.t)).sort((a, b) => a.t - b.t);
     if (capSamples.length === 0)
       continue;
-    const resetTimes = resets.filter((r) => r.cap === cap).map((r) => Date.parse(r.at)).filter((t) => Number.isFinite(t) && t <= now);
-    out.push(...attributeCap(cap, capSamples, msgs, mks, now, resetTimes));
+    const capResets = resets.filter((r) => r.cap === cap).map((r) => ({ t: Date.parse(r.at), previousPct: r.previousPct })).filter((r) => Number.isFinite(r.t) && r.t <= now);
+    out.push(...attributeCap(cap, capSamples, msgs, mks, now, capResets));
   }
   return out;
 }
-function attributeCap(cap, capSamples, msgs, markers, now, resetTimes) {
+var RESET_DROP_MIN_PCT = 2;
+function resolveResetBoundary(capSamples, resetEvents) {
+  let boundary = -Infinity;
+  for (const e of resetEvents) {
+    if (e.t <= boundary)
+      continue;
+    let before = null;
+    let after = null;
+    for (const s of capSamples) {
+      if (s.t < e.t)
+        before = s.pct;
+      else {
+        after = s.pct;
+        break;
+      }
+    }
+    const beforeLevel = before ?? e.previousPct;
+    const corroborated = after === null || beforeLevel - after > RESET_DROP_MIN_PCT;
+    if (corroborated)
+      boundary = e.t;
+  }
+  return boundary;
+}
+function attributeCap(cap, capSamples, msgs, markers, now, resetEvents) {
   const cutoff = now - CAP_WINDOW_MS[cap];
   let start = 0;
   for (let i = 1; i < capSamples.length; i++) {
     if (capSamples[i].t < cutoff)
       start = i;
   }
-  const lastReset = resetTimes.length ? Math.max(...resetTimes) : -Infinity;
+  const lastReset = resolveResetBoundary(capSamples, resetEvents);
   if (lastReset > -Infinity) {
     let firstAfter = capSamples.length - 1;
     for (let i = 0; i < capSamples.length; i++) {
@@ -226,10 +249,104 @@ var AccountConflictError = class extends Error {
 // ../../packages/core/dist/remote/api.js
 var MIN_PASSWORD_LENGTH = 8;
 
-// ../../packages/core/dist/backend/storage.js
-var DEFAULT_PRUNE_INTERVAL_MS = 6 * 36e5;
+// ../../packages/core/dist/backend/finalizer.js
 var DEFAULT_GRACE_MS = 30 * 6e4;
 var DEFAULT_FINALIZE_INTERVAL_MS = 6e4;
+var HistoryFinalizer = class {
+  storage;
+  graceMs;
+  finalizeIntervalMs;
+  retentionMs;
+  now;
+  lastFinalizeMs = 0;
+  /** `${cap} ${windowStart}` of windows already frozen — skip recompute. */
+  frozen = /* @__PURE__ */ new Set();
+  constructor(storage, opts = {}) {
+    this.storage = storage;
+    this.graceMs = opts.graceMs ?? DEFAULT_GRACE_MS;
+    this.finalizeIntervalMs = opts.finalizeIntervalMs ?? DEFAULT_FINALIZE_INTERVAL_MS;
+    this.retentionMs = opts.retentionMs ?? RETENTION_MS;
+    this.now = opts.now ?? Date.now;
+  }
+  /**
+   * Freeze any window whose closing reset is now past the grace period. Throttled.
+   * A window spans two consecutive resets of the cap (the first opens at the
+   * earliest retained sample); shares come from the same `attributeShares` the live
+   * view uses.
+   */
+  async maybeFinalize(now = this.now()) {
+    if (now - this.lastFinalizeMs < this.finalizeIntervalMs)
+      return;
+    this.lastFinalizeMs = now;
+    const since = new Date(now - this.retentionMs).toISOString();
+    const resets = await this.storage.getResetsSince(since);
+    if (resets.length === 0)
+      return;
+    const capResets = /* @__PURE__ */ new Map();
+    for (const r of resets) {
+      const t = Date.parse(r.at);
+      if (!Number.isFinite(t))
+        continue;
+      const arr = capResets.get(r.cap);
+      if (arr)
+        arr.push(t);
+      else
+        capResets.set(r.cap, [t]);
+    }
+    let samples = null;
+    let messages = null;
+    let markers = null;
+    for (const [cap, times] of capResets) {
+      times.sort((a, b) => a - b);
+      for (let i = 0; i < times.length; i++) {
+        const endMs = times[i];
+        if (endMs + this.graceMs > now)
+          continue;
+        if (samples === null) {
+          [samples, messages, markers] = await Promise.all([
+            this.storage.getUsageSamplesSince(since),
+            this.storage.getMessageUsageSince(since),
+            this.storage.getUsageMarkersSince(since).catch(() => [])
+          ]);
+        }
+        const capSamples = samples.filter((s) => s.cap === cap);
+        const startMs = i > 0 ? times[i - 1] : Math.min(...capSamples.map((s) => Date.parse(s.capturedAt)).filter(Number.isFinite));
+        if (!Number.isFinite(startMs) || startMs >= endMs)
+          continue;
+        const windowStart = new Date(startMs).toISOString();
+        const key = `${cap} ${windowStart}`;
+        if (this.frozen.has(key))
+          continue;
+        const windowEnd = new Date(endMs).toISOString();
+        const inWin = (iso) => {
+          const t = Date.parse(iso);
+          return t >= startMs && t < endMs;
+        };
+        const winSamples = capSamples.filter((s) => inWin(s.capturedAt));
+        if (winSamples.length === 0) {
+          this.frozen.add(key);
+          continue;
+        }
+        const winMsgs = messages.filter((m) => inWin(m.timestamp));
+        const winMarkers = markers.filter((m) => inWin(m.at));
+        const openingReset = [{ cap, at: windowStart, previousPct: 0 }];
+        const shares = attributeShares(winSamples, winMsgs, endMs, openingReset, winMarkers).filter((sh) => sh.cap === cap);
+        const overall = Math.max(...winSamples.map((s) => s.pct));
+        const historyShares = shares.map((sh) => ({
+          cap,
+          windowStart,
+          user: sh.user,
+          pct: sh.pct
+        }));
+        await this.storage.recordHistoryWindow({ cap, windowStart, windowEnd, overall, closedAt: new Date(now).toISOString() }, historyShares);
+        this.frozen.add(key);
+      }
+    }
+  }
+};
+
+// ../../packages/core/dist/backend/storage.js
+var DEFAULT_PRUNE_INTERVAL_MS = 6 * 36e5;
 var EnvelopeFilter = class {
   envMax = /* @__PURE__ */ new Map();
   winStart = /* @__PURE__ */ new Map();
@@ -269,22 +386,22 @@ var StorageIngestSink = class {
   lastPruneMs;
   retentionMs;
   pruneIntervalMs;
-  graceMs;
-  finalizeIntervalMs;
-  lastFinalizeMs = 0;
-  /** `${cap} ${windowStart}` of windows already frozen — skip recompute. */
-  frozen = /* @__PURE__ */ new Set();
   now;
   window;
+  finalizer;
   envelope = new EnvelopeFilter();
   constructor(storage, opts = {}) {
     this.storage = storage;
     this.retentionMs = opts.retentionMs ?? RETENTION_MS;
     this.pruneIntervalMs = opts.pruneIntervalMs ?? DEFAULT_PRUNE_INTERVAL_MS;
-    this.graceMs = opts.graceMs ?? DEFAULT_GRACE_MS;
-    this.finalizeIntervalMs = opts.finalizeIntervalMs ?? DEFAULT_FINALIZE_INTERVAL_MS;
     this.now = opts.now ?? Date.now;
     this.window = opts.window;
+    this.finalizer = opts.finalizer ?? new HistoryFinalizer(storage, {
+      graceMs: opts.graceMs,
+      finalizeIntervalMs: opts.finalizeIntervalMs,
+      retentionMs: opts.retentionMs,
+      now: opts.now
+    });
     this.lastPruneMs = this.now();
   }
   /**
@@ -316,7 +433,7 @@ var StorageIngestSink = class {
       this.window?.append(reduced);
     }
     const now = this.now();
-    await this.maybeFinalize(now);
+    await this.finalizer.maybeFinalize(now);
     if (now - this.lastPruneMs >= this.pruneIntervalMs) {
       this.lastPruneMs = now;
       const before = new Date(now - this.retentionMs).toISOString();
@@ -324,82 +441,6 @@ var StorageIngestSink = class {
       this.window?.applyPrune(before);
     }
   }
-  /**
-   * Freeze any window whose closing reset is now past the grace period into an
-   * immutable {@link HistoryWindow} + shares (ADR-0002/0008). Throttled (grace is 30
-   * min). A window spans two consecutive resets of the cap (the first opens at the
-   * earliest retained sample); shares come from the same `attributeShares` the live
-   * view uses. `recordHistoryWindow` is idempotent and `frozen` skips recompute.
-   */
-  async maybeFinalize(now) {
-    if (now - this.lastFinalizeMs < this.finalizeIntervalMs)
-      return;
-    this.lastFinalizeMs = now;
-    const since = new Date(now - this.retentionMs).toISOString();
-    const resets = await this.storage.getResetsSince(since);
-    if (resets.length === 0)
-      return;
-    const capResets = /* @__PURE__ */ new Map();
-    for (const r of resets) {
-      const t = Date.parse(r.at);
-      if (!Number.isFinite(t))
-        continue;
-      const arr = capResets.get(r.cap);
-      if (arr)
-        arr.push(t);
-      else
-        capResets.set(r.cap, [t]);
-    }
-    let samples = null;
-    let messages = null;
-    let markers = null;
-    for (const [cap, times] of capResets) {
-      times.sort((a, b) => a - b);
-      for (let i = 0; i < times.length; i++) {
-        const endMs = times[i];
-        if (endMs + this.graceMs > now)
-          continue;
-        if (samples === null) {
-          [samples, messages, markers] = await Promise.all([
-            this.storage.getUsageSamplesSince(since),
-            this.storage.getMessageUsageSince(since),
-            this.storage.getUsageMarkersSince(since).catch(() => [])
-          ]);
-        }
-        const capSamples = samples.filter((s) => s.cap === cap);
-        const startMs = i > 0 ? times[i - 1] : Math.min(...capSamples.map((s) => Date.parse(s.capturedAt)).filter(Number.isFinite));
-        if (!Number.isFinite(startMs) || startMs >= endMs)
-          continue;
-        const windowStart = new Date(startMs).toISOString();
-        const key = `${cap} ${windowStart}`;
-        if (this.frozen.has(key))
-          continue;
-        const windowEnd = new Date(endMs).toISOString();
-        const inWin = (iso) => {
-          const t = Date.parse(iso);
-          return t >= startMs && t < endMs;
-        };
-        const winSamples = capSamples.filter((s) => inWin(s.capturedAt));
-        if (winSamples.length === 0) {
-          this.frozen.add(key);
-          continue;
-        }
-        const winMsgs = messages.filter((m) => inWin(m.timestamp));
-        const winMarkers = markers.filter((m) => inWin(m.at));
-        const openingReset = [{ cap, at: windowStart, previousPct: 0 }];
-        const shares = attributeShares(winSamples, winMsgs, endMs, openingReset, winMarkers).filter((sh) => sh.cap === cap);
-        const overall = Math.max(...winSamples.map((s) => s.pct));
-        const historyShares = shares.map((sh) => ({
-          cap,
-          windowStart,
-          user: sh.user,
-          pct: sh.pct
-        }));
-        await this.storage.recordHistoryWindow({ cap, windowStart, windowEnd, overall, closedAt: new Date(now).toISOString() }, historyShares);
-        this.frozen.add(key);
-      }
-    }
-  }
   async close() {
     await this.storage.close();
   }
@@ -422,16 +463,22 @@ var StorageViewSource = class {
       before: query.before,
       limit
     });
-    const view = await Promise.all(windows.map(async (w) => ({
+    const shares = await this.storage.getHistorySharesForWindows(query.cap, windows.map((w) => w.windowStart));
+    const byWindow = /* @__PURE__ */ new Map();
+    for (const s of shares) {
+      const arr = byWindow.get(s.windowStart);
+      if (arr)
+        arr.push({ user: s.user, pct: s.pct });
+      else
+        byWindow.set(s.windowStart, [{ user: s.user, pct: s.pct }]);
+    }
+    const view = windows.map((w) => ({
       cap: w.cap,
       windowStart: w.windowStart,
       windowEnd: w.windowEnd,
       overall: w.overall,
-      shares: (await this.storage.getHistoryShares(query.cap, w.windowStart)).map((s) => ({
-        user: s.user,
-        pct: s.pct
-      }))
-    })));
+      shares: byWindow.get(w.windowStart) ?? []
+    }));
     const nextBefore = windows.length === limit && windows.length > 0 ? windows[windows.length - 1].windowStart : null;
     return { windows: view, nextBefore };
   }
@@ -868,6 +915,8 @@ var MAX_INGEST_BYTES = 1024 * 1024;
 var TOKEN_TOUCH_INTERVAL_MS = 6e4;
 var TOKEN_CACHE_TTL_MS = 6e4;
 var TOKEN_CACHE_MAX = 2e4;
+var TOKEN_STALE_MS = 90 * 24 * 36e5;
+var TOKEN_SWEEP_INTERVAL_MS = 6 * 36e5;
 function err(c, status, code, error) {
   return c.json({ error, code }, status);
 }
@@ -897,6 +946,7 @@ function makeApp(deps2) {
   const damper = new FailureDamper();
   const lastTouch = /* @__PURE__ */ new Map();
   const tokenCache = /* @__PURE__ */ new Map();
+  let lastTokenSweep = 0;
   const damperKey = (accountId) => accountId;
   app2.get("/healthz", (c) => c.json({ ok: true }));
   app2.use("/v1/ingest", bearer);
@@ -925,10 +975,21 @@ function makeApp(deps2) {
       tokenCache.set(tokenHash, hit);
     }
     if (now - (lastTouch.get(tokenHash) ?? 0) >= TOKEN_TOUCH_INTERVAL_MS) {
+      lastTouch.delete(tokenHash);
       lastTouch.set(tokenHash, now);
+      if (lastTouch.size > TOKEN_CACHE_MAX) {
+        const oldest = lastTouch.keys().next().value;
+        if (oldest !== void 0) lastTouch.delete(oldest);
+      }
       await registry.touchToken(tokenHash).catch(() => {
       });
     }
+    if (now - lastTokenSweep >= TOKEN_SWEEP_INTERVAL_MS) {
+      lastTokenSweep = now;
+      const before = new Date(now - TOKEN_STALE_MS).toISOString();
+      void registry.deleteStaleTokens(before).catch(() => {
+      });
+    }
     c.set("member", hit.member);
     c.set("group", hit.group);
     await next();
@@ -969,7 +1030,7 @@ function makeApp(deps2) {
       if (e instanceof RegistryConflictError) {
         return err(c, 409, "conflict", "a group for this Claude account already exists \u2014 join it");
       }
-      return err(c, 500, "invalid", `could not provision the group: ${e.message}`);
+      return err(c, 500, "server", `could not provision the group: ${e.message}`);
     }
   });
   app2.post("/v1/groups/join", async (c) => {
@@ -1064,7 +1125,7 @@ function makeApp(deps2) {
       if (e instanceof AccountConflictError) {
         return err(c, 409, "account-conflict", e.message);
       }
-      return err(c, 500, "invalid", e.message);
+      return err(c, 500, "server", e.message);
     }
     return c.body(null, 204);
   });
@@ -1078,6 +1139,8 @@ function makeApp(deps2) {
     const group = c.get("group");
     const tenant = await tenants.get(group);
     const now = Date.now();
+    await tenant.finalizer.maybeFinalize(now).catch(() => {
+    });
     const etag = `"${await tenant.view.currentKey(now)}"`;
     if (c.req.header("if-none-match") === etag) {
       return c.body(null, 304, { ETag: etag });
@@ -1092,6 +1155,8 @@ function makeApp(deps2) {
     const limitRaw = Number(c.req.query("limit"));
     const limit = Number.isFinite(limitRaw) && limitRaw > 0 ? Math.min(200, Math.floor(limitRaw)) : 50;
     const tenant = await tenants.get(c.get("group"));
+    await tenant.finalizer.maybeFinalize(Date.now()).catch(() => {
+    });
     const page = await tenant.view.history({ cap: capQ, before, limit });
     return c.json(page);
   });
@@ -1157,7 +1222,7 @@ var LEDGER_DDL = [
    )`,
   `CREATE INDEX IF NOT EXISTS idx_reset_events_at ON reset_events (group_id, at)`,
   `CREATE UNIQUE INDEX IF NOT EXISTS idx_reset_events_uniq ON reset_events (group_id, cap, at)`,
-  // Immutable history of completed cap cycles (ADR-0002/0005). Retained unbounded.
+  // Immutable history of completed cap cycles. Retained unbounded.
   `CREATE TABLE IF NOT EXISTS history_windows (
      group_id TEXT NOT NULL,
      cap TEXT NOT NULL,
@@ -1269,6 +1334,21 @@ var LibsqlRegistry = class {
       args: [(/* @__PURE__ */ new Date()).toISOString(), tokenHash]
     });
   }
+  /**
+   * Bearer retention: delete every token last used (or, if never used, created)
+   * before `before` (ISO 8601), returning how many were removed. A live daemon
+   * touches its token ~once a minute, so a token untouched for the whole window is
+   * genuinely abandoned — this bounds the `tokens` table without logging anyone
+   * active out. `COALESCE(lastUsedAt, createdAt)` covers a token minted but never
+   * used (login/rejoin that was thrown away).
+   */
+  async deleteStaleTokens(before) {
+    const { rowsAffected } = await this.client.execute({
+      sql: `DELETE FROM tokens WHERE COALESCE(lastUsedAt, createdAt) < ?`,
+      args: [before]
+    });
+    return rowsAffected;
+  }
   async createGroupWithMember(input) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const group = {
@@ -1663,12 +1743,18 @@ var LibsqlStorage = class {
             WHERE group_id = ? AND cap = ? AND windowStart = ?`,
       args: [this.groupId, cap, windowStart]
     });
-    return rows.map((r) => ({
-      cap: r.cap,
-      windowStart: String(r.windowStart),
-      user: String(r.user),
-      pct: Number(r.pct)
-    }));
+    return rows.map(toHistoryShare);
+  }
+  async getHistorySharesForWindows(cap, windowStarts) {
+    if (windowStarts.length === 0)
+      return [];
+    const placeholders = windowStarts.map(() => "?").join(", ");
+    const { rows } = await this.client.execute({
+      sql: `SELECT cap, windowStart, user, pct FROM history_shares
+            WHERE group_id = ? AND cap = ? AND windowStart IN (${placeholders})`,
+      args: [this.groupId, cap, ...windowStarts]
+    });
+    return rows.map(toHistoryShare);
   }
   /** Every write batch ends with this so one tick bumps this group's token once. */
   bumpWriteSeq() {
@@ -1678,6 +1764,14 @@ var LibsqlStorage = class {
     };
   }
 };
+function toHistoryShare(r) {
+  return {
+    cap: r.cap,
+    windowStart: String(r.windowStart),
+    user: String(r.user),
+    pct: Number(r.pct)
+  };
+}
 
 // ../../packages/storage-libsql/dist/url.js
 import { mkdirSync } from "fs";
@@ -1769,10 +1863,12 @@ var TenantCache = class {
     }
     const storage = this.db.forGroup(group.id);
     const window = new LedgerWindow(storage);
+    const finalizer = new HistoryFinalizer(storage);
     const entry = {
       tenant: {
-        sink: new StorageIngestSink(storage, { window }),
-        view: new StorageViewSource(storage, { window })
+        sink: new StorageIngestSink(storage, { window, finalizer }),
+        view: new StorageViewSource(storage, { window }),
+        finalizer
       }
     };
     this.tenants.set(group.id, entry);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ccpool-server",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Multi-tenant HTTP server for ccpool (Hono + libSQL) — the one path to the shared ledger. Self-host it to run your own group.",
   "keywords": [
     "claude",
@@ -48,9 +48,9 @@
     "tsup": "^8.3.5",
     "tsx": "^4.19.2",
     "typescript": "^5.7.2",
-    "@ccpool/core": "0.0.1",
-    "@ccpool/storage-libsql": "0.0.1",
-    "@ccpool/daemon": "0.0.1"
+    "@ccpool/core": "0.0.2",
+    "@ccpool/daemon": "0.0.1",
+    "@ccpool/storage-libsql": "0.0.1"
   },
   "scripts": {
     "build": "tsup",