@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/services/limits/adapters/claude.js

@@ -0,0 +1,219 @@
+import { getSecureStorage } from '../../../utils/secureStorage/index.js';
+import { OAUTH_BETA_HEADER, getOauthConfig } from '../../../constants/oauth.js';
+import { getClaudeCodeUserAgent } from '../../../utils/userAgent.js';
+import { registerAdapter } from '../registry.js';
+const PROVIDER = 'claude';
+function readSecureStorage() {
+    try {
+        return (getSecureStorage().read() ?? {});
+    }
+    catch {
+        return {};
+    }
+}
+function resolveCredential(profile) {
+    const storage = readSecureStorage();
+    const profileApiKey = storage.providerProfileApiKeys?.[profile.id];
+    if (profileApiKey?.trim()) {
+        return { kind: 'api-key', token: profileApiKey.trim(), source: 'profile' };
+    }
+    const profileOauth = storage.providerProfileOauth?.[profile.id]?.accessToken;
+    if (profileOauth?.trim()) {
+        return { kind: 'oauth', token: profileOauth.trim(), source: 'profile' };
+    }
+    const providerApiKey = storage.providerApiKeys?.[PROVIDER];
+    if (providerApiKey?.trim()) {
+        return { kind: 'api-key', token: providerApiKey.trim(), source: 'shared' };
+    }
+    const oauth = storage.claudeAiOauth?.accessToken;
+    if (oauth?.trim()) {
+        return { kind: 'oauth', token: oauth.trim(), source: 'shared' };
+    }
+    return { kind: 'none' };
+}
+function stringifyError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function formatResetShort(value) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return value;
+    const now = Date.now();
+    const diffMs = parsed.getTime() - now;
+    if (diffMs <= 0)
+        return 'pasado';
+    const diffMin = Math.round(diffMs / 60000);
+    if (diffMin < 60)
+        return `en ${diffMin}m`;
+    const diffH = Math.round(diffMin / 60);
+    if (diffH < 24)
+        return `en ${diffH}h`;
+    const diffD = Math.round(diffH / 24);
+    return `en ${diffD}d`;
+}
+/**
+ * Consulta /api/oauth/usage usando el access token del perfil específico.
+ *
+ * `fetchUtilization()` (services/api/usage.ts) lee siempre el OAuth global —
+ * por eso varios perfiles de Claude reportaban el mismo uso. Esta versión
+ * acepta el token directamente para que cada perfil consulte SU cuenta.
+ */
+async function fetchUtilizationForToken(accessToken, signal) {
+    const url = `${getOauthConfig().BASE_API_URL}/api/oauth/usage`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'anthropic-beta': OAUTH_BETA_HEADER,
+            'Content-Type': 'application/json',
+            'User-Agent': getClaudeCodeUserAgent(),
+        },
+        signal,
+    });
+    if (response.status === 401 || response.status === 403) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`Anthropic /api/oauth/usage HTTP ${response.status}`);
+    }
+    const data = (await response.json().catch(() => null));
+    return data;
+}
+export const claudeLimitAdapter = {
+    provider: PROVIDER,
+    isApplicable(profile) {
+        return profile.provider === PROVIDER;
+    },
+    async fetch({ profile, signal }) {
+        const base = {
+            provider: PROVIDER,
+            profileId: profile.id,
+            profileName: profile.name,
+        };
+        const credential = resolveCredential(profile);
+        if (credential.kind === 'none') {
+            return {
+                ...base,
+                status: 'unconfigured',
+                message: 'No hay credencial configurada para este perfil de Claude.',
+            };
+        }
+        if (credential.kind === 'oauth') {
+            // claude.ai expone /api/oauth/usage para suscriptores. Hacemos el fetch
+            // con el access token del perfil para no leer la OAuth global compartida.
+            try {
+                const utilization = await fetchUtilizationForToken(credential.token, signal);
+                if (utilization == null) {
+                    return {
+                        ...base,
+                        status: 'unconfigured',
+                        plan: 'Claude (OAuth)',
+                        message: 'El access token de este perfil fue rechazado (401/403). Vuelve a iniciar sesión con /provider claude profile <nombre> + /login.',
+                    };
+                }
+                if (Object.keys(utilization).length === 0) {
+                    return {
+                        ...base,
+                        status: 'no-data',
+                        plan: 'Claude (OAuth)',
+                        message: 'No hay datos de uso disponibles. Verifica que tu suscripción siga activa con /usage.',
+                    };
+                }
+                // Las ventanas de utilizacion vienen como porcentaje 0-100, no como tokens.
+                const namedWindows = [
+                    { label: 'Sesión actual (5 h)', window: utilization.five_hour },
+                    { label: 'Semana actual (todos los modelos)', window: utilization.seven_day },
+                    { label: 'Semana actual (solo Sonnet)', window: utilization.seven_day_sonnet },
+                    { label: 'Semana actual (solo Opus)', window: utilization.seven_day_opus },
+                    { label: 'Apps OAuth (7 días)', window: utilization.seven_day_oauth_apps },
+                ];
+                const windows = [];
+                const details = [];
+                if (credential.source === 'shared') {
+                    details.push('Credencial OAuth compartida con otros perfiles de Claude (los datos serán iguales en todos).');
+                }
+                let topUsedPercent = null;
+                let topResetsAt;
+                for (const { label, window } of namedWindows) {
+                    if (!window || window.utilization == null)
+                        continue;
+                    const pct = window.utilization;
+                    windows.push({
+                        label,
+                        percentUsed: pct,
+                        resetsAt: window.resets_at ?? undefined,
+                    });
+                    if (topUsedPercent == null || pct > topUsedPercent) {
+                        topUsedPercent = pct;
+                        topResetsAt = window.resets_at ?? undefined;
+                    }
+                }
+                // claude.ai devuelve used_credits y monthly_limit en CENTAVOS de USD,
+                // como en el componente Settings/Usage.tsx (extraUsage.used_credits / 100).
+                const extra = utilization.extra_usage;
+                const usedCents = typeof extra?.used_credits === 'number' ? extra.used_credits : null;
+                const limitCents = typeof extra?.monthly_limit === 'number' ? extra.monthly_limit : null;
+                const costUsedUsd = usedCents != null ? usedCents / 100 : undefined;
+                const costLimitUsd = limitCents != null ? limitCents / 100 : null;
+                const messageParts = [];
+                if (topUsedPercent != null) {
+                    messageParts.push(`uso pico ${topUsedPercent.toFixed(1)}%`);
+                }
+                if (extra?.is_enabled && extra.utilization != null) {
+                    messageParts.push(`extra ${extra.utilization.toFixed(1)}%`);
+                }
+                if (extra && !extra.is_enabled) {
+                    messageParts.push('uso adicional no habilitado');
+                }
+                // El "extra usage" es un complemento opcional de la suscripcion (apps
+                // de terceros). Lo añadimos como una window mas con su propia barra.
+                if (extra?.is_enabled && usedCents != null && limitCents != null) {
+                    const usedUsd = (usedCents / 100).toFixed(2);
+                    const limitUsd = (limitCents / 100).toFixed(2);
+                    const cappedNote = usedCents > limitCents ? ' · límite alcanzado' : '';
+                    windows.push({
+                        label: 'Uso adicional (apps de terceros)',
+                        percentUsed: extra.utilization ?? null,
+                        valueText: `$${usedUsd} / $${limitUsd}`,
+                        note: `gastado$${cappedNote}`,
+                    });
+                }
+                else if (extra && !extra.is_enabled) {
+                    details.push('Uso adicional no habilitado (/extra-usage para activarlo).');
+                }
+                return {
+                    ...base,
+                    status: 'ok',
+                    plan: 'Claude · suscripción',
+                    resetsAt: topResetsAt,
+                    message: messageParts.join(' · ') || undefined,
+                    windows,
+                    details,
+                    raw: utilization,
+                };
+            }
+            catch (error) {
+                return {
+                    ...base,
+                    status: 'error',
+                    plan: 'Claude (OAuth)',
+                    message: stringifyError(error),
+                };
+            }
+        }
+        // credential.kind === 'api-key' (Anthropic API directa).
+        // TODO verificar endpoint /v1/usage en api.anthropic.com (no existe publicamente a la fecha).
+        // Anthropic no expone usage por endpoint REST; solo devuelve headers anthropic-ratelimit-*
+        // tras una llamada real a /v1/messages.
+        return {
+            ...base,
+            status: 'no-data',
+            plan: 'Anthropic API key',
+            message: 'Anthropic API no expone usage por endpoint; usa headers anthropic-ratelimit-* tras una llamada.',
+        };
+    },
+};
+registerAdapter(claudeLimitAdapter);

