opencode-dux 1.0.0

package/src/subscriptions/accounts-store.ts

@@ -0,0 +1,184 @@
+/**
+ * Local file-based storage for subscription accounts.
+ *
+ * Stores account credentials in a local JSON file alongside tui-state.json,
+ * NOT in the plugin config, so auth tokens are never committed to repos or
+ * exposed in the published schema.
+ *
+ * Supports multiple providers (OpenCode Go, Neuralwatt) via discriminated
+ * unions on the `provider` field.
+ *
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { StoredAccount, SubscriptionProvider } from './types';
+
+// Re-export for consumers
+export type { StoredAccount };
+
+interface AccountsFile {
+  version: 2;
+  accounts: StoredAccount[];
+}
+
+export type LoadAccountsResult =
+  | { ok: true; accounts: StoredAccount[] }
+  | { ok: false; accounts: StoredAccount[] };
+
+const STATE_DIR = 'opencode-dux';
+const ACCOUNTS_FILE = 'subscriptions.json';
+
+function dataDir(): string {
+  return (
+    process.env.XDG_DATA_HOME ?? path.join(os.homedir(), '.local', 'share')
+  );
+}
+
+function getAccountsPath(): string {
+  return path.join(dataDir(), 'opencode', 'storage', STATE_DIR, ACCOUNTS_FILE);
+}
+
+function emptyFile(): AccountsFile {
+  return { version: 2, accounts: [] };
+}
+
+function parseAccountsFile(value: string): AccountsFile | null {
+  try {
+    const parsed = JSON.parse(value) as Partial<AccountsFile>;
+    if (parsed?.version === 2 && Array.isArray(parsed.accounts)) {
+      return {
+        version: 2,
+        accounts: parsed.accounts,
+      };
+    }
+  } catch {
+    // Fall through to null
+  }
+  return null;
+}
+
+function writeAccountsFile(file: AccountsFile): void {
+  try {
+    const filePath = getAccountsPath();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(file, null, 2)}\n`);
+  } catch {
+    // Best-effort
+  }
+}
+
+function loadAccountsResult(): LoadAccountsResult {
+  const accountsPath = getAccountsPath();
+  try {
+    const parsed = parseAccountsFile(fs.readFileSync(accountsPath, 'utf8'));
+    if (!parsed) return { ok: false, accounts: [] };
+    return { ok: true, accounts: parsed.accounts };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return { ok: true, accounts: [] };
+    }
+    return { ok: false, accounts: [] };
+  }
+}
+
+function readAccountsFile(): AccountsFile {
+  const result = loadAccountsResult();
+  if (!result.ok) return emptyFile();
+  return { version: 2, accounts: result.accounts };
+}
+
+/**
+ * Load all stored accounts.
+ */
+export function loadAccounts(): StoredAccount[] {
+  return loadAccountsResult().accounts;
+}
+
+export { loadAccountsResult };
+
+/**
+ * Load accounts filtered by provider.
+ */
+export function getAccountsByProvider(
+  provider: SubscriptionProvider,
+): StoredAccount[] {
+  return readAccountsFile().accounts.filter((a) => a.provider === provider);
+}
+
+/**
+ * Add a new account. If an account with the same name already exists,
+ * overwrites it (update).
+ */
+export function saveAccount(account: StoredAccount): void {
+  const file = readAccountsFile();
+  const existing = file.accounts.findIndex((a) => a.name === account.name);
+  if (existing >= 0) {
+    file.accounts[existing] = account;
+  } else {
+    file.accounts.push(account);
+  }
+  writeAccountsFile(file);
+}
+
+/**
+ * Remove an account by name. Returns true if deleted, false if not found.
+ */
+export function removeAccount(name: string): boolean {
+  const file = readAccountsFile();
+  const index = file.accounts.findIndex((a) => a.name === name);
+  if (index < 0) return false;
+  file.accounts.splice(index, 1);
+  writeAccountsFile(file);
+  return true;
+}
+
+/**
+ * Update the auth cookie for an existing OpenCode Go account.
+ * Returns true if updated, false if account not found or not an opencode-go account.
+ */
+export function updateAccountCookie(name: string, authCookie: string): boolean {
+  const file = readAccountsFile();
+  const account = file.accounts.find((a) => a.name === name);
+  if (!account || account.provider !== 'opencode-go') return false;
+  account.authCookie = authCookie;
+  writeAccountsFile(file);
+  return true;
+}
+
+/**
+ * Mask an auth cookie for display (show first 8 + last 4 chars).
+ */
+export function maskCookie(cookie: string): string {
+  if (cookie.length <= 16) {
+    return `${cookie.slice(0, 4)}...${cookie.slice(-4)}`;
+  }
+  return `${cookie.slice(0, 8)}...${cookie.slice(-4)}`;
+}
+
+/**
+ * Look up a stored account by name.
+ */
+export function getAccount(name: string): StoredAccount | undefined {
+  const file = readAccountsFile();
+  return file.accounts.find((a) => a.name === name);
+}
+
+/**
+ * Set the provider and API key for an existing account.
+ * Returns true if updated, false if account not found.
+ */
+export function setAccountKey(
+  name: string,
+  provider: string,
+  apiKey: string,
+): boolean {
+  const file = readAccountsFile();
+  const account = file.accounts.find((a) => a.name === name);
+  if (!account) return false;
+  account.provider = provider as SubscriptionProvider;
+  account.apiKey = apiKey;
+  writeAccountsFile(file);
+  return true;
+}

