subrouter-cli 0.0.0-stage → 0.1.0

package/test/usage-footer.test.ts

@@ -0,0 +1,180 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { providerUsage, usageLimits, modelUsage, fetchUsage } from '../src/usage.ts';
+
+describe('account limits and selected-provider report', () => {
+  it('labels shared quotas separately and preserves zero and unlimited', () => {
+    assert.equal(usageLimits({ user: {
+      rpm_limit: 60, today_tokens: 1000, daily_token_limit: 1000000,
+      week_usd: 1.5, weekly_usd_limit: 10,
+    } }), 'account: 60 rpm · day 1K/1M tokens · week $1.5/$10');
+    assert.equal(usageLimits({ quotas: {
+      rpm_limit: 0, today_tokens: 0, daily_token_limit: null, week_usd: 0, weekly_usd_limit: null,
+    } }), 'account: 0 rpm · day 0/unlimited tokens · week $0/unlimited');
+  });
+
+  it('keeps large account totals compact and reports each provider window only once', () => {
+    const data = { user: { today_tokens: 390672620, daily_token_limit: null, week_usd: 224.068, weekly_usd_limit: 500 }, pools: [
+      { provider: 'grok', window: '5h', used_percent: 10, resets_at: '2026-10-11T04:00:00Z' },
+      { provider: 'grok', window: '7d', used_percent: 20 },
+    ] };
+    assert.equal(usageLimits(data), 'account: day 390.7M/unlimited tokens · week $224.07/$500');
+    const report = modelUsage(data, 'grok/grok-4').join('\n');
+    assert.equal(report.split('5h').length - 1, 1);
+    assert.equal(report.split('7d').length - 1, 1);
+    assert.equal(report.split('390.7M').length - 1, 1);
+    assert.match(report, /resets 10-11 04:00/);
+  });
+
+  it('never invents missing account limits or coerces invalid amounts', () => {
+    for (const json of [undefined, null, [], {}, { user: [] }])
+      assert.equal(usageLimits(json), 'account limits: unknown');
+    for (const value of ['10', -1, NaN, Infinity, {}])
+      assert.equal(usageLimits({ user: { today_tokens: value, daily_token_limit: value } }), 'account: day ?/? tokens');
+    assert.equal(usageLimits({ user: { daily_token_limit: 10 } }), 'account: day ?/10 tokens');
+  });
+
+  it('detailed view includes only the selected provider and handles invalid reset dates', () => {
+    const data = { user: { rpm_limit: 60 }, pools: [
+      { provider: 'anthropic', window: '5h', used_percent: 20, resets_at: 1e100 },
+      { provider: 'openai', window: '7d', used_percent: 10 },
+    ] };
+    const report = modelUsage(data, 'anthropic/claude-test').join('\n');
+    assert.match(report, /anthropic: 5h 80% available/);
+    assert.match(report, /Account limits\n60 rpm/);
+    assert.match(report, /resets unknown/);
+    assert.ok(!report.includes('openai'));
+    assert.match(modelUsage(undefined, 'openai/test').join('\n'), /No provider pool limits reported/);
+  });
+
+  it('explicit refresh bypasses the ordinary 30-second usage cache', async () => {
+    let calls = 0;
+    const client = { usage: async () => ({ calls: ++calls }) };
+    const signal = new AbortController().signal;
+    const first = await fetchUsage(client as never, signal, true);
+    assert.deepEqual(await fetchUsage(client as never, signal), first);
+    assert.deepEqual(await fetchUsage(client as never, signal, true), { calls: 2 });
+  });
+});
+
+describe('providerUsage', () => {
+  it('filters by model prefix and keeps all matching pool windows', () => {
+    const json = {
+      user: { today_tokens: 123, rpm_limit: 60 },
+      pools: [
+        { provider: 'anthropic', window: '5h', used_percent: 25, resets_at: '2026-10-11T04:00:00Z' },
+        { provider: 'openai', window: 'weekly', used_percent: 99 },
+        { provider: 'anthropic', window: '7d', used_percent: 57, resets_at: 1791763200 },
+      ],
+    };
+    assert.equal(providerUsage(json, 'anthropic/claude-sonnet'),
+      'anthropic: 5h 75% · 7d 43% available');
+  });
+
+  it('matches arbitrary explicit providers, with prefixes taking priority over model names', () => {
+    const json = { pools: [
+      { provider: 'opencode', used_percent: 10 },
+      { provider: 'deepseek', used_percent: 20 },
+      { provider: 'openai', used_percent: 30 },
+      { provider: 'anthropic', used_percent: 40 },
+    ] };
+    assert.equal(providerUsage(json, 'opencode/deepseek-v4'), 'opencode: 90% available');
+    assert.equal(providerUsage(json, 'openai/claude-proxy'), 'openai: 70% available');
+    assert.equal(providerUsage(json, 'deepseek/deepseek-v4'), 'deepseek: 80% available');
+  });
+
+  it('normalizes case/whitespace, supports pool name fallback, and aliases xai to grok both ways', () => {
+    assert.equal(providerUsage({ pools: [{ name: ' GROK ', used_percent: 40 }] }, ' XAI/grok-4 '),
+      'grok: 60% available');
+    assert.equal(providerUsage({ pools: [{ provider: 'xai', used_percent: 40 }] }, 'grok/grok-4'),
+      'grok: 60% available');
+    assert.equal(providerUsage({ pools: [{ provider: ' OpenAI ', used_percent: 20 }] }, ' OPENAI/gpt-5 '),
+      'openai: 80% available');
+  });
+
+  it('recognizes supported unprefixed model families, but never guesses unknown families', () => {
+    for (const [model, provider] of [
+      ['claude-sonnet', 'anthropic'], ['claude.sonnet', 'anthropic'],
+      ['gpt-5', 'openai'], ['grok-4', 'grok'], ['deepseek-v4', 'deepseek'],
+    ]) {
+      assert.equal(providerUsage({ pools: [{ provider, used_percent: 0 }] }, model),
+        `${provider}: 100% available`);
+    }
+    assert.equal(providerUsage({ pools: [{ provider: 'openai', used_percent: 0 }] }, 'mystery'), 'usage: unknown');
+    assert.equal(providerUsage({ pools: [{ provider: '', used_percent: 0 }] }, ''), 'usage: unknown');
+  });
+
+  it('distinguishes missing percentages from genuine empty and fully available pools', () => {
+    assert.equal(providerUsage({ pools: [
+      { provider: 'anthropic', window: 'zero', used_percent: 0 },
+      { provider: 'anthropic', window: 'full', used_percent: 100 },
+      { provider: 'anthropic', window: 'missing' },
+    ] }, 'anthropic/claude'),
+    'anthropic: zero 100% · full 0% · missing unknown available');
+  });
+
+  it('does not coerce, clamp, or invent percentages for invalid stats', () => {
+    for (const used_percent of [null, '25', NaN, Infinity, -1, 101, {}, []]) {
+      assert.equal(providerUsage({ pools: [{ provider: 'openai', used_percent }] }, 'openai/gpt'),
+        'openai: unknown available');
+    }
+    assert.equal(providerUsage({ pools: [{ provider: 'openai', used_percent: 33.3 }] }, 'openai/gpt'),
+      'openai: 67% available');
+  });
+
+  it('omits reset metadata whether valid, missing, or malformed', () => {
+    for (const resets_at of [undefined, null, 'nope', NaN, Infinity, 1e100, {}, [],
+      0, 1791763200, '2026-10-11T06:00:00+02:00', '2026-10-11']) {
+      assert.equal(providerUsage({ pools: [{ provider: 'grok', used_percent: 0, resets_at }] }, 'grok/grok-4'),
+        'grok: 100% available');
+    }
+  });
+
+  it('falls back to live user quotas only when no provider pool matches', () => {
+    const json = {
+      user: { today_tokens: 0, daily_token_limit: null, rpm_limit: 0 },
+      pools: [{ provider: 'anthropic', used_percent: 0 }],
+    };
+    assert.equal(providerUsage(json, 'openai/gpt-5'), 'quota: 0 / unlimited tokens today · 0 rpm');
+    assert.equal(providerUsage(json, 'anthropic/claude'), 'anthropic: 100% available');
+  });
+
+  it('supports documented quotas, but does not infer today tokens from undocumented aliases', () => {
+    assert.equal(providerUsage({ quotas: { daily_token_limit: 1000000, daily_tokens_used: 25, rpm_limit: 60 } }, 'grok/grok-4'),
+      'quota: unknown / 1,000,000 tokens today · 60 rpm');
+    assert.equal(providerUsage({ user: { today_tokens: 250000 } }, 'deepseek/deepseek-v4'),
+      'quota: 250,000 / unknown tokens today');
+    assert.equal(providerUsage({ user: { daily_token_limit: 0 } }, 'openai/gpt-5'),
+      'quota: unknown / 0 tokens today');
+    assert.equal(providerUsage({ user: { rpm_limit: '60' } }, 'openai/gpt-5'), 'quota: unknown rpm');
+    assert.equal(providerUsage({ user: { today_tokens: null, daily_token_limit: Infinity, rpm_limit: null } }, 'openai/gpt-5'),
+      'quota: unknown / unknown tokens today · unknown rpm');
+    assert.equal(providerUsage({ user: { rpm_limit: 10 }, quotas: { rpm_limit: 60 } }, 'openai/gpt-5'), 'quota: 10 rpm');
+  });
+
+  it('tolerates malformed payloads and pool entries', () => {
+    for (const json of [undefined, null, false, 0, 'nope', [], {}, { pools: 'nope' }, { user: [] }]) {
+      assert.equal(providerUsage(json, 'openai/gpt-5'), 'usage: unknown');
+    }
+    assert.equal(providerUsage({ pools: [null, 0, 'nope', [], { provider: 123 }, { provider: 'openai-extra', used_percent: 10 }] }, 'openai/gpt-5'),
+      'usage: unknown');
+    assert.equal(providerUsage({ pools: [null, { provider: 'openai', window: '  5h\n weekly ', used_percent: 10 }] }, 'openai/gpt-5'),
+      'openai: 5h weekly 90% available');
+  });
+
+  it('is deterministic, does not mutate input, and never fetches', () => {
+    const pool = Object.freeze({ provider: 'openai', window: '5h', used_percent: 0, resets_at: 0 });
+    const json = Object.freeze({ pools: Object.freeze([pool]) });
+    const before = JSON.stringify(json);
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = async () => { throw new Error('unexpected fetch'); };
+    try {
+      const first = providerUsage(json, 'openai/gpt-5');
+      assert.equal(providerUsage(json, 'openai/gpt-5'), first);
+      assert.equal(first, 'openai: 5h 100% available');
+      assert.equal(JSON.stringify(json), before);
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "lib": ["esnext"],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node"],
+    "strict": true,
+    "noEmit": true,
+    "erasableSyntaxOnly": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src", "scripts", "test"]
+}