package/dist/src/services/limits/adapters/minimax.js

@@ -0,0 +1,177 @@
+import { getSecureStorage } from '../../../utils/secureStorage/index.js';
+import { registerAdapter } from '../registry.js';
+const PROVIDER = 'minimax';
+function readSecureStorage() {
+    try {
+        return (getSecureStorage().read() ?? {});
+    }
+    catch {
+        return {};
+    }
+}
+function resolveCredential(profileId) {
+    const storage = readSecureStorage();
+    const profileApiKey = storage.providerProfileApiKeys?.[profileId];
+    if (profileApiKey?.trim()) {
+        return { kind: 'api-key', token: profileApiKey.trim() };
+    }
+    const profileOauth = storage.providerProfileOauth?.[profileId]?.accessToken;
+    if (profileOauth?.trim()) {
+        return { kind: 'oauth', token: profileOauth.trim() };
+    }
+    const providerApiKey = storage.providerApiKeys?.[PROVIDER];
+    if (providerApiKey?.trim()) {
+        return { kind: 'api-key', token: providerApiKey.trim() };
+    }
+    return { kind: 'none', token: null };
+}
+function stringifyError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+export const minimaxLimitAdapter = {
+    provider: PROVIDER,
+    isApplicable(profile) {
+        return profile.provider === PROVIDER;
+    },
+    async fetch({ profile, signal, }) {
+        const base = {
+            provider: PROVIDER,
+            profileId: profile.id,
+            profileName: profile.name,
+        };
+        try {
+            const credential = resolveCredential(profile.id);
+            if (credential.kind === 'none') {
+                return {
+                    ...base,
+                    status: 'unconfigured',
+                    message: 'No hay credencial configurada para MiniMax en este perfil. Anade una API key desde /provider.',
+                };
+            }
+            if (signal?.aborted) {
+                return {
+                    ...base,
+                    status: 'error',
+                    message: 'Operacion cancelada antes de consultar MiniMax.',
+                };
+            }
+            // Endpoint oficial reverse-engineered desde MiniMax-AI/cli (src/commands/quota/show.ts):
+            // GET https://api.minimax.io/v1/token_plan/remains  (api.minimaxi.com para CN).
+            // Respuesta: { base_resp: { status_code, status_msg }, model_remains: [{ model_name, current_interval_usage_count, current_interval_total_count }] }
+            const baseUrl = (profile.baseUrl ?? '').toLowerCase();
+            const host = baseUrl.includes('minimaxi.com')
+                ? 'https://api.minimaxi.com'
+                : 'https://api.minimax.io';
+            const url = `${host}/v1/token_plan/remains`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${credential.token}`,
+                    'Content-Type': 'application/json',
+                },
+                signal,
+            });
+            if (response.status === 401 || response.status === 403) {
+                return {
+                    ...base,
+                    status: 'no-data',
+                    plan: 'MiniMax API',
+                    message: 'La API key actual no tiene permiso para consultar /v1/token_plan/remains.',
+                };
+            }
+            if (!response.ok) {
+                return {
+                    ...base,
+                    status: 'error',
+                    message: `MiniMax respondio HTTP ${response.status}.`,
+                };
+            }
+            const data = (await response.json());
+            if (data.base_resp?.status_code && data.base_resp.status_code !== 0) {
+                return {
+                    ...base,
+                    status: 'error',
+                    plan: 'MiniMax API',
+                    message: data.base_resp.status_msg ?? `MiniMax error code ${data.base_resp.status_code}`,
+                };
+            }
+            const remains = data.model_remains ?? [];
+            if (remains.length === 0) {
+                return {
+                    ...base,
+                    status: 'no-data',
+                    plan: 'MiniMax API',
+                    message: 'MiniMax no devolvio cuotas para esta API key.',
+                    raw: data,
+                };
+            }
+            let totalUsed = 0;
+            let totalLimit = 0;
+            let allUnlimited = true;
+            const perModel = {};
+            const windows = [];
+            for (const m of remains) {
+                const used = Number(m.current_interval_usage_count ?? 0);
+                const total = Number(m.current_interval_total_count ?? 0);
+                if (Number.isFinite(used))
+                    totalUsed += used;
+                if (Number.isFinite(total) && total > 0) {
+                    totalLimit += total;
+                    allUnlimited = false;
+                }
+                const name = m.model_name ?? 'modelo';
+                if (m.model_name) {
+                    perModel[m.model_name] = {
+                        used,
+                        total,
+                        remaining: Math.max(0, total - used),
+                    };
+                }
+                if (total > 0) {
+                    windows.push({
+                        label: name,
+                        percentUsed: (used / total) * 100,
+                        valueText: `${used.toLocaleString('es')} / ${total.toLocaleString('es')} tokens`,
+                    });
+                }
+                else {
+                    windows.push({
+                        label: name,
+                        percentUsed: null,
+                        valueText: `${used.toLocaleString('es')} tokens usados (sin límite informado)`,
+                    });
+                }
+            }
+            return {
+                ...base,
+                status: 'ok',
+                plan: 'MiniMax · Token Plan',
+                tokensUsed: totalUsed,
+                tokensLimit: allUnlimited ? null : totalLimit,
+                message: remains.length > 1
+                    ? `${remains.length} modelos con cuota.`
+                    : undefined,
+                windows,
+                raw: { perModel, baseHost: host },
+            };
+        }
+        catch (error) {
+            if (error?.name === 'AbortError') {
+                return {
+                    ...base,
+                    status: 'error',
+                    message: 'Consulta a MiniMax cancelada.',
+                };
+            }
+            return {
+                ...base,
+                status: 'error',
+                message: stringifyError(error),
+            };
+        }
+    },
+};
+registerAdapter(minimaxLimitAdapter);

package/dist/src/services/limits/adapters/ollama.js

@@ -0,0 +1,189 @@
+import { getSecureStorage } from '../../../utils/secureStorage/index.js';
+import { registerAdapter } from '../registry.js';
+const DEFAULT_OLLAMA_BASE = 'http://localhost:11434';
+function readSecureStorage() {
+    try {
+        return (getSecureStorage().read() ?? {});
+    }
+    catch {
+        return {};
+    }
+}
+function resolveCredential(provider, profileId) {
+    const storage = readSecureStorage();
+    const profileApiKey = storage.providerProfileApiKeys?.[profileId];
+    if (profileApiKey?.trim()) {
+        return { kind: 'api-key', token: profileApiKey.trim() };
+    }
+    const profileOauth = storage.providerProfileOauth?.[profileId]?.accessToken;
+    if (profileOauth?.trim()) {
+        return { kind: 'oauth', token: profileOauth.trim() };
+    }
+    const providerApiKey = storage.providerApiKeys?.[provider];
+    if (providerApiKey?.trim()) {
+        return { kind: 'api-key', token: providerApiKey.trim() };
+    }
+    return { kind: 'none', token: null };
+}
+function stringifyError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function trimTrailingSlash(value) {
+    return value.endsWith('/') ? value.slice(0, -1) : value;
+}
+/**
+ * Devuelve la base "raiz" del servidor Ollama (sin /v1) para llamar a /api/tags.
+ * Si el perfil define baseUrl con /v1 al final, se elimina.
+ */
+function resolveOllamaApiBase(profile) {
+    const raw = profile.baseUrl?.trim() || DEFAULT_OLLAMA_BASE;
+    let base = trimTrailingSlash(raw);
+    if (base.toLowerCase().endsWith('/v1')) {
+        base = base.slice(0, -3);
+        base = trimTrailingSlash(base);
+    }
+    return base;
+}
+function isLocalhostBase(base) {
+    try {
+        const url = new URL(base);
+        const host = url.hostname.toLowerCase();
+        return (host === 'localhost' ||
+            host === '127.0.0.1' ||
+            host === '0.0.0.0' ||
+            host === '::1' ||
+            host.endsWith('.local'));
+    }
+    catch {
+        return false;
+    }
+}
+async function tryListAvailableModels(base, signal) {
+    try {
+        const response = await fetch(`${base}/api/tags`, {
+            method: 'GET',
+            signal,
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const payload = (await response.json());
+        if (Array.isArray(payload.models)) {
+            return payload.models.length;
+        }
+        return null;
+    }
+    catch {
+        // Tolerar fallo de red silenciosamente.
+        return null;
+    }
+}
+export const ollamaLimitAdapter = {
+    provider: 'ollama',
+    isApplicable(profile) {
+        return profile.provider === 'ollama';
+    },
+    async fetch({ profile, signal, }) {
+        const base = {
+            provider: 'ollama',
+            profileId: profile.id,
+            profileName: profile.name,
+        };
+        try {
+            const apiBase = resolveOllamaApiBase(profile);
+            const availableModels = await tryListAvailableModels(apiBase, signal);
+            const raw = { baseUrl: apiBase };
+            if (availableModels !== null) {
+                raw.availableModels = availableModels;
+            }
+            return {
+                ...base,
+                status: 'ok',
+                plan: 'Ollama local (ilimitado)',
+                tokensLimit: null,
+                costLimitUsd: null,
+                message: 'Ollama corre localmente; no hay limite de proveedor.',
+                raw,
+            };
+        }
+        catch (error) {
+            return {
+                ...base,
+                status: 'error',
+                message: stringifyError(error),
+            };
+        }
+    },
+};
+export const ollamaCloudLimitAdapter = {
+    provider: 'ollama-cloud',
+    isApplicable(profile) {
+        return profile.provider === 'ollama-cloud';
+    },
+    async fetch({ profile, signal, }) {
+        const base = {
+            provider: 'ollama-cloud',
+            profileId: profile.id,
+            profileName: profile.name,
+        };
+        try {
+            const apiBase = resolveOllamaApiBase(profile);
+            // Si el baseUrl apunta a localhost, en realidad es un Ollama local
+            // disfrazado de "ollama-cloud"; lo tratamos como ilimitado.
+            if (isLocalhostBase(apiBase)) {
+                const availableModels = await tryListAvailableModels(apiBase, signal);
+                const raw = { baseUrl: apiBase, mode: 'local' };
+                if (availableModels !== null) {
+                    raw.availableModels = availableModels;
+                }
+                return {
+                    ...base,
+                    status: 'ok',
+                    plan: 'Ollama local (ilimitado)',
+                    tokensLimit: null,
+                    costLimitUsd: null,
+                    message: 'El perfil ollama-cloud apunta a un host local; se trata como Ollama local ilimitado.',
+                    raw,
+                };
+            }
+            const credential = resolveCredential('ollama-cloud', profile.id);
+            if (credential.kind === 'none') {
+                return {
+                    ...base,
+                    status: 'unconfigured',
+                    message: 'No hay credencial configurada para Ollama Cloud en este perfil. Anade una API key desde /provider.',
+                };
+            }
+            if (signal?.aborted) {
+                return {
+                    ...base,
+                    status: 'error',
+                    message: 'Operacion cancelada antes de consultar Ollama Cloud.',
+                };
+            }
+            // Ollama Cloud no expone (a fecha de hoy) un endpoint publico estable
+            // para consultar uso/saldo por API key. Devolvemos `no-data` para que
+            // el comando /limites informe al usuario sin hacer fetch ciegos.
+            // TODO: cuando Ollama Cloud publique /api/usage o equivalente, llamarlo.
+            return {
+                ...base,
+                status: 'no-data',
+                plan: 'Ollama Cloud',
+                message: 'Ollama Cloud no expone endpoint publico de uso por API key. Consulta el dashboard de Ollama.',
+                raw: { baseUrl: apiBase, mode: 'cloud' },
+            };
+        }
+        catch (error) {
+            return {
+                ...base,
+                status: 'error',
+                message: stringifyError(error),
+            };
+        }
+    },
+};
+registerAdapter(ollamaLimitAdapter);
+registerAdapter(ollamaCloudLimitAdapter);