@slkiser/opencode-quota 4.0.1 → 4.1.0

package/dist/lib/copilot.js

@@ -15,6 +15,7 @@ const GITHUB_API_BASE_URL = "https://api.github.com";
 const GITHUB_API_VERSION = "2026-03-10";
 const COPILOT_QUOTA_CONFIG_FILENAME = "copilot-quota-token.json";
 const USER_AGENT = "opencode-quota/copilot-billing";
+const COPILOT_INTERNAL_USER_PATH = "/copilot_internal/user";
 const PERSONAL_AI_CREDIT_TOTALS = {
     pro: 1500,
     "pro+": 7000,
@@ -36,6 +37,61 @@ function dedupeStrings(values) {
     }
     return out;
 }
+function validateEnterpriseHost(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value !== "string" || !value.trim()) {
+        return { error: "enterpriseUrl must be a non-empty string when provided" };
+    }
+    const raw = value.trim();
+    const invalid = {
+        error: "enterpriseUrl must be a hostname or host-only HTTPS URL ending in .ghe.com (without api. prefix, port, path, query, fragment, or userinfo)",
+    };
+    if (!/^[\x21-\x7e]+$/.test(raw) || raw.includes("*"))
+        return invalid;
+    let host;
+    if (raw.includes("://")) {
+        const authority = raw.slice(raw.indexOf("//") + 2).split(/[/?#]/u, 1)[0] ?? "";
+        if (authority.includes(":"))
+            return invalid;
+        let url;
+        try {
+            url = new URL(raw);
+        }
+        catch {
+            return invalid;
+        }
+        if (url.protocol !== "https:" ||
+            url.username ||
+            url.password ||
+            url.port ||
+            (url.pathname !== "" && url.pathname !== "/") ||
+            url.search ||
+            url.hash) {
+            return invalid;
+        }
+        host = url.hostname.toLowerCase();
+    }
+    else {
+        if (/[\/:@?#]/.test(raw))
+            return invalid;
+        host = raw.toLowerCase();
+    }
+    if (host.length > 253 || host.startsWith("api.") || !host.endsWith(".ghe.com")) {
+        return invalid;
+    }
+    const labels = host.split(".");
+    if (labels.some((label) => label.length === 0 || label.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label))) {
+        return invalid;
+    }
+    return { host };
+}
+function getApiBaseUrl(enterpriseHost) {
+    return enterpriseHost ? `https://api.${enterpriseHost}` : GITHUB_API_BASE_URL;
+}
+function getApiHost(apiBaseUrl) {
+    return new URL(apiBaseUrl).hostname;
+}
 function classifyPatTokenKind(token) {
     if (token.startsWith("github_pat_"))
         return "github_pat";
@@ -203,6 +259,9 @@ function validateQuotaConfig(raw) {
         return value.trim();
     };
     try {
+        const enterpriseHost = validateEnterpriseHost(obj.enterpriseUrl);
+        if (enterpriseHost.error)
+            throw new Error(enterpriseHost.error);
         const config = {
             token,
             tier: tier,
@@ -210,6 +269,7 @@ function validateQuotaConfig(raw) {
             username: readOptionalString("username"),
             organization: readOptionalString("organization"),
             enterprise: readOptionalString("enterprise"),
+            enterpriseUrl: enterpriseHost.host,
         };
         const resolved = resolvePatBillingTarget(config);
         if (!resolved.target) {
@@ -256,6 +316,9 @@ export function readQuotaConfigWithMeta() {
     }
     return { state: "absent", checkedPaths };
 }
+function getCopilotOAuthToken(auth) {
+    return auth?.access?.trim() || auth?.refresh?.trim() || null;
+}
 function selectCopilotAuth(authData) {
     if (!authData)
         return { auth: null, keyName: null };
@@ -268,7 +331,7 @@ function selectCopilotAuth(authData) {
     for (const [keyName, auth] of candidates) {
         if (!auth || auth.type !== "oauth")
             continue;
-        if (!auth.access && !auth.refresh)
+        if (!getCopilotOAuthToken(auth))
             continue;
         return { auth, keyName };
     }
@@ -289,6 +352,7 @@ function getRemainingTotalsState(target, config) {
 export function getCopilotQuotaAuthDiagnostics(authData) {
     const pat = readQuotaConfigWithMeta();
     const { auth, keyName } = selectCopilotAuth(authData);
+    const oauthEnterpriseHost = validateEnterpriseHost(auth?.enterpriseUrl);
     const resolved = pat.state === "valid" && pat.config
         ? resolvePatBillingTarget(pat.config)
         : { target: null };
@@ -301,46 +365,88 @@ export function getCopilotQuotaAuthDiagnostics(authData) {
         : auth
             ? "oauth"
             : "none";
-    const billingModel = pat.config?.billingModel ?? "ai_credits";
-    const quotaApi = pat.state !== "valid"
+    const effectiveEnterpriseHost = effectiveSource === "pat"
+        ? pat.config?.enterpriseUrl
+        : effectiveSource === "oauth"
+            ? oauthEnterpriseHost.host
+            : undefined;
+    const enterpriseHostError = effectiveSource === "pat" && pat.error?.startsWith("enterpriseUrl")
+        ? pat.error
+        : effectiveSource === "oauth"
+            ? oauthEnterpriseHost.error
+            : undefined;
+    const deployment = effectiveSource === "none"
         ? "none"
-        : billingModel === "legacy_premium_requests"
+        : enterpriseHostError
+            ? "invalid"
+            : effectiveEnterpriseHost
+                ? "ghe.com"
+                : effectiveSource === "pat" && pat.state !== "valid"
+                    ? "none"
+                    : "github.com";
+    const apiBaseUrl = deployment === "github.com" || deployment === "ghe.com"
+        ? getApiBaseUrl(effectiveEnterpriseHost)
+        : null;
+    const billingModel = pat.config?.billingModel ?? "ai_credits";
+    const oauthAvailable = effectiveSource === "oauth" && Boolean(auth) && !oauthEnterpriseHost.error;
+    const quotaApi = pat.state === "valid"
+        ? billingModel === "legacy_premium_requests"
             ? "github_legacy_premium_request_api"
-            : "github_ai_credit_api";
+            : "github_ai_credit_api"
+        : oauthAvailable
+            ? "copilot_internal_user"
+            : "none";
+    const billingMode = resolved.target?.scope === "organization"
+        ? "organization_usage"
+        : resolved.target?.scope === "enterprise"
+            ? "enterprise_usage"
+            : resolved.target?.scope === "user" || oauthAvailable
+                ? "user_quota"
+                : "none";
     return {
         pat,
         oauth: {
             configured: Boolean(auth),
             keyName,
-            hasRefreshToken: Boolean(auth?.refresh),
+            hasRefreshToken: Boolean(auth?.refresh?.trim()),
             hasAccessToken: Boolean(auth?.access?.trim()),
+            hasEnterpriseUrl: auth?.enterpriseUrl !== undefined,
         },
+        deployment,
+        apiHost: apiBaseUrl ? getApiHost(apiBaseUrl) : null,
+        enterpriseHostSource: effectiveSource === "pat" && pat.config?.enterpriseUrl
+            ? "pat"
+            : effectiveSource === "oauth" && oauthEnterpriseHost.host
+                ? "oauth"
+                : "none",
+        enterpriseHostError,
         effectiveSource,
         override: patBlocksOAuth && auth ? "pat_overrides_oauth" : "none",
         quotaApi,
-        billingMode: resolved.target?.scope === "organization"
-            ? "organization_usage"
-            : resolved.target?.scope === "enterprise"
-                ? "enterprise_usage"
-                : resolved.target?.scope === "user"
-                    ? "user_quota"
-                    : "none",
-        billingScope: resolved.target?.scope ?? "none",
-        billingApiAccessLikely: pat.state === "valid" && Boolean(resolved.target) && !resolved.error && !compatibilityError,
-        remainingTotalsState: getRemainingTotalsState(resolved.target, pat.config),
+        billingMode,
+        billingScope: resolved.target?.scope ?? (oauthAvailable ? "user" : "none"),
+        billingApiAccessLikely: oauthAvailable ||
+            (pat.state === "valid" && Boolean(resolved.target) && !resolved.error && !compatibilityError),
+        remainingTotalsState: oauthAvailable
+            ? "reported_by_copilot_internal_user"
+            : getRemainingTotalsState(resolved.target, pat.config),
         queryPeriod: resolved.target?.billingPeriod,
         usernameFilter: pat.config?.username,
         billingTargetError: resolved.error,
         tokenCompatibilityError: compatibilityError ?? undefined,
         billingModel,
-        budgetApi: billingModel !== "ai_credits"
+        budgetApi: billingModel !== "ai_credits" || oauthAvailable
             ? "not_available"
             : resolved.target?.scope === "organization"
                 ? "organization_budgets"
                 : resolved.target?.scope === "enterprise"
                     ? "enterprise_budgets"
                     : "not_available",
-        oauthAccountingState: auth ? "not_supported_by_public_billing_api" : "not_configured",
+        oauthAccountingState: !auth
+            ? "not_configured"
+            : oauthEnterpriseHost.error
+                ? "invalid_enterprise_host"
+                : "available_via_copilot_internal_user",
     };
 }
 function buildGitHubRestHeaders(token) {
@@ -351,41 +457,59 @@ function buildGitHubRestHeaders(token) {
         "User-Agent": USER_AGENT,
     };
 }
-async function readGitHubRestErrorMessage(response) {
+function redactGitHubErrorText(text, secrets) {
+    let sanitized = sanitizeDisplayText(text);
+    for (const secret of secrets) {
+        if (!secret)
+            continue;
+        sanitized = sanitized.split(secret).join("[redacted]");
+        const sanitizedSecret = sanitizeDisplayText(secret);
+        if (sanitizedSecret) {
+            sanitized = sanitized.split(sanitizedSecret).join("[redacted]");
+        }
+    }
+    return sanitized;
+}
+async function readGitHubRestErrorMessage(response, secrets) {
     const text = await response.text();
     try {
         const parsed = JSON.parse(text);
         const message = typeof parsed.message === "string" ? parsed.message : null;
         const documentationUrl = typeof parsed.documentation_url === "string" ? parsed.documentation_url : null;
         if (message && documentationUrl) {
-            return sanitizeDisplayText(`${message} (${documentationUrl})`);
+            return redactGitHubErrorText(`${message} (${documentationUrl})`, secrets);
         }
         if (message)
-            return sanitizeDisplayText(message);
+            return redactGitHubErrorText(message, secrets);
     }
     catch {
         // Fall through to a bounded plain-text snippet.
     }
-    return sanitizeDisplaySnippet(text, 160);
+    return sanitizeDisplaySnippet(redactGitHubErrorText(text, secrets), 160);
 }
 async function fetchGitHubRestJson(url, token, requestTimeoutMs) {
-    const response = await fetchWithTimeout(url, { headers: buildGitHubRestHeaders(token) }, requestTimeoutMs);
-    if (!response.ok) {
-        const message = await readGitHubRestErrorMessage(response);
-        const rateLimit = response.status === 403 && response.headers.get("x-ratelimit-remaining") === "0"
-            ? " (GitHub API rate limit exhausted)"
-            : "";
-        throw new Error(`GitHub API error ${response.status}: ${message}${rateLimit}`);
-    }
-    try {
-        return (await response.json());
-    }
-    catch {
-        throw new Error("GitHub API returned malformed JSON");
-    }
+    return await fetchWithTimeout(url, {
+        request: { headers: buildGitHubRestHeaders(token) },
+        timeoutMs: requestTimeoutMs,
+        consume: async (response) => {
+            if (!response.ok) {
+                const message = await readGitHubRestErrorMessage(response, [token]);
+                const rateLimit = response.status === 403 && response.headers.get("x-ratelimit-remaining") === "0"
+                    ? " (GitHub API rate limit exhausted)"
+                    : "";
+                throw new Error(`GitHub API error ${response.status}: ${message}${rateLimit}`);
+            }
+            try {
+                return (await response.json());
+            }
+            catch {
+                throw new Error("GitHub API returned malformed JSON");
+            }
+        },
+    });
 }
-async function resolveGitHubUsername(token, requestTimeoutMs) {
-    const response = await fetchGitHubRestJson(`${GITHUB_API_BASE_URL}/user`, token, requestTimeoutMs);
+async function resolveGitHubUsername(apiBaseUrl, token, requestTimeoutMs) {
+    const response = await fetchGitHubRestJson(`${apiBaseUrl}/user`, token, requestTimeoutMs);
     const login = response.login?.trim();
     if (!login) {
         throw new Error("GitHub /user response did not include a login");
@@ -404,27 +528,27 @@ function buildBillingQuery(target) {
     }
     return query;
 }
-function getBillingUsageUrl(target, billingModel) {
+function getBillingUsageUrl(apiBaseUrl, target, billingModel) {
     const report = billingModel === "legacy_premium_requests" ? "premium_request" : "ai_credit";
     const query = buildBillingQuery(target);
     if (target.scope === "enterprise") {
-        return `${GITHUB_API_BASE_URL}/enterprises/${encodeURIComponent(target.enterprise)}/settings/billing/${report}/usage?${query}`;
+        return `${apiBaseUrl}/enterprises/${encodeURIComponent(target.enterprise)}/settings/billing/${report}/usage?${query}`;
     }
     if (target.scope === "organization") {
-        return `${GITHUB_API_BASE_URL}/organizations/${encodeURIComponent(target.organization)}/settings/billing/${report}/usage?${query}`;
+        return `${apiBaseUrl}/organizations/${encodeURIComponent(target.organization)}/settings/billing/${report}/usage?${query}`;
     }
-    return `${GITHUB_API_BASE_URL}/users/${encodeURIComponent(target.username)}/settings/billing/${report}/usage?${query}`;
+    return `${apiBaseUrl}/users/${encodeURIComponent(target.username)}/settings/billing/${report}/usage?${query}`;
 }
 async function fetchBillingUsage(params) {
     const target = params.target.scope === "user"
         ? {
             ...params.target,
             username: params.target.username ??
-                (await resolveGitHubUsername(params.token, params.requestTimeoutMs)),
+                (await resolveGitHubUsername(params.apiBaseUrl, params.token, params.requestTimeoutMs)),
         }
         : params.target;
     return {
-        response: await fetchGitHubRestJson(getBillingUsageUrl(target, params.billingModel), params.token, params.requestTimeoutMs),
+        response: await fetchGitHubRestJson(getBillingUsageUrl(params.apiBaseUrl, target, params.billingModel), params.token, params.requestTimeoutMs),
         target,
     };
 }
@@ -562,10 +686,10 @@ function budgetSpecificity(budget) {
             return 0;
     }
 }
-function getBudgetsUrl(target, page) {
+function getBudgetsUrl(apiBaseUrl, target, page) {
     const base = target.scope === "organization"
-        ? `${GITHUB_API_BASE_URL}/organizations/${encodeURIComponent(target.organization)}/settings/billing/budgets`
-        : `${GITHUB_API_BASE_URL}/enterprises/${encodeURIComponent(target.enterprise)}/settings/billing/budgets`;
+        ? `${apiBaseUrl}/organizations/${encodeURIComponent(target.organization)}/settings/billing/budgets`
+        : `${apiBaseUrl}/enterprises/${encodeURIComponent(target.enterprise)}/settings/billing/budgets`;
     const query = new URLSearchParams({ page: String(page), per_page: "100" });
     if (target.username)
         query.set("user", target.username);
@@ -574,7 +698,7 @@ function getBudgetsUrl(target, page) {
 async function fetchApplicableBudget(params) {
     const budgets = [];
     for (let page = 1; page <= 100; page += 1) {
-        const response = await fetchGitHubRestJson(getBudgetsUrl(params.target, page), params.token, params.requestTimeoutMs);
+        const response = await fetchGitHubRestJson(getBudgetsUrl(params.apiBaseUrl, params.target, page), params.token, params.requestTimeoutMs);
         if (!Array.isArray(response.budgets)) {
             throw new Error("GitHub budgets response did not include a budgets array");
         }
@@ -617,6 +741,7 @@ async function toAiCreditResult(params) {
     if (params.target.scope !== "user") {
         try {
             budget = await fetchApplicableBudget({
+                apiBaseUrl: params.apiBaseUrl,
                 token: params.token,
                 target: params.target,
                 spentUsd: totals.billedAmountUsd,
@@ -685,12 +810,112 @@ function toLegacyResult(response, config) {
 function toQuotaError(message) {
     return { success: false, error: message };
 }
+function buildCopilotInternalHeaders(token) {
+    return {
+        Accept: "application/json",
+        Authorization: `token ${token}`,
+        "Editor-Version": "vscode/1.96.2",
+        "Editor-Plugin-Version": "copilot-chat/0.26.7",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+        "X-GitHub-Api-Version": "2025-04-01",
+    };
+}
+function normalizeCopilotPlan(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const plan = sanitizeDisplayText(value).replace(/\s+/gu, " ").trim().slice(0, 64);
+    return plan || undefined;
+}
+function normalizeResetTime(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : undefined;
+}
+function parseCopilotInternalUser(response) {
+    const plan = normalizeCopilotPlan(response.copilot_plan);
+    const resetTimeIso = normalizeResetTime(response.quota_reset_date_utc ?? response.quota_reset_date);
+    const snapshot = response.quota_snapshots?.premium_interactions;
+    const entitlement = readFiniteNumber(snapshot?.entitlement);
+    const remaining = readFiniteNumber(snapshot?.quota_remaining ?? snapshot?.remaining);
+    const reportedPercentRemaining = readFiniteNumber(snapshot?.percent_remaining);
+    const hasPercentRemaining = snapshot?.percent_remaining !== undefined;
+    const hasReportedPercent = reportedPercentRemaining !== undefined &&
+        reportedPercentRemaining >= 0 &&
+        reportedPercentRemaining <= 100;
+    const isPlaceholder = response.token_based_billing === true &&
+        (!snapshot ||
+            (snapshot.unlimited !== true &&
+                entitlement === 0 &&
+                remaining === 0 &&
+                (!hasReportedPercent || reportedPercentRemaining === 0)));
+    if (isPlaceholder) {
+        return { success: true, mode: "user_plan", plan, resetTimeIso };
+    }
+    if (snapshot?.unlimited === true) {
+        return {
+            success: true,
+            mode: "user_quota",
+            unit: "ai_credits",
+            used: 0,
+            unlimited: true,
+            plan,
+            resetTimeIso,
+        };
+    }
+    if (entitlement !== undefined &&
+        entitlement > 0 &&
+        remaining !== undefined &&
+        remaining >= 0 &&
+        remaining <= entitlement) {
+        return {
+            success: true,
+            mode: "user_quota",
+            unit: "ai_credits",
+            used: entitlement - remaining,
+            total: entitlement,
+            percentRemaining: hasReportedPercent
+                ? reportedPercentRemaining
+                : !hasPercentRemaining
+                    ? Math.min(100, Math.max(0, (remaining / entitlement) * 100))
+                    : undefined,
+            plan,
+            resetTimeIso,
+        };
+    }
+    if (response.token_based_billing === true) {
+        return { success: true, mode: "user_plan", plan, resetTimeIso };
+    }
+    throw new Error("GitHub Copilot user response did not include a usable quota snapshot");
+}
+async function fetchCopilotInternalUser(params) {
+    return await fetchWithTimeout(`${params.apiBaseUrl}${COPILOT_INTERNAL_USER_PATH}`, {
+        request: { headers: buildCopilotInternalHeaders(params.token) },
+        timeoutMs: params.requestTimeoutMs,
+        consume: async (response) => {
+            if (!response.ok) {
+                const message = await readGitHubRestErrorMessage(response, [params.token]);
+                throw new Error(`GitHub Copilot API error ${response.status}: ${message}`);
+            }
+            let parsed;
+            try {
+                parsed = (await response.json());
+            }
+            catch {
+                throw new Error("GitHub Copilot API returned malformed JSON");
+            }
+            if (!parsed || typeof parsed !== "object") {
+                throw new Error("GitHub Copilot API returned malformed JSON");
+            }
+            return parseCopilotInternalUser(parsed);
+        },
+    });
+}
 /**
  * Query GitHub Copilot accounting.
  *
- * A valid local billing token config is required. OpenCode OAuth remains
- * visible in diagnostics but is not sent to GitHub's public billing API
- * because its billing permissions are not part of the documented contract.
+ * A trusted local PAT config remains authoritative. When it is absent, the
+ * OpenCode-managed Copilot OAuth token can query the per-user internal quota endpoint.
  */
 export async function queryCopilotQuota(options = {}) {
     const pat = readQuotaConfigWithMeta();
@@ -698,7 +923,24 @@ export async function queryCopilotQuota(options = {}) {
         return toQuotaError(`Invalid copilot-quota-token.json: ${pat.error ?? "unknown error"}${pat.selectedPath ? ` (${pat.selectedPath})` : ""}`);
     }
     if (pat.state === "absent" || !pat.config) {
-        return null;
+        const { auth } = selectCopilotAuth(await readAuthFile());
+        const token = getCopilotOAuthToken(auth);
+        if (!auth || !token)
+            return null;
+        const enterpriseHost = validateEnterpriseHost(auth.enterpriseUrl);
+        if (enterpriseHost.error) {
+            return toQuotaError(`Invalid OpenCode Copilot enterpriseUrl: ${enterpriseHost.error}`);
+        }
+        try {
+            return await fetchCopilotInternalUser({
+                apiBaseUrl: getApiBaseUrl(enterpriseHost.host),
+                token,
+                requestTimeoutMs: options.requestTimeoutMs,
+            });
+        }
+        catch (error) {
+            return toQuotaError(error instanceof Error ? error.message : String(error));
+        }
     }
     const resolved = resolvePatBillingTarget(pat.config);
     if (!resolved.target) {
@@ -709,7 +951,9 @@ export async function queryCopilotQuota(options = {}) {
         return toQuotaError(compatibilityError);
     try {
         const billingModel = pat.config.billingModel ?? "ai_credits";
+        const apiBaseUrl = getApiBaseUrl(pat.config.enterpriseUrl);
         const { response, target } = await fetchBillingUsage({
+            apiBaseUrl,
             token: pat.config.token,
             target: resolved.target,
             billingModel,
@@ -718,6 +962,7 @@ export async function queryCopilotQuota(options = {}) {
         return billingModel === "legacy_premium_requests"
             ? toLegacyResult(response, pat.config)
             : await toAiCreditResult({
+                apiBaseUrl,
                 response,
                 target,
                 config: pat.config,
@@ -736,6 +981,9 @@ export async function hasCopilotQuotaRuntimeAvailable() {
 export function formatCopilotQuota(result) {
     if (!result || !result.success)
         return null;
+    if (result.mode === "user_plan") {
+        return result.plan ? `Copilot Plan ${result.plan}` : "Copilot Plan available";
+    }
     const unit = result.unit === "ai_credits" ? "AI Credits" : "Premium Requests";
     if (result.mode === "organization_usage") {
         return `Copilot Org (${result.organization}) ${result.used} ${unit} | ${formatBillingPeriod(result.period)}`;