commons-proxy 2.0.0

package/src/account-manager/strategies/trackers/health-tracker.js

@@ -0,0 +1,162 @@
+/**
+ * Health Tracker
+ *
+ * Tracks per-account health scores to prioritize healthy accounts.
+ * Scores increase on success and decrease on failures/rate limits.
+ * Passive recovery over time helps accounts recover from temporary issues.
+ */
+
+// Default configuration (matches opencode-cloudcode-auth)
+const DEFAULT_CONFIG = {
+    initial: 70,           // Starting score for new accounts
+    successReward: 1,      // Points on successful request
+    rateLimitPenalty: -10, // Points on rate limit
+    failurePenalty: -20,   // Points on other failures
+    recoveryPerHour: 10,   // Passive recovery rate (increased from 2 for faster recovery)
+    minUsable: 50,         // Minimum score to be selected
+    maxScore: 100          // Maximum score cap
+};
+
+export class HealthTracker {
+    #scores = new Map(); // email -> { score, lastUpdated, consecutiveFailures }
+    #config;
+
+    /**
+     * Create a new HealthTracker
+     * @param {Object} config - Health score configuration
+     */
+    constructor(config = {}) {
+        this.#config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    /**
+     * Get the health score for an account
+     * @param {string} email - Account email
+     * @returns {number} Current health score (with passive recovery applied)
+     */
+    getScore(email) {
+        const record = this.#scores.get(email);
+        if (!record) {
+            return this.#config.initial;
+        }
+
+        // Apply passive recovery based on time elapsed
+        const now = Date.now();
+        const hoursElapsed = (now - record.lastUpdated) / (1000 * 60 * 60);
+        const recovery = hoursElapsed * this.#config.recoveryPerHour;
+        const recoveredScore = Math.min(
+            this.#config.maxScore,
+            record.score + recovery
+        );
+
+        return recoveredScore;
+    }
+
+    /**
+     * Record a successful request for an account
+     * @param {string} email - Account email
+     */
+    recordSuccess(email) {
+        const currentScore = this.getScore(email);
+        const newScore = Math.min(
+            this.#config.maxScore,
+            currentScore + this.#config.successReward
+        );
+        this.#scores.set(email, {
+            score: newScore,
+            lastUpdated: Date.now(),
+            consecutiveFailures: 0 // Reset on success
+        });
+    }
+
+    /**
+     * Record a rate limit for an account
+     * @param {string} email - Account email
+     */
+    recordRateLimit(email) {
+        const record = this.#scores.get(email);
+        const currentScore = this.getScore(email);
+        const newScore = Math.max(
+            0,
+            currentScore + this.#config.rateLimitPenalty
+        );
+        this.#scores.set(email, {
+            score: newScore,
+            lastUpdated: Date.now(),
+            consecutiveFailures: (record?.consecutiveFailures ?? 0) + 1
+        });
+    }
+
+    /**
+     * Record a failure for an account
+     * @param {string} email - Account email
+     */
+    recordFailure(email) {
+        const record = this.#scores.get(email);
+        const currentScore = this.getScore(email);
+        const newScore = Math.max(
+            0,
+            currentScore + this.#config.failurePenalty
+        );
+        this.#scores.set(email, {
+            score: newScore,
+            lastUpdated: Date.now(),
+            consecutiveFailures: (record?.consecutiveFailures ?? 0) + 1
+        });
+    }
+
+    /**
+     * Check if an account is usable based on health score
+     * @param {string} email - Account email
+     * @returns {boolean} True if account health score is above minimum threshold
+     */
+    isUsable(email) {
+        return this.getScore(email) >= this.#config.minUsable;
+    }
+
+    /**
+     * Get the minimum usable score threshold
+     * @returns {number} Minimum score for an account to be usable
+     */
+    getMinUsable() {
+        return this.#config.minUsable;
+    }
+
+    /**
+     * Get the maximum score cap
+     * @returns {number} Maximum health score
+     */
+    getMaxScore() {
+        return this.#config.maxScore;
+    }
+
+    /**
+     * Reset the score for an account (e.g., after re-authentication)
+     * @param {string} email - Account email
+     */
+    reset(email) {
+        this.#scores.set(email, {
+            score: this.#config.initial,
+            lastUpdated: Date.now(),
+            consecutiveFailures: 0
+        });
+    }
+
+    /**
+     * Get the consecutive failure count for an account
+     * @param {string} email - Account email
+     * @returns {number} Number of consecutive failures
+     */
+    getConsecutiveFailures(email) {
+        return this.#scores.get(email)?.consecutiveFailures ?? 0;
+    }
+
+    /**
+     * Clear all tracked scores
+     */
+    clear() {
+        this.#scores.clear();
+    }
+}
+
+export default HealthTracker;

package/src/account-manager/strategies/trackers/index.js

