opencode-dux 1.0.0

package/src/subscriptions/types.ts

@@ -0,0 +1,145 @@
+/**
+ * Type definitions for multi-provider subscription usage tracking.
+ *
+ * Supports OpenCode Go (dashboard scraping) and Neuralwatt (REST API)
+ * as discriminated unions on the `provider` field.
+ */
+
+/** Provider discriminator. */
+export type SubscriptionProvider = 'opencode-go' | 'neuralwatt';
+
+// ── Account definitions (discriminated union) ──
+
+export interface OpenCodeGoAccount {
+  provider: 'opencode-go';
+  name: string;
+  workspaceId: string;
+  authCookie: string;
+  apiKey?: string;
+}
+
+export interface NeuralwattAccount {
+  provider: 'neuralwatt';
+  name: string;
+  apiKey: string;
+}
+
+export type StoredAccount = OpenCodeGoAccount | NeuralwattAccount;
+
+// ── Usage window (OpenCode Go) ──
+
+/** Per-time-window usage data scraped from the OpenCode Go dashboard. */
+export interface UsageWindow {
+  /** Usage percentage [0..100] */
+  usagePercent: number;
+  /** Seconds until usage resets */
+  resetInSec: number;
+  /** Remaining percentage [0..100] */
+  percentRemaining: number;
+  /** ISO reset timestamp */
+  resetTimeIso: string;
+}
+
+// ── OpenCode Go usage entry ──
+
+/** Snapshot entry per OpenCode Go account - stored in tui-state.json. */
+export interface OpenCodeGoUsageEntry {
+  provider: 'opencode-go';
+  /** Display name for this account (from config). */
+  accountName: string;
+  /** OpenCode Go workspace ID. */
+  workspaceId: string;
+  /** Rolling (~5h) usage window, when present. */
+  rolling?: UsageWindow;
+  /** Weekly usage window, when present. */
+  weekly?: UsageWindow;
+  /** Monthly usage window, when present. */
+  monthly?: UsageWindow;
+  /** Timestamp when data was fetched. */
+  fetchedAt: number;
+  /** Error message if the scrape failed for this account. */
+  error?: string;
+}
+
+// ── Neuralwatt types ──
+
+export interface NeuralwattBalance {
+  credits_remaining_usd: number;
+  total_credits_usd: number;
+  credits_used_usd: number;
+  accounting_method: string;
+}
+
+export interface NeuralwattUsagePeriod {
+  cost_usd: number;
+  requests: number;
+  tokens: number;
+  energy_kwh: number;
+}
+
+export interface NeuralwattUsage {
+  lifetime: NeuralwattUsagePeriod;
+  current_month: NeuralwattUsagePeriod;
+}
+
+export interface NeuralwattSubscription {
+  plan: string;
+  status: 'active' | 'canceling' | 'past_due' | 'paused' | 'trialing';
+  billing_interval: string | null;
+  current_period_start: string | null;
+  current_period_end: string | null;
+  auto_renew: boolean | null;
+  kwh_included: number | null;
+  kwh_used: number | null;
+  kwh_remaining: number | null;
+  in_overage: boolean | null;
+}
+
+/** Snapshot entry per Neuralwatt account - stored in tui-state.json. */
+export interface NeuralwattUsageEntry {
+  provider: 'neuralwatt';
+  /** Display name for this account. */
+  accountName: string;
+  /** ISO timestamp from the API response. */
+  snapshot_at: string;
+  /** Credit balance. */
+  balance: NeuralwattBalance;
+  /** Usage data (lifetime + current month). */
+  usage: NeuralwattUsage;
+  /** Subscription details, null if no active subscription. */
+  subscription: NeuralwattSubscription | null;
+  /** Timestamp when data was fetched. */
+  fetchedAt: number;
+  /** Error message if the fetch failed. */
+  error?: string;
+}
+
+// ── Unified usage entry ──
+
+export type SubscriptionUsageEntry =
+  | OpenCodeGoUsageEntry
+  | NeuralwattUsageEntry;
+
+// ── Detailed usage (OpenCode Go /usage page) ──
+
+/** Detailed usage data from the /usage page. */
+export interface UsageDetail {
+  /** Total number of API calls. */
+  totalCalls: number;
+  /** Total estimated cost in USD. */
+  totalCost: number;
+  /** Per-model breakdown. */
+  perModel: Array<{
+    model: string;
+    calls: number;
+    cost: number;
+  }>;
+}
+
+// ── Config ──
+
+/** Config for the subscription tracking feature. */
+export interface SubscriptionsConfig {
+  /** Minimum interval between auto-refreshes in ms (default: 60000). */
+  refreshIntervalMs: number;
+}

package/src/subscriptions/usage-service.test.ts

