@getpaseo/server 0.1.97 → 0.1.98

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

package/dist/server/services/quota-fetcher/providers/zai.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 ZaiQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+}
+export declare class ZaiQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "zai";
+    readonly displayName = "Z.ai";
+    private readonly logger;
+    private readonly fetchApi;
+    constructor(options: ZaiQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+}
+export {};
+//# sourceMappingURL=zai.d.ts.map

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

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { ApiOptionalStringSchema, fetchProviderApi, unavailableUsage } from "../usage.js";
+const ZaiUsageResponseSchema = z.object({
+    data: z
+        .array(z.object({
+        productName: ApiOptionalStringSchema,
+        status: ApiOptionalStringSchema,
+        purchaseTime: ApiOptionalStringSchema,
+        valid: ApiOptionalStringSchema,
+    }))
+        .optional(),
+});
+export class ZaiQuotaProvider {
+    constructor(options) {
+        this.providerId = "zai";
+        this.displayName = "Z.ai";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+    }
+    async fetchUsage() {
+        const token = process.env["ZAI_API_KEY"] || process.env["GLM_API_KEY"];
+        if (!token)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, "https://api.z.ai/api/biz/subscription/list", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "Z.ai usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = ZaiUsageResponseSchema.parse(await res.json());
+        const sub = resp.data?.[0];
+        if (!sub)
+            return unavailableUsage(this);
+        const details = [];
+        if (sub.status)
+            details.push({ id: "status", label: "Status", value: sub.status });
+        if (sub.valid)
+            details.push({ id: "valid", label: "Valid", value: sub.valid });
+        if (sub.purchaseTime) {
+            details.push({ id: "purchase_time", label: "Purchased", value: sub.purchaseTime });
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: sub.productName || null,
+            windows: [],
+            balances: [],
+            details,
+            error: null,
+        };
+    }
+}
+//# sourceMappingURL=zai.js.map

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

