gh-multi 0.1.0

package/gh-multi-dist/plugin/accounts.js

@@ -0,0 +1,703 @@
+import path from "path";
+import fs from "fs";
+import { rename, writeFile, mkdir, readFile, copyFile, unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { xdgConfig } from "xdg-basedir";
+import { lock } from "proper-lockfile";
+import { createLogger } from "./logger.js";
+import { fetchQuota } from "./quota.js";
+import { isModelAvailableForSku, getRequiredTierForModel } from "./models.js";
+import { OPENCODE_USER_AGENT, MAX_HEALTH, INITIAL_HEALTH, MIN_HEALTH_THRESHOLD, DEFAULT_RATE_LIMIT_COOLDOWN, MAX_FAILURES_BEFORE_SUSPEND, SESSION_CLEANUP_INTERVAL_MS, QUOTA_SYNC_INTERVAL_MS, SYNC_EVERY_N_REQUESTS } from "../constants.js";
+const log = createLogger('accounts');
+const CURRENT_VERSION = 1;
+function mergeAccountStorage(inMemory, onDisk) {
+    const merged = new Map();
+    for (const acc of onDisk) {
+        merged.set(acc.username, acc);
+    }
+    for (const acc of inMemory) {
+        const existing = merged.get(acc.username);
+        if (existing) {
+            const mergedAccount = {
+                ...existing,
+                ...acc,
+                lastUsed: Math.max(existing.lastUsed || 0, acc.lastUsed || 0),
+                health_score: (acc.lastUsed || 0) > (existing.lastUsed || 0)
+                    ? acc.health_score
+                    : existing.health_score,
+                rateLimitedUntil: Math.max(existing.rateLimitedUntil || 0, acc.rateLimitedUntil || 0),
+            };
+            if (acc.lastQuotaSync && existing.lastQuotaSync) {
+                if (existing.lastQuotaSync > acc.lastQuotaSync) {
+                    mergedAccount.premiumRemaining = existing.premiumRemaining;
+                    mergedAccount.premiumTotal = existing.premiumTotal;
+                    mergedAccount.lastQuotaSync = existing.lastQuotaSync;
+                    mergedAccount.quotaResetDate = existing.quotaResetDate;
+                }
+            }
+            merged.set(acc.username, mergedAccount);
+        }
+        else {
+            merged.set(acc.username, acc);
+        }
+    }
+    return Array.from(merged.values());
+}
+async function atomicWriteFile(filePath, data) {
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    const tempPath = path.join(tmpdir(), `copilot-${Date.now()}-${Math.random().toString(36)}.tmp`);
+    await writeFile(tempPath, data, { mode: 0o600 });
+    try {
+        await rename(tempPath, filePath);
+    }
+    catch (error) {
+        if (error.code === 'EXDEV') {
+            await copyFile(tempPath, filePath);
+            await unlink(tempPath);
+        }
+        else {
+            await unlink(tempPath).catch(() => { });
+            throw error;
+        }
+    }
+}
+function getConfigDir() {
+    const dir = process.env.OPENCODE_CONFIG_DIR ||
+        (xdgConfig
+            ? path.join(xdgConfig, "opencode")
+            : path.join(process.env.HOME || "", ".config", "opencode"));
+    return dir;
+}
+export class CopilotAccountManager {
+    accounts = [];
+    config;
+    sessionIdToUsername = new Map();
+    sessionCleanupInterval = null;
+    dataDir;
+    saveTimeout = null;
+    quotaSyncInterval = null;
+    requestCount = 0;
+    constructor(config, dataDir) {
+        this.config = config;
+        this.dataDir = dataDir;
+        this.startQuotaSync();
+        this.startSessionCleanup();
+    }
+    async shutdown() {
+        this.stopQuotaSync();
+        this.stopSessionCleanup();
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+            this.saveTimeout = null;
+            await this.saveAccounts();
+        }
+    }
+    startQuotaSync() {
+        if (this.quotaSyncInterval)
+            return;
+        this.quotaSyncInterval = setInterval(() => {
+            this.syncAllQuotas().catch((err) => {
+                log.error("accounts", "Failed to run periodic quota sync", err);
+            });
+        }, QUOTA_SYNC_INTERVAL_MS);
+        this.quotaSyncInterval.unref();
+    }
+    stopQuotaSync() {
+        if (this.quotaSyncInterval) {
+            clearInterval(this.quotaSyncInterval);
+            this.quotaSyncInterval = null;
+        }
+    }
+    startSessionCleanup() {
+        if (this.sessionCleanupInterval)
+            return;
+        this.sessionCleanupInterval = setInterval(() => {
+            this.cleanupStaleSessions();
+        }, SESSION_CLEANUP_INTERVAL_MS);
+        this.sessionCleanupInterval.unref();
+    }
+    stopSessionCleanup() {
+        if (this.sessionCleanupInterval) {
+            clearInterval(this.sessionCleanupInterval);
+            this.sessionCleanupInterval = null;
+        }
+    }
+    cleanupStaleSessions() {
+        const TTL_MS = 30 * 60 * 1000;
+        const now = Date.now();
+        for (const [sessionId, data] of this.sessionIdToUsername) {
+            if (now - data.addedAt > TTL_MS) {
+                this.sessionIdToUsername.delete(sessionId);
+            }
+        }
+    }
+    async syncAllQuotas() {
+        const activeAccounts = this.accounts.filter((a) => a.status !== "suspended" && a.enabled !== false);
+        let anyUpdated = false;
+        for (const account of activeAccounts) {
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            const updated = await this.syncQuotaForAccount(account, false);
+            if (updated)
+                anyUpdated = true;
+        }
+        if (anyUpdated) {
+            this.requestSave();
+        }
+    }
+    async syncQuotaForAccount(account, shouldSave = true) {
+        try {
+            const quota = await fetchQuota(account.oauthToken);
+            if (quota) {
+                account.quotaResetDate = quota.resetDate || undefined;
+                account.lastQuotaSync = Date.now();
+                if (quota.premium) {
+                    account.premiumRemaining = quota.premium.remaining;
+                    account.premiumTotal = quota.premium.total;
+                }
+                if (shouldSave) {
+                    this.requestSave();
+                }
+                return true;
+            }
+        }
+        catch (error) {
+            log.warn(`[ACCOUNTS] [QUOTA] Failed to sync quota for ${account.username}`, { error: error.message });
+        }
+        return false;
+    }
+    hasAccounts() {
+        return this.accounts.length > 0;
+    }
+    hasHealthyAccounts() {
+        return this.accounts.some((a) => a.status !== "suspended" && a.enabled !== false);
+    }
+    async loadAccounts() {
+        try {
+            const configDir = this.dataDir || getConfigDir();
+            const accountsFile = path.join(configDir, "copilot-accounts.json");
+            if (process.env.NODE_ENV === "test") {
+                const isRealConfig = accountsFile.includes(process.env.HOME || "---never-match---") &&
+                    !accountsFile.includes("tmp") &&
+                    !accountsFile.includes("temp");
+                if (isRealConfig && !this.dataDir) {
+                    log.error("[ACCOUNTS] [LOAD] Test pollution detected! Attempting to load accounts from real config: " +
+                        accountsFile);
+                    throw new Error("Test pollution protection: Attempting to load accounts from real config during tests");
+                }
+            }
+            try {
+                const content = await readFile(accountsFile, "utf-8");
+                const rawData = JSON.parse(content);
+                let data;
+                if (rawData && rawData.version === CURRENT_VERSION && Array.isArray(rawData.accounts)) {
+                    data = rawData;
+                }
+                else {
+                    log.warn("[ACCOUNTS] [LOAD] Invalid or legacy storage format, starting fresh.");
+                    data = { version: CURRENT_VERSION, accounts: [] };
+                }
+                this.accounts = (data.accounts || []).map((account) => ({
+                    ...account,
+                    status: account.status || "active",
+                    enabled: account.enabled ?? true,
+                    health_score: account.health_score ?? INITIAL_HEALTH,
+                    failureCount: account.failureCount || 0,
+                    rateLimitedUntil: account.rateLimitedUntil || 0,
+                    lastUsed: account.lastUsed || 0,
+                }));
+            }
+            catch (err) {
+                if (err.code !== "ENOENT") {
+                    throw err;
+                }
+            }
+        }
+        catch (error) {
+            log.error("[ACCOUNTS] [LOAD] Failed to load accounts:", error);
+            this.accounts = [];
+        }
+        // NON-BLOCKING: Fire-and-forget quota sync to allow immediate plugin load.
+        // We do NOT await this.
+        this.syncAllQuotas().catch((err) => {
+            log.error("[ACCOUNTS] [QUOTA] Failed to run initial quota sync", err);
+        });
+    }
+    async addAccount(oauthToken) {
+        const userResponse = await fetch("https://api.github.com/user", {
+            headers: {
+                Authorization: `token ${oauthToken}`,
+                "User-Agent": OPENCODE_USER_AGENT,
+            },
+        });
+        if (!userResponse.ok) {
+            throw new Error(`Failed to fetch user info: ${userResponse.statusText}`);
+        }
+        const userData = (await userResponse.json());
+        const username = userData.login;
+        let sku;
+        let premiumRemaining;
+        let premiumTotal;
+        let quotaResetDate;
+        let lastQuotaSync;
+        try {
+            const copilotResponse = await fetch("https://api.github.com/copilot_internal/user", {
+                headers: {
+                    Authorization: `Bearer ${oauthToken}`,
+                    "User-Agent": OPENCODE_USER_AGENT,
+                },
+            });
+            if (copilotResponse.ok) {
+                const copilotData = (await copilotResponse.json());
+                sku = copilotData.access_type_sku;
+                if (sku === "free_limited_copilot") {
+                }
+                else if (sku === "no_access") {
+                    log.warn(`[ACCOUNTS] [NO_ACCESS] Account ${username} has no Copilot access. Please enable at github.com/settings/copilot`);
+                }
+                else {
+                }
+                log.info(`[ACCOUNTS] [ADD] Detected Copilot SKU for ${username}: ${sku}`);
+            }
+            else {
+                log.warn(`[ACCOUNTS] [ADD] Failed to fetch Copilot user info: ${copilotResponse.status} ${copilotResponse.statusText}`);
+            }
+        }
+        catch (error) {
+            log.error("[ACCOUNTS] [ADD] Error fetching Copilot user info:", error);
+        }
+        try {
+            const quota = await fetchQuota(oauthToken);
+            if (quota) {
+                if (quota.premium) {
+                    premiumRemaining = quota.premium.remaining;
+                    premiumTotal = quota.premium.total;
+                }
+                quotaResetDate = quota.resetDate || undefined;
+                lastQuotaSync = Date.now();
+                log.info(`[ACCOUNTS] [ADD] Fetched quota for ${username}: Reset=${quotaResetDate} | Premium: ${premiumRemaining}/${premiumTotal}`);
+            }
+        }
+        catch (e) {
+            log.error(`[ACCOUNTS] [ADD] Failed to fetch quota for ${username}`, e);
+        }
+        const isNoAccess = sku === "no_access";
+        const newAccount = {
+            username,
+            oauthToken,
+            addedAt: Date.now(),
+            status: isNoAccess ? "suspended" : "active",
+            enabled: !isNoAccess,
+            health_score: INITIAL_HEALTH,
+            failureCount: 0,
+            rateLimitedUntil: 0,
+            lastUsed: 0,
+            sku,
+            premiumRemaining,
+            premiumTotal,
+            quotaResetDate,
+            lastQuotaSync,
+        };
+        this.accounts = this.accounts.filter((a) => a.username !== username);
+        this.accounts.push(newAccount);
+        await this.saveAccounts();
+        return newAccount;
+    }
+    async refreshAccountInfo(username) {
+        const account = this.accounts.find((a) => a.username === username);
+        if (!account)
+            return null;
+        try {
+            const copilotResponse = await fetch("https://api.github.com/copilot_internal/user", {
+                headers: {
+                    Authorization: `Bearer ${account.oauthToken}`,
+                    "User-Agent": OPENCODE_USER_AGENT,
+                },
+            });
+            if (copilotResponse.ok) {
+                const copilotData = (await copilotResponse.json());
+                account.sku = copilotData.access_type_sku;
+                if (account.sku === "free_limited_copilot") {
+                }
+                else if (account.sku === "no_access") {
+                    account.status = "suspended";
+                    account.enabled = false;
+                    log.warn(`[ACCOUNTS] [NO_ACCESS] Account ${username} has no Copilot access. Please enable at github.com/settings/copilot`);
+                }
+                else {
+                    if (account.status === "suspended" &&
+                        account.enabled === false) {
+                        log.info(`[ACCOUNTS] [RECOVER] Account ${username} now has access (SKU: ${account.sku}). Re-enabling.`);
+                        account.status = "active";
+                        account.enabled = true;
+                    }
+                }
+                log.info(`[ACCOUNTS] [REFRESH] Refreshed Copilot info for ${username}: SKU=${account.sku}`);
+                try {
+                    const quota = await fetchQuota(account.oauthToken);
+                    if (quota) {
+                        if (quota.premium) {
+                            account.premiumRemaining = quota.premium.remaining;
+                            account.premiumTotal = quota.premium.total;
+                        }
+                        account.quotaResetDate = quota.resetDate || undefined;
+                        account.lastQuotaSync = Date.now();
+                        log.info(`[ACCOUNTS] [REFRESH] Refreshed quota for ${username}: Premium=${account.premiumRemaining}/${account.premiumTotal}`);
+                    }
+                }
+                catch (e) {
+                    log.warn(`[ACCOUNTS] [REFRESH] Failed to refresh quota for ${username}`, { error: e.message });
+                }
+                await this.saveAccounts();
+            }
+        }
+        catch (error) {
+            log.error(`[ACCOUNTS] [REFRESH] Failed to refresh account info for ${username}:`, error);
+        }
+        return account;
+    }
+    requestSave() {
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+        }
+        this.saveTimeout = setTimeout(async () => {
+            this.saveTimeout = null;
+            try {
+                await this.saveAccounts();
+            }
+            catch (err) {
+                log.error("[ACCOUNTS] [SAVE] Failed to save accounts in background", err);
+            }
+        }, 300);
+    }
+    async saveAccounts(accountsToRemove = []) {
+        const configDir = this.dataDir || getConfigDir();
+        const accountsFile = path.join(configDir, "copilot-accounts.json");
+        if (process.env.NODE_ENV === "test") {
+            const isRealConfig = accountsFile.includes(process.env.HOME || "---never-match---") &&
+                !accountsFile.includes("tmp") &&
+                !accountsFile.includes("temp");
+            if (isRealConfig && !this.dataDir) {
+                log.error("[ACCOUNTS] [SAVE] Test pollution detected! Attempting to save accounts to real config: " +
+                    accountsFile);
+                throw new Error("Test pollution protection: Attempting to save accounts to real config during tests");
+            }
+        }
+        const fileDir = path.dirname(accountsFile);
+        await mkdir(fileDir, { recursive: true });
+        if (!fs.existsSync(accountsFile)) {
+            await writeFile(accountsFile, JSON.stringify({ version: CURRENT_VERSION, accounts: [] }), { mode: 0o600 });
+        }
+        let release;
+        release = await lock(accountsFile, { retries: 5 });
+        try {
+            let onDisk = [];
+            try {
+                if (fs.existsSync(accountsFile)) {
+                    const content = await readFile(accountsFile, "utf-8");
+                    const raw = JSON.parse(content);
+                    let data;
+                    if (raw && raw.version === CURRENT_VERSION && Array.isArray(raw.accounts)) {
+                        data = raw;
+                    }
+                    else {
+                        data = { version: CURRENT_VERSION, accounts: [] };
+                    }
+                    onDisk = data.accounts || [];
+                }
+            }
+            catch (e) {
+                log.warn("[ACCOUNTS] [SAVE] Failed to read existing accounts for merge", { error: e });
+            }
+            if (accountsToRemove.length > 0) {
+                onDisk = onDisk.filter((a) => !accountsToRemove.includes(a.username));
+            }
+            const merged = mergeAccountStorage(this.accounts, onDisk);
+            this.accounts = merged;
+            const data = {
+                version: CURRENT_VERSION,
+                accounts: merged,
+            };
+            await atomicWriteFile(accountsFile, JSON.stringify(data, null, 2));
+            log.info(`[ACCOUNTS] [SAVE] Successfully saved ${this.accounts.length} accounts to disk`);
+        }
+        finally {
+            await release();
+        }
+    }
+    async getCurrentOrNext(sessionId, model) {
+        const account = this.selectNextAccount(sessionId, model);
+        if (!account) {
+            const rateLimitedAccounts = this.accounts.filter((a) => a.status === "rate_limited" &&
+                a.enabled !== false &&
+                a.rateLimitedUntil &&
+                a.rateLimitedUntil > Date.now());
+            if (rateLimitedAccounts.length > 0) {
+                rateLimitedAccounts.sort((a, b) => (a.rateLimitedUntil || 0) - (b.rateLimitedUntil || 0));
+                const soonest = rateLimitedAccounts[0];
+                const waitTime = (soonest.rateLimitedUntil || 0) - Date.now();
+                const maxWait = 300 * 1000;
+                log.info(`[ACCOUNTS] [RATELIMIT] All accounts rate limited. Next available: ${soonest.username} in ${waitTime}ms`);
+                if (waitTime > 0 && waitTime < maxWait) {
+                    await new Promise((resolve) => setTimeout(resolve, waitTime + 100));
+                    soonest.status = "active";
+                    soonest.rateLimitedUntil = 0;
+                    await this.saveAccounts();
+                    log.info(`[ACCOUNTS] [RESTORE] Account ${soonest.username} restored from rate limit wait`);
+                    return soonest;
+                }
+            }
+            return null;
+        }
+        return account;
+    }
+    selectAccountByQuota(pool) {
+        const candidates = pool.filter((a) => a.premiumRemaining === undefined || a.premiumRemaining > 0);
+        if (candidates.length === 0)
+            return null;
+        const validCandidates = candidates.filter((a) => a.premiumRemaining !== undefined);
+        if (validCandidates.length === 0) {
+            candidates.sort((a, b) => (a.lastUsed || 0) - (b.lastUsed || 0));
+            return candidates[0];
+        }
+        const totalWeight = validCandidates.reduce((sum, a) => sum + (a.premiumRemaining || 0), 0);
+        if (totalWeight <= 0) {
+            validCandidates.sort((a, b) => (a.lastUsed || 0) - (b.lastUsed || 0));
+            return validCandidates[0];
+        }
+        let random = Math.random() * totalWeight;
+        for (const account of validCandidates) {
+            random -= account.premiumRemaining || 0;
+            if (random <= 0) {
+                return account;
+            }
+        }
+        return validCandidates[validCandidates.length - 1];
+    }
+    selectNextAccount(sessionId, model) {
+        const now = Date.now();
+        this.accounts.forEach((a) => {
+            if (a.status === "rate_limited" &&
+                a.rateLimitedUntil &&
+                a.rateLimitedUntil <= now) {
+                log.info(`[ACCOUNTS] [RESTORE] Rate limit expired for ${a.username}, restoring to active`);
+                a.status = "active";
+                a.rateLimitedUntil = 0;
+            }
+        });
+        let availableAccounts = this.accounts;
+        if (model) {
+            const compatible = availableAccounts.filter(acc => isModelAvailableForSku(model, acc.sku));
+            if (compatible.length === 0) {
+                const requiredTier = getRequiredTierForModel(model);
+                log.error(`[ACCOUNTS] No accounts support model "${model}" (requires ${requiredTier})`);
+                throw new Error(`No accounts available for model "${model}". Requires ${requiredTier}.`);
+            }
+            if (compatible.length < availableAccounts.length) {
+                log.info(`[ACCOUNTS] Filtered ${availableAccounts.length - compatible.length} accounts incompatible with "${model}"`);
+            }
+            availableAccounts = compatible;
+        }
+        const validAccounts = [];
+        const healthyAccounts = [];
+        for (const a of availableAccounts) {
+            if (a.enabled === false) {
+                continue;
+            }
+            if (a.status === "suspended") {
+                continue;
+            }
+            if (a.status === "quota_exhausted") {
+                continue;
+            }
+            if (a.status === "rate_limited" &&
+                (!a.rateLimitedUntil || a.rateLimitedUntil > now)) {
+                continue;
+            }
+            validAccounts.push(a);
+            if (a.health_score > MIN_HEALTH_THRESHOLD) {
+                healthyAccounts.push(a);
+            }
+        }
+        if (validAccounts.length === 0) {
+            const exhaustedAccounts = availableAccounts.filter((a) => a.status === "quota_exhausted");
+            if (exhaustedAccounts.length > 0) {
+                const resetDates = exhaustedAccounts
+                    .map((a) => a.quotaResetDate)
+                    .filter(Boolean)
+                    .sort();
+                const earliestReset = resetDates[0] || "unknown";
+                throw new Error(`All available accounts${model ? ` for model ${model}` : ''} are out of quota. Earliest reset: ${earliestReset}`);
+            }
+        }
+        const pool = healthyAccounts.length > 0 ? healthyAccounts : validAccounts;
+        if (this.config.rotation_strategy === "sticky" && sessionId) {
+            const stickyData = this.sessionIdToUsername.get(sessionId);
+            if (stickyData) {
+                const account = validAccounts.find((a) => a.username === stickyData.username);
+                if (account) {
+                    log.info(`[ACCOUNTS] [SELECT] Strategy: sticky. Selected ${account.username} for session ${sessionId}`);
+                    account.lastUsed = Date.now();
+                    return account;
+                }
+            }
+        }
+        let selected;
+        if (this.config.rotation_strategy === "least-used") {
+            const quotaAccount = this.selectAccountByQuota(pool);
+            if (quotaAccount) {
+                selected = quotaAccount;
+                log.info(`[ACCOUNTS] [SELECT] Strategy: least-used (quota-weighted). Selected ${selected.username} (Premium: ${selected.premiumRemaining}/${selected.premiumTotal})`);
+            }
+        }
+        if (!selected) {
+            if (this.config.rotation_strategy === 'random') {
+                selected = pool[Math.floor(Math.random() * pool.length)];
+            }
+            else {
+                pool.sort((a, b) => {
+                    const diff = (a.lastUsed || 0) - (b.lastUsed || 0);
+                    if (diff !== 0)
+                        return diff;
+                    return a.addedAt - b.addedAt;
+                });
+                selected = pool[0];
+            }
+        }
+        log.info("--- Account Selection ---");
+        log.info(`[ACCOUNTS] Strategy: ${this.config.rotation_strategy}, Pool: ${pool.length}/${this.accounts.length}`);
+        if (selected) {
+            log.info(`[ACCOUNTS] [SELECT] Selected: ${selected.username} (SKU: ${selected.sku || 'unknown'}) | Premium: ${selected.premiumRemaining}/${selected.premiumTotal}`);
+        }
+        else {
+            log.warn(`[ACCOUNTS] [SELECT] No healthy account available!`);
+        }
+        if (sessionId && selected) {
+            if (this.sessionIdToUsername.size >= 10000) {
+                const firstKey = this.sessionIdToUsername.keys().next().value;
+                if (firstKey)
+                    this.sessionIdToUsername.delete(firstKey);
+            }
+            this.sessionIdToUsername.set(sessionId, {
+                username: selected.username,
+                addedAt: Date.now(),
+            });
+        }
+        if (selected) {
+            selected.lastUsed = Date.now();
+        }
+        return selected;
+    }
+    markQuotaExhausted(account) {
+        const acc = this.accounts.find((a) => a.username === account.username);
+        if (!acc)
+            return;
+        acc.premiumRemaining = 0;
+        acc.status = "quota_exhausted";
+        log.info(`[ACCOUNTS] [QUOTA] Marked ${acc.username} as quota exhausted`);
+        this.requestSave();
+    }
+    async markRateLimited(account, cooldownMs) {
+        const acc = this.accounts.find((a) => a.username === account.username);
+        if (!acc)
+            return;
+        acc.status = "rate_limited";
+        acc.last_error_at = Date.now();
+        acc.failureCount = (acc.failureCount || 0) + 1;
+        acc.health_score = Math.max(0, acc.health_score - 10 * 5);
+        acc.rateLimitedUntil = Date.now() + cooldownMs;
+        log.warn(`[ACCOUNTS] [RATELIMIT] Rate limit detected for ${account.username}, suspending until ${new Date(acc.rateLimitedUntil).toISOString()}`);
+        this.syncQuotaForAccount(acc).catch((err) => log.warn(`[ACCOUNTS] [QUOTA] Failed to sync quota during rate limit for ${account.username}`, { error: err }));
+        await this.saveAccounts();
+    }
+    markSuccess(account, _duration) {
+        const acc = this.accounts.find((a) => a.username === account.username);
+        if (!acc)
+            return;
+        if (acc.status === "rate_limited") {
+            log.info(`[ACCOUNTS] [RECOVER] Account ${account.username} recovered from rate limit`);
+            acc.status = "active";
+            acc.rateLimitedUntil = 0;
+        }
+        acc.health_score = Math.min(MAX_HEALTH, acc.health_score + 2);
+        acc.failureCount = 0;
+        acc.lastUsed = Date.now();
+        this.requestCount++;
+        if (this.requestCount >= SYNC_EVERY_N_REQUESTS) {
+            this.requestCount = 0;
+            this.syncAllQuotas().catch((err) => log.warn("[ACCOUNTS] [QUOTA] Failed to run request-based quota sync", { error: err }));
+        }
+        this.saveAccounts().catch((err) => log.error("[ACCOUNTS] [SAVE] Failed to save accounts", err));
+    }
+    markFailed(account, error, statusCode) {
+        const acc = this.accounts.find((a) => a.username === account.username);
+        if (!acc)
+            return;
+        acc.last_error_at = Date.now();
+        if (statusCode === 401 || statusCode === 403) {
+            acc.status = "suspended";
+            acc.health_score = 0;
+            acc.enabled = false;
+            log.error(`[ACCOUNTS] [SUSPEND] Account ${acc.username} suspended due to auth error (${statusCode})`);
+        }
+        else if (statusCode === 429) {
+            acc.status = "rate_limited";
+            acc.failureCount = (acc.failureCount || 0) + 1;
+            acc.health_score = Math.max(0, acc.health_score - 50);
+            acc.rateLimitedUntil = Date.now() + DEFAULT_RATE_LIMIT_COOLDOWN;
+            log.warn(`[ACCOUNTS] [RATELIMIT] Account ${acc.username} marked rate limited from status code 429`);
+            this.syncQuotaForAccount(acc).catch((err) => log.warn(`[ACCOUNTS] [QUOTA] Failed to sync quota during rate limit for ${acc.username}`, { error: err }));
+        }
+        else {
+            const isClientError = statusCode && statusCode >= 400 && statusCode < 500;
+            if (!isClientError) {
+                acc.failureCount = (acc.failureCount || 0) + 1;
+            }
+            const oldScore = acc.health_score;
+            acc.health_score = Math.max(0, acc.health_score - 10);
+            const errorMessage = error ? error.message : `HTTP ${statusCode}`;
+            log.warn(`[ACCOUNTS] [FAIL] Operation failed for ${acc.username}. Error: ${errorMessage}. Health: ${oldScore} -> ${acc.health_score}. Failures: ${acc.failureCount}`);
+            if ((acc.failureCount || 0) >= MAX_FAILURES_BEFORE_SUSPEND) {
+                log.warn(`[ACCOUNTS] [SUSPEND] Account ${acc.username} suspended due to excessive failures (${acc.failureCount})`);
+                acc.status = "suspended";
+                acc.enabled = false;
+            }
+        }
+        this.saveAccounts().catch((err) => log.error("[ACCOUNTS] [SAVE] Failed to save accounts", err));
+    }
+    listAccounts() {
+        return [...this.accounts];
+    }
+    async updateAccount(username, updates) {
+        const account = this.accounts.find((a) => a.username === username);
+        if (account) {
+            Object.assign(account, updates);
+            await this.saveAccounts();
+        }
+    }
+    async toggleAccount(username, enabled) {
+        const account = this.accounts.find((a) => a.username === username);
+        if (account) {
+            account.enabled = enabled;
+            await this.saveAccounts();
+        }
+    }
+    updateAccountQuota(username, quota) {
+        const account = this.accounts.find((a) => a.username === username);
+        if (!account) {
+            log.warn(`[ACCOUNTS] [QUOTA] Cannot update quota - account not found: ${username}`);
+            return;
+        }
+        account.premiumRemaining = quota.premium.remaining;
+        account.premiumTotal = quota.premium.total;
+        account.quotaResetDate = quota.resetDate || undefined;
+        account.lastQuotaSync = Date.now();
+        log.info(`[ACCOUNTS] [QUOTA] Updated quota for ${username}: Premium=${account.premiumRemaining}/${account.premiumTotal}`);
+        this.requestSave();
+    }
+    async removeAccount(username) {
+        this.accounts = this.accounts.filter((a) => a.username !== username);
+        await this.saveAccounts([username]);
+    }
+}
+//# sourceMappingURL=accounts.js.map