@@ -0,0 +1,9 @@
+/**
+ * Trackers Index
+ *
+ * Exports all tracker classes for account selection strategies.
+ */
+
+export { HealthTracker } from './health-tracker.js';
+export { TokenBucketTracker } from './token-bucket-tracker.js';
+export { QuotaTracker } from './quota-tracker.js';

package/src/account-manager/strategies/trackers/quota-tracker.js

@@ -0,0 +1,120 @@
+/**
+ * Quota Tracker
+ *
+ * Tracks per-account quota levels to prioritize accounts with available quota.
+ * Uses quota data from account.quota.models[modelId].remainingFraction.
+ * Accounts below critical threshold are excluded from selection.
+ */
+
+// Default configuration
+const DEFAULT_CONFIG = {
+    lowThreshold: 0.10,       // 10% - reduce score
+    criticalThreshold: 0.05,  // 5% - exclude from candidates
+    staleMs: 300000,          // 5 min - max age of quota data to trust
+    unknownScore: 50          // Score for accounts with unknown quota
+};
+
+export class QuotaTracker {
+    #config;
+
+    /**
+     * Create a new QuotaTracker
+     * @param {Object} config - Quota tracker configuration
+     */
+    constructor(config = {}) {
+        this.#config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    /**
+     * Get the quota fraction for an account and model
+     * @param {Object} account - Account object
+     * @param {string} modelId - Model ID to check
+     * @returns {number|null} Remaining fraction (0-1) or null if unknown
+     */
+    getQuotaFraction(account, modelId) {
+        if (!account?.quota?.models?.[modelId]) return null;
+        const fraction = account.quota.models[modelId].remainingFraction;
+        return typeof fraction === 'number' ? fraction : null;
+    }
+
+    /**
+     * Check if quota data is fresh enough to be trusted
+     * @param {Object} account - Account object
+     * @returns {boolean} True if quota data is fresh
+     */
+    isQuotaFresh(account) {
+        if (!account?.quota?.lastChecked) return false;
+        return (Date.now() - account.quota.lastChecked) < this.#config.staleMs;
+    }
+
+    /**
+     * Check if an account has critically low quota for a model
+     * @param {Object} account - Account object
+     * @param {string} modelId - Model ID to check
+     * @returns {boolean} True if quota is at or below critical threshold
+     */
+    isQuotaCritical(account, modelId) {
+        const fraction = this.getQuotaFraction(account, modelId);
+        // Unknown quota = not critical (assume OK)
+        if (fraction === null) return false;
+        // Only apply critical check if data is fresh
+        if (!this.isQuotaFresh(account)) return false;
+        return fraction <= this.#config.criticalThreshold;
+    }
+
+    /**
+     * Check if an account has low (but not critical) quota for a model
+     * @param {Object} account - Account object
+     * @param {string} modelId - Model ID to check
+     * @returns {boolean} True if quota is below low threshold but above critical
+     */
+    isQuotaLow(account, modelId) {
+        const fraction = this.getQuotaFraction(account, modelId);
+        if (fraction === null) return false;
+        return fraction <= this.#config.lowThreshold && fraction > this.#config.criticalThreshold;
+    }
+
+    /**
+     * Get a score (0-100) for an account based on quota
+     * Higher score = more quota available
+     * @param {Object} account - Account object
+     * @param {string} modelId - Model ID to check
+     * @returns {number} Score from 0-100
+     */
+    getScore(account, modelId) {
+        const fraction = this.getQuotaFraction(account, modelId);
+
+        // Unknown quota = middle score
+        if (fraction === null) {
+            return this.#config.unknownScore;
+        }
+
+        // Convert fraction (0-1) to score (0-100)
+        let score = fraction * 100;
+
+        // Apply small penalty for stale data (reduce confidence)
+        if (!this.isQuotaFresh(account)) {
+            score *= 0.9; // 10% penalty for stale data
+        }
+
+        return score;
+    }
+
+    /**
+     * Get the critical threshold
+     * @returns {number} Critical threshold (0-1)
+     */
+    getCriticalThreshold() {
+        return this.#config.criticalThreshold;
+    }
+
+    /**
+     * Get the low threshold
+     * @returns {number} Low threshold (0-1)
+     */
+    getLowThreshold() {
+        return this.#config.lowThreshold;
+    }
+}
+
+export default QuotaTracker;

package/src/account-manager/strategies/trackers/token-bucket-tracker.js

@@ -0,0 +1,155 @@
+/**
+ * Token Bucket Tracker
+ *
+ * Client-side rate limiting using the token bucket algorithm.
+ * Each account has a bucket of tokens that regenerate over time.
+ * Requests consume tokens; accounts without tokens are deprioritized.
+ */
+
+// Default configuration (matches opencode-cloudcode-auth)
+const DEFAULT_CONFIG = {
+    maxTokens: 50,        // Maximum token capacity
+    tokensPerMinute: 6,   // Regeneration rate
+    initialTokens: 50     // Starting tokens
+};
+
+export class TokenBucketTracker {
+    #buckets = new Map(); // email -> { tokens, lastUpdated }
+    #config;
+
+    /**
+     * Create a new TokenBucketTracker
+     * @param {Object} config - Token bucket configuration
+     */
+    constructor(config = {}) {
+        this.#config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    /**
+     * Get the current token count for an account
+     * @param {string} email - Account email
+     * @returns {number} Current token count (with regeneration applied)
+     */
+    getTokens(email) {
+        const bucket = this.#buckets.get(email);
+        if (!bucket) {
+            return this.#config.initialTokens;
+        }
+
+        // Apply token regeneration based on time elapsed
+        const now = Date.now();
+        const minutesElapsed = (now - bucket.lastUpdated) / (1000 * 60);
+        const regenerated = minutesElapsed * this.#config.tokensPerMinute;
+        const currentTokens = Math.min(
+            this.#config.maxTokens,
+            bucket.tokens + regenerated
+        );
+
+        return currentTokens;
+    }
+
+    /**
+     * Check if an account has tokens available
+     * @param {string} email - Account email
+     * @returns {boolean} True if account has at least 1 token
+     */
+    hasTokens(email) {
+        return this.getTokens(email) >= 1;
+    }
+
+    /**
+     * Consume a token from an account's bucket
+     * @param {string} email - Account email
+     * @returns {boolean} True if token was consumed, false if no tokens available
+     */
+    consume(email) {
+        const currentTokens = this.getTokens(email);
+        if (currentTokens < 1) {
+            return false;
+        }
+
+        this.#buckets.set(email, {
+            tokens: currentTokens - 1,
+            lastUpdated: Date.now()
+        });
+        return true;
+    }
+
+    /**
+     * Refund a token to an account's bucket (e.g., on request failure before processing)
+     * @param {string} email - Account email
+     */
+    refund(email) {
+        const currentTokens = this.getTokens(email);
+        const newTokens = Math.min(
+            this.#config.maxTokens,
+            currentTokens + 1
+        );
+        this.#buckets.set(email, {
+            tokens: newTokens,
+            lastUpdated: Date.now()
+        });
+    }
+
+    /**
+     * Get the maximum token capacity
+     * @returns {number} Maximum tokens per bucket
+     */
+    getMaxTokens() {
+        return this.#config.maxTokens;
+    }
+
+    /**
+     * Reset the bucket for an account
+     * @param {string} email - Account email
+     */
+    reset(email) {
+        this.#buckets.set(email, {
+            tokens: this.#config.initialTokens,
+            lastUpdated: Date.now()
+        });
+    }
+
+    /**
+     * Clear all tracked buckets
+     */
+    clear() {
+        this.#buckets.clear();
+    }
+
+    /**
+     * Get time in milliseconds until next token is available for an account
+     * @param {string} email - Account email
+     * @returns {number} Milliseconds until next token, 0 if tokens available now
+     */
+    getTimeUntilNextToken(email) {
+        const currentTokens = this.getTokens(email);
+        if (currentTokens >= 1) {
+            return 0;
+        }
+
+        // Calculate time to regenerate 1 token
+        const tokensNeeded = 1 - currentTokens;
+        const minutesNeeded = tokensNeeded / this.#config.tokensPerMinute;
+        return Math.ceil(minutesNeeded * 60 * 1000);
+    }
+
+    /**
+     * Get the minimum time until any account in the list has a token
+     * @param {Array<string>} emails - List of account emails
+     * @returns {number} Minimum milliseconds until any account has a token
+     */
+    getMinTimeUntilToken(emails) {
+        if (emails.length === 0) return 0;
+
+        let minWait = Infinity;
+        for (const email of emails) {
+            const wait = this.getTimeUntilNextToken(email);
+            if (wait === 0) return 0;
+            minWait = Math.min(minWait, wait);
+        }
+        return minWait === Infinity ? 0 : minWait;
+    }
+}
+
+export default TokenBucketTracker;

