@pellux/goodvibes-agent 0.1.0

package/src/panels/provider-account-snapshot.ts

@@ -0,0 +1,259 @@
+import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
+import type {
+  ProviderAccountInspectionQuery,
+} from '../runtime/ui-service-queries.ts';
+
+export type ProviderAuthRoute = 'api-key' | 'subscription' | 'service-oauth' | 'unconfigured';
+export type ProviderAuthFreshness = 'healthy' | 'expiring' | 'expired' | 'pending' | 'unconfigured';
+
+export interface ProviderUsageWindow {
+  readonly label: string;
+  readonly detail: string;
+}
+
+export interface ProviderRouteRecord {
+  readonly route: Exclude<ProviderAuthRoute, 'unconfigured'>;
+  readonly usable: boolean;
+  readonly freshness: ProviderAuthFreshness;
+  readonly detail: string;
+  readonly issues: readonly string[];
+}
+
+export interface ProviderAccountRecord {
+  readonly providerId: string;
+  readonly active: boolean;
+  readonly modelCount: number;
+  readonly configured: boolean;
+  readonly oauthReady: boolean;
+  readonly pendingLogin: boolean;
+  readonly availableRoutes: readonly ProviderAuthRoute[];
+  readonly preferredRoute: ProviderAuthRoute;
+  readonly activeRoute: ProviderAuthRoute;
+  readonly activeRouteReason: string;
+  readonly authFreshness: ProviderAuthFreshness;
+  readonly fallbackRoute?: ProviderAuthRoute;
+  readonly fallbackRisk?: string;
+  readonly expiresAt?: number;
+  readonly tokenType?: string;
+  readonly notes: readonly string[];
+  readonly usageWindows: readonly ProviderUsageWindow[];
+  readonly issues: readonly string[];
+  readonly recommendedActions: readonly string[];
+  readonly routeRecords: readonly ProviderRouteRecord[];
+}
+
+export interface ProviderAccountSnapshot {
+  readonly capturedAt: number;
+  readonly providers: readonly ProviderAccountRecord[];
+  readonly configuredCount: number;
+  readonly issueCount: number;
+}
+
+export interface ProviderAccountSnapshotDeps extends ProviderAccountInspectionQuery {}
+
+export interface ProviderAccountSnapshotQuery {
+  readonly loadSnapshot: () => Promise<ProviderAccountSnapshot>;
+}
+
+export function createProviderAccountSnapshotQuery(
+  deps: ProviderAccountSnapshotDeps,
+): ProviderAccountSnapshotQuery {
+  return {
+    loadSnapshot: () => buildProviderAccountSnapshot(deps),
+  };
+}
+
+function determineActiveRoute(routes: readonly ProviderAuthRoute[]): ProviderAuthRoute {
+  if (routes.includes('subscription')) return 'subscription';
+  if (routes.includes('service-oauth')) return 'service-oauth';
+  if (routes.includes('api-key')) return 'api-key';
+  return 'unconfigured';
+}
+
+function isExpired(expiresAt?: number): boolean {
+  return typeof expiresAt === 'number' && Number.isFinite(expiresAt) && expiresAt <= Date.now();
+}
+
+function determineFreshness(input: {
+  readonly hasSubscription: boolean;
+  readonly expiresAt?: number;
+  readonly pending: boolean;
+  readonly hasServiceOAuth: boolean;
+  readonly hasApiKey: boolean;
+}): ProviderAuthFreshness {
+  if (input.hasSubscription) {
+    if (isExpired(input.expiresAt)) return 'expired';
+    if (input.expiresAt && input.expiresAt <= Date.now() + 24 * 60 * 60 * 1000) return 'expiring';
+    if (input.pending) return 'pending';
+    return 'healthy';
+  }
+  if (input.hasServiceOAuth || input.hasApiKey) return 'healthy';
+  return 'unconfigured';
+}
+
+function builtinWindowsForProvider(providerId: string): readonly ProviderUsageWindow[] {
+  if (providerId === 'openai') {
+    return [
+      { label: '5-hour window', detail: 'Subscription-backed Codex access may be constrained by rolling 5-hour usage limits.' },
+      { label: '1-week window', detail: 'Subscription-backed Codex access may also be constrained by a rolling weekly limit.' },
+    ];
+  }
+  return [];
+}
+
+export async function buildProviderAccountSnapshot(
+  deps: ProviderAccountSnapshotDeps,
+): Promise<ProviderAccountSnapshot> {
+  const models = deps.providerModels.listModels();
+  const services = deps.services.getAll();
+  const subscriptions = deps.subscriptions;
+  const builtinSubscriptionProviders = new Set(listBuiltinSubscriptionProviders().map((entry) => entry.provider));
+  const serviceInspections = await Promise.all(Object.keys(services).map(async (name) => ({
+    name,
+    inspection: await deps.services.inspect(name),
+  })));
+  const serviceOauthByProvider = new Map<string, { configured: boolean; usable: boolean }>();
+  for (const { inspection } of serviceInspections) {
+    if (!inspection || inspection.config.authType !== 'oauth') continue;
+    const providerId = inspection.config.providerId ?? inspection.config.name;
+    const existing = serviceOauthByProvider.get(providerId);
+    serviceOauthByProvider.set(providerId, {
+      configured: true,
+      usable: Boolean(existing?.usable || inspection.hasPrimaryCredential),
+    });
+  }
+
+  const providerIds = new Set<string>([
+    ...models.map((model) => model.provider),
+    ...Object.keys(services),
+    ...subscriptions.list().map((entry) => entry.provider),
+    ...subscriptions.listPending().map((entry) => entry.provider),
+    ...builtinSubscriptionProviders,
+  ]);
+
+  const providers = await Promise.all([...providerIds].sort((a, b) => a.localeCompare(b)).map(async (providerId) => {
+    const subscription = subscriptions.get(providerId);
+    const pending = subscriptions.getPending(providerId);
+    const serviceConfig = Object.values(services).find((entry) => (entry.providerId ?? entry.name) === providerId) ?? null;
+    const serviceOauth = serviceOauthByProvider.get(providerId);
+    const hasApiKey = Boolean(serviceConfig?.tokenKey && deps.environment.hasEnvironmentVariable(serviceConfig.tokenKey));
+    const hasSubscription = subscription != null;
+    const hasServiceOAuth = Boolean(serviceOauth?.configured);
+    const routes: ProviderAuthRoute[] = [];
+    if (hasApiKey) routes.push('api-key');
+    if (hasSubscription) routes.push('subscription');
+    if (hasServiceOAuth) routes.push('service-oauth');
+    if (routes.length === 0) routes.push('unconfigured');
+
+    const usableRoutes: Exclude<ProviderAuthRoute, 'unconfigured'>[] = [];
+    if (hasApiKey) usableRoutes.push('api-key');
+    if (hasSubscription && !isExpired(subscription.expiresAt)) usableRoutes.push('subscription');
+    if (hasServiceOAuth) usableRoutes.push('service-oauth');
+
+    const activeRoute = determineActiveRoute(usableRoutes.length > 0 ? usableRoutes : routes);
+    const preferredRoute = determineActiveRoute(routes);
+    const freshness = determineFreshness({
+      hasSubscription,
+      expiresAt: subscription?.expiresAt,
+      pending: pending != null,
+      hasServiceOAuth,
+      hasApiKey,
+    });
+    const usageWindows = builtinWindowsForProvider(providerId);
+    const routeRecords: ProviderRouteRecord[] = [];
+
+    if (hasApiKey) {
+      routeRecords.push({
+        route: 'api-key',
+        usable: true,
+        freshness: 'healthy',
+        detail: 'Ambient API key is available for direct provider access.',
+        issues: [],
+      });
+    }
+    if (hasSubscription) {
+      routeRecords.push({
+        route: 'subscription',
+        usable: !isExpired(subscription?.expiresAt),
+        freshness: pending ? 'pending' : isExpired(subscription?.expiresAt) ? 'expired' : 'healthy',
+        detail: subscription?.overrideAmbientApiKeys
+          ? 'Subscription route is configured to override ambient API-key resolution.'
+          : 'Subscription route is configured, but ambient API keys remain active unless selected explicitly.',
+        issues: isExpired(subscription?.expiresAt) ? ['Stored subscription session is expired.'] : [],
+      });
+    }
+    if (hasServiceOAuth) {
+      routeRecords.push({
+        route: 'service-oauth',
+        usable: true,
+        freshness: 'healthy',
+        detail: 'Service OAuth credential is available for this provider.',
+        issues: [],
+      });
+    }
+
+    const issues: string[] = [];
+    const notes: string[] = [`${models.filter((model) => model.provider === providerId).length} model${models.filter((model) => model.provider === providerId).length === 1 ? '' : 's'} registered`];
+    if (serviceConfig) notes.push(`service config: ${serviceConfig.authType}`);
+    const recommendedActions: string[] = [];
+    if (routes.length === 1 && routes[0] === 'unconfigured') {
+      issues.push('Provider has no configured auth route.');
+      recommendedActions.push(`Configure API keys, subscriptions, or service OAuth for ${providerId}.`);
+    }
+    if (hasSubscription && isExpired(subscription?.expiresAt)) {
+      issues.push('Stored subscription session is expired and needs refresh.');
+      recommendedActions.push(`Refresh or replace the ${providerId} subscription session before relying on it.`);
+    } else if (hasSubscription && subscription?.expiresAt && subscription.expiresAt <= Date.now() + 24 * 60 * 60 * 1000) {
+      issues.push('Stored subscription session is nearing expiry.');
+      recommendedActions.push(`Renew or verify the ${providerId} subscription session soon to avoid route drift.`);
+    }
+    if (pending) {
+      issues.push('Provider has a pending OAuth login that has not been completed yet.');
+      recommendedActions.push(`Finish /subscription login ${providerId} finish <code> or clear the pending login.`);
+    }
+    if (hasSubscription && hasApiKey) {
+      issues.push('Provider has both subscription and API-key auth paths; routing must remain explicit.');
+      recommendedActions.push('Review provider routing before switching models or auth paths.');
+    }
+    if (hasServiceOAuth && !serviceOauth?.usable) {
+      issues.push('Service OAuth is configured but missing a usable credential.');
+      recommendedActions.push(`Repair service OAuth credentials for ${providerId} in /services or /settings.`);
+    }
+
+    return {
+      providerId,
+      active: activeRoute !== 'unconfigured',
+      modelCount: models.filter((model) => model.provider === providerId).length,
+      configured: hasApiKey || hasSubscription || hasServiceOAuth || models.some((model) => model.provider === providerId),
+      oauthReady: Boolean(serviceConfig?.oauth),
+      pendingLogin: Boolean(pending),
+      availableRoutes: routes,
+      preferredRoute,
+      activeRoute,
+      activeRouteReason: activeRoute === 'subscription'
+        ? 'Subscription route is currently preferred.'
+        : activeRoute === 'service-oauth'
+          ? 'Service OAuth route is currently preferred.'
+          : activeRoute === 'api-key'
+            ? 'Ambient API-key route is currently preferred.'
+            : 'No usable auth route is configured for this provider.',
+      authFreshness: freshness,
+      fallbackRoute: activeRoute !== preferredRoute ? preferredRoute : undefined,
+      fallbackRisk: hasSubscription && hasApiKey ? 'Both subscription and API key are present; check route priority.' : undefined,
+      expiresAt: subscription?.expiresAt,
+      tokenType: subscription?.tokenType,
+      notes,
+      usageWindows,
+      issues,
+      recommendedActions,
+      routeRecords,
+    };
+  }));
+
+  return {
+    capturedAt: Date.now(),
+    providers,
+    configuredCount: providers.filter((provider) => provider.configured).length,
+    issueCount: providers.reduce((sum, provider) => sum + provider.issues.length, 0),
+  };
+}