@@ -0,0 +1,28 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "./provider.js";
+export interface ProviderUsageServiceOptions {
+    logger: Logger;
+    fetchers?: ProviderUsageFetcher[];
+    fetch?: ProviderApiFetch;
+    cacheTtlMs?: number;
+    now?: () => number;
+}
+export interface ProviderUsageListResult {
+    fetchedAt: string;
+    providers: ProviderUsage[];
+}
+export declare class ProviderUsageService {
+    private readonly logger;
+    private readonly fetchers;
+    private readonly cacheTtlMs;
+    private readonly now;
+    private cached;
+    private inFlight;
+    constructor(options: ProviderUsageServiceOptions);
+    listUsage(options?: {
+        forceRefresh?: boolean;
+    }): Promise<ProviderUsageListResult>;
+    private fetchFreshUsage;
+}
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1,58 @@
+import { createProviderUsageFetchers } from "./manifest.js";
+import { unavailableUsage } from "./usage.js";
+const DEFAULT_PROVIDER_USAGE_CACHE_TTL_MS = 5 * 60 * 1000;
+export class ProviderUsageService {
+    constructor(options) {
+        this.cached = null;
+        this.inFlight = null;
+        this.logger = options.logger.child({ module: "provider-usage-service" });
+        this.fetchers =
+            options.fetchers ??
+                createProviderUsageFetchers({
+                    logger: this.logger,
+                    fetch: options.fetch,
+                });
+        this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_PROVIDER_USAGE_CACHE_TTL_MS;
+        this.now = options.now ?? Date.now;
+    }
+    async listUsage(options) {
+        const nowMs = this.now();
+        if (!options?.forceRefresh &&
+            this.cached &&
+            nowMs - this.cached.fetchedAtMs < this.cacheTtlMs) {
+            return this.cached.result;
+        }
+        if (this.inFlight) {
+            return this.inFlight;
+        }
+        const request = this.fetchFreshUsage(nowMs);
+        this.inFlight = request;
+        try {
+            return await request;
+        }
+        finally {
+            if (this.inFlight === request) {
+                this.inFlight = null;
+            }
+        }
+    }
+    async fetchFreshUsage(nowMs) {
+        const settled = await Promise.allSettled(this.fetchers.map((fetcher) => fetcher.fetchUsage()));
+        const providers = settled.map((result, index) => {
+            const fetcher = this.fetchers[index];
+            if (result.status === "fulfilled") {
+                return result.value;
+            }
+            this.logger.debug({ err: result.reason, providerId: fetcher.providerId }, "Provider usage fetch failed");
+            return unavailableUsage({
+                providerId: fetcher.providerId,
+                displayName: fetcher.displayName,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+        });
+        const result = { fetchedAt: new Date(nowMs).toISOString(), providers };
+        this.cached = { fetchedAtMs: nowMs, result };
+        return result;
+    }
+}
+//# sourceMappingURL=service.js.map

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

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import type { ProviderUsage, ProviderUsageBalance, ProviderUsageWindow } from "../../server/messages.js";
+import type { ProviderApiFetch } from "./provider.js";
+export declare const ApiNumberSchema: z.ZodCoercedNumber<unknown>;
+export declare const ApiNullableNumberSchema: z.ZodPreprocess<z.ZodNullable<z.ZodCoercedNumber<unknown>>>;
+export declare const ApiOptionalStringSchema: z.ZodPreprocess<z.ZodOptional<z.ZodCoercedString<unknown>>>;
+export declare function fetchProviderApi(fetchApi: ProviderApiFetch, input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export declare function unavailableUsage(provider: {
+    providerId: string;
+    displayName: string;
+    error?: string | null;
+}): ProviderUsage;
+export declare function windowFromUsedPct(input: {
+    id: string;
+    label: string;
+    utilizationPct: number | null | undefined;
+    resetsAt?: string | null;
+    tone?: ProviderUsageWindow["tone"];
+}): ProviderUsageWindow;
+export declare function balanceToneFromRemaining(remaining: number | null | undefined): ProviderUsageBalance["tone"];
+export declare function toIsoStringOrNull(timestampMs: number): string | null;
+//# sourceMappingURL=usage.d.ts.map

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+const PROVIDER_HTTP_TIMEOUT_MS = 15000;
+export const ApiNumberSchema = z.coerce.number().finite();
+export const ApiNullableNumberSchema = z.preprocess((value) => (value == null ? null : value), ApiNumberSchema.nullable());
+export const ApiOptionalStringSchema = z.preprocess((value) => (value == null ? undefined : value), z.coerce.string().optional());
+export function fetchProviderApi(fetchApi, input, init = {}) {
+    return fetchApi(input, {
+        ...init,
+        signal: init.signal ?? AbortSignal.timeout(PROVIDER_HTTP_TIMEOUT_MS),
+    });
+}
+export function unavailableUsage(provider) {
+    return {
+        providerId: provider.providerId,
+        displayName: provider.displayName,
+        status: provider.error ? "error" : "unavailable",
+        planLabel: null,
+        windows: [],
+        balances: [],
+        details: [],
+        error: provider.error ?? null,
+    };
+}
+export function windowFromUsedPct(input) {
+    const usedPct = typeof input.utilizationPct === "number" ? input.utilizationPct : null;
+    const window = {
+        id: input.id,
+        label: input.label,
+        usedPct,
+        remainingPct: usedPct === null ? null : Math.max(0, 100 - usedPct),
+        resetsAt: input.resetsAt ?? null,
+    };
+    if (input.tone) {
+        window.tone = input.tone;
+    }
+    return window;
+}
+export function balanceToneFromRemaining(remaining) {
+    if (typeof remaining !== "number")
+        return "default";
+    if (remaining <= 0)
+        return "danger";
+    return "ok";
+}
+export function toIsoStringOrNull(timestampMs) {
+    const date = new Date(timestampMs);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}
+//# sourceMappingURL=usage.js.map