@@ -0,0 +1,202 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { readTuiSnapshot } from '../tui-state';
+import { UsageService } from './usage-service';
+
+let previousXdgDataHome: string | undefined;
+let tempDir: string;
+
+function getStorageDir(): string {
+  return path.join(tempDir, 'opencode', 'storage', 'opencode-dux');
+}
+
+function getSubscriptionsPath(): string {
+  return path.join(getStorageDir(), 'subscriptions.json');
+}
+
+function getAuthPath(): string {
+  return path.join(tempDir, 'opencode', 'auth.json');
+}
+
+function writeSubscriptions(raw: unknown): void {
+  fs.mkdirSync(getStorageDir(), { recursive: true });
+  fs.writeFileSync(getSubscriptionsPath(), `${JSON.stringify(raw, null, 2)}\n`);
+}
+
+function createUsageService(options?: {
+  authSet?: (input: unknown) => Promise<void>;
+}): UsageService {
+  const client = {
+    auth: {
+      set: options?.authSet ?? (async () => undefined),
+    },
+    tui: {
+      showToast: async () => undefined,
+    },
+  } as unknown as import('@opencode-ai/plugin').PluginInput['client'];
+  return new UsageService(client, 60_000, 600_000);
+}
+
+beforeEach(() => {
+  previousXdgDataHome = process.env.XDG_DATA_HOME;
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'omos-usage-service-'));
+  process.env.XDG_DATA_HOME = tempDir;
+});
+
+afterEach(() => {
+  if (previousXdgDataHome === undefined) {
+    delete process.env.XDG_DATA_HOME;
+  } else {
+    process.env.XDG_DATA_HOME = previousXdgDataHome;
+  }
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('usage-service', () => {
+  test('creates explicit sidebar error for faulty OpenCode Go credentials', async () => {
+    writeSubscriptions({
+      version: 2,
+      accounts: [
+        {
+          provider: 'opencode-go',
+          name: 'broken-go',
+          workspaceId: 'wrk_123',
+          authCookie: '',
+          apiKey: '',
+        },
+      ],
+    });
+
+    const service = createUsageService();
+    const entries = await service.refresh(true);
+    service.dispose();
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.accountName).toBe('broken-go');
+    expect(entries[0]?.error).toContain('Missing OpenCode Go cookie');
+
+    const snapshot = readTuiSnapshot();
+    const usage = Object.values(snapshot.subscriptionUsage);
+    expect(usage).toHaveLength(1);
+    expect(usage[0]?.accountName).toBe('broken-go');
+    expect(usage[0]?.error).toContain('Missing OpenCode Go cookie');
+  });
+
+  test('syncActiveAccounts resolves active names per provider from auth.json', () => {
+    writeSubscriptions({
+      version: 2,
+      accounts: [
+        {
+          provider: 'opencode-go',
+          name: 'go-main',
+          workspaceId: 'wrk_123',
+          authCookie: 'cookie',
+          apiKey: 'go-key',
+        },
+        {
+          provider: 'neuralwatt',
+          name: 'nw-main',
+          apiKey: 'nw-key',
+        },
+      ],
+    });
+
+    fs.mkdirSync(path.dirname(getAuthPath()), { recursive: true });
+    fs.writeFileSync(
+      getAuthPath(),
+      `${JSON.stringify(
+        {
+          'opencode-go': { type: 'api', key: 'go-key' },
+          neuralwatt: { type: 'api', key: 'nw-key' },
+        },
+        null,
+        2,
+      )}\n`,
+    );
+
+    const service = createUsageService();
+    const active = service.syncActiveAccounts();
+    service.dispose();
+
+    expect(active['opencode-go']).toBe('go-main');
+    expect(active.neuralwatt).toBe('nw-main');
+    const snapshot = readTuiSnapshot();
+    expect(snapshot.activeSubscriptionByProvider['opencode-go']).toBe(
+      'go-main',
+    );
+    expect(snapshot.activeSubscriptionByProvider.neuralwatt).toBe('nw-main');
+  });
+
+  test('failed account-file read does not poison next non-forced refresh', async () => {
+    fs.mkdirSync(getStorageDir(), { recursive: true });
+    fs.writeFileSync(getSubscriptionsPath(), '{ malformed json');
+
+    const service = createUsageService();
+    const first = await service.refresh(false);
+    expect(first).toEqual([]);
+
+    writeSubscriptions({
+      version: 2,
+      accounts: [
+        {
+          provider: 'opencode-go',
+          name: 'needs-key',
+          workspaceId: 'wrk_123',
+          authCookie: 'cookie',
+        },
+      ],
+    });
+
+    const second = await service.refresh(false);
+    service.dispose();
+
+    expect(second).toHaveLength(1);
+    expect(second[0]?.accountName).toBe('needs-key');
+    expect(second[0]?.error).toContain('Missing OpenCode Go API key');
+  });
+
+  test('switch requires provider and selects matching account', async () => {
+    writeSubscriptions({
+      version: 2,
+      accounts: [
+        {
+          provider: 'opencode-go',
+          name: 'Main',
+          workspaceId: 'wrk_123',
+          authCookie: 'cookie',
+          apiKey: 'go-main-key',
+        },
+        {
+          provider: 'neuralwatt',
+          name: 'Main',
+          apiKey: 'nw-main-key',
+        },
+      ],
+    });
+
+    const authSetCalls: unknown[] = [];
+    const service = createUsageService({
+      authSet: async (input) => {
+        authSetCalls.push(input);
+      },
+    });
+    const output = { parts: [] as Array<{ type: string; text?: string }> };
+    await service.handleCommandExecuteBefore(
+      {
+        command: 'subscriptions',
+        sessionID: 'ses_test',
+        arguments: 'switch neuralwatt Main',
+      },
+      output,
+    );
+    service.dispose();
+
+    expect(authSetCalls).toHaveLength(1);
+    expect(authSetCalls[0]).toEqual({
+      path: { id: 'neuralwatt' },
+      body: { type: 'api', key: 'nw-main-key' },
+    });
+  });
+});