package/src/panels/provider-accounts-panel.ts

@@ -0,0 +1,218 @@
+import type { Line } from '../types/grid.ts';
+import { createEmptyLine } from '../types/grid.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import {
+  buildDetailBlock,
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelListRow,
+  buildPanelLine,
+  buildSummaryBlock,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  resolvePrimaryScrollableSection,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+import {
+  type ProviderAccountRecord,
+  type ProviderAccountSnapshot,
+  type ProviderAccountSnapshotQuery,
+} from './provider-account-snapshot.ts';
+
+export interface ProviderAccountsPanelDeps {
+  readonly providerAccounts: ProviderAccountSnapshotQuery;
+}
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  selectBg: '#1e293b',
+} as const;
+
+export class ProviderAccountsPanel extends ScrollableListPanel<ProviderAccountRecord> {
+  private records: ProviderAccountRecord[] = [];
+  private loading = false;
+  private readonly providerAccounts: ProviderAccountSnapshotQuery;
+
+  public constructor(deps: ProviderAccountsPanelDeps) {
+    super('accounts', 'Accounts', 'Q', 'monitoring');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this.providerAccounts = deps.providerAccounts;
+    void this.refresh();
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    if (!this.loading) void this.refresh();
+  }
+
+  protected getItems(): readonly ProviderAccountRecord[] {
+    return this.records;
+  }
+
+  protected renderItem(item: ProviderAccountRecord, _index: number, selected: boolean, width: number): Line {
+    return buildPanelListRow(width, [
+      { text: item.providerId.padEnd(16), fg: item.active ? C.good : C.value },
+      { text: ` ${item.activeRoute.padEnd(14)}`, fg: item.activeRoute === 'subscription' ? C.info : item.activeRoute === 'api-key' ? C.warn : item.activeRoute === 'service-oauth' ? C.value : C.dim },
+      { text: ` models=${String(item.modelCount).padEnd(4)}`, fg: C.dim },
+      { text: ` ${item.authFreshness.padEnd(10)}`, fg: item.authFreshness === 'expired' ? C.bad : item.authFreshness === 'expiring' || item.authFreshness === 'pending' ? C.warn : C.dim },
+      { text: ` issues=${String(item.issues.length).padEnd(2)}`, fg: item.issues.length > 0 ? C.bad : C.good },
+    ], C, { selected });
+  }
+
+  public handleInput(key: string): boolean {
+    if (key === 'r') {
+      void this.refresh();
+      return true;
+    }
+    return super.handleInput(key);
+  }
+
+  private async refresh(): Promise<void> {
+    this.loading = true;
+    this.markDirty();
+    const snapshot = await this.buildSnapshot();
+    this.records = [...snapshot.providers];
+    this.clampSelection();
+    this.loading = false;
+    this.markDirty();
+  }
+
+  private async buildSnapshot(): Promise<ProviderAccountSnapshot> {
+    return this.providerAccounts.loadSnapshot();
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    const intro = 'Provider auth routes, subscription posture, quota-window hints, and routing-safety notes.';
+    const footerLines = [buildPanelLine(width, [['  Up/Down move  r refresh  /accounts routes <provider>  /accounts repair <provider>', C.dim]])];
+    if (this.loading && this.records.length === 0) {
+      const lines = buildPanelWorkspace(width, height, {
+        title: 'Provider Account Control Room',
+        intro,
+        sections: [{ lines: [buildPanelLine(width, [[' Loading provider account posture...', C.info]])] }],
+        palette: C,
+      });
+      while (lines.length < height) lines.push(createEmptyLine(width));
+      return lines;
+    }
+    if (this.records.length === 0) {
+      const lines = buildPanelWorkspace(width, height, {
+        title: 'Provider Account Control Room',
+        intro,
+        sections: [{
+          lines: buildEmptyState(width, ' No provider accounts discovered.', 'Configure API keys or subscriptions to populate account routing posture.', [{ command: '/provider', summary: 'review current provider and model posture' }], C),
+        }],
+        palette: C,
+      });
+      while (lines.length < height) lines.push(createEmptyLine(width));
+      return lines;
+    }
+    const issueCount = this.records.reduce((sum, record) => sum + record.issues.length + (record.fallbackRisk ? 1 : 0), 0);
+    const expiredCount = this.records.filter((record) => record.authFreshness === 'expired').length;
+    const pendingCount = this.records.filter((record) => record.pendingLogin).length;
+    const fallbackCount = this.records.filter((record) => Boolean(record.fallbackRisk)).length;
+    const selected = this.records[this.selectedIndex]!;
+    const postureLines: Line[] = [
+      buildKeyValueLine(width, [
+        { label: 'providers', value: String(this.records.length), valueColor: C.value },
+        { label: 'expired auth', value: String(expiredCount), valueColor: expiredCount > 0 ? C.bad : C.good },
+        { label: 'pending login', value: String(pendingCount), valueColor: pendingCount > 0 ? C.warn : C.dim },
+        { label: 'fallback risk', value: String(fallbackCount), valueColor: fallbackCount > 0 ? C.warn : C.good },
+      ], C),
+      buildKeyValueLine(width, [
+        { label: 'total issues', value: String(issueCount), valueColor: issueCount > 0 ? C.bad : C.good },
+        { label: 'selected', value: selected.providerId, valueColor: C.info },
+        { label: 'route', value: selected.activeRoute, valueColor: selected.activeRoute === 'subscription' ? C.info : selected.activeRoute === 'api-key' ? C.warn : C.value },
+        { label: 'freshness', value: selected.authFreshness, valueColor: selected.authFreshness === 'expired' ? C.bad : selected.authFreshness === 'expiring' || selected.authFreshness === 'pending' ? C.warn : C.good },
+      ], C),
+      buildGuidanceLine(width, '/accounts repair <provider>', 'review routing safety, fallback cost, and provider-specific recovery steps', C),
+    ];
+    const detailRows: Line[] = [
+      buildKeyValueLine(width, [
+        { label: 'provider', value: selected.providerId, valueColor: C.value },
+        { label: 'active route', value: selected.activeRoute, valueColor: selected.activeRoute === 'subscription' ? C.info : selected.activeRoute === 'api-key' ? C.warn : selected.activeRoute === 'service-oauth' ? C.value : C.bad },
+        { label: 'preferred route', value: selected.preferredRoute, valueColor: C.dim },
+        { label: 'freshness', value: selected.authFreshness, valueColor: selected.authFreshness === 'expired' ? C.bad : selected.authFreshness === 'expiring' || selected.authFreshness === 'pending' ? C.warn : C.good },
+      ], C),
+      buildKeyValueLine(width, [
+        { label: 'configured', value: selected.configured ? 'yes' : 'no', valueColor: selected.configured ? C.good : C.bad },
+        { label: 'oauth ready', value: selected.oauthReady ? 'yes' : 'no', valueColor: selected.oauthReady ? C.info : C.dim },
+        { label: 'pending login', value: selected.pendingLogin ? 'yes' : 'no', valueColor: selected.pendingLogin ? C.warn : C.dim },
+      ], C),
+      buildPanelLine(width, [[`  Active route reason: ${selected.activeRouteReason}`.slice(0, width), C.dim]]),
+      buildPanelLine(width, [[`  Available routes: ${selected.availableRoutes.join(', ') || 'unconfigured'}`.slice(0, width), C.dim]]),
+    ];
+    if (selected.expiresAt) {
+      detailRows.push(buildPanelLine(width, [
+        ['  Expires: ', C.label],
+        [new Date(selected.expiresAt).toISOString(), C.dim],
+        ['  Token: ', C.label],
+        [selected.tokenType ?? 'n/a', C.value],
+      ]));
+    }
+    if (selected.fallbackRisk) {
+      detailRows.push(buildPanelLine(width, [[`  fallback: ${selected.fallbackRisk}`.slice(0, width), C.warn]]));
+    }
+    for (const route of selected.routeRecords) {
+      detailRows.push(buildPanelLine(width, [[
+        `  route ${route.route}: ${route.usable ? 'usable' : 'blocked'} • ${route.freshness} • ${route.detail}`.slice(0, width),
+        route.usable ? C.dim : C.bad,
+      ]]));
+      for (const issue of route.issues) {
+        detailRows.push(buildPanelLine(width, [[`    issue: ${issue}`.slice(0, width), C.bad]]));
+      }
+    }
+    for (const windowHint of selected.usageWindows) {
+      detailRows.push(buildPanelLine(width, [[`  ${windowHint.label}: ${windowHint.detail}`.slice(0, width), C.dim]]));
+    }
+    for (const issue of selected.issues) {
+      detailRows.push(buildPanelLine(width, [[`  issue: ${issue}`.slice(0, width), C.bad]]));
+    }
+    for (const note of selected.notes) {
+      detailRows.push(buildPanelLine(width, [[`  note: ${note}`.slice(0, width), C.info]]));
+    }
+    for (const action of selected.recommendedActions) {
+      detailRows.push(buildPanelLine(width, [[`  next: ${action}`.slice(0, width), C.value]]));
+    }
+    if (selected.issues.length === 0 && selected.notes.length === 0 && selected.usageWindows.length === 0 && selected.recommendedActions.length === 0) {
+      detailRows.push(buildPanelLine(width, [['  No active account warnings for this provider.', C.dim]]));
+    }
+    const postureSection: PanelWorkspaceSection = { lines: buildSummaryBlock(width, 'Provider posture', postureLines, C) };
+    const detailsSection: PanelWorkspaceSection = { lines: buildDetailBlock(width, 'Selected provider', detailRows, C) };
+    const rawProviderLines: Line[] = this.records.map((record, absolute) =>
+      this.renderItem(record, absolute, absolute === this.selectedIndex, width),
+    );
+    const resolvedProvidersSection = resolvePrimaryScrollableSection(width, height, {
+      intro,
+      footerLines,
+      palette: C,
+      beforeSections: [postureSection],
+      section: {
+        title: 'Providers',
+        scrollableLines: rawProviderLines,
+        selectedIndex: this.selectedIndex,
+        scrollOffset: this.scrollStart,
+        guardRows: 1,
+        minRows: 4,
+        appendWindowSummary: { dimColor: C.dim },
+      },
+      afterSections: [detailsSection],
+    });
+    this.scrollStart = resolvedProvidersSection.scrollOffset;
+    const sections: PanelWorkspaceSection[] = [
+      postureSection,
+      resolvedProvidersSection.section,
+      detailsSection,
+    ];
+    const lines = buildPanelWorkspace(width, height, {
+      title: 'Provider Account Control Room',
+      intro,
+      sections,
+      footerLines,
+      palette: C,
+    });
+    while (lines.length < height) lines.push(createEmptyLine(width));
+    return lines.slice(0, height);
+  }
+}