@otto-code/server 0.5.0

package/dist/server/services/quota-fetcher/manifest.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderUsageFetcher, ProviderUsageFetcherFactoryOptions, ProviderUsageFetcherManifestEntry } from "./provider.js";
+export declare const PROVIDER_USAGE_FETCHERS: readonly ProviderUsageFetcherManifestEntry[];
+export declare function createProviderUsageFetchers(options: ProviderUsageFetcherFactoryOptions): ProviderUsageFetcher[];
+//# sourceMappingURL=manifest.d.ts.map

package/dist/server/services/quota-fetcher/manifest.js

@@ -0,0 +1,52 @@
+import { ClaudeQuotaProvider } from "./providers/claude.js";
+import { CodexQuotaProvider } from "./providers/codex.js";
+import { CopilotQuotaProvider } from "./providers/copilot.js";
+import { CursorQuotaProvider } from "./providers/cursor.js";
+import { GrokQuotaProvider } from "./providers/grok.js";
+import { KimiQuotaProvider } from "./providers/kimi.js";
+import { MiniMaxQuotaProvider } from "./providers/minimax.js";
+import { ZaiQuotaProvider } from "./providers/zai.js";
+export const PROVIDER_USAGE_FETCHERS = [
+    {
+        providerId: "claude",
+        create: (options) => new ClaudeQuotaProvider({
+            logger: options.logger,
+            fetch: options.fetch,
+        }),
+    },
+    {
+        providerId: "codex",
+        create: (options) => new CodexQuotaProvider({
+            logger: options.logger,
+            fetch: options.fetch,
+        }),
+    },
+    {
+        providerId: "copilot",
+        create: (options) => new CopilotQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
+    {
+        providerId: "cursor",
+        create: (options) => new CursorQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
+    {
+        providerId: "zai",
+        create: (options) => new ZaiQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
+    {
+        providerId: "grok",
+        create: (options) => new GrokQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
+    {
+        providerId: "kimi",
+        create: (options) => new KimiQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
+    {
+        providerId: "minimax",
+        create: (options) => new MiniMaxQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
+];
+export function createProviderUsageFetchers(options) {
+    return PROVIDER_USAGE_FETCHERS.map((entry) => entry.create(options));
+}
+//# sourceMappingURL=manifest.js.map

package/dist/server/services/quota-fetcher/provider.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../server/messages.js";
+export type ProviderApiFetch = typeof fetch;
+export interface ProviderUsageFetcher {
+    readonly providerId: string;
+    readonly displayName: string;
+    fetchUsage(): Promise<ProviderUsage>;
+}
+export interface ProviderUsageFetcherFactoryOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+}
+export interface ProviderUsageFetcherManifestEntry {
+    readonly providerId: string;
+    create(options: ProviderUsageFetcherFactoryOptions): ProviderUsageFetcher;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/server/services/quota-fetcher/provider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider.js.map

package/dist/server/services/quota-fetcher/providers/claude.d.ts

@@ -0,0 +1,26 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface ClaudeQuotaProviderOptions {
+    logger: Logger;
+    claudeHome?: string;
+    claudeKeychainReader?: () => Promise<unknown | null>;
+    platform?: typeof process.platform;
+    fetch?: ProviderApiFetch;
+}
+export declare class ClaudeQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "claude";
+    readonly displayName = "Claude";
+    private readonly claudeHome;
+    private readonly readKeychainCredentials;
+    private readonly platform;
+    private readonly fetchApi;
+    constructor(options: ClaudeQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private readCredentials;
+    private callClaudeApi;
+    private refreshClaudeToken;
+    private saveClaudeCredentials;
+}
+export {};
+//# sourceMappingURL=claude.d.ts.map

package/dist/server/services/quota-fetcher/providers/claude.js

@@ -0,0 +1,217 @@
+import { execFile } from "node:child_process";
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { ApiNumberSchema, fetchProviderApi, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const execFileAsync = promisify(execFile);
+const CLAUDE_KEYCHAIN_TIMEOUT_MS = 2000;
+const CLAUDE_OAUTH_BETA = "oauth-2025-04-20";
+const CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+const ClaudeCredentialsSchema = z.object({
+    claudeAiOauth: z
+        .object({
+        accessToken: z.string().optional(),
+        refreshToken: z.string().optional(),
+        subscriptionType: z.string().optional(),
+        rateLimitTier: z.string().optional(),
+    })
+        .optional(),
+});
+const ClaudeUsageWindowSchema = z.object({
+    utilization: ApiNumberSchema,
+    resets_at: z.string().nullish(),
+});
+const ClaudeUsageResponseSchema = z.object({
+    five_hour: ClaudeUsageWindowSchema.nullish(),
+    seven_day: ClaudeUsageWindowSchema.nullish(),
+    seven_day_opus: ClaudeUsageWindowSchema.nullish(),
+    seven_day_omelette: ClaudeUsageWindowSchema.nullish(),
+    extra_usage: z
+        .object({
+        is_enabled: z.boolean().optional(),
+    })
+        .nullish(),
+});
+const ClaudeTokenRefreshSchema = z.object({
+    access_token: z.string().optional(),
+    refresh_token: z.string().optional(),
+});
+function buildClaudePlan(subscriptionType, rateLimitTier) {
+    if (!subscriptionType)
+        return null;
+    const label = subscriptionType.charAt(0).toUpperCase() + subscriptionType.slice(1);
+    const tier = rateLimitTier?.split("_").pop();
+    return tier ? `${label} ${tier}` : label;
+}
+async function readClaudeKeychainCredentials() {
+    try {
+        const { stdout } = await execFileAsync("security", ["find-generic-password", "-s", CLAUDE_KEYCHAIN_SERVICE, "-w"], { timeout: CLAUDE_KEYCHAIN_TIMEOUT_MS });
+        const raw = stdout.trim();
+        if (!raw)
+            return null;
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export class ClaudeQuotaProvider {
+    constructor(options) {
+        this.providerId = "claude";
+        this.displayName = "Claude";
+        this.claudeHome =
+            options.claudeHome || process.env["CLAUDE_HOME"] || join(homedir(), ".claude");
+        this.readKeychainCredentials = options.claudeKeychainReader ?? readClaudeKeychainCredentials;
+        this.platform = options.platform ?? process.platform;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const credentials = await this.readCredentials();
+        if (!credentials) {
+            return unavailableUsage(this);
+        }
+        const { oauth, filePath } = credentials;
+        const plan = buildClaudePlan(oauth.subscriptionType, oauth.rateLimitTier);
+        let resp = await this.callClaudeApi(oauth.accessToken);
+        if (resp === "NEEDS_AUTH") {
+            if (!filePath || !oauth.refreshToken) {
+                return unavailableUsage(this);
+            }
+            const refreshed = await this.refreshClaudeToken(oauth.refreshToken);
+            if (!refreshed?.access_token) {
+                return unavailableUsage(this);
+            }
+            await this.saveClaudeCredentials(filePath, {
+                ...oauth,
+                accessToken: refreshed.access_token,
+                refreshToken: refreshed.refresh_token ?? oauth.refreshToken,
+            });
+            resp = await this.callClaudeApi(refreshed.access_token);
+            if (resp === "NEEDS_AUTH") {
+                return unavailableUsage(this);
+            }
+        }
+        const windows = [];
+        if (resp.five_hour) {
+            windows.push(windowFromUsedPct({
+                id: "five_hour",
+                label: "Session",
+                utilizationPct: resp.five_hour.utilization,
+                resetsAt: resp.five_hour.resets_at ?? null,
+                tone: "ok",
+            }));
+        }
+        if (resp.seven_day) {
+            windows.push(windowFromUsedPct({
+                id: "weekly",
+                label: "Weekly",
+                utilizationPct: resp.seven_day.utilization,
+                resetsAt: resp.seven_day.resets_at ?? null,
+                tone: "ok",
+            }));
+        }
+        if (resp.seven_day_opus) {
+            windows.push(windowFromUsedPct({
+                id: "weekly_opus",
+                label: "Weekly · Opus",
+                utilizationPct: resp.seven_day_opus.utilization,
+                resetsAt: resp.seven_day_opus.resets_at ?? null,
+                tone: "ok",
+            }));
+        }
+        if (resp.seven_day_omelette) {
+            windows.push(windowFromUsedPct({
+                id: "weekly_omelette",
+                label: "Weekly · Omelette",
+                utilizationPct: resp.seven_day_omelette.utilization,
+                resetsAt: resp.seven_day_omelette.resets_at ?? null,
+                tone: "ok",
+            }));
+        }
+        const details = [];
+        const extraUsageEnabled = resp.extra_usage?.is_enabled;
+        if (extraUsageEnabled !== undefined) {
+            details.push({
+                id: "extra_usage",
+                label: "Extra usage",
+                value: extraUsageEnabled ? "Enabled" : "Disabled",
+            });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: plan,
+            windows,
+            balances: [],
+            details,
+            error: null,
+        };
+    }
+    async readCredentials() {
+        const credPath = join(this.claudeHome, ".credentials.json");
+        if (existsSync(credPath)) {
+            try {
+                const creds = ClaudeCredentialsSchema.parse(JSON.parse(await fs.readFile(credPath, "utf8")));
+                const oauth = creds.claudeAiOauth;
+                if (oauth?.accessToken) {
+                    return { oauth: { ...oauth, accessToken: oauth.accessToken }, filePath: credPath };
+                }
+            }
+            catch {
+                // Fall through to the macOS Keychain below.
+            }
+        }
+        if (this.platform === "darwin") {
+            const creds = ClaudeCredentialsSchema.safeParse(await this.readKeychainCredentials());
+            const oauth = creds.success ? creds.data.claudeAiOauth : undefined;
+            if (oauth?.accessToken) {
+                return { oauth: { ...oauth, accessToken: oauth.accessToken }, filePath: null };
+            }
+        }
+        return null;
+    }
+    async callClaudeApi(token) {
+        const res = await fetchProviderApi(this.fetchApi, "https://api.anthropic.com/api/oauth/usage", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+                "anthropic-beta": CLAUDE_OAUTH_BETA,
+            },
+        });
+        if (res.status === 401 || res.status === 403)
+            return "NEEDS_AUTH";
+        if (!res.ok)
+            throw new Error(`Claude usage API returned ${res.status}`);
+        return ClaudeUsageResponseSchema.parse(await res.json());
+    }
+    async refreshClaudeToken(refreshToken) {
+        const res = await fetchProviderApi(this.fetchApi, "https://platform.claude.com/v1/oauth/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                grant_type: "refresh_token",
+                refresh_token: refreshToken,
+                client_id: CLAUDE_CLIENT_ID,
+                scope: "user:profile user:inference user:sessions:claude_code user:mcp_servers",
+            }),
+        });
+        if (!res.ok)
+            return null;
+        return ClaudeTokenRefreshSchema.parse(await res.json());
+    }
+    async saveClaudeCredentials(credPath, oauth) {
+        try {
+            const existing = ClaudeCredentialsSchema.parse(JSON.parse(await fs.readFile(credPath, "utf8")));
+            existing.claudeAiOauth = oauth;
+            await fs.writeFile(credPath, JSON.stringify(existing, null, 2), { mode: 0o600 });
+        }
+        catch {
+            // Non-fatal; Claude Code can refresh again on its own next time.
+        }
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/server/services/quota-fetcher/providers/codex.d.ts

@@ -0,0 +1,23 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface CodexQuotaProviderOptions {
+    logger: Logger;
+    codexHome?: string;
+    fetch?: ProviderApiFetch;
+}
+export declare class CodexQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "codex";
+    readonly displayName = "Codex";
+    private readonly codexHome;
+    private readonly fetchApi;
+    constructor(options: CodexQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private toUsage;
+    private readCodexAuth;
+    private callCodexApi;
+    private refreshCodexToken;
+    private saveCodexAuth;
+}
+export {};
+//# sourceMappingURL=codex.d.ts.map

package/dist/server/services/quota-fetcher/providers/codex.js

@@ -0,0 +1,211 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, balanceToneFromRemaining, fetchProviderApi, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const CodexAuthSchema = z.object({
+    tokens: z
+        .object({
+        access_token: z.string().optional(),
+        refresh_token: z.string().optional(),
+        account_id: z.string().optional(),
+    })
+        .optional(),
+});
+const CodexWindowSchema = z.object({
+    used_percent: ApiNumberSchema.optional(),
+    reset_at: ApiNumberSchema.optional(),
+});
+const CodexUsageResponseSchema = z.object({
+    plan_type: z.string().optional(),
+    email: z.string().optional(),
+    rate_limit: z
+        .object({
+        primary_window: CodexWindowSchema.nullish(),
+        secondary_window: CodexWindowSchema.nullish(),
+    })
+        .nullish(),
+    code_review_rate_limit: z
+        .object({
+        primary_window: CodexWindowSchema.nullish(),
+    })
+        .nullish(),
+    credits: z
+        .object({
+        has_credits: z.boolean().optional(),
+        unlimited: z.boolean().optional(),
+        balance: ApiNumberSchema.optional(),
+    })
+        .nullish(),
+});
+const CodexTokenRefreshSchema = z.object({
+    access_token: z.string().optional(),
+    refresh_token: z.string().optional(),
+});
+function codexWindow(window) {
+    if (!window)
+        return null;
+    return {
+        usedPct: window.used_percent ?? 0,
+        resetsAt: window.reset_at != null ? new Date(window.reset_at * 1000).toISOString() : null,
+    };
+}
+export class CodexQuotaProvider {
+    constructor(options) {
+        this.providerId = "codex";
+        this.displayName = "Codex";
+        this.codexHome = options.codexHome || process.env["CODEX_HOME"] || join(homedir(), ".codex");
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const authRecord = await this.readCodexAuth();
+        const auth = authRecord?.auth;
+        const accessToken = auth?.tokens?.access_token;
+        if (!authRecord || !auth || !accessToken) {
+            return unavailableUsage(this);
+        }
+        const { refresh_token, account_id } = auth.tokens ?? {};
+        let resp = await this.callCodexApi(accessToken, account_id);
+        if (resp === "NEEDS_AUTH") {
+            if (!refresh_token) {
+                return unavailableUsage(this);
+            }
+            const refreshed = await this.refreshCodexToken(refresh_token);
+            if (!refreshed?.access_token) {
+                return unavailableUsage(this);
+            }
+            await this.saveCodexAuth(authRecord.path, auth, refreshed);
+            resp = await this.callCodexApi(refreshed.access_token, account_id);
+            if (resp === "NEEDS_AUTH") {
+                return unavailableUsage(this);
+            }
+        }
+        return this.toUsage(resp);
+    }
+    toUsage(resp) {
+        const session = codexWindow(resp.rate_limit?.primary_window);
+        const weekly = codexWindow(resp.rate_limit?.secondary_window);
+        const codeReview = codexWindow(resp.code_review_rate_limit?.primary_window);
+        const windows = [];
+        if (session) {
+            windows.push(windowFromUsedPct({
+                id: "session",
+                label: "Session",
+                utilizationPct: session.usedPct,
+                resetsAt: session.resetsAt,
+                tone: "ok",
+            }));
+        }
+        if (weekly) {
+            windows.push(windowFromUsedPct({
+                id: "weekly",
+                label: "Weekly",
+                utilizationPct: weekly.usedPct,
+                resetsAt: weekly.resetsAt,
+                tone: weekly.usedPct >= 70 ? "warning" : "ok",
+            }));
+        }
+        if (codeReview) {
+            windows.push(windowFromUsedPct({
+                id: "code_review",
+                label: "Code review",
+                utilizationPct: codeReview.usedPct,
+                resetsAt: codeReview.resetsAt,
+                tone: codeReview.usedPct >= 70 ? "warning" : "ok",
+            }));
+        }
+        const balances = [];
+        if (resp.credits?.balance !== undefined) {
+            balances.push({
+                id: "credits",
+                label: "Credits",
+                remaining: resp.credits.balance,
+                unit: "usd",
+                tone: balanceToneFromRemaining(resp.credits.balance),
+            });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: resp.plan_type ?? null,
+            windows,
+            balances,
+            details: [],
+            error: null,
+        };
+    }
+    async readCodexAuth() {
+        const candidates = [
+            ...(process.env["CODEX_HOME"] ? [join(process.env["CODEX_HOME"], "auth.json")] : []),
+            join(homedir(), ".config", "codex", "auth.json"),
+            join(this.codexHome, "auth.json"),
+        ];
+        for (const path of candidates) {
+            if (!existsSync(path))
+                continue;
+            try {
+                const auth = CodexAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
+                if (auth.tokens?.access_token)
+                    return { auth, path };
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    async callCodexApi(token, accountId) {
+        const headers = {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
+        };
+        if (accountId)
+            headers["ChatGPT-Account-Id"] = accountId;
+        const res = await fetchProviderApi(this.fetchApi, "https://chatgpt.com/backend-api/wham/usage", {
+            headers,
+        });
+        if (res.status === 401 || res.status === 403)
+            return "NEEDS_AUTH";
+        if (!res.ok)
+            throw new Error(`Codex usage API returned ${res.status}`);
+        const text = await res.text();
+        if (text.trim().startsWith("<"))
+            return "NEEDS_AUTH";
+        return CodexUsageResponseSchema.parse(JSON.parse(text));
+    }
+    async refreshCodexToken(refreshToken) {
+        const params = new URLSearchParams({
+            grant_type: "refresh_token",
+            client_id: CODEX_CLIENT_ID,
+            refresh_token: refreshToken,
+        });
+        const res = await fetchProviderApi(this.fetchApi, "https://auth.openai.com/oauth/token", {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: params.toString(),
+        });
+        if (!res.ok)
+            return null;
+        return CodexTokenRefreshSchema.parse(await res.json());
+    }
+    async saveCodexAuth(authPath, original, refreshed) {
+        try {
+            const updated = {
+                ...original,
+                tokens: {
+                    ...original.tokens,
+                    access_token: refreshed.access_token ?? original.tokens?.access_token,
+                    refresh_token: refreshed.refresh_token ?? original.tokens?.refresh_token,
+                },
+            };
+            await fs.writeFile(authPath, JSON.stringify(updated, null, 2), { mode: 0o600 });
+        }
+        catch {
+            // Non-fatal; the next call can refresh again.
+        }
+    }
+}
+//# sourceMappingURL=codex.js.map

package/dist/server/services/quota-fetcher/providers/copilot.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface CopilotQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+}
+export declare class CopilotQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "copilot";
+    readonly displayName = "GitHub Copilot";
+    private readonly logger;
+    private readonly fetchApi;
+    constructor(options: CopilotQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+}
+export {};
+//# sourceMappingURL=copilot.d.ts.map

package/dist/server/services/quota-fetcher/providers/copilot.js

@@ -0,0 +1,75 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiOptionalStringSchema, fetchProviderApi, unavailableUsage } from "../usage.js";
+const CopilotUsageResponseSchema = z.object({
+    copilot_plan: ApiOptionalStringSchema,
+    quota_reset_date: ApiOptionalStringSchema,
+});
+async function readGithubCliToken() {
+    const candidates = [];
+    if (process.env["APPDATA"]) {
+        candidates.push(join(process.env["APPDATA"], "GitHub CLI", "hosts.yml"));
+    }
+    candidates.push(join(homedir(), ".config", "gh", "hosts.yml"));
+    for (const path of candidates) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const raw = await fs.readFile(path, "utf8");
+            const match = raw.match(/oauth_token:\s*["']?([a-zA-Z0-9_-]+)["']?/);
+            if (match?.[1])
+                return match[1];
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export class CopilotQuotaProvider {
+    constructor(options) {
+        this.providerId = "copilot";
+        this.displayName = "GitHub Copilot";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["COPILOT_TOKEN"] ||
+            process.env["GITHUB_TOKEN"] ||
+            process.env["GITHUB_PAT"] ||
+            (await readGithubCliToken());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api.github.com/copilot_internal/user", {
+            headers: {
+                Authorization: `token ${token}`,
+                Accept: "application/json",
+                "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",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Copilot usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = CopilotUsageResponseSchema.parse(await res.json());
+        const details = resp.quota_reset_date
+            ? [{ id: "reset", label: "Quota reset", value: resp.quota_reset_date }]
+            : [];
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: resp.copilot_plan || null,
+            windows: [],
+            balances: [],
+            details,
+            error: null,
+        };
+    }
+}
+//# sourceMappingURL=copilot.js.map

package/dist/server/services/quota-fetcher/providers/cursor.d.ts

@@ -0,0 +1,17 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface CursorQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+}
+export declare class CursorQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "cursor";
+    readonly displayName = "Cursor";
+    private readonly logger;
+    private readonly fetchApi;
+    constructor(options: CursorQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+}
+export {};
+//# sourceMappingURL=cursor.d.ts.map