package/src/auth/database.js

@@ -0,0 +1,169 @@
+/**
+ * SQLite Database Access Module
+ * Provides cross-platform database operations for Cloud Code IDE state.
+ *
+ * Uses better-sqlite3 for:
+ * - Windows compatibility (no CLI dependency)
+ * - Native performance
+ * - Synchronous API (simple error handling)
+ *
+ * Includes auto-rebuild capability for handling Node.js version updates
+ * that cause native module incompatibility.
+ */
+
+import { createRequire } from 'module';
+import { CLOUDCODE_DB_PATH } from '../constants.js';
+import { isModuleVersionError, attemptAutoRebuild, clearRequireCache } from '../utils/native-module-helper.js';
+import { logger } from '../utils/logger.js';
+import { NativeModuleError } from '../errors.js';
+
+const require = createRequire(import.meta.url);
+
+// Lazy-loaded Database constructor
+let Database = null;
+let moduleLoadError = null;
+
+/**
+ * Load the better-sqlite3 module with auto-rebuild on version mismatch
+ * Uses synchronous require to maintain API compatibility
+ * @returns {Function} The Database constructor
+ * @throws {Error} If module cannot be loaded even after rebuild
+ */
+function loadDatabaseModule() {
+    // Return cached module if already loaded
+    if (Database) return Database;
+
+    // Re-throw cached error if previous load failed permanently
+    if (moduleLoadError) throw moduleLoadError;
+
+    try {
+        Database = require('better-sqlite3');
+        return Database;
+    } catch (error) {
+        if (isModuleVersionError(error)) {
+            logger.warn('[Database] Native module version mismatch detected');
+
+            if (attemptAutoRebuild(error)) {
+                // Clear require cache and retry
+                try {
+                    const resolvedPath = require.resolve('better-sqlite3');
+                    // Clear the module and all its dependencies from cache
+                    clearRequireCache(resolvedPath, require.cache);
+
+                    Database = require('better-sqlite3');
+                    logger.success('[Database] Module reloaded successfully after rebuild');
+                    return Database;
+                } catch (retryError) {
+                    // Rebuild succeeded but reload failed - user needs to restart
+                    moduleLoadError = new NativeModuleError(
+                        'Native module rebuild completed. Please restart the server to apply the fix.',
+                        true,  // rebuildSucceeded
+                        true   // restartRequired
+                    );
+                    logger.info('[Database] Rebuild succeeded - server restart required');
+                    throw moduleLoadError;
+                }
+            } else {
+                moduleLoadError = new NativeModuleError(
+                    'Failed to auto-rebuild native module. Please run manually:\n' +
+                    '  npm rebuild better-sqlite3\n' +
+                    'Or if using npx, find the package location in the error and run:\n' +
+                    '  cd /path/to/better-sqlite3 && npm rebuild',
+                    false,  // rebuildSucceeded
+                    false   // restartRequired
+                );
+                throw moduleLoadError;
+            }
+        }
+
+        // Non-version-mismatch error, just throw it
+        throw error;
+    }
+}
+
+/**
+ * Query Cloud Code IDE database for authentication status
+ * @param {string} [dbPath] - Optional custom database path
+ * @returns {Object} Parsed auth data with apiKey, email, name, etc.
+ * @throws {Error} If database doesn't exist, query fails, or no auth status found
+ */
+export function getAuthStatus(dbPath = CLOUDCODE_DB_PATH) {
+    const Db = loadDatabaseModule();
+    let db;
+    try {
+        // Open database in read-only mode
+        db = new Db(dbPath, {
+            readonly: true,
+            fileMustExist: true
+        });
+
+        // Prepare and execute query
+        const stmt = db.prepare(
+            "SELECT value FROM ItemTable WHERE key = 'cloudcodeAuthStatus'"
+        );
+        const row = stmt.get();
+
+        if (!row || !row.value) {
+            throw new Error('No auth status found in database');
+        }
+
+        // Parse JSON value
+        const authData = JSON.parse(row.value);
+
+        if (!authData.apiKey) {
+            throw new Error('Auth data missing apiKey field');
+        }
+
+        return authData;
+    } catch (error) {
+        // Enhance error messages for common issues
+        if (error.code === 'SQLITE_CANTOPEN') {
+            throw new Error(
+                `Database not found at ${dbPath}. ` +
+                'Make sure the Cloud Code IDE is installed and you are logged in.'
+            );
+        }
+        // Re-throw with context if not already our error
+        if (error.message.includes('No auth status') || error.message.includes('missing apiKey')) {
+            throw error;
+        }
+        // Re-throw native module errors from loadDatabaseModule without wrapping
+        if (error instanceof NativeModuleError) {
+            throw error;
+        }
+        throw new Error(`Failed to read Cloud Code IDE database: ${error.message}`);
+    } finally {
+        // Always close database connection
+        if (db) {
+            db.close();
+        }
+    }
+}
+
+/**
+ * Check if database exists and is accessible
+ * @param {string} [dbPath] - Optional custom database path
+ * @returns {boolean} True if database exists and can be opened
+ */
+export function isDatabaseAccessible(dbPath = CLOUDCODE_DB_PATH) {
+    let db;
+    try {
+        const Db = loadDatabaseModule();
+        db = new Db(dbPath, {
+            readonly: true,
+            fileMustExist: true
+        });
+        return true;
+    } catch {
+        return false;
+    } finally {
+        if (db) {
+            db.close();
+        }
+    }
+}
+
+export default {
+    getAuthStatus,
+    isDatabaseAccessible
+};