crewx 0.9.0-rc.63 → 0.9.0-rc.64

package/dist-server/common/cache-db.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kvGet = kvGet;
+exports.kvSet = kvSet;
+exports.kvDel = kvDel;
+exports.kvHas = kvHas;
+exports.close = close;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const sdk_1 = require("@crewx/sdk");
+const MEMORY_MISS = Symbol('cache-miss');
+const memory = new Map();
+let database;
+let databasePath;
+function loadDatabaseConstructor() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require('better-sqlite3');
+}
+function secureDatabaseFiles(filePath) {
+    for (const path of [filePath, `${filePath}-wal`, `${filePath}-shm`]) {
+        try {
+            (0, node_fs_1.chmodSync)(path, 0o600);
+        }
+        catch {
+            // SQLite may not have created a sidecar file yet.
+        }
+    }
+}
+function removeDatabaseFiles(filePath) {
+    for (const path of [filePath, `${filePath}-wal`, `${filePath}-shm`]) {
+        try {
+            (0, node_fs_1.unlinkSync)(path);
+        }
+        catch {
+            // The file may not exist or may already be gone.
+        }
+    }
+}
+function initializeDatabase(filePath) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.join)(filePath, '..'), { recursive: true, mode: 0o700 });
+    const db = new (loadDatabaseConstructor())(filePath);
+    try {
+        db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA busy_timeout = 5000;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA user_version = 1;
+
+      CREATE TABLE IF NOT EXISTS kv (
+        key        TEXT    PRIMARY KEY NOT NULL,
+        value      TEXT    NOT NULL,
+        expires_at INTEGER NOT NULL,
+        CHECK (length(key) BETWEEN 1 AND 1024),
+        CHECK (instr(key, char(0)) = 0),
+        CHECK (expires_at >= 0)
+      ) WITHOUT ROWID;
+
+      CREATE INDEX IF NOT EXISTS idx_kv_expires_at
+        ON kv (expires_at);
+    `);
+        db.prepare('DELETE FROM kv WHERE expires_at <= ?').run(Date.now());
+        secureDatabaseFiles(filePath);
+        return db;
+    }
+    catch (error) {
+        try {
+            db.close();
+        }
+        catch {
+            // Ignore close errors while recovering a broken cache database.
+        }
+        throw error;
+    }
+}
+function openDatabase(filePath) {
+    try {
+        return initializeDatabase(filePath);
+    }
+    catch {
+        removeDatabaseFiles(filePath);
+        try {
+            return initializeDatabase(filePath);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function getDatabase() {
+    const filePath = (0, node_path_1.join)((0, sdk_1.getCrewxHome)(), 'cache.db');
+    if (database && databasePath !== filePath) {
+        close();
+    }
+    if (!database) {
+        databasePath = filePath;
+        database = openDatabase(filePath);
+    }
+    return database;
+}
+function deletePersistent(key) {
+    const db = getDatabase();
+    if (!db)
+        return;
+    try {
+        db.prepare('DELETE FROM kv WHERE key = ?').run(key);
+        secureDatabaseFiles(databasePath ?? '');
+    }
+    catch {
+        // Cache file writes are best effort.
+    }
+}
+function getMemoryEntry(key, now) {
+    const entry = memory.get(key);
+    if (!entry)
+        return undefined;
+    if (entry.expiresAt <= now) {
+        memory.delete(key);
+        deletePersistent(key);
+        return undefined;
+    }
+    return entry;
+}
+function readPersistent(key, now) {
+    const db = getDatabase();
+    if (!db)
+        return MEMORY_MISS;
+    let row;
+    try {
+        row = db.prepare('SELECT value, expires_at FROM kv WHERE key = ?').get(key);
+    }
+    catch {
+        return MEMORY_MISS;
+    }
+    if (!row)
+        return MEMORY_MISS;
+    if (row.expires_at <= now) {
+        deletePersistent(key);
+        return MEMORY_MISS;
+    }
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        deletePersistent(key);
+        return MEMORY_MISS;
+    }
+}
+function kvGet(key) {
+    const now = Date.now();
+    const memoryEntry = getMemoryEntry(key, now);
+    if (memoryEntry)
+        return memoryEntry.value;
+    const value = readPersistent(key, now);
+    if (value === MEMORY_MISS)
+        return undefined;
+    const row = getDatabase()?.prepare('SELECT expires_at FROM kv WHERE key = ?').get(key);
+    if (row)
+        memory.set(key, { value, expiresAt: row.expires_at });
+    return value;
+}
+function kvSet(key, value, ttlMs) {
+    const expiresAt = Date.now() + ttlMs;
+    memory.set(key, { value, expiresAt });
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        return;
+    }
+    if (serialized === undefined)
+        return;
+    const db = getDatabase();
+    if (!db)
+        return;
+    try {
+        db.prepare(`
+      INSERT INTO kv (key, value, expires_at) VALUES (?, ?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value, expires_at = excluded.expires_at
+    `).run(key, serialized, expiresAt);
+        secureDatabaseFiles(databasePath ?? '');
+    }
+    catch {
+        // The in-memory value remains available when the cache file is unavailable.
+    }
+}
+function kvDel(key) {
+    memory.delete(key);
+    deletePersistent(key);
+}
+function kvHas(key) {
+    const now = Date.now();
+    if (getMemoryEntry(key, now))
+        return true;
+    const value = readPersistent(key, now);
+    if (value === MEMORY_MISS)
+        return false;
+    const row = getDatabase()?.prepare('SELECT expires_at FROM kv WHERE key = ?').get(key);
+    if (row)
+        memory.set(key, { value, expiresAt: row.expires_at });
+    return true;
+}
+function close() {
+    memory.clear();
+    try {
+        database?.close();
+    }
+    catch {
+        // Ignore close errors during shutdown and test cleanup.
+    }
+    database = undefined;
+    databasePath = undefined;
+}

package/dist-server/common/decorator/cached.decorator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cached = Cached;
+const cache_db_js_1 = require("../cache-db.js");
+function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && 'then' in value && typeof value.then === 'function';
+}
+function Cached(options) {
+    return (_target, _propertyKey, descriptor) => {
+        if (!descriptor || typeof descriptor.value !== 'function') {
+            throw new TypeError('@Cached can only decorate methods');
+        }
+        const original = descriptor.value;
+        const returnsPromise = original.constructor.name === 'AsyncFunction';
+        const wrapped = function (...args) {
+            const cacheKey = options.key.replace(/\{(\d+)\}/g, (_match, index) => {
+                const argument = args[Number(index)];
+                return argument === undefined || argument === null ? '' : String(argument);
+            });
+            const cached = (0, cache_db_js_1.kvGet)(cacheKey);
+            if (cached !== undefined)
+                return returnsPromise ? Promise.resolve(cached) : cached;
+            const result = original.apply(this, args);
+            if (isPromiseLike(result)) {
+                return Promise.resolve(result).then((value) => {
+                    (0, cache_db_js_1.kvSet)(cacheKey, value, options.ttlMs);
+                    return value;
+                });
+            }
+            (0, cache_db_js_1.kvSet)(cacheKey, result, options.ttlMs);
+            return result;
+        };
+        descriptor.value = wrapped;
+    };
+}

package/dist-server/domain/auth/session-store.js

@@ -1,26 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionStore = void 0;
 exports.createSession = createSession;
 exports.validateSession = validateSession;
 exports.destroySession = destroySession;
-const crypto_1 = require("crypto");
-const sessions = new Map();
+exports.closeSessionStore = closeSessionStore;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const crewx_home_js_1 = require("../../shared/crewx-home.js");
+const sessions_db_js_1 = require("./sessions-db.js");
 const SESSION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days (matches cookie maxAge)
+function hashSessionId(sessionId) {
+    return (0, node_crypto_1.createHash)('sha256').update(sessionId).digest('hex');
+}
+function defaultSessionsPath() {
+    return (0, node_path_1.join)((0, crewx_home_js_1.getCrewxHome)(), 'sessions.db');
+}
+/** Owns one sessions.db handle and its in-memory first-level session cache. */
+class SessionStore {
+    database;
+    sessions = new Map();
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    createSession() {
+        const now = Date.now();
+        const expiresAt = now + SESSION_MAX_AGE_MS;
+        const rawSessionId = (0, node_crypto_1.randomBytes)(32).toString('hex');
+        const hashedSessionId = hashSessionId(rawSessionId);
+        // The database write must complete before the raw cookie value is returned.
+        this.databaseHandle()
+            .prepare('INSERT INTO web_sessions (id, created_at, expires_at) VALUES (?, ?, ?)')
+            .run(hashedSessionId, now, expiresAt);
+        this.sessions.set(rawSessionId, { expiresAt });
+        return rawSessionId;
+    }
+    validateSession(rawSessionId) {
+        const now = Date.now();
+        const memorySession = this.sessions.get(rawSessionId);
+        if (memorySession) {
+            if (memorySession.expiresAt > now)
+                return true;
+            this.sessions.delete(rawSessionId);
+            this.deleteByHash(hashSessionId(rawSessionId));
+            return false;
+        }
+        const hashedSessionId = hashSessionId(rawSessionId);
+        const row = this.databaseHandle()
+            .prepare('SELECT id, created_at, expires_at FROM web_sessions WHERE id = ?')
+            .get(hashedSessionId);
+        if (!row)
+            return false;
+        if (row.expires_at <= now) {
+            this.deleteByHash(hashedSessionId);
+            return false;
+        }
+        this.sessions.set(rawSessionId, { expiresAt: row.expires_at });
+        return true;
+    }
+    destroySession(rawSessionId) {
+        this.sessions.delete(rawSessionId);
+        this.deleteByHash(hashSessionId(rawSessionId));
+    }
+    /** Close the handle and clear the memory cache, simulating a process restart. */
+    close() {
+        this.sessions.clear();
+        if (!this.database)
+            return;
+        this.database.close();
+        this.database = undefined;
+    }
+    databaseHandle() {
+        if (!this.database) {
+            this.database = (0, sessions_db_js_1.openSessionsDatabase)(this.dbPath ?? defaultSessionsPath());
+            this.database.prepare('DELETE FROM web_sessions WHERE expires_at <= ?').run(Date.now());
+        }
+        return this.database;
+    }
+    deleteByHash(hashedSessionId) {
+        this.databaseHandle().prepare('DELETE FROM web_sessions WHERE id = ?').run(hashedSessionId);
+    }
+}
+exports.SessionStore = SessionStore;
+let defaultStore;
+function getDefaultStore() {
+    return (defaultStore ??= new SessionStore());
+}
 function createSession() {
-    const sessionId = (0, crypto_1.randomBytes)(32).toString('hex');
-    sessions.set(sessionId, { createdAt: Date.now() });
-    return sessionId;
+    return getDefaultStore().createSession();
 }
 function validateSession(sessionId) {
-    const session = sessions.get(sessionId);
-    if (!session)
-        return false;
-    if (Date.now() - session.createdAt > SESSION_MAX_AGE_MS) {
-        sessions.delete(sessionId);
-        return false;
-    }
-    return true;
+    return getDefaultStore().validateSession(sessionId);
 }
 function destroySession(sessionId) {
-    sessions.delete(sessionId);
+    getDefaultStore().destroySession(sessionId);
+}
+/** Close the module singleton so the next operation reopens sessions.db. */
+function closeSessionStore() {
+    defaultStore?.close();
 }

package/dist-server/domain/auth/sessions-db.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSessionsDatabase = openSessionsDatabase;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const DATABASE_FILE_MODE = 0o600;
+const DATABASE_DIRECTORY_MODE = 0o700;
+const WEB_SESSIONS_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS web_sessions (
+    id         TEXT    PRIMARY KEY NOT NULL,
+    created_at INTEGER NOT NULL,
+    expires_at INTEGER NOT NULL,
+    CHECK (
+      length(id) = 64
+      AND id = lower(id)
+      AND id NOT GLOB '*[^0-9a-f]*'
+    ),
+    CHECK (created_at >= 0),
+    CHECK (expires_at > created_at)
+  ) WITHOUT ROWID;
+
+  CREATE INDEX IF NOT EXISTS idx_web_sessions_expires_at
+    ON web_sessions (expires_at);
+`;
+function chmodIfPresent(filePath) {
+    if ((0, node_fs_1.existsSync)(filePath))
+        (0, node_fs_1.chmodSync)(filePath, DATABASE_FILE_MODE);
+}
+function setFilePermissions(dbPath) {
+    chmodIfPresent(dbPath);
+    chmodIfPresent(`${dbPath}-wal`);
+    chmodIfPresent(`${dbPath}-shm`);
+}
+function isCorruptionError(error) {
+    if (!(error instanceof Error))
+        return false;
+    return /not a database|database disk image is malformed|file is encrypted|malformed/i.test(error.message);
+}
+function removeDatabaseFiles(dbPath) {
+    for (const filePath of [dbPath, `${dbPath}-wal`, `${dbPath}-shm`]) {
+        try {
+            (0, node_fs_1.unlinkSync)(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+}
+function initializeDatabase(dbPath) {
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(dbPath), { recursive: true, mode: DATABASE_DIRECTORY_MODE });
+    const database = new better_sqlite3_1.default(dbPath);
+    try {
+        database.pragma('journal_mode = WAL');
+        database.pragma('busy_timeout = 5000');
+        database.pragma('synchronous = FULL');
+        database.pragma('user_version = 1');
+        database.exec(WEB_SESSIONS_SCHEMA);
+        setFilePermissions(dbPath);
+        return database;
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+}
+/** Open the dedicated web-session database with its durability and permission policy. */
+function openSessionsDatabase(dbPath) {
+    try {
+        return initializeDatabase(dbPath);
+    }
+    catch (error) {
+        if (!isCorruptionError(error))
+            throw error;
+        removeDatabaseFiles(dbPath);
+        return initializeDatabase(dbPath);
+    }
+}

package/dist-server/domain/usage/usage.service.js

@@ -59,15 +59,13 @@ const project_repository_js_1 = require("../../repository/project.repository.js"
 const usage_limit_snapshot_repository_js_1 = require("../../repository/usage-limit-snapshot.repository.js");
 const repository_1 = require("@crewx/sdk/repository");
 const sdk_1 = require("@crewx/sdk");
-const CACHE_TTL = 5 * 60 * 1000; // 5분
-const CACHE_MAX_SIZE = 10;
-const CACHE_CLEANUP_INTERVAL = 5 * 60 * 1000; // 5분
+const cache_db_js_1 = require("../../common/cache-db.js");
+const cached_decorator_js_1 = require("../../common/decorator/cached.decorator.js");
 const CLAUDE_OAUTH_CACHE_TTL = 5 * 60 * 1000; // 5분
 const GLM_OAUTH_CACHE_TTL = 5 * 60 * 1000; // 5분
 const GROK_OAUTH_CACHE_TTL = 5 * 60 * 1000; // 5분
 const CODEX_CACHE_TTL = 5 * 60 * 1000; // 5분
-const AGG_CACHE_TTL_MS = 60_000;
-const AGG_CACHE_MAX_SIZE = 64;
+const AGG_CACHE_TTL_MS = 30 * 60 * 1000;
 // WI-20260718-002: exponential backoff for negative (failed) provider caches.
 // 30s → 1m → 2m → 5m (max), reset to step 0 on the next success.
 const FAIL_BACKOFF_STEPS_MS = [30 * 1000, 60 * 1000, 2 * 60 * 1000, 5 * 60 * 1000];
@@ -90,9 +88,6 @@ let UsageService = UsageService_1 = class UsageService {
     projectRepository;
     snapshotRepo;
     logger = new common_1.Logger(UsageService_1.name);
-    cache = new Map();
-    aggCache = new Map();
-    cleanupInterval;
     claudeOAuthCache = createProviderCache();
     glmCache = createProviderCache();
     grokCache = createProviderCache();
@@ -112,32 +107,22 @@ let UsageService = UsageService_1 = class UsageService {
         this.taskRepository = taskRepository;
         this.projectRepository = projectRepository;
         this.snapshotRepo = snapshotRepo;
-        this.cleanupInterval = setInterval(() => this.evictExpired(), CACHE_CLEANUP_INTERVAL);
-    }
-    onModuleDestroy() {
-        clearInterval(this.cleanupInterval);
     }
     async getDailyUsage(provider, force) {
-        const cacheKey = `daily:${provider}`;
-        if (!force) {
-            const cached = this.getFromCache(cacheKey);
-            if (cached)
-                return { data: cached, cached: true };
-        }
+        const cacheKey = `usage:daily:${provider}`;
+        if (force)
+            (0, cache_db_js_1.kvDel)(cacheKey);
+        const cached = !force && (0, cache_db_js_1.kvHas)(cacheKey);
         const data = await this.loadDaily(provider);
-        this.setCache(cacheKey, data);
-        return { data, cached: false };
+        return { data, cached };
     }
     async getMonthlyUsage(provider, force) {
-        const cacheKey = `monthly:${provider}`;
-        if (!force) {
-            const cached = this.getFromCache(cacheKey);
-            if (cached)
-                return { data: cached, cached: true };
-        }
+        const cacheKey = `usage:monthly:${provider}`;
+        if (force)
+            (0, cache_db_js_1.kvDel)(cacheKey);
+        const cached = !force && (0, cache_db_js_1.kvHas)(cacheKey);
         const data = await this.loadMonthly(provider);
-        this.setCache(cacheKey, data);
-        return { data, cached: false };
+        return { data, cached };
     }
     async loadDaily(provider) {
         const warnings = [];
@@ -177,10 +162,6 @@ let UsageService = UsageService_1 = class UsageService {
     }
     // --- USG.AGENT: Agent usage aggregation ---
     getAgentUsage(from, to, workspace) {
-        const cacheKey = this.aggCacheKey('agent', from, to, workspace);
-        const cached = this.getAggCache(cacheKey);
-        if (cached)
-            return cached;
         const rows = this.taskRepository.getAgentUsage(from, to, workspace);
         const wsNameMap = this.resolveWorkspaceNames(rows.map((r) => r.workspace_id).filter((id) => id !== null));
         const grandTotalTokens = rows.reduce((sum, r) => sum + r.total_tokens, 0);
@@ -207,15 +188,10 @@ let UsageService = UsageService_1 = class UsageService {
             totalActiveDurationMs: rows.reduce((sum, r) => sum + r.active_duration_ms, 0),
         };
         const data = { from, to, agents, totals };
-        this.setAggCache(cacheKey, data);
         return data;
     }
     // --- USG.AGENT.TREND: Agent daily trend ---
     getAgentUsageTrend(from, to, tz, workspace) {
-        const cacheKey = this.aggCacheKey('trend', from, to, workspace, tz);
-        const cached = this.getAggCache(cacheKey);
-        if (cached)
-            return cached;
         const rows = this.taskRepository.getAgentUsageTrendRaw(from, to, workspace);
         // Group by local date (tz-converted) × agent_id
         const dailyMap = new Map();
@@ -250,15 +226,10 @@ let UsageService = UsageService_1 = class UsageService {
                 .sort((a, b) => b.totalTokens - a.totalTokens),
         }));
         const data = { from, to, timezone: tz, daily };
-        this.setAggCache(cacheKey, data);
         return data;
     }
     // --- USG.PROVIDER: Provider usage aggregation ---
     getProviderUsage(from, to, workspace) {
-        const cacheKey = this.aggCacheKey('provider', from, to, workspace);
-        const cached = this.getAggCache(cacheKey);
-        if (cached)
-            return cached;
         const rows = this.taskRepository.getProviderUsage(from, to, workspace);
         const grandTotalTokens = rows.reduce((sum, r) => sum + r.totalTokens, 0);
         const providers = rows.map((r) => ({
@@ -282,15 +253,10 @@ let UsageService = UsageService_1 = class UsageService {
             totalActiveDurationMs: rows.reduce((sum, r) => sum + r.activeDurationMs, 0),
         };
         const data = { from, to, providers, totals };
-        this.setAggCache(cacheKey, data);
         return data;
     }
     // --- USG.MODEL: Model usage aggregation ---
     getModelUsage(from, to, workspace) {
-        const cacheKey = this.aggCacheKey('model', from, to, workspace);
-        const cached = this.getAggCache(cacheKey);
-        if (cached)
-            return cached;
         const rows = this.taskRepository.getModelUsage(from, to, workspace);
         const grandTotalTokens = rows.reduce((sum, r) => sum + r.totalTokens, 0);
         const models = rows
@@ -317,7 +283,6 @@ let UsageService = UsageService_1 = class UsageService {
             totalActiveDurationMs: rows.reduce((sum, r) => sum + r.activeDurationMs, 0),
         };
         const data = { from, to, models, totals };
-        this.setAggCache(cacheKey, data);
         return data;
     }
     // --- USR: Rework rate (thread consecutive-call heuristic) ---
@@ -588,77 +553,6 @@ let UsageService = UsageService_1 = class UsageService {
         }
         return map;
     }
-    // --- Cache with size limit ---
-    getFromCache(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return null;
-        if (Date.now() - entry.timestamp > CACHE_TTL) {
-            this.cache.delete(key);
-            return null;
-        }
-        return entry.data;
-    }
-    setCache(key, data) {
-        if (this.cache.size >= CACHE_MAX_SIZE && !this.cache.has(key)) {
-            const oldestKey = this.findOldestKey();
-            if (oldestKey)
-                this.cache.delete(oldestKey);
-        }
-        this.cache.set(key, { data, timestamp: Date.now() });
-    }
-    aggCacheKey(kind, from, to, workspace, tz) {
-        return `${kind}:${from}:${to}:${workspace ?? ''}:${tz ?? ''}`;
-    }
-    getAggCache(key) {
-        const entry = this.aggCache.get(key);
-        if (!entry)
-            return null;
-        if (Date.now() - entry.timestamp > AGG_CACHE_TTL_MS) {
-            this.aggCache.delete(key);
-            return null;
-        }
-        return entry.data;
-    }
-    setAggCache(key, data) {
-        if (this.aggCache.size >= AGG_CACHE_MAX_SIZE && !this.aggCache.has(key)) {
-            let oldestKey = null;
-            let oldestTime = Infinity;
-            for (const [entryKey, entry] of this.aggCache) {
-                if (entry.timestamp < oldestTime) {
-                    oldestTime = entry.timestamp;
-                    oldestKey = entryKey;
-                }
-            }
-            if (oldestKey)
-                this.aggCache.delete(oldestKey);
-        }
-        this.aggCache.set(key, { data, timestamp: Date.now() });
-    }
-    findOldestKey() {
-        let oldestKey = null;
-        let oldestTime = Infinity;
-        for (const [key, entry] of this.cache) {
-            if (entry.timestamp < oldestTime) {
-                oldestTime = entry.timestamp;
-                oldestKey = key;
-            }
-        }
-        return oldestKey;
-    }
-    evictExpired() {
-        const now = Date.now();
-        for (const [key, entry] of this.cache) {
-            if (now - entry.timestamp > CACHE_TTL) {
-                this.cache.delete(key);
-            }
-        }
-        for (const [key, entry] of this.aggCache) {
-            if (now - entry.timestamp > AGG_CACHE_TTL_MS) {
-                this.aggCache.delete(key);
-            }
-        }
-    }
     // --- USG.LIMITS: Subscription limit windows ---
     async getSubscriptionLimits() {
         const [codex, claude, glm, grok] = await Promise.all([
@@ -792,7 +686,7 @@ let UsageService = UsageService_1 = class UsageService {
         return { fromIso: from.toISOString(), toIso };
     }
     async parseCodexLimits() {
-        return this.getCachedWithDedupe(this.codexCache, CODEX_CACHE_TTL, () => this.computeCodexLimits());
+        return this.getCachedWithDedupe(this.codexCache, CODEX_CACHE_TTL, () => this.computeCodexLimits(), 'codex');
     }
     computeCodexLimits() {
         // Tracks whether a session file was actually found this call — only a found-but-unreadable
@@ -1000,7 +894,7 @@ let UsageService = UsageService_1 = class UsageService {
         return { usedPercent: Math.round(usedPercent), resetsAt };
     }
     async parseClaudeLimits() {
-        return this.getCachedWithDedupe(this.claudeOAuthCache, CLAUDE_OAUTH_CACHE_TTL, () => this.computeClaudeLimits());
+        return this.getCachedWithDedupe(this.claudeOAuthCache, CLAUDE_OAUTH_CACHE_TTL, () => this.computeClaudeLimits(), 'claude');
     }
     async computeClaudeLimits() {
         try {
@@ -1071,7 +965,7 @@ let UsageService = UsageService_1 = class UsageService {
         return { fiveHour, sevenDay };
     }
     async parseGrokLimits() {
-        return this.getCachedWithDedupe(this.grokCache, GROK_OAUTH_CACHE_TTL, () => this.computeGrokLimits());
+        return this.getCachedWithDedupe(this.grokCache, GROK_OAUTH_CACHE_TTL, () => this.computeGrokLimits(), 'grok');
     }
     async computeGrokLimits() {
         try {
@@ -1202,7 +1096,7 @@ let UsageService = UsageService_1 = class UsageService {
         return Math.min(100, Math.max(0, Math.round(value)));
     }
     async parseGlmLimits() {
-        return this.getCachedWithDedupe(this.glmCache, GLM_OAUTH_CACHE_TTL, () => this.computeGlmLimits());
+        return this.getCachedWithDedupe(this.glmCache, GLM_OAUTH_CACHE_TTL, () => this.computeGlmLimits(), 'glm');
     }
     async computeGlmLimits() {
         try {
@@ -1262,26 +1156,36 @@ let UsageService = UsageService_1 = class UsageService {
      * - Concurrent callers hitting a cache miss share the same in-flight promise instead of
      *   firing duplicate external calls.
      */
-    async getCachedWithDedupe(cache, successTtl, fetcher) {
+    async getCachedWithDedupe(cache, successTtl, fetcher, provider) {
         const now = Date.now();
         if (!cache.inFlight && !this.isProviderCacheValid(cache, now, successTtl)) {
-            cache.inFlight = Promise.resolve()
-                .then(() => fetcher())
-                .then((result) => {
-                cache.data = result;
-                cache.ts = Date.now();
-                if (result !== null) {
-                    cache.failCount = 0;
-                    cache.lastGood = result;
-                }
-                else {
-                    cache.failCount += 1;
-                }
-                return result;
-            })
-                .finally(() => {
-                cache.inFlight = null;
-            });
+            const persisted = (0, cache_db_js_1.kvGet)(`usage:limits:${provider}`);
+            if (persisted !== undefined) {
+                cache.data = persisted;
+                cache.ts = now;
+                cache.failCount = 0;
+                cache.lastGood = persisted;
+            }
+            else {
+                cache.inFlight = Promise.resolve()
+                    .then(() => fetcher())
+                    .then((result) => {
+                    cache.data = result;
+                    cache.ts = Date.now();
+                    if (result !== null) {
+                        cache.failCount = 0;
+                        cache.lastGood = result;
+                        (0, cache_db_js_1.kvSet)(`usage:limits:${provider}`, result, successTtl);
+                    }
+                    else {
+                        cache.failCount += 1;
+                    }
+                    return result;
+                })
+                    .finally(() => {
+                    cache.inFlight = null;
+                });
+            }
         }
         if (cache.inFlight) {
             const result = await cache.inFlight;
@@ -1311,6 +1215,42 @@ let UsageService = UsageService_1 = class UsageService {
     }
 };
 exports.UsageService = UsageService;
+__decorate([
+    (0, cached_decorator_js_1.Cached)({ key: 'usage:daily:{0}', ttlMs: 5 * 60 * 1000 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UsageService.prototype, "loadDaily", null);
+__decorate([
+    (0, cached_decorator_js_1.Cached)({ key: 'usage:monthly:{0}', ttlMs: 5 * 60 * 1000 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], UsageService.prototype, "loadMonthly", null);
+__decorate([
+    (0, cached_decorator_js_1.Cached)({ key: 'usage:agg:agent:{0}:{1}:{2}', ttlMs: AGG_CACHE_TTL_MS }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Object)
+], UsageService.prototype, "getAgentUsage", null);
+__decorate([
+    (0, cached_decorator_js_1.Cached)({ key: 'usage:agg:trend:{0}:{1}:{3}:{2}', ttlMs: AGG_CACHE_TTL_MS }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, String]),
+    __metadata("design:returntype", Object)
+], UsageService.prototype, "getAgentUsageTrend", null);
+__decorate([
+    (0, cached_decorator_js_1.Cached)({ key: 'usage:agg:provider:{0}:{1}:{2}', ttlMs: AGG_CACHE_TTL_MS }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Object)
+], UsageService.prototype, "getProviderUsage", null);
+__decorate([
+    (0, cached_decorator_js_1.Cached)({ key: 'usage:agg:model:{0}:{1}:{2}', ttlMs: AGG_CACHE_TTL_MS }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Object)
+], UsageService.prototype, "getModelUsage", null);
 exports.UsageService = UsageService = UsageService_1 = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [task_repository_js_1.TaskRepository,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crewx",
-  "version": "0.9.0-rc.63",
+  "version": "0.9.0-rc.64",
   "description": "CrewX — AI agent team dashboard with Electron UI and CLI (Web + Electron + Global CLI)",
   "main": "server.js",
   "bin": {
@@ -82,20 +82,20 @@
     "wink-nlp-utils": "2.1.0",
     "yargs": "17.7.0",
     "zod": "3.25.76",
-    "@crewx/chromex": "0.1.0-rc.95",
-    "@crewx/cli": "0.9.0-rc.63",
-    "@crewx/cron": "0.1.10-rc.97",
-    "@crewx/doc": "0.1.9-rc.55",
-    "@crewx/dreaming": "0.1.0-rc.88",
-    "@crewx/sdk": "0.9.0-rc.63",
-    "@crewx/memory": "0.1.23-rc.79",
-    "@crewx/search": "0.1.10-rc.58",
-    "@crewx/knowledge-core": "0.1.17-rc.72",
+    "@crewx/chromex": "0.1.0-rc.96",
+    "@crewx/cron": "0.1.10-rc.98",
+    "@crewx/cli": "0.9.0-rc.64",
+    "@crewx/doc": "0.1.9-rc.56",
+    "@crewx/dreaming": "0.1.0-rc.89",
+    "@crewx/knowledge-core": "0.1.17-rc.73",
+    "@crewx/memory": "0.1.23-rc.80",
+    "@crewx/sdk": "0.9.0-rc.64",
+    "@crewx/search": "0.1.10-rc.59",
     "@crewx/shared": "0.0.6",
     "@crewx/skill": "0.1.20",
-    "@crewx/wbs": "0.1.10-rc.88",
-    "@crewx/wi": "0.1.10-rc.83",
-    "@crewx/workflow": "0.3.22-rc.109"
+    "@crewx/wbs": "0.1.10-rc.89",
+    "@crewx/wi": "0.1.10-rc.84",
+    "@crewx/workflow": "0.3.22-rc.110"
   },
   "devDependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.132",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewx/cli",
-  "version": "0.9.0-rc.63",
+  "version": "0.9.0-rc.64",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20.19.0"