dsh-claude-subscription 0.3.0 → 0.4.0

package/lib/types/usage.d.ts

@@ -0,0 +1,90 @@
+export declare const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+export declare const CLAUDE_MODELS_URL = "https://api.anthropic.com/v1/models?limit=1000";
+export interface ClaudeModel {
+    readonly id: string;
+    readonly name: string;
+    readonly api: "anthropic-messages";
+    readonly provider: "anthropic";
+    readonly baseUrl: "https://api.anthropic.com";
+    readonly reasoning: boolean;
+    readonly input: readonly ["text"] | readonly ["text", "image"];
+    readonly cost: {
+        readonly input: 0;
+        readonly output: 0;
+        readonly cacheRead: 0;
+        readonly cacheWrite: 0;
+    };
+    readonly contextWindow: number;
+    readonly maxTokens: number;
+}
+export interface UsageWindow {
+    readonly id: string;
+    readonly label: string;
+    readonly remainingPercent: number;
+    readonly appliesTo?: string | undefined;
+    readonly resetsAt?: number | undefined;
+}
+export interface ExtraUsage {
+    readonly enabled: boolean;
+    readonly currency?: string | undefined;
+    readonly decimalPlaces?: number | undefined;
+    readonly monthlyLimit?: number | undefined;
+    readonly usedCredits?: number | undefined;
+    readonly utilization?: number | undefined;
+}
+export interface UsageProjection {
+    readonly windows: readonly UsageWindow[];
+    readonly extraUsage?: ExtraUsage | undefined;
+}
+export interface FetchedUsage extends UsageProjection {
+    readonly fetchedAt: number;
+}
+export interface AuthResolution {
+    readonly auth?: {
+        readonly apiKey?: string | undefined;
+    } | undefined;
+}
+export interface ModelReaderOptions {
+    readonly getAuth: (options?: {
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<AuthResolution | undefined>;
+    readonly setModels: (models: readonly ClaudeModel[]) => void;
+    readonly fetch?: typeof fetch | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly ttlMs?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+}
+export interface ModelReader {
+    readonly read: (options?: {
+        readonly force?: boolean | undefined;
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<unknown>;
+    readonly clear: () => void;
+}
+export interface UsageReaderOptions {
+    readonly getAuth: (options?: {
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<AuthResolution | undefined>;
+    readonly fetch?: typeof fetch | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly ttlMs?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly userAgent?: string | undefined;
+}
+export interface UsageReader {
+    readonly read: (options?: {
+        readonly force?: boolean | undefined;
+        readonly signal?: AbortSignal | undefined;
+    }) => Promise<FetchedUsage>;
+    readonly clear: () => void;
+}
+export declare function parseClaudeModels(value: unknown): ClaudeModel[];
+export declare function createClaudeModelReader(options: ModelReaderOptions): ModelReader;
+/** Reduce the provider payload to a browser-safe quota projection. */
+export declare function parseClaudeUsage(value: unknown): UsageProjection;
+/**
+ * Read quota through the same refreshable OAuth lifecycle used by model turns.
+ * The browser receives only a parsed quota projection; the bearer token is a
+ * request-local host value. Concurrent polls share one request.
+ */
+export declare function createClaudeUsageReader(options: UsageReaderOptions): UsageReader;

package/lib/usage.js

@@ -0,0 +1,303 @@
+export const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+export const CLAUDE_MODELS_URL = "https://api.anthropic.com/v1/models?limit=1000";
+const DEFAULT_TTL_MS = 60_000;
+const DEFAULT_TIMEOUT_MS = 15_000;
+const OAUTH_BETA = "oauth-2025-04-20";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function parseClaudeModels(value) {
+    if (!record(value) || !Array.isArray(value.data))
+        throw new Error("Claude returned a malformed model list");
+    return value.data.map((entry) => {
+        if (!record(entry) ||
+            typeof entry.id !== "string" ||
+            entry.id.length === 0 ||
+            typeof entry.display_name !== "string" ||
+            entry.display_name.length === 0)
+            throw new Error("Claude returned a malformed model");
+        if (!Number.isSafeInteger(entry.max_input_tokens) ||
+            entry.max_input_tokens <= 0 ||
+            !Number.isSafeInteger(entry.max_tokens) ||
+            entry.max_tokens <= 0)
+            throw new Error("Claude returned invalid model limits");
+        const capabilities = record(entry.capabilities) ? entry.capabilities : {};
+        const thinkingSupported = record(capabilities.thinking) && capabilities.thinking.supported === true;
+        const imageSupported = record(capabilities.image_input) && capabilities.image_input.supported === true;
+        return {
+            id: entry.id,
+            name: entry.display_name,
+            api: "anthropic-messages",
+            provider: "anthropic",
+            baseUrl: "https://api.anthropic.com",
+            reasoning: thinkingSupported,
+            input: imageSupported ? ["text", "image"] : ["text"],
+            cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+            },
+            contextWindow: entry.max_input_tokens,
+            maxTokens: entry.max_tokens,
+        };
+    });
+}
+export function createClaudeModelReader(options) {
+    const getAuth = options.getAuth;
+    const setModels = options.setModels;
+    const fetchModels = options.fetch ?? fetch;
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    let fetchedAt = 0;
+    let inFlight;
+    const load = async (signal) => {
+        const access = (await getAuth({ signal }))?.auth?.apiKey;
+        if (typeof access !== "string" || access.length === 0)
+            throw new Error("Claude subscription is not signed in");
+        const response = await fetchModels(CLAUDE_MODELS_URL, {
+            method: "GET",
+            redirect: "error",
+            headers: {
+                authorization: `Bearer ${access}`,
+                "anthropic-beta": OAUTH_BETA,
+                "anthropic-version": "2023-06-01",
+                accept: "application/json",
+                "cache-control": "no-store",
+            },
+            signal: requestSignal(signal, timeoutMs),
+        });
+        if (!response.ok)
+            throw new Error(`Claude model request failed (HTTP ${response.status})`);
+        const models = parseClaudeModels(await response.json());
+        setModels(models);
+        fetchedAt = now();
+        return models;
+    };
+    return Object.freeze({
+        read({ force = false, signal, } = {}) {
+            if (!force && fetchedAt !== 0 && now() - fetchedAt < ttlMs)
+                return Promise.resolve();
+            if (inFlight !== undefined)
+                return inFlight;
+            const current = load(signal).finally(() => {
+                if (inFlight === current)
+                    inFlight = undefined;
+            });
+            inFlight = current;
+            return current;
+        },
+        clear() {
+            fetchedAt = 0;
+            setModels([]);
+        },
+    });
+}
+function epochSecondsOf(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? Math.floor(parsed / 1_000) : undefined;
+}
+function windowOf(id, label, utilization, resetsAtValue, appliesTo) {
+    if (typeof utilization !== "number" || !Number.isFinite(utilization) || utilization < 0 || utilization > 100)
+        throw new Error("Claude returned an invalid utilization percentage");
+    const resetsAt = epochSecondsOf(resetsAtValue);
+    return {
+        id,
+        label,
+        remainingPercent: 100 - utilization,
+        ...(appliesTo === undefined ? {} : { appliesTo }),
+        ...(resetsAt === undefined ? {} : { resetsAt }),
+    };
+}
+function decimalOf(value, label) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+        throw new Error(`Claude returned an invalid ${label}`);
+    return value;
+}
+function extraUsageOf(value, spend) {
+    if (record(spend) && typeof spend.enabled === "boolean") {
+        const used = record(spend.used) ? spend.used : undefined;
+        const limit = record(spend.limit) ? spend.limit : undefined;
+        const usedCredits = decimalOf(used?.amount_minor, "used credit amount");
+        const monthlyLimit = decimalOf(limit?.amount_minor, "monthly credit limit");
+        const usedCurrency = used?.currency;
+        const limitCurrency = limit?.currency;
+        const currency = (usedCurrency ?? limitCurrency);
+        const decimalPlaces = (used?.exponent ?? limit?.exponent);
+        if (currency !== undefined &&
+            (typeof currency !== "string" || !/^[A-Za-z]{3}$/.test(currency)))
+            throw new Error("Claude returned an invalid extra usage currency");
+        if (decimalPlaces !== undefined &&
+            (!Number.isSafeInteger(decimalPlaces) ||
+                decimalPlaces < 0 ||
+                decimalPlaces > 20))
+            throw new Error("Claude returned invalid extra usage decimal places");
+        if ((typeof usedCurrency === "string" &&
+            typeof limitCurrency === "string" &&
+            usedCurrency.toUpperCase() !== limitCurrency.toUpperCase()) ||
+            (Number.isSafeInteger(used?.exponent) &&
+                Number.isSafeInteger(limit?.exponent) &&
+                used?.exponent !== limit?.exponent))
+            throw new Error("Claude returned inconsistent extra usage units");
+        return {
+            enabled: spend.enabled,
+            ...(currency === undefined
+                ? {}
+                : { currency: currency.toUpperCase() }),
+            ...(decimalPlaces === undefined ? {} : { decimalPlaces: decimalPlaces }),
+            ...(monthlyLimit === undefined ? {} : { monthlyLimit }),
+            ...(usedCredits === undefined ? {} : { usedCredits }),
+            ...(typeof spend.percent === "number" && Number.isFinite(spend.percent)
+                ? { utilization: spend.percent }
+                : {}),
+        };
+    }
+    if (value === undefined || value === null)
+        return undefined;
+    if (!record(value))
+        throw new Error("Claude returned malformed extra usage details");
+    if (typeof value.is_enabled !== "boolean")
+        return undefined;
+    const monthlyLimit = decimalOf(value.monthly_limit, "monthly credit limit");
+    const usedCredits = decimalOf(value.used_credits, "used credit amount");
+    const utilization = decimalOf(value.utilization, "extra usage utilization");
+    const currency = value.currency;
+    const decimalPlaces = value.decimal_places;
+    if (currency !== undefined &&
+        currency !== null &&
+        (typeof currency !== "string" || !/^[A-Za-z]{3}$/.test(currency)))
+        throw new Error("Claude returned an invalid extra usage currency");
+    if (decimalPlaces !== undefined &&
+        decimalPlaces !== null &&
+        (!Number.isSafeInteger(decimalPlaces) ||
+            decimalPlaces < 0 ||
+            decimalPlaces > 20))
+        throw new Error("Claude returned invalid extra usage decimal places");
+    return {
+        enabled: value.is_enabled,
+        ...(typeof currency === "string" ? { currency: currency.toUpperCase() } : {}),
+        ...(Number.isSafeInteger(decimalPlaces) ? { decimalPlaces: decimalPlaces } : {}),
+        ...(monthlyLimit === undefined ? {} : { monthlyLimit }),
+        ...(usedCredits === undefined ? {} : { usedCredits }),
+        ...(utilization === undefined ? {} : { utilization }),
+    };
+}
+/** Reduce the provider payload to a browser-safe quota projection. */
+export function parseClaudeUsage(value) {
+    if (!record(value))
+        throw new Error("Claude returned a malformed usage response");
+    const windows = Array.isArray(value.limits)
+        ? value.limits.map((entry, index) => {
+            if (!record(entry) || typeof entry.kind !== "string" || entry.kind.length === 0)
+                throw new Error("Claude returned a malformed usage window");
+            const scope = record(entry.scope) ? entry.scope : undefined;
+            const model = scope !== undefined && record(scope.model) ? scope.model : undefined;
+            const modelName = typeof model?.display_name === "string" && model.display_name.length > 0
+                ? model.display_name
+                : undefined;
+            const group = typeof entry.group === "string" && entry.group.length > 0
+                ? entry.group
+                : entry.kind;
+            const label = modelName === undefined ? group : `${group} (${modelName})`;
+            const appliesTo = model === undefined
+                ? "all"
+                : typeof model.id === "string" && model.id.length > 0
+                    ? model.id
+                    : undefined;
+            return windowOf(`${entry.kind}:${index}`, label, entry.percent, entry.resets_at, appliesTo);
+        })
+        : Object.entries(value)
+            .filter(([, entry]) => record(entry) && Object.hasOwn(entry, "utilization") && Object.hasOwn(entry, "resets_at"))
+            .map(([id, entry]) => {
+            const rec = entry;
+            return windowOf(id, id, rec.utilization, rec.resets_at);
+        });
+    const extraUsage = extraUsageOf(value.extra_usage, value.spend);
+    return {
+        windows,
+        ...(extraUsage === undefined ? {} : { extraUsage }),
+    };
+}
+const requestSignal = (signal, timeoutMs) => {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return signal === undefined ? timeout : AbortSignal.any([signal, timeout]);
+};
+function messageForStatus(status) {
+    if (status === 401 || status === 403)
+        return "Claude sign-in needs to be renewed";
+    if (status === 429)
+        return "Claude usage requests are rate limited. Try again later";
+    return `Claude usage request failed (HTTP ${status})`;
+}
+/**
+ * Read quota through the same refreshable OAuth lifecycle used by model turns.
+ * The browser receives only a parsed quota projection; the bearer token is a
+ * request-local host value. Concurrent polls share one request.
+ */
+export function createClaudeUsageReader(options) {
+    const getAuth = options.getAuth;
+    const fetchUsage = options.fetch ?? fetch;
+    const now = options.now ?? Date.now;
+    const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const userAgent = options.userAgent ?? "dsh-claude-subscription/0.4.0";
+    let cached;
+    let inFlight;
+    const load = async (signal) => {
+        const access = (await getAuth({ signal }))?.auth?.apiKey;
+        if (typeof access !== "string" || access.length === 0)
+            throw new Error("Claude subscription is not signed in");
+        const response = await fetchUsage(CLAUDE_USAGE_URL, {
+            method: "GET",
+            redirect: "error",
+            headers: {
+                authorization: `Bearer ${access}`,
+                "anthropic-beta": OAUTH_BETA,
+                accept: "application/json",
+                "cache-control": "no-store",
+                "user-agent": userAgent,
+            },
+            signal: requestSignal(signal, timeoutMs),
+        });
+        if (!response.ok)
+            throw new Error(messageForStatus(response.status));
+        let value;
+        try {
+            value = await response.json();
+        }
+        catch {
+            throw new Error("Claude returned an unreadable usage response");
+        }
+        return {
+            ...parseClaudeUsage(value),
+            fetchedAt: now(),
+        };
+    };
+    return Object.freeze({
+        read({ force = false, signal, } = {}) {
+            if (!force && cached !== undefined && now() - cached.fetchedAt < ttlMs)
+                return Promise.resolve(structuredClone(cached));
+            if (inFlight !== undefined)
+                return inFlight.then((v) => structuredClone(v));
+            const current = load(signal)
+                .then((value) => {
+                cached = structuredClone(value);
+                return structuredClone(value);
+            })
+                .finally(() => {
+                if (inFlight === current)
+                    inFlight = undefined;
+            });
+            inFlight = current;
+            return current;
+        },
+        clear() {
+            cached = undefined;
+        },
+    });
+}

package/package.json

@@ -1,18 +1,31 @@
 {
   "name": "dsh-claude-subscription",
-  "version": "0.3.0",
-  "packageManager": "pnpm@11.19.0",
+  "version": "0.4.0",
   "description": "Claude Pro/Max subscription for DeepSeek Harness with official Anthropic OAuth login and automatic token refresh",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/x5427876/dsh-claude-subscription.git"
+  },
+  "homepage": "https://github.com/x5427876/dsh-claude-subscription",
+  "bugs": "https://github.com/x5427876/dsh-claude-subscription/issues",
   "type": "module",
   "main": "./lib/index.js",
+  "types": "./lib/types/index.d.ts",
   "exports": {
-    ".": "./lib/index.js",
-    "./client": "./lib/client.js",
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client.d.ts",
+      "default": "./lib/client.js"
+    },
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./package.json": "./package.json"
   },
   "files": [
     "lib/*.js",
+    "lib/types/**/*.d.ts",
     "cordis.patch.yml",
     "README.md",
     "README.en.md",
@@ -38,11 +51,6 @@
       "platform": "web"
     }
   },
-  "scripts": {
-    "build": "node --check lib/index.js && node --check lib/client.js",
-    "test": "node --test tests/*.test.mjs",
-    "check": "pnpm run test && pnpm run build && pnpm pack --pack-destination .artifacts"
-  },
   "keywords": [
     "dsh-plugin",
     "deepseek",
@@ -63,21 +71,49 @@
     "node": "^22.19.0 || >=24.0.0"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-ui-primitives": "0.1.2-alpha.5",
-    "@deepseek-ai/dsh-credentials": "0.1.2-alpha.5",
-    "@deepseek-ai/dsh-llm": "0.1.2-alpha.5",
-    "@deepseek-ai/dsh-llm-pi-ai": "0.1.2-alpha.5",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-credentials": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-llm-pi-ai": "0.1.6-alpha.2",
     "@deepseek-ai/schemastery": "^3.18.2",
-    "@earendil-works/pi-ai": "^0.84.2",
+    "@earendil-works/pi-ai": "^0.85.1",
     "react": "^18.2.0"
   },
   "peerDependenciesMeta": {
-    "@deepseek-ai/dsh-client-ui-primitives": { "optional": true },
-    "@deepseek-ai/dsh-credentials": { "optional": true },
-    "@deepseek-ai/dsh-llm": { "optional": true },
-    "@deepseek-ai/dsh-llm-pi-ai": { "optional": true },
-    "@deepseek-ai/schemastery": { "optional": true },
-    "@earendil-works/pi-ai": { "optional": true },
-    "react": { "optional": true }
+    "@deepseek-ai/dsh-client-ui-primitives": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-credentials": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm-pi-ai": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    },
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.6",
+    "@types/react": "~18.3.31",
+    "publint": "^0.3.24",
+    "tsx": "^4.23.15",
+    "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "tsc && node scripts/build.mjs",
+    "pretest": "pnpm run build",
+    "test": "tsx --test tests/*.test.mjs",
+    "check": "pnpm run typecheck && pnpm run test && pnpm pack --pack-destination .artifacts"
   }
 }