package/src/subscriptions/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Multi-provider subscription tracking module.
+ *
+ * Provides account management (local storage), provider-specific scrapers,
+ * caching, and slash-command support for subscription usage data displayed
+ * in the TUI sidebar and via /subscriptions command.
+ */
+
+export type { StoredAccount } from './accounts-store';
+export {
+  getAccount,
+  getAccountsByProvider,
+  loadAccounts,
+  loadAccountsResult,
+  maskCookie,
+  removeAccount,
+  saveAccount,
+  setAccountKey,
+  updateAccountCookie,
+} from './accounts-store';
+export { scrapeNeuralwattQuota } from './neuralwatt-scraper';
+export { scrapeQuota, scrapeUsagePage } from './opencode-go-scraper';
+export type {
+  NeuralwattUsageEntry,
+  OpenCodeGoUsageEntry,
+  SubscriptionUsageEntry,
+  UsageDetail,
+  UsageWindow,
+} from './types';
+export { createUsageService, UsageService } from './usage-service';

package/src/subscriptions/neuralwatt-scraper.ts

@@ -0,0 +1,108 @@
+/**
+ * Neuralwatt quota API scraper.
+ *
+ * Fetches usage data from the Neuralwatt REST API using Bearer token
+ * authentication. Returns structured quota data including credit balance,
+ * energy usage (kWh), and subscription details.
+ *
+ * Rate limit: 1 request per second per customer.
+ */
+
+import type { NeuralwattUsageEntry } from './types';
+
+const NEURALWATT_QUOTA_URL = 'https://api.neuralwatt.com/v1/quota';
+
+const EMPTY_BALANCE = {
+  credits_remaining_usd: 0,
+  total_credits_usd: 0,
+  credits_used_usd: 0,
+  accounting_method: 'energy',
+};
+
+const EMPTY_USAGE_PERIOD = {
+  cost_usd: 0,
+  requests: 0,
+  tokens: 0,
+  energy_kwh: 0,
+};
+
+const EMPTY_USAGE = {
+  lifetime: { ...EMPTY_USAGE_PERIOD },
+  current_month: { ...EMPTY_USAGE_PERIOD },
+};
+
+/**
+ * Fetch Neuralwatt quota data via the REST API.
+ */
+export async function scrapeNeuralwattQuota(
+  apiKey: string,
+  signal?: AbortSignal,
+): Promise<NeuralwattUsageEntry> {
+  const now = Date.now();
+
+  try {
+    const response = await fetch(NEURALWATT_QUOTA_URL, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: 'application/json',
+      },
+      signal,
+    });
+
+    if (!response.ok) {
+      let detail = '';
+      try {
+        const body = await response.text();
+        detail = body.slice(0, 200).replace(/\s+/g, ' ').trim();
+      } catch {
+        // Ignore body read errors
+      }
+      return {
+        provider: 'neuralwatt',
+        accountName: '',
+        snapshot_at: '',
+        balance: { ...EMPTY_BALANCE },
+        usage: {
+          lifetime: { ...EMPTY_USAGE_PERIOD },
+          current_month: { ...EMPTY_USAGE_PERIOD },
+        },
+        subscription: null,
+        fetchedAt: now,
+        error: `API error ${response.status}${detail ? `: ${detail}` : ''}`,
+      };
+    }
+
+    const data = (await response.json()) as Record<string, unknown>;
+
+    return {
+      provider: 'neuralwatt',
+      accountName: '',
+      snapshot_at: (data.snapshot_at as string) ?? '',
+      balance: (data.balance as NeuralwattUsageEntry['balance']) ?? {
+        ...EMPTY_BALANCE,
+      },
+      usage: (data.usage as NeuralwattUsageEntry['usage']) ?? {
+        ...EMPTY_USAGE,
+      },
+      subscription:
+        (data.subscription as NeuralwattUsageEntry['subscription']) ?? null,
+      fetchedAt: now,
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      provider: 'neuralwatt',
+      accountName: '',
+      snapshot_at: '',
+      balance: { ...EMPTY_BALANCE },
+      usage: {
+        lifetime: { ...EMPTY_USAGE_PERIOD },
+        current_month: { ...EMPTY_USAGE_PERIOD },
+      },
+      subscription: null,
+      fetchedAt: now,
+      error: `Fetch failed: ${message}`,
+    };
+  }
+}

