dsh-plugin-subscription-oauth 0.3.0 → 0.5.0

package/lib/auth/ccswitch.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The cc-switch balance query, reimplemented for the plugin's node half.
+ *
+ * cc-switch (github.com/farion1231/cc-switch) reads a DeepSeek-compatible provider's
+ * balance with `GET https://api.deepseek.com/user/balance`, an `Authorization: Bearer
+ * <api key>` header, and a 15 s timeout. This is that request, with the URL hardcoded
+ * exactly as cc-switch does — the provider's own base URL is never substituted in.
+ *
+ * The endpoint answers `{ is_available, balance_infos: [{ currency, total_balance, … }] }`,
+ * where a balance is a number or a numeric string. The module reduces that to the one
+ * figure a status chip needs: the first currency's total. Anything else — a missing key,
+ * a non-2xx answer, malformed JSON — resolves to nothing, so the caller shows no balance
+ * rather than a wrong one.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/ccswitch
+ */
+import type { FetchFn } from '../http.js';
+/** One currency's balance, normalised from the endpoint's answer. */
+export interface CcSwitchBalance {
+    /** The currency the balance is denominated in. */
+    currency: string;
+    /** The remaining balance, as a decimal string. */
+    total: string;
+    /** Whether the account reports itself as usable. */
+    available: boolean;
+}
+/**
+ * Query one provider's balance the way cc-switch does.
+ *
+ * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export declare function queryCcSwitchBalance(input: {
+    apiKey: string;
+    fetchFn?: FetchFn;
+}): Promise<CcSwitchBalance | undefined>;

package/lib/auth/ccswitch.js

@@ -0,0 +1,75 @@
+/**
+ * The cc-switch balance query, reimplemented for the plugin's node half.
+ *
+ * cc-switch (github.com/farion1231/cc-switch) reads a DeepSeek-compatible provider's
+ * balance with `GET https://api.deepseek.com/user/balance`, an `Authorization: Bearer
+ * <api key>` header, and a 15 s timeout. This is that request, with the URL hardcoded
+ * exactly as cc-switch does — the provider's own base URL is never substituted in.
+ *
+ * The endpoint answers `{ is_available, balance_infos: [{ currency, total_balance, … }] }`,
+ * where a balance is a number or a numeric string. The module reduces that to the one
+ * figure a status chip needs: the first currency's total. Anything else — a missing key,
+ * a non-2xx answer, malformed JSON — resolves to nothing, so the caller shows no balance
+ * rather than a wrong one.
+ *
+ * @module dsh-plugin-subscription-oauth/auth/ccswitch
+ */
+import { proxiedFetch } from '../http.js';
+/** Read a balance field that may be a number or a numeric string. */
+function num(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value)))
+        return value.trim();
+    return undefined;
+}
+/**
+ * Query one provider's balance the way cc-switch does.
+ *
+ * @param input - the provider's API key, and optionally a fetch to substitute in tests.
+ * @returns the balance, or undefined when the provider did not answer with one.
+ */
+export async function queryCcSwitchBalance(input) {
+    const fetchFn = input.fetchFn ?? proxiedFetch;
+    let response;
+    try {
+        // cc-switch's exact request shape: hardcoded URL, bearer auth, 15 s timeout.
+        response = await fetchFn('https://api.deepseek.com/user/balance', {
+            headers: { authorization: `Bearer ${input.apiKey}`, accept: 'application/json' },
+            signal: AbortSignal.timeout(15_000),
+        });
+    }
+    catch {
+        return undefined;
+    }
+    if (!response.ok)
+        return undefined;
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof payload !== 'object' || payload === null)
+        return undefined;
+    const record = payload;
+    const infos = record.balance_infos;
+    if (!Array.isArray(infos))
+        return undefined;
+    for (const raw of infos) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const info = raw;
+        const total = num(info.total_balance);
+        if (total === undefined)
+            continue;
+        const currency = typeof info.currency === 'string' && info.currency.trim() !== '' ? info.currency.trim() : 'CNY';
+        return {
+            currency,
+            total,
+            available: record.is_available !== false,
+        };
+    }
+    return undefined;
+}

package/lib/auth/rpc.d.ts

@@ -1,3 +1,10 @@
+/**
+ * How one named credential resolves to a value.
+ *
+ * The host's credential service owns this; the RPC layer only calls it, so the balance
+ * query does not re-derive how a key is stored.
+ */
+export type CredentialResolver = (ref: string) => Promise<string | undefined>;
 /**
  * The host-side transport behind the Settings page.
  *
@@ -21,7 +28,7 @@ import type { SubscriptionRegistry } from './registry.js';
  * @param payload - the request's decoded payload.
  * @returns the envelope result.
  */
