@robhowley/pi-openrouter 0.9.1 → 0.11.0

package/extensions/openrouter/__tests__/status-bar.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { setLocalUsageDir, dedupeLocalUsageEvents } from '../local-usage.js';
+import {
+  calculateOpenRouterStatusStats,
+  formatOpenRouterStatusBar,
+  loadOpenRouterStatusBar,
+  loadOpenRouterStatusStats,
+  type OpenRouterStatusStats,
+} from '../status-bar.js';
+import type { LocalUsageEvent } from '../types.js';
+
+let testDir: string;
+
+function createLocalUsageEvent(
+  id: string,
+  completedAt: string,
+  cost: number,
+  overrides: Partial<LocalUsageEvent> = {},
+): LocalUsageEvent {
+  return {
+    id,
+    generationId: `${id}-generation`,
+    sessionId: 'session-test',
+    completedAt,
+    requests: 1,
+    model: 'openrouter/anthropic/claude-sonnet-4',
+    provider: 'anthropic',
+    promptTokens: 10,
+    completionTokens: 5,
+    cost,
+    ...overrides,
+  };
+}
+
+async function writeDailyFile(
+  dateUtc: string,
+  rows: Array<LocalUsageEvent | string>,
+): Promise<void> {
+  const content = rows
+    .map((row) => (typeof row === 'string' ? row : JSON.stringify(row)))
+    .join('\n');
+  await fs.writeFile(path.join(testDir, `${dateUtc}.jsonl`), `${content}\n`, 'utf8');
+}
+
+beforeEach(async () => {
+  testDir = path.join(
+    os.tmpdir(),
+    `pi-openrouter-status-bar-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await fs.mkdir(testDir, { recursive: true });
+  setLocalUsageDir(testDir);
+});
+
+afterEach(async () => {
+  setLocalUsageDir(null);
+  vi.restoreAllMocks();
+  vi.doUnmock('../local-usage.js');
+  vi.doUnmock('../status-bar.js');
+
+  try {
+    await fs.rm(testDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors.
+  }
+});
+
+describe('calculateOpenRouterStatusStats', () => {
+  it('returns null for no local events', () => {
+    expect(calculateOpenRouterStatusStats([], '2026-05-22')).toBeNull();
+  });
+
+  it('returns null when the full 30-day window totals zero local spend', () => {
+    expect(
+      calculateOpenRouterStatusStats(
+        [
+          createLocalUsageEvent('today-zero', '2026-05-22T09:15:00.000Z', 0),
+          createLocalUsageEvent('older-zero', '2026-05-12T09:15:00.000Z', 0),
+        ],
+        '2026-05-22',
+      ),
+    ).toBeNull();
+  });
+
+  it('includes only UTC-today spend and divides by exactly 30 calendar days', () => {
+    const stats = calculateOpenRouterStatusStats(
+      [
+        createLocalUsageEvent('today', '2026-05-22T09:15:00.000Z', 3),
+        createLocalUsageEvent('yesterday', '2026-05-21T09:15:00.000Z', 9),
+      ],
+      '2026-05-22',
+    );
+
+    expect(stats).toEqual({
+      todayLocalSpend: 3,
+      averageLocalDailySpendLast30Days: 0.4,
+      burnRateMultiplier: 7.5,
+    });
+  });
+
+  it('uses only the today-29 through today window', () => {
+    const stats = calculateOpenRouterStatusStats(
+      [
+        createLocalUsageEvent('old', '2026-04-22T12:00:00.000Z', 100),
+        createLocalUsageEvent('boundary', '2026-04-23T12:00:00.000Z', 6),
+        createLocalUsageEvent('recent', '2026-05-21T12:00:00.000Z', 3),
+        createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 1.5),
+      ],
+      '2026-05-22',
+    );
+
+    expect(stats).toEqual({
+      todayLocalSpend: 1.5,
+      averageLocalDailySpendLast30Days: 0.35,
+      burnRateMultiplier: 1.5 / 0.35,
+    });
+  });
+
+  it('deduplicates event ids exactly once across the full 30-day window', () => {
+    const events = [
+      createLocalUsageEvent('duplicate-id', '2026-05-20T12:00:00.000Z', 1),
+      createLocalUsageEvent('duplicate-id', '2026-05-22T12:00:00.000Z', 99),
+      createLocalUsageEvent('unique-id', '2026-05-22T13:00:00.000Z', 2),
+    ];
+
+    expect(dedupeLocalUsageEvents(events)).toHaveLength(2);
+    expect(calculateOpenRouterStatusStats(events, '2026-05-22')).toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.1,
+      burnRateMultiplier: 20,
+    });
+  });
+});
+
+describe('formatOpenRouterStatusBar', () => {
+  it('formats the representative status text exactly', () => {
+    const stats: OpenRouterStatusStats = {
+      todayLocalSpend: 2.14,
+      averageLocalDailySpendLast30Days: 1.64,
+      burnRateMultiplier: 1.3,
+    };
+
+    expect(formatOpenRouterStatusBar(stats)).toBe('OR $2.14 today · 1.3x 30d avg');
+  });
+
+  it('formats $0.00 today · 0.0x 30d avg when prior 30-day spend exists but today spend is zero', () => {
+    const stats: OpenRouterStatusStats = {
+      todayLocalSpend: 0,
+      averageLocalDailySpendLast30Days: 0.5,
+      burnRateMultiplier: 0,
+    };
+
+    expect(formatOpenRouterStatusBar(stats)).toBe('OR $0.00 today · 0.0x 30d avg');
+  });
+
+  it('omits the multiplier when given a stats object with no denominator', () => {
+    expect(
+      formatOpenRouterStatusBar({
+        todayLocalSpend: 2.14,
+        averageLocalDailySpendLast30Days: 0,
+        burnRateMultiplier: null,
+      }),
+    ).toBe('OR $2.14 today');
+  });
+});
+
+describe('loadOpenRouterStatusStats and loadOpenRouterStatusBar', () => {
+  it('returns an empty result for empty local usage data', async () => {
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toBeNull();
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({ kind: 'empty' });
+  });
+
+  it('returns an empty result when the 30-day window has only zero-cost local rows', async () => {
+    await writeDailyFile('2026-05-12', [
+      createLocalUsageEvent('older-zero', '2026-05-12T12:00:00.000Z', 0),
+    ]);
+    await writeDailyFile('2026-05-22', [
+      createLocalUsageEvent('today-zero', '2026-05-22T12:00:00.000Z', 0),
+    ]);
+
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toBeNull();
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({ kind: 'empty' });
+  });
+
+  it('requests local usage only from today-29 through today', async () => {
+    vi.resetModules();
+    const actualLocalUsage =
+      await vi.importActual<typeof import('../local-usage.js')>('../local-usage.js');
+    const readLocalUsage = vi
+      .fn()
+      .mockResolvedValue([
+        createLocalUsageEvent('boundary', '2026-04-23T12:00:00.000Z', 1),
+        createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 2),
+      ]);
+
+    vi.doMock('../local-usage.js', () => ({
+      ...actualLocalUsage,
+      readLocalUsage,
+    }));
+
+    const { loadOpenRouterStatusStats: loadMockedStats } = await import('../status-bar.js');
+
+    await expect(loadMockedStats(new Date('2026-05-22T12:00:00.000Z'))).resolves.toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.1,
+      burnRateMultiplier: 20,
+    });
+    expect(readLocalUsage).toHaveBeenCalledTimes(1);
+    expect(readLocalUsage).toHaveBeenCalledWith({
+      fromDateUtc: '2026-04-23',
+      toDateUtc: '2026-05-22',
+    });
+  });
+
+  it('tolerates missing files and malformed rows while returning a ready status', async () => {
+    await writeDailyFile('2026-05-10', [
+      createLocalUsageEvent('older', '2026-05-10T12:00:00.000Z', 4),
+      '{not json}',
+    ]);
+    await writeDailyFile('2026-05-22', [
+      createLocalUsageEvent('today', '2026-05-22T12:00:00.000Z', 2),
+      '',
+    ]);
+
+    const now = new Date('2026-05-22T12:00:00.000Z');
+
+    await expect(loadOpenRouterStatusStats(now)).resolves.toEqual({
+      todayLocalSpend: 2,
+      averageLocalDailySpendLast30Days: 0.2,
+      burnRateMultiplier: 10,
+    });
+    await expect(loadOpenRouterStatusBar(now)).resolves.toEqual({
+      kind: 'ready',
+      text: 'OR $2.00 today · 10.0x 30d avg',
+    });
+  });
+
+  it('returns a failed result when the local usage read path throws unexpectedly', async () => {
+    vi.resetModules();
+
+    const readLocalUsage = vi.fn().mockRejectedValue(new Error('disk exploded'));
+    vi.doMock('../local-usage.js', async () => {
+      const actual = await vi.importActual<typeof import('../local-usage.js')>('../local-usage.js');
+      return {
+        ...actual,
+        readLocalUsage,
+      };
+    });
+
+    const { loadOpenRouterStatusBar: loadMockedBar } = await import('../status-bar.js');
+
+    await expect(loadMockedBar(new Date('2026-05-22T12:00:00.000Z'))).resolves.toEqual({
+      kind: 'failed',
+    });
+  });
+});

package/extensions/openrouter/account-client.ts

@@ -1,20 +1,52 @@
+import type { CreateKeysRequestBody } from '@openrouter/sdk/models/operations/index.js';
 import { OpenRouter } from '@openrouter/sdk/sdk/sdk.js';
-import type { KeyInfo, KeyStatus } from './account-types.js';
+import type { CurrentKeyRelation, KeyInfo, KeyStatus } from './account-types.js';
 
 // Re-export error types from client.ts
 import { AuthError, ApiError } from './client.js';
 import { normalizeSdkKeyMetadata } from './normalizers.js';
 
 let client: OpenRouter | null = null;
+let clientApiKey: string | null = null;
+
+function getClientForApiKey(apiKey: string): OpenRouter {
+  if (client && clientApiKey === apiKey) {
+    return client;
+  }
 
-function getClient(): OpenRouter | null {
-  if (client) return client;
-  const apiKey = process.env['OPENROUTER_MANAGEMENT_KEY'] || process.env['OPENROUTER_API_KEY'];
-  if (!apiKey) return null;
   client = new OpenRouter({ apiKey });
+  clientApiKey = apiKey;
   return client;
 }
 
+function getUsageOrManagementApiKey(): string | undefined {
+  const managementKey = process.env['OPENROUTER_MANAGEMENT_KEY'];
+  if (managementKey && managementKey.trim() !== '') {
+    return managementKey;
+  }
+
+  const apiKey = process.env['OPENROUTER_API_KEY'];
+  if (apiKey && apiKey.trim() !== '') {
+    return apiKey;
+  }
+
+  return undefined;
+}
+
+function getClient(): OpenRouter | null {
+  const apiKey = getUsageOrManagementApiKey();
+  if (!apiKey) return null;
+  return getClientForApiKey(apiKey);
+}
+
+function getManagementClient(): OpenRouter {
+  const apiKey = process.env['OPENROUTER_MANAGEMENT_KEY'];
+  if (!apiKey || apiKey.trim() === '') {
+    throw new AuthError('OPENROUTER_MANAGEMENT_KEY is required for API key management.');
+  }
+  return getClientForApiKey(apiKey);
+}
+
 // =============================================================================
 // Account Credits API
 // =============================================================================
@@ -37,9 +69,23 @@ export async function getAccountCredits(): Promise<number | null> {
 // Workspace ID for the default workspace (empty string) - used when workspaceId is not specified
 const DEFAULT_WORKSPACE_ID = '';
 
-export async function getAllKeys(): Promise<KeyInfo[] | null> {
+export type KeyInventoryDegradedReason = 'management-unavailable' | 'missing-api-key';
+
+export interface KeyInventoryResult {
+  keys: KeyInfo[];
+  canManageKeys: boolean;
+  degradedReason?: KeyInventoryDegradedReason;
+}
+
+export async function getAllKeys(): Promise<KeyInventoryResult> {
   const client = getClient();
-  if (!client) return null;
+  if (!client) {
+    return {
+      keys: [],
+      canManageKeys: false,
+      degradedReason: 'missing-api-key',
+    };
+  }
 
   try {
     // First, get all workspaces
@@ -66,12 +112,19 @@ export async function getAllKeys(): Promise<KeyInfo[] | null> {
       allKeys.push(...keys);
     }
 
-    return allKeys;
+    return {
+      keys: allKeys,
+      canManageKeys: true,
+    };
   } catch (err) {
-    // If management key fails (403), fall back to current key only
-    const sdkErr = err as { status?: number };
-    if (sdkErr.status === 403) {
-      return null;
+    // If management inventory is unavailable (403), fall back to current key only.
+    const sdkErr = err as { status?: number; statusCode?: number };
+    if ((sdkErr.status ?? sdkErr.statusCode) === 403) {
+      return {
+        keys: [],
+        canManageKeys: false,
+        degradedReason: 'management-unavailable',
+      };
     }
     throw mapSdkError(err);
   }
@@ -88,14 +141,162 @@ export async function getCurrentKey(): Promise<KeyInfo | null> {
   }
 }
 
+/**
+ * Resolve how the current authenticated key relates to the listed inventory rows.
+ *
+ * OpenRouter current-key metadata does not reliably expose the stable inventory
+ * hash, so we fall back to label matching and distinguish external provisioning
+ * keys from genuinely unresolved identity.
+ */
+export async function resolveCurrentKeyRelation(keys: KeyInfo[]): Promise<CurrentKeyRelation> {
+  if (keys.length === 0) {
+    return { kind: 'unresolved', reason: 'no-inventory-keys' };
+  }
+
+  const client = getClient();
+  if (!client) {
+    return { kind: 'unresolved', reason: 'missing-api-key' };
+  }
+
+  try {
+    const response = await client.apiKeys.getCurrentKeyMetadata();
+    const raw = response.data;
+    const currentKey = normalizeSdkKeyMetadata(raw);
+
+    if (hasTrustedHash(currentKey.hash)) {
+      const matchedByHash = keys.find((key) => key.hash === currentKey.hash);
+      if (matchedByHash) {
+        return {
+          kind: 'inventory-match',
+          hash: currentKey.hash,
+          label: matchedByHash.label,
+        };
+      }
+
+      if (raw.isProvisioningKey === true) {
+        return { kind: 'external-provisioning', label: currentKey.label };
+      }
+
+      return {
+        kind: 'unresolved',
+        reason: 'current-hash-not-in-inventory',
+        label: currentKey.label,
+      };
+    }
+
+    const currentLabel = currentKey.label.trim();
+    if (currentLabel === '') {
+      return { kind: 'unresolved', reason: 'missing-current-label' };
+    }
+
+    const matchingHashes = Array.from(
+      new Set(
+        keys
+          .filter((key) => key.label.trim() === currentLabel)
+          .map((key) => (hasTrustedHash(key.hash) ? key.hash : undefined))
+          .filter((hash): hash is string => hash !== undefined),
+      ),
+    );
+
+    if (matchingHashes.length === 1) {
+      return { kind: 'inventory-match', hash: matchingHashes[0]!, label: currentLabel };
+    }
+
+    if (matchingHashes.length > 1) {
+      return { kind: 'ambiguous-label', label: currentLabel, matchingHashes };
+    }
+
+    if (raw.isProvisioningKey === true) {
+      return { kind: 'external-provisioning', label: currentLabel };
+    }
+
+    return { kind: 'unresolved', reason: 'no-inventory-match', label: currentLabel };
+  } catch (err) {
+    throw mapSdkError(err);
+  }
+}
+
+export interface CreateApiKeyInput {
+  name: string;
+  limit?: number | null;
+  limitReset?: CreateKeysRequestBody['limitReset'];
+  includeByokInLimit?: boolean;
+  workspaceId?: string;
+  expiresAt?: Date;
+}
+
+export type ApiKeyMutationInfo = Omit<KeyInfo, 'workspaceName'>;
+
+export interface CreatedApiKeyResult {
+  key: string;
+  keyState: ApiKeyMutationInfo;
+}
+
+export async function createApiKey(input: CreateApiKeyInput): Promise<CreatedApiKeyResult> {
+  const client = getManagementClient();
+
+  const requestBody: CreateKeysRequestBody = {
+    name: input.name,
+  };
+
+  if (input.limit !== undefined) {
+    requestBody.limit = input.limit;
+  }
+  if (input.limitReset !== undefined) {
+    requestBody.limitReset = input.limitReset;
+  }
+  if (input.includeByokInLimit !== undefined) {
+    requestBody.includeByokInLimit = input.includeByokInLimit;
+  }
+  if (input.workspaceId !== undefined) {
+    requestBody.workspaceId = input.workspaceId;
+  }
+  if (input.expiresAt !== undefined) {
+    requestBody.expiresAt = input.expiresAt;
+  }
+
+  try {
+    const response = await client.apiKeys.create({ requestBody });
+    return {
+      key: response.key,
+      keyState: keyMetadataToMutationInfo(normalizeSdkKeyMetadata(response.data)),
+    };
+  } catch (err) {
+    throw mapManagementSdkError(err, 'create API keys');
+  }
+}
+
+export async function setApiKeyDisabled(
+  hash: string,
+  disabled: boolean,
+): Promise<ApiKeyMutationInfo> {
+  const client = getManagementClient();
+
+  try {
+    const response = await client.apiKeys.update({
+      hash,
+      requestBody: {
+        disabled,
+      },
+    });
+
+    return keyMetadataToMutationInfo(normalizeSdkKeyMetadata(response.data));
+  } catch (err) {
+    throw mapManagementSdkError(err, `${disabled ? 'disable' : 'enable'} API keys`);
+  }
+}
+
 // =============================================================================
 // Helper Functions
 // =============================================================================
 
-function keyMetadataToKeyInfo(
+function hasTrustedHash(hash?: string): hash is string {
+  return typeof hash === 'string' && hash.trim() !== '';
+}
+
+function keyMetadataToMutationInfo(
   metadata: ReturnType<typeof normalizeSdkKeyMetadata>,
-  workspaceName: string,
-): KeyInfo {
+): ApiKeyMutationInfo {
   const { name, label, used, limit, remaining, resetCadence, byok, hash, disabled } = metadata;
 
   // Calculate status based on usage percentage
@@ -119,7 +320,7 @@ function keyMetadataToKeyInfo(
     }
   }
 
-  const keyInfo: KeyInfo = {
+  const keyState: ApiKeyMutationInfo = {
     name,
     label,
     status,
@@ -127,39 +328,85 @@ function keyMetadataToKeyInfo(
     spend: used, // spend is the same as usage (in USD)
     resetCadence,
     byok,
-    hash,
     disabled,
-    workspaceName,
   };
 
+  if (hash !== undefined) {
+    keyState.hash = hash;
+  }
   if (limit !== undefined) {
-    keyInfo.limit = limit;
+    keyState.limit = limit;
   }
   if (remaining !== undefined) {
-    keyInfo.remaining = remaining;
+    keyState.remaining = remaining;
   }
 
-  return keyInfo;
+  return keyState;
+}
+
+function keyMetadataToKeyInfo(
+  metadata: ReturnType<typeof normalizeSdkKeyMetadata>,
+  workspaceName: string,
+): KeyInfo {
+  return {
+    ...keyMetadataToMutationInfo(metadata),
+    workspaceName,
+  };
 }
 
 function mapSdkError(err: unknown): Error {
-  const rawErr = err as { status?: number; message?: string };
-  const status = rawErr.status;
+  const rawErr = err as { status?: number; statusCode?: number; message?: string };
+  const status = rawErr.status ?? rawErr.statusCode;
   const message = rawErr.message ?? 'Unknown error';
 
   if (status === 401) {
     return new AuthError(message);
   }
   if (status === 403) {
-    return new ApiError(`Forbidden: ${message}`);
+    return new ApiError(`Forbidden: ${message}`, 403);
+  }
+  if (status !== undefined) {
+    return new ApiError(message, status);
   }
 
   if (err instanceof Error) return err;
   return new Error(String(err));
 }
 
-export function getCurrentKeyHash(): string | undefined {
-  // For v1, we don't hash the current API key for comparison
-  // This is a follow-up item from the planning docs
-  return undefined;
+function mapManagementSdkError(err: unknown, action: string): Error {
+  const rawErr = err as { status?: number; statusCode?: number; message?: string };
+  const status = rawErr.status ?? rawErr.statusCode;
+  const message = rawErr.message ?? 'Unknown error';
+
+  if (status === 401) {
+    return new AuthError(
+      `OPENROUTER_MANAGEMENT_KEY is required to ${action}. Set it to a valid management key.`,
+    );
+  }
+
+  if (status === 403) {
+    return new ApiError(
+      `OPENROUTER_MANAGEMENT_KEY does not have permission to ${action}. Set it to a valid management key.`,
+      403,
+    );
+  }
+
+  if (err instanceof Error && /unauthorized/i.test(err.message)) {
+    return new AuthError(
+      `OPENROUTER_MANAGEMENT_KEY is required to ${action}. Set it to a valid management key.`,
+    );
+  }
+
+  if (err instanceof Error && /forbidden/i.test(err.message)) {
+    return new ApiError(
+      `OPENROUTER_MANAGEMENT_KEY does not have permission to ${action}. Set it to a valid management key.`,
+      403,
+    );
+  }
+
+  if (status === 400) {
+    return new ApiError(message, 400);
+  }
+
+  return mapSdkError(err);
 }