cc-usage-bar 0.1.0

package/dist/src/fetch.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStdinJson = readStdinJson;
+exports.extractFromStdin = extractFromStdin;
+exports.run = run;
+exports.main = main;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const render_1 = require("./render");
+const registry_1 = require("./providers/registry");
+const format_1 = require("./format");
+const CACHE_PATH = path.join(os.tmpdir(), 'cc-oauth-usage.json');
+const SUCCESS_TTL_MS = 30_000;
+const AUTH_FAIL_TTL_MS = 60_000;
+const STDIN_TIMEOUT_MS = 500;
+async function readStdinJson(timeoutMs = STDIN_TIMEOUT_MS) {
+    if (process.stdin.isTTY)
+        return null;
+    return new Promise((resolve) => {
+        const chunks = [];
+        let resolved = false;
+        const finish = (val) => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve(val);
+        };
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        process.stdin.on('data', (c) => {
+            chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(c));
+        });
+        process.stdin.on('end', () => {
+            clearTimeout(timer);
+            const raw = Buffer.concat(chunks).toString('utf8').trim();
+            if (!raw)
+                return finish(null);
+            try {
+                finish(JSON.parse(raw));
+            }
+            catch {
+                finish(null);
+            }
+        });
+        process.stdin.on('error', () => {
+            clearTimeout(timer);
+            finish(null);
+        });
+    });
+}
+function normalizeStdinTier(t) {
+    if (!t || typeof t !== 'object')
+        return null;
+    const obj = t;
+    const pct = obj.used_percentage;
+    if (typeof pct !== 'number' || !Number.isFinite(pct))
+        return null;
+    const out = { utilization: pct };
+    const r = obj.resets_at;
+    if (typeof r === 'number' && Number.isFinite(r)) {
+        out.resets_at = new Date(r * 1000).toISOString();
+    }
+    else if (typeof r === 'string' && r) {
+        out.resets_at = r;
+    }
+    return out;
+}
+function extractFromStdin(json) {
+    if (!json || typeof json !== 'object')
+        return null;
+    const rl = json.rate_limits;
+    if (!rl || typeof rl !== 'object')
+        return null;
+    const obj = rl;
+    const result = {};
+    const fh = normalizeStdinTier(obj.five_hour);
+    if (fh)
+        result.five_hour = fh;
+    const sd = normalizeStdinTier(obj.seven_day);
+    if (sd)
+        result.seven_day = sd;
+    return Object.keys(result).length > 0 ? result : null;
+}
+function stdinAsSubscription(d) {
+    if (!d)
+        return null;
+    const out = { kind: 'subscription' };
+    if (typeof d.five_hour?.utilization === 'number') {
+        out.five_hour = { utilization: d.five_hour.utilization, resets_at: d.five_hour.resets_at };
+    }
+    if (typeof d.seven_day?.utilization === 'number') {
+        out.seven_day = { utilization: d.seven_day.utilization, resets_at: d.seven_day.resets_at };
+    }
+    return out;
+}
+function readCache() {
+    try {
+        const raw = fs.readFileSync(CACHE_PATH, 'utf8');
+        const p = JSON.parse(raw);
+        if (typeof p.fetched_at !== 'number' || !p.status || !p.adapter_id)
+            return null;
+        return p;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(entry) {
+    try {
+        fs.writeFileSync(CACHE_PATH, JSON.stringify(entry));
+    }
+    catch {
+    }
+}
+function isCacheFresh(entry) {
+    const age = Date.now() - entry.fetched_at;
+    if (entry.status === 'ok')
+        return age >= 0 && age < SUCCESS_TTL_MS;
+    if (entry.status === 'auth_failed')
+        return age >= 0 && age < AUTH_FAIL_TTL_MS;
+    return false;
+}
+async function run(opts = {}) {
+    if (!opts.skipStdin) {
+        const stdinJson = await readStdinJson();
+        const fromStdin = stdinAsSubscription(extractFromStdin(stdinJson));
+        if (fromStdin) {
+            return {
+                data: fromStdin,
+                source: 'stdin',
+                adapterId: 'anthropic',
+                cacheStatus: 'skipped',
+                authFailed: false,
+            };
+        }
+    }
+    const env = (0, registry_1.getEnv)();
+    const adapter = (0, registry_1.selectAdapter)(env);
+    if (!adapter) {
+        return {
+            data: null,
+            source: 'none',
+            adapterId: null,
+            cacheStatus: 'miss',
+            authFailed: false,
+            error: `unsupported provider for ${env.baseUrl ?? '<no base url>'}`,
+        };
+    }
+    const cache = opts.forceFresh ? null : readCache();
+    if (cache && cache.adapter_id === adapter.id && isCacheFresh(cache)) {
+        return {
+            data: cache.data,
+            source: 'cache',
+            adapterId: adapter.id,
+            cacheStatus: cache.status === 'auth_failed' ? 'auth_failed_cached' : 'hit',
+            authFailed: cache.status === 'auth_failed',
+        };
+    }
+    const cacheStatusOnMiss = cache && cache.adapter_id !== adapter.id ? 'adapter_changed' : cache ? 'expired' : 'miss';
+    const result = await adapter.fetch(env);
+    if (result.ok && result.data) {
+        writeCache({ fetched_at: Date.now(), status: 'ok', adapter_id: adapter.id, data: result.data });
+        return {
+            data: result.data,
+            source: 'api',
+            adapterId: adapter.id,
+            cacheStatus: cacheStatusOnMiss,
+            authFailed: false,
+        };
+    }
+    if (result.authFailed) {
+        writeCache({ fetched_at: Date.now(), status: 'auth_failed', adapter_id: adapter.id, data: null });
+        return {
+            data: null,
+            source: 'api',
+            adapterId: adapter.id,
+            cacheStatus: cacheStatusOnMiss,
+            authFailed: true,
+            error: result.error,
+        };
+    }
+    return {
+        data: null,
+        source: 'api',
+        adapterId: adapter.id,
+        cacheStatus: cacheStatusOnMiss,
+        authFailed: false,
+        error: result.error,
+    };
+}
+function parseArg(args, name) {
+    const eq = args.find((a) => a.startsWith(`--${name}=`));
+    if (eq)
+        return eq.slice(name.length + 3);
+    const idx = args.indexOf(`--${name}`);
+    if (idx >= 0 && idx + 1 < args.length)
+        return args[idx + 1];
+    return undefined;
+}
+const HELP = `cc-usage-fetch — emit one statusline string from Claude Code subscription data.
+
+Usage: cc-usage-fetch [options]
+
+Output:
+  --json                Emit raw JSON (data + meta) instead of rendered string
+  --plain               Drop ANSI colors
+  --no-stdin            Skip reading rate_limits from stdin (force live query)
+
+Format:
+  --format=<preset>     ${format_1.FORMAT_PRESETS.join(' | ')}   (default: compact)
+  --bar-width=<N>       Bar width for bar / bar-time presets (default: 10)
+  --bar-spec=<json>     Custom bar JSON: cells, tint, or frames
+
+Custom template (env, overrides --format):
+  CC_USAGE_TEMPLATE     e.g. '{label} {percent}% ({expiry})'
+                        placeholders: {label} {percent} {bar} {expiry} {provider} {amount}
+  CC_USAGE_BAR_SPEC     Same JSON shape as --bar-spec
+
+Presets render like:
+  compact    5h 47% Wk 59%
+  numeric    47% / 59%
+  time       47% until 18:23 / 59% until 5/12 09:00
+  bar        [█████░░░░░] 47% / [██████░░░░] 59%
+  bar-time   [█████░░░░░] 47% until 18:23 / [██████░░░░] 59% until 5/12 09:00
+
+Other:
+  NO_COLOR=1            Force-disable colors
+  --help                Show this message
+`;
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('--help') || args.includes('-h')) {
+        process.stdout.write(HELP);
+        return;
+    }
+    const wantJson = args.includes('--json');
+    const wantPlain = args.includes('--plain');
+    const skipStdin = args.includes('--no-stdin');
+    const formatArg = parseArg(args, 'format');
+    const barWidthArg = parseArg(args, 'bar-width');
+    const barSpecArg = parseArg(args, 'bar-spec');
+    const templateEnv = process.env.CC_USAGE_TEMPLATE;
+    const barSpecEnv = process.env.CC_USAGE_BAR_SPEC;
+    const fmt = { ...format_1.DEFAULT_FORMAT };
+    if (formatArg && (0, format_1.isValidPreset)(formatArg))
+        fmt.format = formatArg;
+    if (barWidthArg) {
+        const n = parseInt(barWidthArg, 10);
+        if (Number.isFinite(n) && n > 0 && n <= 50)
+            fmt.barWidth = n;
+    }
+    if (templateEnv)
+        fmt.template = templateEnv;
+    const barSpec = (0, format_1.parseBarSpec)(barSpecArg ?? barSpecEnv);
+    if (barSpec)
+        fmt.barSpec = barSpec;
+    const result = await run({ skipStdin });
+    if (wantJson) {
+        process.stdout.write(JSON.stringify({
+            data: result.data,
+            source: result.source,
+            adapterId: result.adapterId,
+            cacheStatus: result.cacheStatus,
+            authFailed: result.authFailed,
+            error: result.error ?? null,
+        }, null, 2) + '\n');
+        return;
+    }
+    fmt.color = !wantPlain && (0, render_1.shouldUseColor)();
+    fmt.showProviderName = result.adapterId !== null && result.adapterId !== 'anthropic';
+    const out = (0, render_1.renderNormalized)(result.data, fmt);
+    if (out)
+        process.stdout.write(out);
+}

