@getpaseo/server 0.1.97-beta.3 → 0.1.98

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

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

@@ -0,0 +1,123 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { ApiNullableNumberSchema, balanceToneFromRemaining, fetchProviderApi, toIsoStringOrNull, unavailableUsage, } from "../usage.js";
+const execFileAsync = promisify(execFile);
+const CURSOR_SQLITE_TIMEOUT_MS = 2000;
+const CursorBillingCycleTimestampSchema = z.preprocess((value) => (typeof value === "string" || typeof value === "number" ? value : null), z.union([z.string(), z.number()]).nullable());
+const CursorUsageResponseSchema = z.object({
+    planUsage: z
+        .object({
+        totalSpend: ApiNullableNumberSchema,
+        includedSpend: ApiNullableNumberSchema,
+        bonusSpend: ApiNullableNumberSchema,
+        remaining: ApiNullableNumberSchema,
+        limit: ApiNullableNumberSchema,
+    })
+        .nullish(),
+    billingCycleStart: CursorBillingCycleTimestampSchema,
+    billingCycleEnd: CursorBillingCycleTimestampSchema,
+});
+const CursorAuthStatusSchema = z.object({
+    accessToken: z.string().optional(),
+});
+function parseCursorBillingCycleTimestamp(value) {
+    if (value === null)
+        return null;
+    const raw = String(value).trim();
+    if (!raw)
+        return null;
+    const numeric = Number(raw);
+    if (Number.isFinite(numeric)) {
+        const timestampMs = Math.abs(numeric) < 10000000000 ? numeric * 1000 : numeric;
+        return toIsoStringOrNull(timestampMs);
+    }
+    return toIsoStringOrNull(new Date(raw).getTime());
+}
+function centsToDollars(value) {
+    return value === null ? null : value / 100;
+}
+async function readCursorTokenFromSqlite() {
+    const dbPaths = [];
+    if (process.env["APPDATA"]) {
+        dbPaths.push(join(process.env["APPDATA"], "Cursor", "User", "globalStorage", "state.vscdb"));
+    }
+    dbPaths.push(join(homedir(), "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb"));
+    dbPaths.push(join(homedir(), ".config", "Cursor", "User", "globalStorage", "state.vscdb"));
+    for (const path of dbPaths) {
+        if (!existsSync(path))
+            continue;
+        try {
+            const { stdout } = await execFileAsync("sqlite3", [path, "SELECT value FROM ItemTable WHERE key = 'cursorAuthStatus'"], { timeout: CURSOR_SQLITE_TIMEOUT_MS });
+            if (stdout) {
+                const parsed = CursorAuthStatusSchema.parse(JSON.parse(stdout.trim()));
+                if (parsed.accessToken)
+                    return parsed.accessToken;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+export class CursorQuotaProvider {
+    constructor(options) {
+        this.providerId = "cursor";
+        this.displayName = "Cursor";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["CURSOR_ACCESS_TOKEN"] ||
+            process.env["CURSOR_TOKEN"] ||
+            (await readCursorTokenFromSqlite());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json",
+                "Connect-Protocol-Version": "1",
+            },
+            body: JSON.stringify({}),
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Cursor usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = CursorUsageResponseSchema.parse(await res.json());
+        const billingCycleEnd = parseCursorBillingCycleTimestamp(resp.billingCycleEnd);
+        const balances = [];
+        if (resp.planUsage) {
+            const totalSpend = centsToDollars(resp.planUsage.totalSpend);
+            const remaining = centsToDollars(resp.planUsage.remaining);
+            const limit = centsToDollars(resp.planUsage.limit);
+            balances.push({
+                id: "plan_usage",
+                label: "Plan usage",
+                used: totalSpend,
+                remaining,
+                limit,
+                unit: "usd",
+                resetsAt: billingCycleEnd,
+                tone: balanceToneFromRemaining(remaining),
+            });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows: [],
+            balances,
+            details: [],
+            error: null,
+        };
+    }
+}
+//# sourceMappingURL=cursor.js.map

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

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

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

@@ -0,0 +1,89 @@
+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, } from "../usage.js";
+const GrokUsageResponseSchema = z.object({
+    config: z
+        .object({
+        monthlyLimit: z
+            .object({
+            val: ApiNumberSchema.optional(),
+        })
+            .nullish(),
+    })
+        .nullish(),
+    usage: z
+        .object({
+        creditUsage: ApiNumberSchema.optional(),
+    })
+        .nullish(),
+});
+const GrokAuthSchema = z.object({
+    access_token: z.string().optional(),
+});
+export class GrokQuotaProvider {
+    constructor(options) {
+        this.providerId = "grok";
+        this.displayName = "Grok";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["GROK_API_KEY"] || process.env["GROK_TOKEN"] || (await this.readGrokToken());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://cli-chat-proxy.grok.com/v1/billing", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                "X-XAI-Token-Auth": "xai-grok-cli",
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Grok usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = GrokUsageResponseSchema.parse(await res.json());
+        const monthlyLimit = resp.config?.monthlyLimit?.val ?? null;
+        const creditUsage = resp.usage?.creditUsage ?? null;
+        const balances = [];
+        if (monthlyLimit !== null || creditUsage !== null) {
+            const remaining = monthlyLimit !== null && creditUsage !== null
+                ? Math.max(0, monthlyLimit - creditUsage)
+                : null;
+            balances.push({
+                id: "monthly_credits",
+                label: "Monthly credits",
+                used: creditUsage,
+                remaining,
+                limit: monthlyLimit,
+                unit: "credits",
+                tone: balanceToneFromRemaining(remaining),
+            });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows: [],
+            balances,
+            details: [],
+            error: null,
+        };
+    }
+    async readGrokToken() {
+        const path = join(homedir(), ".grok", "auth.json");
+        if (!existsSync(path))
+            return null;
+        try {
+            const auth = GrokAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
+            return auth.access_token ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=grok.js.map

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

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

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

@@ -0,0 +1,89 @@
+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 KimiUsageResponseSchema = z.object({
+    usage: z
+        .object({
+        limit: ApiOptionalStringSchema,
+        remaining: ApiOptionalStringSchema,
+        resetTime: ApiOptionalStringSchema,
+    })
+        .nullish(),
+});
+const KimiAuthSchema = z.object({
+    access_token: z.string().optional(),
+});
+export class KimiQuotaProvider {
+    constructor(options) {
+        this.providerId = "kimi";
+        this.displayName = "Kimi";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+        this.homeDir = options.homeDir;
+    }
+    async fetchUsage() {
+        const token = process.env["KIMI_TOKEN"] || process.env["KIMI_API_KEY"] || (await this.readKimiToken());
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api.kimi.com/coding/v1/usages", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Kimi usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = KimiUsageResponseSchema.parse(await res.json());
+        const limit = resp.usage?.limit === undefined ? null : Number(resp.usage.limit);
+        const remaining = resp.usage?.remaining === undefined ? null : Number(resp.usage.remaining);
+        const hasFiniteLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0;
+        const hasFiniteRemaining = typeof remaining === "number" && Number.isFinite(remaining);
+        const usedPct = hasFiniteLimit && hasFiniteRemaining
+            ? Math.max(0, Math.min(100, ((limit - remaining) / limit) * 100))
+            : null;
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows: [
+                {
+                    id: "coding_usage",
+                    label: "Coding usage",
+                    usedPct,
+                    remainingPct: usedPct === null ? null : Math.max(0, 100 - usedPct),
+                    resetsAt: resp.usage?.resetTime ?? null,
+                    tone: "ok",
+                },
+            ],
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async readKimiToken() {
+        const homeDir = this.homeDir ?? homedir();
+        const paths = [
+            join(process.env["KIMI_CODE_HOME"] || join(homeDir, ".kimi-code"), "credentials", "kimi-code.json"),
+            join(homeDir, ".kimi", "credentials", "kimi-code.json"),
+        ];
+        for (const path of paths) {
+            if (!existsSync(path))
+                continue;
+            try {
+                const credentials = KimiAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
+                if (credentials.access_token)
+                    return credentials.access_token;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=kimi.js.map