dsh-plugin-subscription-oauth 0.13.0 → 0.16.0

package/lib/protocol.d.ts

@@ -12,7 +12,7 @@
 /** Prefix of every RPC method this plugin serves. */
 export declare const RPC_PREFIX = "subscription-oauth.";
 /** Endpoints the Settings page may call. */
-export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload", "auto-state", "setAutoOn", "deepseek-balance", "ccswitch-balance", "model-variants"];
+export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload", "auto-state", "setAutoOn", "checkin", "tasks", "deepseek-balance", "ccswitch-balance", "model-variants"];
 /** One endpoint name. */
 export type RpcEndpoint = typeof RPC_ENDPOINTS[number];
 /** Client → host envelope. */
@@ -146,6 +146,13 @@ export interface ProviderUsage {
     renewsAt?: number;
     /** Metered allowances, most relevant first. */
     windows: readonly UsageWindow[];
+    /** Daily check-in state, when the provider states one. */
+    checkin?: {
+        active: boolean;
+        todayCheckedIn: boolean;
+        streakDays: number;
+        todayCredit: number;
+    };
     /** Epoch milliseconds these figures were read. */
     fetchedAt: number;
     /**
@@ -323,6 +330,14 @@ export interface RpcMap {
         payload: SetAutoOnRequest;
         value: AutoStateResult;
     };
+    checkin: {
+        payload: CheckinRequest;
+        value: CheckinResult;
+    };
+    tasks: {
+        payload: TasksRequest;
+        value: TasksResult;
+    };
     'deepseek-balance': {
         payload: DeepSeekBalanceRequest;
         value: DeepSeekBalanceResult;
@@ -398,6 +413,40 @@ export interface SetAutoOnRequest {
 export interface AutoStateResult {
     enabled: boolean;
 }
+/** Payload of `checkin`: which account claims today's reward. */
+export interface CheckinRequest {
+    provider: string;
+    account: string;
+}
+/** Result of `checkin`: the credit granted and the streak after claiming. */
+export interface CheckinResult {
+    credit: number;
+    streakDays: number;
+    already: boolean;
+}
+/** Payload of `tasks`: which account to read and auto-claim. */
+export interface TasksRequest {
+    provider: string;
+    account: string;
+    /** Claim every claimable reward; false only lists. */
+    claim?: boolean;
+}
+/** One task's state for the card. */
+export interface WorkBuddyTaskState {
+    taskCode: string;
+    title: string;
+    credit: number;
+    target: number;
+    current: number;
+    state: 'pending' | 'claimable' | 'claimed' | 'locked';
+}
+/** Result of `tasks`: the task list and what auto-claiming earned. */
+export interface TasksResult {
+    tasks: WorkBuddyTaskState[];
+    claimed: number;
+    claimable: number;
+    creditEarned: number;
+}
 /** Payload of `deepseek-balance`. */
 export interface DeepSeekBalanceRequest {
     /** Client metadata the host's account service expects. */

package/lib/protocol.js

@@ -28,6 +28,8 @@ export const RPC_ENDPOINTS = [
     'reload',
     'auto-state',
     'setAutoOn',
+    'checkin',
+    'tasks',
     'deepseek-balance',
     'ccswitch-balance',
     'model-variants',

package/lib/providers/workbuddy-credits.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Per-account credit spend tracking for the WorkBuddy route.
+ *
+ * The gateway states the real billed figure for a turn — `usage.credit` on the last
+ * usage frame of the stream — so the spent total is a sum of those, never an estimate
+ * from tokens and a rate. Spends accumulate per account in a small JSON file beside the
+ * credentials, and fold with the live packages' remaining allowance into one precise
+ * spent-against-limit window.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/workbuddy-credits
+ */
+/** One account's accumulated spend. */
+interface AccountSpend {
+    spent: number;
+    calls: number;
+}
+/** The spend ledger, keyed by account id. */
+export type SpendLedger = Record<string, AccountSpend>;
+/** Read the ledger, tolerating a missing or corrupt file. */
+export declare function readSpendLedger(file: string): Promise<SpendLedger>;
+/** Add one turn's billed credit to an account's spend, returning the new totals. */
+export declare function recordSpend(file: string, account: string, credit: number): Promise<AccountSpend>;
+export {};

package/lib/providers/workbuddy-credits.js

@@ -0,0 +1,52 @@
+/**
+ * Per-account credit spend tracking for the WorkBuddy route.
+ *
+ * The gateway states the real billed figure for a turn — `usage.credit` on the last
+ * usage frame of the stream — so the spent total is a sum of those, never an estimate
+ * from tokens and a rate. Spends accumulate per account in a small JSON file beside the
+ * credentials, and fold with the live packages' remaining allowance into one precise
+ * spent-against-limit window.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/workbuddy-credits
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+/** Read the ledger, tolerating a missing or corrupt file. */
+export async function readSpendLedger(file) {
+    try {
+        const raw = JSON.parse(await readFile(file, 'utf8'));
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (typeof value !== 'object' || value === null)
+                continue;
+            const record = value;
+            const spent = typeof record.spent === 'number' && Number.isFinite(record.spent) ? record.spent : 0;
+            const calls = typeof record.calls === 'number' && Number.isFinite(record.calls) ? record.calls : 0;
+            out[key] = { spent: Math.max(0, spent), calls: Math.max(0, calls) };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** Add one turn's billed credit to an account's spend, returning the new totals. */
+export async function recordSpend(file, account, credit) {
+    const ledger = await readSpendLedger(file);
+    const previous = ledger[account] ?? { spent: 0, calls: 0 };
+    const next = {
+        spent: Math.round((previous.spent + Math.max(0, credit)) * 10000) / 10000,
+        calls: previous.calls + 1,
+    };
+    ledger[account] = next;
+    try {
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(ledger, null, 2), 'utf8');
+    }
+    catch {
+        // A failed write keeps the in-memory figure; the next turn retries.
+    }
+    return next;
+}

package/lib/providers/workbuddy-provider.js

@@ -8,7 +8,9 @@ import { REAUTH_REQUIRED, ProviderError } from '../errors.js';
 import { TokenStore } from '../auth/store.js';
 import { TokenManager } from '../auth/tokens.js';
 import { LOGIN_CANCELLED_MESSAGE } from '../auth/device-flow.js';
-import { finishWorkBuddySignIn, parseWorkBuddySession, readWorkBuddyUsage, refreshWorkBuddyToken, startWorkBuddySignIn, workbuddyRefreshable, workbuddyStale, WORKBUDDY_EARLY_MS, } from '../auth/workbuddy-flow.js';
+import path from 'node:path';
+import { readSpendLedger } from './workbuddy-credits.js';
+import { finishWorkBuddySignIn, parseWorkBuddySession, readWorkBuddyUsage, refreshWorkBuddyToken, startWorkBuddySignIn, workbuddyRefreshable, workbuddyStale, claimWorkBuddyCheckin, listWorkBuddyTasks, acceptWorkBuddyTasks, claimWorkBuddyTask, WORKBUDDY_EARLY_MS, } from '../auth/workbuddy-flow.js';
 import { WorkBuddyAdapter, WORKBUDDY_CODE_URL, WORKBUDDY_CATALOG, WORKBUDDY_DEFAULT_MODEL, WORKBUDDY_PROVIDER_ID, WORKBUDDY_PROVIDER_NAME, } from './workbuddy.js';
 import { ProviderController } from '../auth/provider-controller.js';
 import { proxiedFetch } from '../http.js';
@@ -129,9 +131,11 @@ export function createWorkBuddyProvider(options) {
             }
         },
     });
+    const spendFile = path.join(path.dirname(options.credentialFile), 'workbuddy-spend.json');
     const adapter = new WorkBuddyAdapter({
         streamIdleTimeoutMs: options.streamIdleTimeoutMs,
         tokens,
+        spendFile,
         ...options.onWarn === undefined ? {} : { onWarn: options.onWarn },
         hiddenModels: () => options.preferences.hiddenIds(WORKBUDDY_PROVIDER_ID),
         userModels: () => options.preferences.extraIds(WORKBUDDY_PROVIDER_ID),
@@ -164,8 +168,10 @@ export function createWorkBuddyProvider(options) {
             const held = await store.get(account);
             if (held === undefined)
                 return undefined;
-            const read = await readWorkBuddyUsage(tokenOf(held), held.accountId, fetchFn);
-            return { plan: read.plan, windows: read.windows };
+            const ledger = await readSpendLedger(spendFile);
+            const spend = ledger[account];
+            const read = await readWorkBuddyUsage(tokenOf(held), held.accountId, fetchFn, spend === undefined ? undefined : { spent: spend.spent });
+            return { plan: read.plan, windows: read.windows, ...read.checkin === undefined ? {} : { checkin: read.checkin } };
         },
         details: () => [
             { key: 'provider', value: WORKBUDDY_PROVIDER_NAME },
@@ -201,5 +207,66 @@ export function createWorkBuddyProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
+        checkin: async (account) => {
+            const held = await store.get(account);
+            if (held === undefined)
+                throw new ProviderError('WorkBuddy account not signed in', REAUTH_REQUIRED);
+            try {
+                const claim = await claimWorkBuddyCheckin(tokenOf(held), fetchFn);
+                return { credit: claim.credit, streakDays: claim.streakDays, already: claim.credit === 0 };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                // An already-claimed check-in is a normal answer, not a failure.
+                if (/already|已签到/i.test(message))
+                    return { credit: 0, streakDays: 0, already: true };
+                throw new ProviderError(`WorkBuddy check-in failed: ${message}`, REAUTH_REQUIRED);
+            }
+        },
+        tasks: async (account, claim) => {
+            const held = await store.get(account);
+            if (held === undefined)
+                throw new ProviderError('WorkBuddy account not signed in', REAUTH_REQUIRED);
+            const token = tokenOf(held);
+            // Enrol in every open task first: accepting is the sign-up half, and replaying it is
+            // a safe no-op, so progress a chat or an activity report lights is never missed.
+            const tasks = await listWorkBuddyTasks(token, fetchFn);
+            const open = tasks.filter((task) => !task.claimed && !task.locked && task.acceptStatus !== 'claimed').map((task) => task.taskCode);
+            try {
+                await acceptWorkBuddyTasks(token, open, fetchFn);
+            }
+            catch {
+                // Accepting is best-effort; a failure here does not block reading or claiming.
+            }
+            const fresh = await listWorkBuddyTasks(token, fetchFn);
+            let creditEarned = 0;
+            let claimedCount = 0;
+            if (claim) {
+                for (const task of fresh.filter((entry) => entry.claimable && !entry.locked)) {
+                    try {
+                        const reward = await claimWorkBuddyTask(token, task.taskCode, fetchFn);
+                        creditEarned += reward.credit;
+                        claimedCount += 1;
+                    }
+                    catch {
+                        // One task's refusal does not stop the others.
+                    }
+                }
+            }
+            const stateOf = (task) => task.claimed ? 'claimed' : task.locked ? 'locked' : task.claimable ? 'claimable' : 'pending';
+            return {
+                tasks: fresh.map((task) => ({
+                    taskCode: task.taskCode,
+                    title: task.title,
+                    credit: task.credit,
+                    target: task.target,
+                    current: task.current,
+                    state: stateOf(task),
+                })),
+                claimed: claimedCount,
+                claimable: fresh.filter((task) => task.claimable && !task.locked).length,
+                creditEarned,
+            };
+        },
     };
 }

package/lib/providers/workbuddy.d.ts

@@ -43,6 +43,8 @@ export interface WorkBuddyAdapterOptions {
     onWarn?: (message: string) => void;
     hiddenModels?: () => Promise<ReadonlySet<string>>;
     userModels?: () => Promise<readonly string[]>;
+    /** Where per-account credit spends accumulate; beside the credential file. */
+    spendFile?: string;
     fetchFn?: FetchFn;
 }
 /** The WorkBuddy China wire adapter serving the `workbuddy` route. */
@@ -60,6 +62,8 @@ export declare class WorkBuddyAdapter extends LlmAdapter {
     resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;
     providerRetryPolicy(): undefined;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** The current turn's billed credit, read off the last usage frame. */
+    private turnCredit;
     /** The stored session's fields as the token the request signs with. */
     private tokenOf;
     private requestBody;

package/lib/providers/workbuddy.js

@@ -13,6 +13,7 @@ import { idleWatchdog, mapFetchFailure } from './common.js';
 import { proxiedFetch } from '../http.js';
 import { findEntry } from './catalog.js';
 import { WORKBUDDY_ENDPOINT, WORKBUDDY_UA_VERSION, workbuddyHeaders } from '../auth/workbuddy-flow.js';
+import { recordSpend } from './workbuddy-credits.js';
 /** The `workbuddy` provider route key (China build). */
 export const WORKBUDDY_PROVIDER_ID = 'workbuddy';
 /** Human name for the route and its cards. */
@@ -277,6 +278,9 @@ export class WorkBuddyAdapter extends LlmAdapter {
         // Capture the tool-call history so unsafe tool names in past turns can be renamed to
         // the safe ones the model now sees, keeping the conversation consistent.
         this.historyMessages = options.messages.filter((message) => message.role === 'assistant' || message.role === 'tool');
+        // The last usage frame carries the turn's real billed credit; record it so the spend
+        // total is a sum of real figures, not an estimate.
+        this.turnCredit = 0;
         try {
             const body = this.requestBody(options);
             const response = await this.fetchFn(WORKBUDDY_API, {
@@ -308,8 +312,13 @@ export class WorkBuddyAdapter extends LlmAdapter {
         }
         finally {
             watchdog.stop();
+            if (this.turnCredit > 0 && this.options.spendFile !== undefined) {
+                void recordSpend(this.options.spendFile, held.account, this.turnCredit).catch(() => { });
+            }
         }
     }
+    /** The current turn's billed credit, read off the last usage frame. */
+    turnCredit = 0;
     /** The stored session's fields as the token the request signs with. */
     tokenOf(session) {
         return {
@@ -564,6 +573,11 @@ export class WorkBuddyAdapter extends LlmAdapter {
                     if (usage !== undefined && usage !== null) {
                         const input = usage.prompt_tokens ?? 0;
                         const output = usage.completion_tokens ?? 0;
+                        // The last usage frame carries the real billed credit; keep the latest, so a
+                        // mid-stream retry does not double-count.
+                        if (typeof usage.credit === 'number' && Number.isFinite(usage.credit)) {
+                            this.turnCredit = usage.credit;
+                        }
                         yield {
                             type: 'usage',
                             usage: { inputTokens: input, outputTokens: output, totalTokens: usage.total_tokens ?? input + output },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.13.0",
+  "version": "0.16.0",
   "description": "Use subscription accounts as DeepSeek Harness LLM providers — Kimi Code (OAuth device flow), Grok / X Premium (OIDC + PKCE), Google Antigravity (Google OAuth + Cloud Code Assist) and GLM / BigModel (ZCode's browser sign-in) — with per-model visibility, drag-to-reorder Auto fallback and plan quotas from the web Settings page",
   "license": "MIT",
   "author": "EricFL1998",