package/dist/src/format.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FORMAT = exports.FORMAT_PRESETS = void 0;
+exports.formatExpiry = formatExpiry;
+exports.parseBarSpec = parseBarSpec;
+exports.formatBar = formatBar;
+exports.renderSubscription = renderSubscription;
+exports.renderBalance = renderBalance;
+exports.renderUsage = renderUsage;
+exports.isValidPreset = isValidPreset;
+exports.shouldUseColor = shouldUseColor;
+exports.FORMAT_PRESETS = ['compact', 'numeric', 'time', 'bar', 'bar-time'];
+exports.DEFAULT_FORMAT = {
+    format: 'compact',
+    barWidth: 10,
+    color: true,
+    showProviderName: true,
+};
+const SUB_PRESET_TPL = {
+    compact: '{label} {percent}%',
+    numeric: '{percent}%',
+    time: '{percent}% until {expiry}',
+    bar: '[{bar}] {percent}%',
+    'bar-time': '[{bar}] {percent}% until {expiry}',
+};
+const BAL_PRESET_TPL = {
+    compact: '{amount}',
+    numeric: '{amount}',
+    time: '{amount}',
+    bar: '[{bar}] {amount}',
+    'bar-time': '[{bar}] {amount}',
+};
+const ANSI = {
+    reset: '\x1b[0m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    boldRed: '\x1b[1;31m',
+};
+const pad2 = (n) => n.toString().padStart(2, '0');
+function formatExpiry(iso, now = new Date()) {
+    if (!iso)
+        return '?';
+    const target = new Date(iso);
+    if (Number.isNaN(target.getTime()))
+        return '?';
+    const sameDay = target.getFullYear() === now.getFullYear() &&
+        target.getMonth() === now.getMonth() &&
+        target.getDate() === now.getDate();
+    if (sameDay)
+        return `${pad2(target.getHours())}:${pad2(target.getMinutes())}`;
+    const diffMs = target.getTime() - now.getTime();
+    const diffDays = Math.floor(diffMs / 86_400_000);
+    if (diffDays >= 0 && diffDays < 7) {
+        return `${target.getMonth() + 1}/${target.getDate()} ${pad2(target.getHours())}:${pad2(target.getMinutes())}`;
+    }
+    return `${target.getFullYear()}-${pad2(target.getMonth() + 1)}-${pad2(target.getDate())}`;
+}
+function isNonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0;
+}
+function parseBarSpec(raw) {
+    if (!raw)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return null;
+    const obj = parsed;
+    if (obj.mode === 'cells') {
+        if (!isNonEmptyString(obj.filled) || !isNonEmptyString(obj.empty))
+            return null;
+        const out = { mode: 'cells', filled: obj.filled, empty: obj.empty };
+        if (typeof obj.width === 'number' && Number.isFinite(obj.width) && obj.width >= 1 && obj.width <= 50) {
+            out.width = Math.floor(obj.width);
+        }
+        return out;
+    }
+    if (obj.mode === 'tint') {
+        if (!isNonEmptyString(obj.text))
+            return null;
+        const out = { mode: 'tint', text: obj.text };
+        if (obj.emptyStyle === 'plain' || obj.emptyStyle === 'dim')
+            out.emptyStyle = obj.emptyStyle;
+        return out;
+    }
+    if (obj.mode === 'frames') {
+        if (!Array.isArray(obj.frames))
+            return null;
+        const frames = obj.frames.filter(isNonEmptyString);
+        if (frames.length < 2)
+            return null;
+        return { mode: 'frames', frames };
+    }
+    return null;
+}
+function splitText(s) {
+    return Array.from(s);
+}
+function formatBar(pct, width = 10, spec, activeColor = null, useColor = false) {
+    const clamped = Math.max(0, Math.min(100, pct));
+    if (spec?.mode === 'cells') {
+        const specWidth = spec.width ?? width;
+        const filled = Math.round((clamped / 100) * specWidth);
+        return spec.filled.repeat(filled) + spec.empty.repeat(Math.max(0, specWidth - filled));
+    }
+    if (spec?.mode === 'tint') {
+        const chars = splitText(spec.text);
+        const filled = Math.round((clamped / 100) * chars.length);
+        const active = chars.slice(0, filled).join('');
+        const inactive = chars.slice(filled).join('');
+        if (!useColor)
+            return active + inactive;
+        const activePart = activeColor && active ? paint(active, activeColor, true) : active;
+        const inactivePart = inactive && spec.emptyStyle !== 'plain' ? paint(inactive, ANSI.dim, true) : inactive;
+        return activePart + inactivePart;
+    }
+    if (spec?.mode === 'frames') {
+        const idx = Math.min(spec.frames.length - 1, Math.floor((clamped / 100) * spec.frames.length));
+        return spec.frames[idx];
+    }
+    const filled = Math.round((clamped / 100) * width);
+    return '█'.repeat(filled) + '░'.repeat(Math.max(0, width - filled));
+}
+function fiveHourColor(util) {
+    if (util < 60)
+        return ANSI.green;
+    if (util < 85)
+        return ANSI.yellow;
+    return ANSI.red;
+}
+function weekColor(util) {
+    return util >= 80 ? ANSI.boldRed : null;
+}
+function paint(text, color, useColor) {
+    if (!useColor || !color)
+        return text;
+    return `${color}${text}${ANSI.reset}`;
+}
+function applyTemplate(tpl, vars) {
+    return tpl.replace(/\{(\w+)\}/g, (_, k) => (k in vars ? vars[k] : `{${k}}`));
+}
+function renderTier(ctx, opts) {
+    const pct = Math.round(ctx.tier.utilization);
+    const tpl = opts.template ?? SUB_PRESET_TPL[opts.format];
+    const color = ctx.label === '5h' ? fiveHourColor(pct) : weekColor(pct);
+    const text = applyTemplate(tpl, {
+        label: ctx.label,
+        percent: String(pct),
+        bar: formatBar(pct, opts.barWidth, opts.barSpec, color, opts.color),
+        expiry: formatExpiry(ctx.tier.resets_at, opts.now),
+        provider: ctx.provider,
+    });
+    if (opts.barSpec?.mode === 'tint' && opts.color && tpl.includes('{bar}'))
+        return text;
+    return paint(text, color, opts.color);
+}
+function currencySymbol(unit) {
+    switch (unit.toUpperCase()) {
+        case 'CNY':
+        case 'RMB':
+            return '¥';
+        case 'USD':
+            return '$';
+        default:
+            return '';
+    }
+}
+function fmtMoney(n, unit) {
+    const sym = currencySymbol(unit);
+    return sym ? `${sym}${n.toFixed(2)}` : `${n.toFixed(2)} ${unit}`;
+}
+function renderSubscription(d, opts) {
+    const provider = d.planName ?? '';
+    const parts = [];
+    if (d.five_hour)
+        parts.push(renderTier({ tier: d.five_hour, label: '5h', provider }, opts));
+    if (d.seven_day)
+        parts.push(renderTier({ tier: d.seven_day, label: 'Wk', provider }, opts));
+    if (parts.length === 0)
+        return '';
+    const sep = opts.format === 'compact' && !opts.template ? ' ' : ' / ';
+    const body = parts.join(sep);
+    return opts.showProviderName && d.planName ? `${d.planName} ${body}` : body;
+}
+function renderBalance(d, opts) {
+    if (d.isValid === false && d.invalidMessage) {
+        const msg = paint(d.invalidMessage, ANSI.red, opts.color);
+        return opts.showProviderName && d.planName ? `${d.planName} ${msg}` : msg;
+    }
+    const amount = typeof d.total === 'number'
+        ? `${fmtMoney(d.remaining, d.unit)}/${fmtMoney(d.total, d.unit)}`
+        : fmtMoney(d.remaining, d.unit);
+    const usedPct = typeof d.total === 'number' && d.total > 0
+        ? ((d.total - d.remaining) / d.total) * 100
+        : 0;
+    const tpl = opts.template ?? BAL_PRESET_TPL[opts.format];
+    const color = typeof d.total === 'number' ? fiveHourColor(usedPct) : null;
+    const text = applyTemplate(tpl, {
+        label: '',
+        percent: String(Math.round(usedPct)),
+        bar: typeof d.total === 'number' ? formatBar(usedPct, opts.barWidth, opts.barSpec, color, opts.color) : '',
+        expiry: '',
+        provider: d.planName ?? '',
+        amount,
+    });
+    if (opts.barSpec?.mode === 'tint' && opts.color && tpl.includes('{bar}')) {
+        return opts.showProviderName && d.planName ? `${d.planName} ${text}` : text;
+    }
+    const colored = paint(text, color, opts.color);
+    return opts.showProviderName && d.planName ? `${d.planName} ${colored}` : colored;
+}
+function renderUsage(data, opts) {
+    if (!data)
+        return '';
+    return data.kind === 'subscription' ? renderSubscription(data, opts) : renderBalance(data, opts);
+}
+function isValidPreset(s) {
+    return exports.FORMAT_PRESETS.includes(s);
+}
+function shouldUseColor() {
+    return !process.env.NO_COLOR;
+}