package/src/subscriptions/opencode-go-scraper.ts

@@ -0,0 +1,301 @@
+/**
+ * OpenCode Go dashboard scraper.
+ *
+ * Fetches the OpenCode Go workspace dashboard page and parses SolidJS SSR
+ * hydration output for known usage windows (rollingUsage, weeklyUsage,
+ * monthlyUsage) containing usagePercent and resetInSec fields.
+ */
+
+import type { OpenCodeGoUsageEntry, UsageDetail, UsageWindow } from './types';
+
+const DASHBOARD_URL_PREFIX = 'https://opencode.ai/workspace/';
+const DASHBOARD_URL_SUFFIX = '/go';
+const USAGE_URL_SUFFIX = '/usage';
+const USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/148.0';
+const _SCRAPE_TIMEOUT_MS = 10_000;
+
+/**
+ * Regex patterns matching SolidJS SSR hydration output for usage windows.
+ * Field order may vary, so we try both orderings.
+ */
+const SCRAPED_NUMBER_PATTERN = String.raw`(-?\d+(?:\.\d+)?)`;
+
+const RE_ROLLING_PCT_FIRST = new RegExp(
+  String.raw`rollingUsage:\$R\[\d+\]=\{[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+const RE_ROLLING_RESET_FIRST = new RegExp(
+  String.raw`rollingUsage:\$R\[\d+\]=\{[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+
+const RE_WEEKLY_PCT_FIRST = new RegExp(
+  String.raw`weeklyUsage:\$R\[\d+\]=\{[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+const RE_WEEKLY_RESET_FIRST = new RegExp(
+  String.raw`weeklyUsage:\$R\[\d+\]=\{[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+
+const RE_MONTHLY_PCT_FIRST = new RegExp(
+  String.raw`monthlyUsage:\$R\[\d+\]=\{[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+const RE_MONTHLY_RESET_FIRST = new RegExp(
+  String.raw`monthlyUsage:\$R\[\d+\]=\{[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+
+interface ScrapedWindowUsage {
+  usagePercent: number;
+  resetInSec: number;
+}
+
+function parseWindowUsage(
+  html: string,
+  rePctFirst: RegExp,
+  reResetFirst: RegExp,
+): ScrapedWindowUsage | null {
+  const pctFirstMatch = rePctFirst.exec(html);
+  if (pctFirstMatch) {
+    const usagePercent = Number(pctFirstMatch[1]);
+    const resetInSec = Number(pctFirstMatch[2]);
+    if (Number.isFinite(usagePercent) && Number.isFinite(resetInSec)) {
+      return { usagePercent, resetInSec };
+    }
+  }
+
+  const resetFirstMatch = reResetFirst.exec(html);
+  if (resetFirstMatch) {
+    const resetInSec = Number(resetFirstMatch[1]);
+    const usagePercent = Number(resetFirstMatch[2]);
+    if (Number.isFinite(usagePercent) && Number.isFinite(resetInSec)) {
+      return { usagePercent, resetInSec };
+    }
+  }
+
+  return null;
+}
+
+function normalizeWindowUsage(
+  window: ScrapedWindowUsage,
+  now: number,
+): UsageWindow {
+  const usagePercent = Math.max(0, window.usagePercent);
+  const resetInSec = Math.max(0, window.resetInSec);
+
+  return {
+    usagePercent,
+    resetInSec,
+    percentRemaining: 100 - usagePercent,
+    resetTimeIso: new Date(now + resetInSec * 1000).toISOString(),
+  };
+}
+
+/**
+ * Fetch the OpenCode Go dashboard /go page and extract quota usage data.
+ */
+export async function scrapeQuota(
+  workspaceId: string,
+  authCookie: string,
+  signal?: AbortSignal,
+): Promise<OpenCodeGoUsageEntry> {
+  const now = Date.now();
+  const url = `${DASHBOARD_URL_PREFIX}${encodeURIComponent(workspaceId)}${DASHBOARD_URL_SUFFIX}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'User-Agent': USER_AGENT,
+        Accept: 'text/html',
+        Cookie: `auth=${authCookie}`,
+      },
+      signal,
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      const snippet = text.slice(0, 200).replace(/\s+/g, ' ').trim();
+      return {
+        provider: 'opencode-go',
+        accountName: '',
+        workspaceId,
+        fetchedAt: now,
+        error: `Dashboard error ${response.status}: ${snippet}`,
+      };
+    }
+
+    const html = await response.text();
+
+    const rolling = parseWindowUsage(
+      html,
+      RE_ROLLING_PCT_FIRST,
+      RE_ROLLING_RESET_FIRST,
+    );
+    const weekly = parseWindowUsage(
+      html,
+      RE_WEEKLY_PCT_FIRST,
+      RE_WEEKLY_RESET_FIRST,
+    );
+    const monthly = parseWindowUsage(
+      html,
+      RE_MONTHLY_PCT_FIRST,
+      RE_MONTHLY_RESET_FIRST,
+    );
+
+    if (!rolling && !weekly && !monthly) {
+      return {
+        provider: 'opencode-go',
+        accountName: '',
+        workspaceId,
+        fetchedAt: now,
+        error:
+          'Could not parse any usage windows (rollingUsage, weeklyUsage, monthlyUsage) from dashboard. ' +
+          'The dashboard format may have changed.',
+      };
+    }
+
+    return {
+      provider: 'opencode-go',
+      accountName: '',
+      workspaceId,
+      fetchedAt: now,
+      ...(rolling ? { rolling: normalizeWindowUsage(rolling, now) } : {}),
+      ...(weekly ? { weekly: normalizeWindowUsage(weekly, now) } : {}),
+      ...(monthly ? { monthly: normalizeWindowUsage(monthly, now) } : {}),
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      provider: 'opencode-go',
+      accountName: '',
+      workspaceId,
+      fetchedAt: now,
+      error: `Fetch failed: ${message}`,
+    };
+  }
+}
+
+/**
+ * Scrape detailed usage data from the /usage page.
+ * The page embeds individual usage records in SolidJS SSR hydration format
+ * as $R[N]={id:"usg_...} records with model, inputTokens, outputTokens, cost fields.
+ * No total or summary is present - we aggregate from individual records.
+ */
+export async function scrapeUsagePage(
+  workspaceId: string,
+  authCookie: string,
+  signal?: AbortSignal,
+): Promise<UsageDetail | { error: string }> {
+  const url = `${DASHBOARD_URL_PREFIX}${encodeURIComponent(workspaceId)}${USAGE_URL_SUFFIX}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'User-Agent': USER_AGENT,
+        Accept: 'text/html',
+        Cookie: `auth=${authCookie}`,
+      },
+      signal,
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      const snippet = text.slice(0, 200).replace(/\s+/g, ' ').trim();
+      return { error: `Usage page error ${response.status}: ${snippet}` };
+    }
+
+    const html = await response.text();
+
+    // Parse SSR hydration data directly from the raw HTML.
+    // The /usage page embeds records as $R[N]={id:"usg_...} in SolidJS SSR output.
+    return parseUsageSSR(html);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: `Failed to fetch usage page: ${message}` };
+  }
+}
+
+function parseUsageSSR(payload: string): UsageDetail | { error: string } {
+  // Find all usage records embedded in SSR hydration data.
+  // Format: $R[N]={id:"usg_...",...,model:"...",inputTokens:N,outputTokens:N,cost:N,...}
+  const records: Array<{
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cost: number;
+  }> = [];
+
+  const recordRegex = /\$R\[\d+\]=\{id:"usg_[^}]+?\}/g;
+
+  for (
+    let match: RegExpExecArray | null = recordRegex.exec(payload);
+    match;
+    match = recordRegex.exec(payload)
+  ) {
+    const text = match[0];
+
+    const modelMatch = text.match(/model:"([^"]+)"/);
+    if (!modelMatch) continue;
+
+    const inputTokens = Number(text.match(/inputTokens:(\d+)/)?.[1] ?? 0);
+    const outputTokens = Number(text.match(/outputTokens:(\d+)/)?.[1] ?? 0);
+    const cost = Number(text.match(/cost:(\d+)/)?.[1] ?? 0);
+
+    records.push({
+      model: modelMatch[1],
+      inputTokens,
+      outputTokens,
+      cost,
+    });
+  }
+
+  if (records.length === 0) {
+    return { error: 'Could not parse usage data from the page.' };
+  }
+
+  // Aggregate by model
+  const perModelMap = new Map<
+    string,
+    { calls: number; cost: number; inputTokens: number; outputTokens: number }
+  >();
+
+  for (const r of records) {
+    const existing = perModelMap.get(r.model) ?? {
+      calls: 0,
+      cost: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+    };
+    existing.calls += 1;
+    existing.cost += r.cost;
+    existing.inputTokens += r.inputTokens;
+    existing.outputTokens += r.outputTokens;
+    perModelMap.set(r.model, existing);
+  }
+
+  const totalCalls = records.length;
+  // Cost appears to be in micro-dollars (1/1,000,000 of a dollar)
+  // Divide by 1,000,000 to get dollar amount
+  const totalCostDollars =
+    records.reduce((sum, r) => sum + r.cost, 0) / 1_000_000;
+
+  const perModel = Array.from(perModelMap.entries())
+    .map(([model, data]) => ({
+      model,
+      calls: data.calls,
+      cost: data.cost / 1_000_000,
+    }))
+    .sort((a, b) => b.calls - a.calls);
+
+  return { totalCalls, totalCost: totalCostDollars, perModel };
+}
+
+function _parseUsageHTML(
+  _doc: globalThis.Document,
+): UsageDetail | { error: string } {
+  // The /usage page is client-side rendered and all data is in SSR hydration.
+  // HTML table parsing is not applicable.
+  return { error: 'Could not parse usage data from the page.' };
+}
+
+// Export for testing
+export { parseWindowUsage as _parseWindowUsage };