@robhowley/pi-openrouter 0.10.0 → 0.11.0

package/extensions/openrouter/__tests__/account-overlay.test.ts

@@ -0,0 +1,683 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Theme } from '@mariozechner/pi-coding-agent';
+import type { CurrentKeyRelation, KeyInfo, RollupStatus } from '../account-types.js';
+
+const tuiMocks = vi.hoisted(() => ({
+  matchesKey: vi.fn(),
+}));
+
+const accountClientMocks = vi.hoisted(() => ({
+  getAllKeys: vi.fn(),
+  getCurrentKey: vi.fn(),
+  resolveCurrentKeyRelation: vi.fn(),
+  getAccountCredits: vi.fn(),
+  setApiKeyDisabled: vi.fn(),
+}));
+
+vi.mock('@mariozechner/pi-tui', () => ({
+  matchesKey: tuiMocks.matchesKey,
+  truncateToWidth: (text: string) => text,
+}));
+
+vi.mock('../account-client.js', () => ({
+  getAllKeys: accountClientMocks.getAllKeys,
+  getCurrentKey: accountClientMocks.getCurrentKey,
+  resolveCurrentKeyRelation: accountClientMocks.resolveCurrentKeyRelation,
+  getAccountCredits: accountClientMocks.getAccountCredits,
+  setApiKeyDisabled: accountClientMocks.setApiKeyDisabled,
+}));
+
+import { AccountOverlayComponent } from '../account-overlay.js';
+
+function createIdentityTheme(): Theme {
+  return {
+    bold: (text: string) => text,
+    fg: (_style: string, text: string) => text,
+  } as Theme;
+}
+
+function createKey(overrides: Partial<KeyInfo> = {}): KeyInfo {
+  return {
+    name: 'Primary',
+    label: 'sk-or-v1-123',
+    status: 'healthy',
+    used: 10,
+    remaining: 90,
+    limit: 100,
+    resetCadence: 'monthly',
+    byok: 'incl',
+    hash: 'hash-1',
+    disabled: false,
+    workspaceName: 'Main Workspace',
+    spend: 10,
+    ...overrides,
+  };
+}
+
+function createInventoryMatchRelation(
+  hash = 'hash-management',
+  label = 'sk-or-v1-management',
+): CurrentKeyRelation {
+  return { kind: 'inventory-match', hash, label };
+}
+
+function createExternalProvisioningRelation(label = 'sk-or-v1-provisioning'): CurrentKeyRelation {
+  return { kind: 'external-provisioning', label };
+}
+
+function createKeyInventory(
+  keys: KeyInfo[] = [createKey()],
+  options: { canManageKeys?: boolean; degradedReason?: string } = {},
+) {
+  return {
+    keys,
+    canManageKeys: options.canManageKeys ?? true,
+    ...(options.degradedReason ? { degradedReason: options.degradedReason } : {}),
+  };
+}
+
+function createDeferred<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  const promise = new Promise<T>((resolvePromise) => {
+    resolve = resolvePromise;
+  });
+  return { promise, resolve };
+}
+
+function createApiError(message: string, statusCode: number): Error & { statusCode: number } {
+  return Object.assign(new Error(message), { name: 'ApiError', statusCode });
+}
+
+function createAuthError(message: string): Error & {
+  name: string;
+} {
+  return Object.assign(new Error(message), { name: 'AuthError' });
+}
+
+function renderText(component: AccountOverlayComponent): string {
+  return component.render(120).join('\n');
+}
+
+function installSimpleKeyMatcher(): void {
+  tuiMocks.matchesKey.mockImplementation((data: string, key: string) => {
+    if ((key === 'enter' || key === 'return') && data === 'enter') {
+      return true;
+    }
+    return data === key;
+  });
+}
+
+describe('AccountOverlayComponent', () => {
+  const components: AccountOverlayComponent[] = [];
+  const rollupStatus: RollupStatus = { status: 'healthy', message: '🔴 0  🟡 0  🟢 2' };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    installSimpleKeyMatcher();
+    accountClientMocks.resolveCurrentKeyRelation.mockResolvedValue({
+      kind: 'unresolved',
+      reason: 'missing-current-key-match',
+    });
+  });
+
+  afterEach(() => {
+    for (const component of components) {
+      component.dispose();
+    }
+    components.length = 0;
+  });
+
+  it('does not render internal hashes and advertises disable when the selected inventory row is mutable', () => {
+    const longHash = '1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+    const component = new AccountOverlayComponent(
+      [
+        createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 }),
+        createKey({ name: 'Automation', hash: longHash, spend: 5, label: 'sk-or-v1-999' }),
+      ],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-management'),
+    );
+    components.push(component);
+
+    const output = renderText(component);
+
+    expect(output).not.toContain('hash      ');
+    expect(output).not.toContain('hash-primary');
+    expect(output).not.toContain(longHash);
+    expect(output).toContain('t disable');
+  });
+
+  it('uses the selected key hash internally for t+enter and keeps that key selected after re-sort', async () => {
+    const updatedState: Partial<KeyInfo> = {
+      ...createKey({
+        name: 'Primary',
+        hash: 'hash-primary',
+        status: 'disabled',
+        disabled: true,
+        spend: 20,
+      }),
+    };
+    delete updatedState.workspaceName;
+    accountClientMocks.setApiKeyDisabled.mockResolvedValue(updatedState);
+
+    const component = new AccountOverlayComponent(
+      [
+        createKey({
+          name: 'Primary',
+          hash: 'hash-primary',
+          spend: 20,
+          workspaceName: 'Canonical Workspace',
+        }),
+        createKey({
+          name: 'Automation',
+          hash: 'hash-automation',
+          spend: 5,
+          label: 'sk-or-v1-999',
+          workspaceName: 'Other Workspace',
+        }),
+      ],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-management'),
+    );
+    components.push(component);
+
+    component.handleInput('t');
+    expect(renderText(component)).toContain('Press Enter to disable Primary');
+
+    component.handleInput('enter');
+
+    await vi.waitFor(() => {
+      expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-primary', true);
+    });
+
+    await vi.waitFor(() => {
+      const output = renderText(component);
+      expect(output).toContain('name      Primary');
+      expect(output).toContain('status    disabled');
+      expect(output).toContain('status    Primary disabled.');
+      expect(output).toContain('Canonical');
+      expect(output).not.toContain('hash-primary');
+      expect(output).not.toContain('hash-automation');
+    });
+  });
+
+  it('renders read-only when management key capabilities are unavailable', () => {
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      false,
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain('readonly  Set OPENROUTER_MANAGEMENT_KEY');
+    expect(renderText(component)).not.toContain('·  t ');
+
+    component.handleInput('t');
+
+    expect(accountClientMocks.setApiKeyDisabled).not.toHaveBeenCalled();
+    expect(renderText(component)).toContain('Set OPENROUTER_MANAGEMENT_KEY');
+    expect(renderText(component)).not.toContain('hash-primary');
+  });
+
+  it('blocks toggles for rows without a trusted inventory hash', () => {
+    const currentKey = createKey({ name: 'Current Key', spend: 20 });
+    delete currentKey.hash;
+
+    const component = new AccountOverlayComponent(
+      [currentKey],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-management'),
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain(
+      'readonly  This row is not backed by key inventory metadata.',
+    );
+    expect(renderText(component)).not.toContain('·  t ');
+
+    component.handleInput('t');
+
+    expect(accountClientMocks.setApiKeyDisabled).not.toHaveBeenCalled();
+    expect(renderText(component)).toContain('This row is not backed by key inventory metadata.');
+  });
+
+  it('blocks disabling keys until current management key identity exists', () => {
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain(
+      'readonly  Cannot verify current key matches this row.',
+    );
+    expect(renderText(component)).not.toContain('·  t ');
+
+    component.handleInput('t');
+
+    expect(accountClientMocks.setApiKeyDisabled).not.toHaveBeenCalled();
+    expect(renderText(component)).toContain('Cannot verify current key matches this row.');
+  });
+
+  it('allows disabling inventory rows when current auth is an external provisioning key', async () => {
+    accountClientMocks.setApiKeyDisabled.mockResolvedValue(
+      createKey({
+        name: 'default-space-key',
+        hash: 'hash-default-space',
+        status: 'disabled',
+        disabled: true,
+        spend: 0,
+        label: 'sk-or-v1-8ef...062',
+      }),
+    );
+
+    const component = new AccountOverlayComponent(
+      [
+        createKey({
+          name: 'default-space-key',
+          hash: 'hash-default-space',
+          label: 'sk-or-v1-8ef...062',
+          spend: 20,
+        }),
+      ],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createExternalProvisioningRelation('sk-or-v1-4a0...459'),
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain('t disable');
+    expect(renderText(component)).not.toContain(
+      'readonly  Cannot verify current key matches this row.',
+    );
+
+    component.handleInput('t');
+    component.handleInput('enter');
+
+    await vi.waitFor(() => {
+      expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-default-space', true);
+    });
+  });
+
+  it('blocks disabling rows when multiple inventory keys match the current key label', () => {
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      {
+        kind: 'ambiguous-label',
+        label: 'sk-or-v1-123',
+        matchingHashes: ['hash-primary', 'hash-secondary'],
+      },
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain('readonly  Multiple keys match the current key label.');
+    expect(renderText(component)).not.toContain('·  t ');
+  });
+
+  it('allows enabling disabled keys even when current management key identity is unavailable', async () => {
+    accountClientMocks.setApiKeyDisabled.mockResolvedValue(
+      createKey({
+        name: 'Disabled Key',
+        hash: 'hash-disabled',
+        status: 'healthy',
+        disabled: false,
+        spend: 5,
+      }),
+    );
+
+    const component = new AccountOverlayComponent(
+      [
+        createKey({
+          name: 'Disabled Key',
+          hash: 'hash-disabled',
+          status: 'disabled',
+          disabled: true,
+          spend: 0,
+        }),
+      ],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain('t enable');
+
+    component.handleInput('t');
+    expect(renderText(component)).toContain('Press Enter to enable Disabled Key');
+
+    component.handleInput('enter');
+
+    await vi.waitFor(() => {
+      expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-disabled', false);
+    });
+
+    await vi.waitFor(() => {
+      expect(renderText(component)).toContain('status    Disabled Key enabled.');
+    });
+  });
+
+  it('blocks disabling the active management key when its identity is known', () => {
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-primary', 'sk-or-v1-123'),
+    );
+    components.push(component);
+
+    expect(renderText(component)).toContain('readonly  Cannot disable the active management key.');
+    expect(renderText(component)).not.toContain('·  t ');
+
+    component.handleInput('t');
+
+    expect(accountClientMocks.setApiKeyDisabled).not.toHaveBeenCalled();
+    expect(renderText(component)).toContain('Cannot disable the active management key.');
+  });
+
+  it('blocks close shortcuts while a toggle is pending', async () => {
+    const toggle = createDeferred<Partial<KeyInfo>>();
+    accountClientMocks.setApiKeyDisabled.mockReturnValue(toggle.promise);
+    const onClose = vi.fn();
+
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      onClose,
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-management'),
+    );
+    components.push(component);
+
+    component.handleInput('t');
+    component.handleInput('enter');
+
+    await vi.waitFor(() => {
+      expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-primary', true);
+    });
+
+    expect(renderText(component)).toContain('status    Disabling Primary...');
+
+    component.handleInput('q');
+    component.handleInput('ctrl+c');
+    component.handleInput('escape');
+
+    expect(onClose).not.toHaveBeenCalled();
+
+    toggle.resolve({
+      name: 'Primary',
+      hash: 'hash-primary',
+      status: 'disabled',
+      disabled: true,
+      spend: 20,
+    });
+
+    await vi.waitFor(() => {
+      expect(renderText(component)).toContain('status    Primary disabled.');
+    });
+
+    component.handleInput('q');
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('finalizes the toggle result even if the overlay is disposed while pending', async () => {
+    const toggle = createDeferred<Partial<KeyInfo>>();
+    accountClientMocks.setApiKeyDisabled.mockReturnValue(toggle.promise);
+
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-management'),
+    );
+    components.push(component);
+
+    component.handleInput('t');
+    component.handleInput('enter');
+
+    await vi.waitFor(() => {
+      expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-primary', true);
+    });
+
+    component.dispose();
+
+    toggle.resolve({
+      name: 'Primary',
+      hash: 'hash-primary',
+      status: 'disabled',
+      disabled: true,
+      spend: 20,
+    });
+
+    await vi.waitFor(() => {
+      const output = renderText(component);
+      expect(output).toContain('status    disabled');
+      expect(output).toContain('status    Primary disabled.');
+      expect((component as any).pendingToggleHash).toBeNull();
+    });
+  });
+
+  it('does not fall back to current-key metadata on refresh when inventory is empty but manageable', async () => {
+    accountClientMocks.getAllKeys.mockResolvedValue(
+      createKeyInventory([], { canManageKeys: true }),
+    );
+    accountClientMocks.getAccountCredits.mockResolvedValue(25);
+    accountClientMocks.getCurrentKey.mockResolvedValue(
+      createKey({ name: 'Current', hash: 'hash-current' }),
+    );
+
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      {} as any,
+    );
+    components.push(component);
+
+    await component.refresh();
+
+    expect(accountClientMocks.resolveCurrentKeyRelation).not.toHaveBeenCalled();
+    expect(accountClientMocks.getCurrentKey).not.toHaveBeenCalled();
+    expect(renderText(component)).toContain('No keys available');
+    expect(renderText(component)).not.toContain('readonly  Set OPENROUTER_MANAGEMENT_KEY');
+  });
+
+  it('falls back to current-key metadata on refresh when management capability is degraded', async () => {
+    accountClientMocks.getAllKeys.mockResolvedValue(
+      createKeyInventory([], {
+        canManageKeys: false,
+        degradedReason: 'management-unavailable',
+      }),
+    );
+    accountClientMocks.getAccountCredits.mockResolvedValue(25);
+    accountClientMocks.getCurrentKey.mockResolvedValue(
+      createKey({ name: 'Current', hash: 'hash-current', spend: 12 }),
+    );
+
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      {} as any,
+    );
+    components.push(component);
+
+    await component.refresh();
+
+    expect(accountClientMocks.getCurrentKey).toHaveBeenCalledTimes(1);
+    expect(renderText(component)).toContain('name      Current');
+    expect(renderText(component)).toContain('readonly  Set OPENROUTER_MANAGEMENT_KEY');
+  });
+
+  it.each([400, 404])(
+    'maps invalid or missing selected-key toggle errors (status %s) to refresh guidance without rendering internal hashes',
+    async (statusCode) => {
+      accountClientMocks.setApiKeyDisabled.mockRejectedValue(
+        createApiError(
+          statusCode === 400 ? 'OpenRouter rejected hash-primary as invalid' : 'Key not found',
+          statusCode,
+        ),
+      );
+
+      const component = new AccountOverlayComponent(
+        [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+        25,
+        rollupStatus,
+        null,
+        createIdentityTheme(),
+        () => {},
+        () => {},
+        undefined,
+        true,
+        createInventoryMatchRelation('hash-management'),
+      );
+      components.push(component);
+
+      component.handleInput('t');
+      component.handleInput('enter');
+
+      await vi.waitFor(() => {
+        expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-primary', true);
+      });
+
+      await vi.waitFor(() => {
+        expect((component as any).inlineMessage).toBe(
+          'Failed to disable Primary: OpenRouter could not match the selected key. Refresh the account view and try again.',
+        );
+        const output = renderText(component);
+        expect(output).not.toContain('hash-primary');
+        expect(output).not.toContain('rejected hash-primary');
+      });
+    },
+  );
+
+  it.each([
+    {
+      title: 'management-key auth errors',
+      error: createAuthError('Unauthorized'),
+      expected:
+        'Failed to disable Primary: Set OPENROUTER_MANAGEMENT_KEY to a valid management key, then refresh and try again.',
+    },
+    {
+      title: 'management-key permission errors',
+      error: createApiError('Forbidden', 403),
+      expected:
+        'Failed to disable Primary: OPENROUTER_MANAGEMENT_KEY does not have permission to update keys. Set it to a valid management key and refresh.',
+    },
+    {
+      title: 'retryable rate-limit errors',
+      error: createApiError('Too Many Requests', 429),
+      expected:
+        'Failed to disable Primary: OpenRouter could not update the selected key right now. Retry in a moment and refresh.',
+    },
+    {
+      title: 'retryable service errors',
+      error: createApiError('Service unavailable', 503),
+      expected:
+        'Failed to disable Primary: OpenRouter could not update the selected key right now. Retry in a moment and refresh.',
+    },
+  ])('maps $title to distinct inline guidance', async ({ error, expected }) => {
+    accountClientMocks.setApiKeyDisabled.mockRejectedValue(error);
+
+    const component = new AccountOverlayComponent(
+      [createKey({ name: 'Primary', hash: 'hash-primary', spend: 20 })],
+      25,
+      rollupStatus,
+      null,
+      createIdentityTheme(),
+      () => {},
+      () => {},
+      undefined,
+      true,
+      createInventoryMatchRelation('hash-management'),
+    );
+    components.push(component);
+
+    component.handleInput('t');
+    component.handleInput('enter');
+
+    await vi.waitFor(() => {
+      expect(accountClientMocks.setApiKeyDisabled).toHaveBeenCalledWith('hash-primary', true);
+    });
+
+    await vi.waitFor(() => {
+      expect((component as any).inlineMessage).toBe(expected);
+      const output = renderText(component);
+      expect(output).not.toContain('hash-primary');
+    });
+  });
+});