-export declare function dispatchRpc(registry: SubscriptionRegistry, endpoint: string, payload: unknown): Promise<RpcResult>;
+export declare function dispatchRpc(registry: SubscriptionRegistry, endpoint: string, payload: unknown, resolveCredential?: CredentialResolver): Promise<RpcResult>;
 /**
  * Register every endpoint route on the `connection` service, when one exists.
  *

package/lib/auth/rpc.js

@@ -1,15 +1,5 @@
-/**
- * The host-side transport behind the Settings page.
- *
- * Each endpoint is served as its own `POST /api/subscription-oauth.<endpoint>`
- * Fetch route on the `connection` service. `connection` is deliberately not in
- * the plugin's `inject` list: a headless composition has no connection service,
- * and the provider routes must still work there. Nothing else is registered
- * when it is absent, so the browser half simply finds no routes.
- *
- * @module dsh-plugin-subscription-oauth/auth/rpc
- */
 import { BAD_REQUEST, ProviderError } from '../errors.js';
+import { queryCcSwitchBalance } from './ccswitch.js';
 import { RPC_ENDPOINTS, RPC_PREFIX } from '../protocol.js';
 /** Wrap a value as a successful envelope result. */
 function success(value) {
@@ -85,9 +75,9 @@ function requiredProvider(payload, endpoint) {
  * @param payload - the request's decoded payload.
  * @returns the envelope result.
  */
-export async function dispatchRpc(registry, endpoint, payload) {
+export async function dispatchRpc(registry, endpoint, payload, resolveCredential) {
     try {
-        return success(await runEndpoint(registry, endpoint, payload));
+        return success(await runEndpoint(registry, endpoint, payload, resolveCredential));
     }
     catch (error) {
         return failure(error);
@@ -97,7 +87,7 @@ export async function dispatchRpc(registry, endpoint, payload) {
  * The endpoint table.
  * @throws {ProviderError} for a request the registry refuses.
  */
-async function runEndpoint(registry, endpoint, payload) {
+async function runEndpoint(registry, endpoint, payload, resolveCredential) {
     switch (endpoint) {
         case 'status':
             return registry.status();
@@ -145,6 +135,21 @@ async function runEndpoint(registry, endpoint, payload) {
         }
         case 'usage':
             return registry.usage(requiredProvider(payload, endpoint), booleanField(payload, 'force'));
+        case 'ccswitch-balance': {
+            // A manually added provider's balance, by cc-switch's query. The caller names the
+            // credential reference the provider's profile uses (its apiKeyEnv), and the host's
+            // credential service resolves it. No key, or a key the provider does not answer
+            // for, means no balance — never a fabricated zero.
+            if (resolveCredential === undefined)
+                return undefined;
+            const credentialRef = stringField(payload, 'credentialRef');
+            if (credentialRef === undefined)
+                return undefined;
+            const apiKey = await resolveCredential(credentialRef);
+            if (apiKey === undefined)
+                return undefined;
+            return await queryCcSwitchBalance({ apiKey });
+        }
         case 'reload':
             return registry.reload();
         default:
@@ -152,7 +157,7 @@ async function runEndpoint(registry, endpoint, payload) {
     }
 }
 /** Build the Fetch route for one endpoint. */
-function rpcRoute(endpoint, registry) {
+function rpcRoute(endpoint, registry, resolveCredential) {
     const method = `${RPC_PREFIX}${endpoint}`;
     return {
         path: `/api/${method}`,
@@ -176,7 +181,7 @@ function rpcRoute(endpoint, registry) {
             if (envelopeRequest.type !== 'client-request' || envelopeRequest.method !== method) {
                 return rejection(rpcId, 'gateway/bad-request', `${method} received an envelope for another method`, 400);
             }
-            return envelope(rpcId, await dispatchRpc(registry, endpoint, envelopeRequest.payload));
+            return envelope(rpcId, await dispatchRpc(registry, endpoint, envelopeRequest.payload, resolveCredential));
         },
     };
 }
@@ -191,10 +196,17 @@ export function registerSubscriptionRpc(ctx, registry) {
         const connection = connectionCtx.get('connection');
         if (connection === undefined)
             return;
+        // The cc-switch balance endpoint resolves a credential reference through the host's
+        // credential service. It is optional: a composition with no credential service still
+        // serves every other endpoint, and the balance endpoint simply answers nothing.
+        const credentials = connectionCtx.get('credentials');
+        const resolveCredential = credentials?.resolve === undefined
+            ? undefined
+            : async (ref) => (await credentials.resolve?.(ref))?.value;
         const register = (route) => connection.fetch.register(route);
         for (const endpoint of RPC_ENDPOINTS) {
             const method = `${RPC_PREFIX}${endpoint}`;
-            connectionCtx.effect(() => register(rpcRoute(endpoint, registry)), `dsh-plugin-subscription-oauth: /api/${method} route`);
+            connectionCtx.effect(() => register(rpcRoute(endpoint, registry, resolveCredential)), `dsh-plugin-subscription-oauth: /api/${method} route`);
         }
     });
 }

package/lib/client/UsageChip.d.ts

@@ -0,0 +1,188 @@
+/**
+ * The usage chip that rides the composer's bottom bar.
+ *
+ * The bar itself is a slot the shell owns. `conversation.composer.dock` is a
+ * session-scoped `list`, and the shell's own stats pills (`tok/s`, cache hit) and its
+ * context meter register into it; this chip joins as the last entry, so it reads to the
+ * right of the context meter. It is deliberately compact — an abbreviated route name
+ * and the percentage — because the bar is a status line, not a dashboard; the full
+ * figure, its reset and the meter appear when the chip is clicked.
+ *
+ * Two silences are deliberate: a provider this plugin does not own shows nothing rather
+ * than a fabricated zero, and switching to a foreign provider keeps the last own reading
+ * on screen instead of blanking the bar — the shell's own pills already speak for the
+ * foreign one.
+ *
+ * @module dsh-plugin-subscription-oauth/client/UsageChip
+ */
+import type { ReactNode } from 'react';
+import type { SessionStandardProps } from '@deepseek-ai/dsh-client-ui-slots';
+import type { SubscriptionsCall, AccountBalanceCall, CcSwitchBalanceCall } from './subscriptions-rpc.js';
+import type { ProviderUsage, UsageWindow } from '../protocol.js';
+/** Injected props the chip is registered with. */
+export interface UsageChipInjected {
+    /** The plugin's own RPC caller. */
+    call: SubscriptionsCall;
+    /** Copy for the active locale. */
+    t: (key: 'usageChipTitle' | 'usageChipFull', values?: Record<string, string | number>) => string;
+    /** Whether the provider is one this plugin serves. */
+    isOwnProvider: (provider: string) => boolean;
+    /**
+     * The DeepSeek account's balance, when the session uses it.
+     *
+     * The host owns that account's grant and the platform endpoint, so the chip asks the
+     * host rather than re-deriving either. It resolves to `undefined` when the account is
+     * signed out or the read fails, in which case the chip stays silent.
+     */
+    accountBalance: AccountBalanceCall;
+    /**
+     * A manually added provider's balance, by cc-switch's query.
+     *
+     * The caller names the credential reference the provider's profile uses (its
+     * `apiKeyEnv`); the host's credential service resolves it, and the node half asks
+     * cc-switch's balance endpoint. It resolves to `undefined` when there is no key or
+     * the provider did not answer.
+     */
+    ccSwitchBalance: CcSwitchBalanceCall;
+    /**
+     * The credential reference a manually added provider's balance query uses, by provider
+     * id.
+     *
+     * A manually added provider is not one this plugin serves and has no account route, so
+     * the only way to read its balance is cc-switch's query, which needs the provider's API
+     * key. That key is named by the provider's profile (`apiKeyEnv`), and the host's
+     * credential service resolves the name; this map is the one place a provider id is tied
+     * to that name. A provider with no entry gets no balance.
+     */
+    ccSwitchCredentialRef: (provider: string) => string | undefined;
+}
+/** One model choice, as the host records it. */
+export interface ModelSelection {
+    /** Provider route key. */
+    readonly provider: string;
+    /** Model id. */
+    readonly model: string;
+    /** Reasoning effort, when one was chosen. */
+    readonly reasoningEffort?: string;
+}
+/**
+ * The session's model-selection projection, as the host wires it.
+ *
+ * `next` is a selection the user has made but not yet used; `lastUsed` is the one a
+ * request actually ran with. Reading `next` first is what makes the chip follow the
+ * picker immediately rather than only after the next message.
+ */
+export interface ModelSelectionProjection {
+    /** The last selection a request ran with. */
+    readonly lastUsed: ModelSelection | null;
+    /** The selection in force now. */
+    readonly next: ModelSelection | null;
+}
+/** The session's provider, from its model-selection projection. */
+export declare function providerOf(projection: ModelSelectionProjection | null | undefined): string | undefined;
+/** What one route's allowance reduces to for a single line. */
+export interface ChipReading {
+    /** Route the figures belong to. */
+    provider: string;
+    /** Name to show, as the route states it. */
+    label: string;
+    /** Every window that states a figure, in the order the route stated them. */
+    windows: readonly UsageWindow[];
+    /** The window worth showing in the compact line: the one closest to its limit. */
+    window: UsageWindow;
+    /** Plan name, when the provider stated one. */
+    plan?: string;
+}
+/** One currency's balance, as the host's account controller reports it. */
+export interface ChipBalance {
+    /** The wallet's currency. */
+    currency: string;
+    /** Remaining balance, as a decimal string. */
+    balance: string;
+    /** Whether this is a bonus / promotional wallet rather than topped-up credit. */
+    bonus: boolean;
+}
+/**
+ * Reduce the host's account-balance payload to the wallets the chip shows.
+ *
+ * Bonus wallets are shown after the topped-up ones, so a reader sees their own credit
+ * first and any promotional credit as a secondary figure.
+ *
+ * @param value - the host's ready balance, or undefined when there is none.
+ * @returns the wallets, topped-up first then bonus, or undefined when nothing is usable.
+ */
+export declare function balanceOf(value: {
+    value?: readonly {
+        currency: string;
+        balance: string;
+    }[];
+    bonusWallets?: readonly {
+        currency: string;
+        balance: string;
+    }[];
+} | {
+    status: string;
+} | null | undefined): readonly ChipBalance[] | undefined;
+/**
+ * Format one wallet for the chip's compact line.
+ *
+ * A balance is money, not a percentage, so it renders as `¥6.89` rather than a meter;
+ * the currency prefix keeps two currencies from being mistaken for one sum.
+ *
+ * @param wallet - the wallet to show.
+ * @returns the short form, e.g. `¥6.89` or `+¥2` for a bonus wallet.
+ */
+export declare function formatBalance(wallet: ChipBalance): string;
+/**
+ * The short form of a route's name.
+ *
+ * @param provider - the route id.
+ * @param label - the route's own display name.
+ * @returns an abbreviation that still identifies the route.
+ */
+export declare function shortLabel(provider: string, label: string): string;
+/**
+ * The short form of a window's name.
+ *
+ * @param label - the window's own name, e.g. `weekly`.
+ * @returns an abbreviation, or the label itself when it is already short.
+ */
+export declare function shortWindow(label: string): string;
+/**
+ * Pick the window a single line should show.
+ *
+ * A plan can meter several windows at once (a rolling five-hour one and a weekly one).
+ * The most constrained is the one that will stop work soonest, so it earns the space;
+ * ties fall to the earlier window, which is the order the providers state them in.
+ *
+ * @param windows - the route's metered windows.
+ * @returns the window to show, or undefined when none states a figure.
+ */
+export declare function pickWindow(windows: readonly UsageWindow[]): UsageWindow | undefined;
+/**
+ * Reduce one route's usage to what the chip renders.
+ *
+ * @param provider - the route the figures came from.
+ * @param label - the route's display name.
+ * @param usage - the accounts the route answered for.
+ * @returns the reading, or undefined when the route stated no figure.
+ */
+export declare function readingOf(provider: string, label: string, usage: readonly ProviderUsage[]): ChipReading | undefined;
+/**
+ * Format a window's reset the way the settings cards do.
+ *
+ * The rule is shared with the cards on purpose: a figure reading `6d20h` here and
+ * something else there would be two answers to one question.
+ *
+ * @param at - epoch milliseconds, or undefined when the provider states none.
+ * @param now - the instant to measure from.
+ * @returns a short phrase, or undefined when there is no reset to show.
+ */
+export declare function formatReset(at: number | undefined, now: number): string | undefined;
+/**
+ * The composer's usage chip.
+ *
+ * @param props - injected RPC caller, copy, and the session's provider reader.
+ * @returns the chip, or null when there is nothing true to say.
+ */
+export declare function UsageChip({ call, t, isOwnProvider, accountBalance, ccSwitchBalance, ccSwitchCredentialRef, useProjection }: UsageChipInjected & SessionStandardProps): ReactNode;