letmecode 0.1.19 → 0.1.21

package/ink-app/dist/providers/copilot/quota.js

@@ -0,0 +1,257 @@
+import { execFile } from "node:child_process";
+import { asRecord } from "../limits.js";
+/**
+ * Resolve a GitHub token and fetch the Copilot quota/plan. The token is never
+ * echoed into the result or warnings. Token resolution and the HTTP fetch are
+ * injectable so tests run fully offline. A missing token is not an error — it
+ * yields a warning and no quota, leaving local OTEL usage unaffected.
+ */
+export async function getCopilotUserInfo(options) {
+    const env = options?.env ?? process.env;
+    const resolveToken = options?.resolveToken ?? resolveGitHubToken;
+    const fetchUser = options?.fetchUser ?? getCopilotUser;
+    const token = await resolveToken(env);
+    if (!token) {
+        return {
+            warnings: [
+                "Copilot plan and quota are unavailable: no GitHub token found. " +
+                    "Set GH_TOKEN or GITHUB_TOKEN, or install GitHub CLI and run `gh auth login`."
+            ]
+        };
+    }
+    const result = await fetchUser(token);
+    if (!result.ok) {
+        return { warnings: [result.warning] };
+    }
+    return { quotaInfo: parseCopilotQuota(result.data), warnings: [] };
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Token resolution: GH_TOKEN → GITHUB_TOKEN → `gh auth token`
+// ────────────────────────────────────────────────────────────────────────────
+const GH_TIMEOUT_MS = 2000;
+async function resolveGitHubToken(env) {
+    const fromEnv = nonEmpty(env.GH_TOKEN) ?? nonEmpty(env.GITHUB_TOKEN);
+    if (fromEnv) {
+        return fromEnv;
+    }
+    return ghAuthToken();
+}
+function ghAuthToken() {
+    return new Promise((resolve) => {
+        execFile("gh", ["auth", "token"], { timeout: GH_TIMEOUT_MS }, (error, stdout) => {
+            resolve(error ? null : nonEmpty(stdout));
+        });
+    });
+}
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+// ────────────────────────────────────────────────────────────────────────────
+// HTTP transport (Node built-in fetch)
+// ────────────────────────────────────────────────────────────────────────────
+const COPILOT_USER_URL = "https://api.github.com/copilot_internal/user";
+const REQUEST_TIMEOUT_MS = 10000;
+// Header values mirror a real Copilot Chat client; the endpoint ignores requests
+// with implausible editor/plugin versions.
+const HEADERS = {
+    Accept: "application/json",
+    "User-Agent": "GitHubCopilotChat/0.26.7",
+    "Editor-Version": "vscode/1.96.2",
+    "Editor-Plugin-Version": "copilot-chat/0.26.7",
+    "X-GitHub-Api-Version": "2025-04-01"
+};
+async function getCopilotUser(token) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(COPILOT_USER_URL, {
+            headers: { ...HEADERS, Authorization: `token ${token}` },
+            signal: controller.signal
+        });
+        if (!response.ok) {
+            return { ok: false, warning: warningForStatus(response.status) };
+        }
+        try {
+            return { ok: true, data: await response.json() };
+        }
+        catch {
+            return { ok: false, warning: "Copilot quota API returned invalid JSON." };
+        }
+    }
+    catch {
+        // Aborts (timeout) and network failures land here; the response body, if any,
+        // is never read or logged.
+        return { ok: false, warning: "Copilot quota API request failed." };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function warningForStatus(status) {
+    switch (status) {
+        case 401:
+            return "Copilot quota API returned 401; run `gh auth login` again.";
+        case 403:
+            return "Copilot quota API returned 403; the token may lack Copilot access.";
+        case 404:
+            return "Copilot quota API returned 404; the Copilot user endpoint is unavailable.";
+        case 429:
+            return "Copilot quota API is rate limited; try again later.";
+        default:
+            return `Copilot quota API returned ${status}.`;
+    }
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Quota parsing (two known response shapes)
+// ────────────────────────────────────────────────────────────────────────────
+const KNOWN_LABELS = {
+    premium_interactions: "Premium",
+    chat: "Chat",
+    completions: "Completions"
+};
+/**
+ * Parse the raw `/copilot_internal/user` JSON into {@link CopilotQuotaInfo}.
+ * Tolerates both the paid (`quota_snapshots`) and free
+ * (`monthly_quotas`/`limited_user_quotas`) shapes, never throws, derives
+ * percentages only from valid data, clamps them to 0..100, and leaves an
+ * unknown percentage undefined (never a false 0%). If the paid form yields no
+ * usable buckets, the free form is used as a fallback.
+ */
+export function parseCopilotQuota(raw) {
+    const root = asRecord(raw);
+    if (!root) {
+        return { quotas: [] };
+    }
+    const snapshots = asRecord(root.quota_snapshots);
+    const paid = snapshots ? parsePaidQuotas(snapshots) : [];
+    const usePaid = paid.length > 0;
+    const quotas = usePaid ? paid : parseFreeQuotas(root);
+    const info = {
+        quotas: quotas.sort((a, b) => a.id.localeCompare(b.id))
+    };
+    const plan = asString(root.copilot_plan);
+    if (plan !== undefined) {
+        info.plan = plan;
+    }
+    if (root.token_based_billing === true) {
+        info.tokenBasedBilling = true;
+    }
+    // Prefer the precise UTC reset timestamp; fall back to the date-only field.
+    const resetAt = usePaid
+        ? asString(root.quota_reset_date_utc) ?? asString(root.quota_reset_date)
+        : asString(root.limited_user_reset_date);
+    if (resetAt !== undefined) {
+        info.resetAt = resetAt;
+    }
+    return info;
+}
+function parsePaidQuotas(snapshots) {
+    const quotas = [];
+    for (const [key, value] of Object.entries(snapshots)) {
+        const snapshot = asRecord(value);
+        const id = (snapshot && asString(snapshot.quota_id)) || key;
+        const quota = { id, label: labelForKey(key) };
+        if (!snapshot) {
+            quotas.push(quota);
+            continue;
+        }
+        if (snapshot.unlimited === true) {
+            quota.unlimited = true;
+        }
+        const total = finiteNonNegative(snapshot.entitlement);
+        if (total !== undefined) {
+            quota.total = total;
+        }
+        const percentRemaining = finiteNonNegative(snapshot.percent_remaining);
+        // `quota_remaining` carries the precise (often fractional) balance; `remaining`
+        // is a rounded integer. Prefer the precise one for credit math.
+        const rawRemaining = finiteNonNegative(snapshot.quota_remaining) ?? finiteNonNegative(snapshot.remaining);
+        if (percentRemaining !== undefined) {
+            quota.remainingPercent = clampPercent(percentRemaining);
+            quota.usedPercent = clampPercent(100 - quota.remainingPercent);
+        }
+        else if (rawRemaining !== undefined && total !== undefined && total > 0) {
+            quota.remainingPercent = clampPercent((rawRemaining / total) * 100);
+            quota.usedPercent = clampPercent(100 - quota.remainingPercent);
+        }
+        if (rawRemaining !== undefined) {
+            const remaining = total !== undefined ? Math.min(rawRemaining, total) : rawRemaining;
+            quota.remaining = remaining;
+            if (total !== undefined) {
+                quota.used = Math.max(0, total - remaining);
+            }
+        }
+        quotas.push(quota);
+    }
+    return quotas;
+}
+function parseFreeQuotas(root) {
+    const monthly = asRecord(root.monthly_quotas) ?? {};
+    const limited = asRecord(root.limited_user_quotas) ?? {};
+    const keys = new Set([...Object.keys(monthly), ...Object.keys(limited)]);
+    const quotas = [];
+    for (const key of keys) {
+        const quota = { id: key, label: labelForKey(key) };
+        const total = finiteNonNegative(monthly[key]);
+        const rawRemaining = finiteNonNegative(limited[key]);
+        if (total !== undefined) {
+            quota.total = total;
+        }
+        if (rawRemaining !== undefined) {
+            const remaining = total !== undefined ? Math.min(rawRemaining, total) : rawRemaining;
+            quota.remaining = remaining;
+            if (total !== undefined) {
+                quota.used = Math.max(0, total - remaining);
+                if (total > 0) {
+                    quota.usedPercent = clampPercent((quota.used / total) * 100);
+                    quota.remainingPercent = clampPercent(100 - quota.usedPercent);
+                }
+            }
+        }
+        quotas.push(quota);
+    }
+    return quotas;
+}
+function labelForKey(key) {
+    if (KNOWN_LABELS[key] !== undefined) {
+        return KNOWN_LABELS[key];
+    }
+    const words = key.replace(/_/g, " ").trim().split(/\s+/);
+    return words
+        .map((word) => (word.length === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
+        .join(" ") || key;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/** Coerce a number-or-numeric-string into a finite, non-negative number. */
+function finiteNonNegative(value) {
+    const n = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim().length > 0
+            ? Number(value)
+            : undefined;
+    return n !== undefined && Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+function clampPercent(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.min(100, Math.max(0, value));
+}
+/**
+ * Subtract one calendar month from a date in UTC, clamping the day so that, e.g.
+ * 2026-03-31 → 2026-02-28 and 2024-03-31 → 2024-02-29. A reset on the first of a
+ * month maps to the first of the previous month. Used to derive the start of the
+ * current monthly billing window from its reset (end) date.
+ */
+export function subtractOneUtcCalendarMonth(value) {
+    const result = new Date(value);
+    const originalDay = result.getUTCDate();
+    result.setUTCDate(1);
+    result.setUTCMonth(result.getUTCMonth() - 1);
+    const daysInTargetMonth = new Date(Date.UTC(result.getUTCFullYear(), result.getUTCMonth() + 1, 0)).getUTCDate();
+    result.setUTCDate(Math.min(originalDay, daysInTargetMonth));
+    return result;
+}

package/ink-app/dist/providers/copilot/usage/aggregate.js

@@ -0,0 +1,84 @@
+import { addUsageTotals, sumUsageTotals } from "../../contract.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "../../daily.js";
+import { isNonBillableCopilotModel, normalizeCopilotModelId, rateForCopilotModel } from "../models.js";
+/**
+ * Select events whose timestamp falls in the half-open interval
+ * `[startTimeMs, endTimeMs)`. An event exactly at `endTimeMs` belongs to the
+ * next window and is excluded. Used to scope OTEL usage to a billing window
+ * without re-parsing — the same events feed all-time and per-window rollups.
+ */
+export function filterCopilotUsageEvents(events, startTimeMs, endTimeMs) {
+    return events.filter((event) => event.timestampMs >= startTimeMs && event.timestampMs < endTimeMs);
+}
+/**
+ * Aggregate normalized Copilot usage events into per-model and per-day rollups
+ * plus summary totals, applying the corrected cache accounting model where the
+ * reported input already INCLUDES cache-read tokens but NOT cache-write tokens.
+ * Pure and deterministic: independent of input ordering.
+ */
+export function aggregateCopilotUsage(events) {
+    const byModel = new Map();
+    const byDay = createDailyUsageAggregates();
+    for (const event of events) {
+        const modelId = normalizeCopilotModelId(event.modelId);
+        const hasCacheInfo = event.cacheReadStatus === "known" || event.cacheWriteStatus === "known";
+        // The reported input already INCLUDES cache-read but NOT cache-write. The
+        // cache-read bucket is preserved IN FULL; only the portion that overlaps the
+        // reported input is subtracted to derive the uncached input. Capping cacheRead
+        // at inputTokens would silently lose cache-only events (input 0, cacheRead N).
+        const reportedInput = Math.max(0, event.inputTokens);
+        const cacheRead = hasCacheInfo ? Math.max(0, event.cacheReadInputTokens) : 0;
+        const uncachedInput = hasCacheInfo
+            ? Math.max(0, reportedInput - cacheRead)
+            : reportedInput;
+        const cacheWrite = hasCacheInfo ? Math.max(0, event.cacheWriteInputTokens) : 0;
+        const output = event.outputTokens;
+        const reasoning = Math.min(event.reasoningOutputTokens, output);
+        const nonBillable = isNonBillableCopilotModel(modelId);
+        const rate = nonBillable ? undefined : rateForCopilotModel(modelId, event.inputTokens);
+        const creditsKnown = nonBillable || (hasCacheInfo && rate !== undefined);
+        const estimatedCreditsStatus = creditsKnown ? "known" : "unavailable";
+        const estimatedCredits = rate !== undefined && hasCacheInfo
+            ? (uncachedInput / 1000000) * rate.input +
+                (cacheRead / 1000000) * rate.cacheRead +
+                (cacheWrite / 1000000) * rate.cacheWrite +
+                (output / 1000000) * rate.output
+            : 0;
+        const totals = {
+            inputTokens: uncachedInput,
+            outputTokens: output,
+            cacheReadInputTokens: cacheRead,
+            cacheWriteInputTokens: cacheWrite,
+            cacheWrite5mInputTokens: 0,
+            cacheWrite1hInputTokens: 0,
+            reasoningOutputTokens: reasoning,
+            totalTokens: uncachedInput + cacheRead + cacheWrite + output,
+            estimatedCredits,
+            eventCount: 1,
+            cacheReadStatus: event.cacheReadStatus,
+            cacheWriteStatus: event.cacheWriteStatus,
+            estimatedCreditsStatus
+        };
+        const existing = byModel.get(modelId);
+        if (existing) {
+            addUsageTotals(existing, totals);
+        }
+        else {
+            byModel.set(modelId, { ...totals });
+        }
+        addDailyUsage(byDay, event.timestampMs, modelId, undefined, totals);
+    }
+    const modelUsage = [...byModel.entries()]
+        .map(([modelId, totals]) => ({ modelId, totals }))
+        .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+    const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+    const distinctModels = modelUsage.map((row) => row.modelId);
+    const dayUsage = buildDailyUsageRows(byDay);
+    return {
+        modelUsage,
+        dayUsage,
+        summaryTotals,
+        distinctModels,
+        tokenEvents: events.length
+    };
+}