@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,260 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, ApiOptionalStringSchema, fetchProviderApi, toneFromUsedPct, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const KIMI_USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+const KimiUsageFieldsSchema = z.object({
+    limit: ApiOptionalStringSchema,
+    used: ApiOptionalStringSchema,
+    remaining: ApiOptionalStringSchema,
+    resetTime: ApiOptionalStringSchema,
+    resetAt: ApiOptionalStringSchema,
+    reset_time: ApiOptionalStringSchema,
+    reset_at: ApiOptionalStringSchema,
+    name: ApiOptionalStringSchema,
+    title: ApiOptionalStringSchema,
+    scope: ApiOptionalStringSchema,
+    duration: z.unknown().optional(),
+    timeUnit: ApiOptionalStringSchema,
+});
+const KimiUsageLimitSchema = z
+    .object({
+    window: z.unknown().optional(),
+    detail: z.unknown().optional(),
+})
+    .passthrough();
+const KimiUsageResponseSchema = z.object({
+    usage: z.unknown().nullish(),
+    limits: z.unknown().nullish(),
+});
+function parseUsageFields(value) {
+    const parsed = KimiUsageFieldsSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function usedPctFromFields(fields) {
+    const limit = fields.limit === undefined ? null : Number(fields.limit);
+    const used = fields.used === undefined ? null : Number(fields.used);
+    const remaining = fields.remaining === undefined ? null : Number(fields.remaining);
+    if (limit === null || !Number.isFinite(limit) || limit <= 0)
+        return null;
+    let usedValue = null;
+    if (used !== null && Number.isFinite(used)) {
+        usedValue = used;
+    }
+    else if (remaining !== null && Number.isFinite(remaining)) {
+        usedValue = limit - remaining;
+    }
+    return usedValue === null ? null : Math.max(0, Math.min(100, (usedValue / limit) * 100));
+}
+function resetTimeFromFields(fields) {
+    return fields.resetTime ?? fields.resetAt ?? fields.reset_time ?? fields.reset_at ?? null;
+}
+function explicitUsageLabel(...fields) {
+    for (const field of fields) {
+        if (!field)
+            continue;
+        const label = field.name ?? field.title ?? field.scope;
+        if (label?.trim())
+            return label.trim();
+    }
+    return null;
+}
+function durationFrom(value) {
+    const duration = Number(value);
+    return Number.isFinite(duration) && duration > 0 ? duration : null;
+}
+function durationLabel(duration, timeUnit) {
+    if (!timeUnit)
+        return null;
+    const normalizedUnit = timeUnit.replace(/^TIME_UNIT_/i, "").toUpperCase();
+    if (normalizedUnit.includes("MINUTE")) {
+        if (duration % 60 === 0)
+            return `${duration / 60}-hour limit`;
+        return `${duration}-minute limit`;
+    }
+    if (normalizedUnit.includes("HOUR"))
+        return `${duration}-hour limit`;
+    if (normalizedUnit.includes("DAY"))
+        return `${duration}-day limit`;
+    if (normalizedUnit.includes("WEEK"))
+        return `${duration}-week limit`;
+    if (normalizedUnit.includes("SECOND"))
+        return `${duration}-second limit`;
+    return null;
+}
+function idPart(value) {
+    return String(value)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+function hasUsageData(fields) {
+    return (fields !== null &&
+        (fields.limit !== undefined || fields.used !== undefined || fields.remaining !== undefined));
+}
+function limitFields(limit) {
+    const metadata = parseUsageFields(limit);
+    const detail = parseUsageFields(limit.detail);
+    return {
+        fields: hasUsageData(detail) ? detail : metadata,
+        metadata,
+    };
+}
+function windowMetadata(limit) {
+    return parseUsageFields(limit.window);
+}
+function limitIdentity(input) {
+    const label = explicitUsageLabel(input.metadata, input.fields);
+    const duration = durationFrom(input.window?.duration ?? input.metadata?.duration ?? input.fields.duration);
+    const timeUnit = input.window?.timeUnit ?? input.metadata?.timeUnit ?? input.fields.timeUnit;
+    const generatedLabel = duration === null ? null : durationLabel(duration, timeUnit);
+    if (duration !== null && timeUnit) {
+        return {
+            id: `coding_limit_${idPart(duration)}_${idPart(timeUnit)}`,
+            label: label ?? generatedLabel ?? `Limit ${input.index + 1}`,
+        };
+    }
+    if (label) {
+        return { id: `coding_limit_${idPart(label)}`, label };
+    }
+    return {
+        id: `coding_limit_${input.index + 1}`,
+        label: generatedLabel ?? `Limit ${input.index + 1}`,
+    };
+}
+function windowFromFields(input) {
+    const usedPct = usedPctFromFields(input.fields);
+    return windowFromUsedPct({
+        id: input.id,
+        label: input.label,
+        utilizationPct: usedPct,
+        resetsAt: resetTimeFromFields(input.fields),
+        tone: toneFromUsedPct(usedPct),
+    });
+}
+function uniqueWindowId(baseId, seenIds) {
+    let id = baseId;
+    let suffix = 2;
+    while (seenIds.has(id)) {
+        id = `${baseId}_${suffix}`;
+        suffix += 1;
+    }
+    seenIds.add(id);
+    return id;
+}
+function kimiUsageWindowsFromPayload(payload, logger) {
+    const response = KimiUsageResponseSchema.parse(payload);
+    const windows = [];
+    const seenWindowIds = new Set();
+    const usage = parseUsageFields(response.usage);
+    if (hasUsageData(usage)) {
+        windows.push(windowFromFields({
+            id: uniqueWindowId("coding_usage", seenWindowIds),
+            label: explicitUsageLabel(usage) ?? "Weekly limit",
+            fields: usage,
+        }));
+    }
+    const limits = Array.isArray(response.limits) ? response.limits : [];
+    for (const [index, rawLimit] of limits.entries()) {
+        const parsedLimit = KimiUsageLimitSchema.safeParse(rawLimit);
+        if (!parsedLimit.success) {
+            logger.debug({ index }, "Ignoring malformed Kimi usage limit window");
+            continue;
+        }
+        const limit = parsedLimit.data;
+        const { fields, metadata } = limitFields(limit);
+        if (!hasUsageData(fields)) {
+            logger.debug({ index }, "Ignoring malformed Kimi usage limit window");
+            continue;
+        }
+        const window = windowMetadata(limit);
+        const identity = limitIdentity({ metadata, fields, window, index });
+        windows.push(windowFromFields({
+            id: uniqueWindowId(identity.id, seenWindowIds),
+            label: identity.label,
+            fields,
+        }));
+    }
+    return windows;
+}
+const KimiAuthSchema = z
+    .object({
+    access_token: z.string().nullish(),
+    refresh_token: z.string().nullish(),
+    expires_at: ApiNumberSchema.nullish(),
+    expires_in: ApiNumberSchema.nullish(),
+    scope: z.string().nullish(),
+    token_type: z.string().nullish(),
+})
+    .passthrough();
+export class KimiQuotaProvider {
+    constructor(options) {
+        this.providerId = "kimi";
+        this.displayName = "Kimi";
+        this.logger = options.logger.child({ module: "kimi-quota-provider" });
+        this.fetchApi = options.fetch ?? fetch;
+        this.homeDir = options.homeDir;
+    }
+    async fetchUsage() {
+        const credentials = await this.readCredentials();
+        if (!credentials)
+            return unavailableUsage(this);
+        const res = await this.callUsageApi(credentials.access_token);
+        if (!res.ok) {
+            // Read-only on credentials; the Kimi CLI owns refresh. See docs/providers.md.
+            this.logger.debug({ status: res.status }, "Kimi usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const windows = kimiUsageWindowsFromPayload(await res.json(), this.logger);
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: "available",
+            planLabel: null,
+            windows,
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async callUsageApi(token) {
+        return fetchProviderApi(this.fetchApi, KIMI_USAGE_URL, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                Accept: "application/json",
+            },
+        });
+    }
+    async readCredentials() {
+        const environmentToken = process.env["KIMI_TOKEN"] || process.env["KIMI_API_KEY"];
+        if (environmentToken) {
+            return { access_token: environmentToken };
+        }
+        for (const path of this.credentialPaths()) {
+            const credentials = await this.readCredentialFile(path);
+            if (credentials?.access_token) {
+                return { ...credentials, access_token: credentials.access_token };
+            }
+        }
+        return null;
+    }
+    credentialPaths() {
+        const homeDir = this.homeDir ?? homedir();
+        return [
+            join(process.env["KIMI_CODE_HOME"] || join(homeDir, ".kimi-code"), "credentials", "kimi-code.json"),
+            join(homeDir, ".kimi", "credentials", "kimi-code.json"),
+        ];
+    }
+    async readCredentialFile(path) {
+        if (!existsSync(path))
+            return null;
+        try {
+            return KimiAuthSchema.parse(JSON.parse(await fs.readFile(path, "utf8")));
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=kimi.js.map

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

@@ -0,0 +1,29 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface MiniMaxQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+    configPath?: string;
+    credentialsPath?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => number;
+}
+export declare class MiniMaxQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "minimax";
+    readonly displayName = "MiniMax";
+    private readonly logger;
+    private readonly fetchApi;
+    private readonly configPath;
+    private readonly credentialsPath;
+    private readonly env;
+    private readonly now;
+    constructor(options: MiniMaxQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private resolveAuth;
+    private isExpired;
+    private readCredentials;
+    private readConfig;
+}
+export {};
+//# sourceMappingURL=minimax.d.ts.map

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

@@ -0,0 +1,227 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, ApiOptionalStringSchema, fetchProviderApi, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const MINIMAX_GLOBAL_BASE_URL = "https://api.minimax.io";
+const MINIMAX_CN_BASE_URL = "https://api.minimaxi.com";
+const MINIMAX_CREDENTIALS_PATH = join(homedir(), ".mmx", "credentials.json");
+const MINIMAX_CONFIG_PATH = join(homedir(), ".mmx", "config.json");
+const MiniMaxModelRemainSchema = z.object({
+    model_name: ApiOptionalStringSchema,
+    start_time: ApiNumberSchema.optional(),
+    end_time: ApiNumberSchema.optional(),
+    remains_time: ApiNumberSchema.optional(),
+    current_interval_total_count: ApiNumberSchema.optional(),
+    current_interval_usage_count: ApiNumberSchema.optional(),
+    current_interval_remaining_percent: ApiNumberSchema.optional(),
+    current_weekly_total_count: ApiNumberSchema.optional(),
+    current_weekly_usage_count: ApiNumberSchema.optional(),
+    current_weekly_remaining_percent: ApiNumberSchema.optional(),
+    current_interval_status: ApiNumberSchema.optional(),
+    current_weekly_status: ApiNumberSchema.optional(),
+    weekly_start_time: ApiNumberSchema.optional(),
+    weekly_end_time: ApiNumberSchema.optional(),
+    weekly_remains_time: ApiNumberSchema.optional(),
+    weekly_boost_permille: ApiNumberSchema.optional(),
+});
+const MiniMaxQuotaResponseSchema = z.object({
+    model_remains: z.array(MiniMaxModelRemainSchema).optional(),
+});
+const MiniMaxCredentialsSchema = z.object({
+    access_token: z.string().optional(),
+    refresh_token: z.string().optional(),
+    expires_at: ApiOptionalStringSchema,
+    resource_url: ApiOptionalStringSchema,
+});
+const MiniMaxConfigSchema = z.object({
+    api_key: z.string().optional(),
+    region: z.string().optional(),
+    base_url: ApiOptionalStringSchema,
+    oauth: MiniMaxCredentialsSchema.optional(),
+});
+function resolveBaseUrl(input) {
+    const explicit = input.baseUrl;
+    if (explicit && explicit.startsWith("http"))
+        return explicit;
+    if (input.region === "cn")
+        return MINIMAX_CN_BASE_URL;
+    return MINIMAX_GLOBAL_BASE_URL;
+}
+function computeUsedPct(remaining, total) {
+    if (typeof remaining !== "number" || typeof total !== "number")
+        return null;
+    if (!Number.isFinite(total) || total <= 0)
+        return null;
+    if (!Number.isFinite(remaining))
+        return null;
+    const used = total - remaining;
+    return Math.max(0, Math.min(100, (used / total) * 100));
+}
+function epochMsToIso(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return null;
+    return new Date(value).toISOString();
+}
+function toneForStatus(status) {
+    if (status === 2)
+        return "danger";
+    if (status === 3)
+        return "default";
+    return "ok";
+}
+function toIntervalWindow(modelName, model) {
+    const total = model.current_interval_total_count ?? null;
+    const used = model.current_interval_usage_count ?? null;
+    const remainingPercent = model.current_interval_remaining_percent ?? null;
+    const usedPct = typeof remainingPercent === "number" && Number.isFinite(remainingPercent)
+        ? Math.max(0, Math.min(100, 100 - remainingPercent))
+        : computeUsedPct(typeof total === "number" && typeof used === "number" ? total - used : null, total);
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `interval_${modelName}`,
+        label: `${modelName} · Interval`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.end_time),
+        tone: toneForStatus(model.current_interval_status),
+    });
+}
+function toWeeklyWindow(modelName, model) {
+    const total = model.current_weekly_total_count ?? null;
+    const used = model.current_weekly_usage_count ?? null;
+    const remainingPercent = model.current_weekly_remaining_percent ?? null;
+    let usedPct = null;
+    if (typeof remainingPercent === "number" && Number.isFinite(remainingPercent)) {
+        usedPct = Math.max(0, Math.min(100, 100 - remainingPercent));
+    }
+    else if (typeof total === "number" && typeof used === "number") {
+        usedPct = computeUsedPct(total - used, total);
+    }
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `weekly_${modelName}`,
+        label: `${modelName} · Weekly`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.weekly_end_time),
+        tone: toneForStatus(model.current_weekly_status),
+    });
+}
+export class MiniMaxQuotaProvider {
+    constructor(options) {
+        this.providerId = "minimax";
+        this.displayName = "MiniMax";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+        this.configPath = options.configPath ?? MINIMAX_CONFIG_PATH;
+        this.credentialsPath = options.credentialsPath ?? MINIMAX_CREDENTIALS_PATH;
+        this.env = options.env ?? process.env;
+        this.now = options.now ?? Date.now;
+    }
+    async fetchUsage() {
+        const auth = await this.resolveAuth();
+        if (!auth)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, `${auth.baseUrl}/v1/token_plan/remains`, {
+            headers: {
+                Authorization: `Bearer ${auth.token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "MiniMax usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = MiniMaxQuotaResponseSchema.parse(await res.json());
+        const models = resp.model_remains ?? [];
+        const windows = [];
+        for (const model of models) {
+            const name = model.model_name ?? "token-plan";
+            const intervalWindow = toIntervalWindow(name, model);
+            if (intervalWindow)
+                windows.push(intervalWindow);
+            const weeklyWindow = toWeeklyWindow(name, model);
+            if (weeklyWindow)
+                windows.push(weeklyWindow);
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: windows.length > 0 ? "available" : "unavailable",
+            planLabel: null,
+            windows,
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async resolveAuth() {
+        const envToken = this.env["MINIMAX_API_KEY"];
+        if (envToken) {
+            const envBase = this.env["MINIMAX_BASE_URL"];
+            return {
+                token: envToken,
+                baseUrl: resolveBaseUrl({ baseUrl: envBase }),
+            };
+        }
+        const credentials = await this.readCredentials();
+        if (credentials?.access_token && !this.isExpired(credentials.expires_at)) {
+            return {
+                token: credentials.access_token,
+                baseUrl: resolveBaseUrl({ baseUrl: credentials.resource_url }),
+            };
+        }
+        const config = await this.readConfig();
+        if (config?.api_key) {
+            return {
+                token: config.api_key,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        if (config?.oauth?.access_token && !this.isExpired(config.oauth.expires_at)) {
+            return {
+                token: config.oauth.access_token,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.oauth.resource_url ?? config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        return null;
+    }
+    isExpired(expiresAt) {
+        if (!expiresAt)
+            return false;
+        const parsed = Date.parse(expiresAt);
+        if (!Number.isFinite(parsed))
+            return false;
+        return parsed <= this.now();
+    }
+    async readCredentials() {
+        if (!existsSync(this.credentialsPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.credentialsPath, "utf8"));
+            return MiniMaxCredentialsSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async readConfig() {
+        if (!existsSync(this.configPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.configPath, "utf8"));
+            return MiniMaxConfigSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=minimax.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,34 @@
+import type { Logger } from "pino";
+import type { MutableDaemonConfig } from "@camerontaylor/paseo-protocol/messages";
+import type { ProviderUsage } from "../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "./provider.js";
+export interface ProviderUsageServiceOptions {
+    logger: Logger;
+    fetchers?: ProviderUsageFetcher[];
+    fetch?: ProviderApiFetch;
+    providerConfigs?: MutableDaemonConfig["providers"];
+    fetcherFactory?: (providers: MutableDaemonConfig["providers"]) => ProviderUsageFetcher[];
+    cacheTtlMs?: number;
+    now?: () => number;
+}
+export interface ProviderUsageListResult {
+    fetchedAt: string;
+    providers: ProviderUsage[];
+}
+export declare class ProviderUsageService {
+    private readonly logger;
+    private fetchers;
+    private readonly rebuildFetchers;
+    private readonly cacheTtlMs;
+    private readonly now;
+    private cached;
+    private inFlight;
+    private revision;
+    constructor(options: ProviderUsageServiceOptions);
+    updateProviderConfigs(providers: MutableDaemonConfig["providers"]): void;
+    listUsage(options?: {
+        forceRefresh?: boolean;
+    }): Promise<ProviderUsageListResult>;
+    private fetchFreshUsage;
+}
+//# sourceMappingURL=service.d.ts.map