package/dist/src/providers/anthropic.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anthropicAdapter = void 0;
+exports.parseAnthropic = parseAnthropic;
+const token_1 = require("../token");
+const http_1 = require("./http");
+const ENDPOINT = 'https://api.anthropic.com/api/oauth/usage';
+const BETA = 'oauth-2025-04-20';
+function parseAnthropic(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const out = { kind: 'subscription' };
+    if (typeof r.five_hour?.utilization === 'number') {
+        out.five_hour = {
+            utilization: r.five_hour.utilization,
+            resets_at: typeof r.five_hour.resets_at === 'string' ? r.five_hour.resets_at : undefined,
+        };
+    }
+    if (typeof r.seven_day?.utilization === 'number') {
+        out.seven_day = {
+            utilization: r.seven_day.utilization,
+            resets_at: typeof r.seven_day.resets_at === 'string' ? r.seven_day.resets_at : undefined,
+        };
+    }
+    if (!out.five_hour && !out.seven_day)
+        return null;
+    return out;
+}
+exports.anthropicAdapter = {
+    id: 'anthropic',
+    displayName: 'Anthropic',
+    matches(env) {
+        if (!env.baseUrl)
+            return true;
+        return env.baseUrl.toLowerCase().includes('anthropic.com');
+    },
+    async fetch() {
+        const tk = (0, token_1.getToken)();
+        if (!tk.token)
+            return { ok: false, error: tk.error };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, {
+            Authorization: `Bearer ${tk.token}`,
+            'anthropic-beta': BETA,
+        });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseAnthropic(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};

package/dist/src/providers/deepseek.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepseekAdapter = void 0;
+exports.parseDeepSeek = parseDeepSeek;
+const http_1 = require("./http");
+const ENDPOINT = 'https://api.deepseek.com/user/balance';
+function toNum(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string') {
+        const n = parseFloat(v);
+        return Number.isFinite(n) ? n : null;
+    }
+    return null;
+}
+function parseDeepSeek(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const r = body;
+    const infos = r.balance_infos;
+    if (!Array.isArray(infos) || infos.length === 0)
+        return null;
+    const pick = infos.find((i) => i?.currency === 'CNY') ?? infos[0];
+    const balance = toNum(pick?.total_balance);
+    if (balance === null)
+        return null;
+    const unit = typeof pick?.currency === 'string' ? pick.currency : 'CNY';
+    return {
+        kind: 'balance',
+        remaining: balance,
+        unit,
+        planName: 'DeepSeek',
+        isValid: r.is_available !== false,
+    };
+}
+exports.deepseekAdapter = {
+    id: 'deepseek',
+    displayName: 'DeepSeek',
+    matches(env) {
+        return !!env.baseUrl && env.baseUrl.toLowerCase().includes('api.deepseek.com');
+    },
+    async fetch(env) {
+        if (!env.authToken)
+            return { ok: false, error: 'ANTHROPIC_AUTH_TOKEN not set' };
+        const res = await (0, http_1.httpGetJson)(ENDPOINT, { Authorization: `Bearer ${env.authToken}` });
+        if (res.authFailed)
+            return { ok: false, authFailed: true, error: res.error };
+        if (!res.ok || !res.body)
+            return { ok: false, error: res.error ?? 'request failed' };
+        const data = parseDeepSeek(res.body);
+        if (!data)
+            return { ok: false, error: 'invalid response shape' };
+        return { ok: true, data };
+    },
+};