@algochad/archcoder 2.0.2

package/server/lib/package-manager.js

@@ -0,0 +1,505 @@
+import { spawnSync } from 'child_process';
+import crypto from 'crypto';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PACKAGE_NAME = '@algochad/archcoder';
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}`;
+const CHANGELOG_URL = 'https://raw.githubusercontent.com/archcoder/archcoder/main/CHANGELOG.md';
+let cachedDetectedPm = null;
+
+function getSpawnSyncBaseOptions() {
+  return process.platform === 'win32' ? { windowsHide: true } : {};
+}
+const UPDATE_CHECK_URL = process.env.ARCHCODER_UPDATE_API_URL || 'https://api.archcoder.archlast.com/v1/update/check';
+
+function getArchCoderConfigDir() {
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA;
+    if (appData) return path.join(appData, 'archcoder');
+  }
+
+  return path.join(os.homedir(), '.config', 'archcoder');
+}
+
+function sanitizeInstallScope(scope) {
+  if (scope === 'desktop-tauri' || scope === 'vscode' || scope === 'web') return scope;
+  return 'web';
+}
+
+function getOrCreateInstallId(scope = 'web') {
+  const configDir = getArchCoderConfigDir();
+  const normalizedScope = sanitizeInstallScope(scope);
+  const idPath = path.join(configDir, `install-id-${normalizedScope}`);
+
+  try {
+    const existing = fs.readFileSync(idPath, 'utf8').trim();
+    if (existing) return existing;
+  } catch {
+    // Generate new id.
+  }
+
+  const installId = crypto.randomUUID();
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.writeFileSync(idPath, `${installId}\n`, { encoding: 'utf8', mode: 0o600 });
+  return installId;
+}
+
+function mapPlatform(value) {
+  if (value === 'darwin') return 'macos';
+  if (value === 'win32') return 'windows';
+  if (value === 'linux') return 'linux';
+  return 'web';
+}
+
+function mapArch(value) {
+  if (value === 'arm64' || value === 'aarch64') return 'arm64';
+  if (value === 'x64' || value === 'amd64') return 'x64';
+  return 'unknown';
+}
+
+function normalizeAppType(value) {
+  if (value === 'web' || value === 'desktop-tauri' || value === 'vscode') return value;
+  return 'web';
+}
+
+function normalizeDeviceClass(value) {
+  if (value === 'mobile' || value === 'tablet' || value === 'desktop' || value === 'unknown') return value;
+  return 'unknown';
+}
+
+function normalizePlatform(value) {
+  if (value === 'macos' || value === 'windows' || value === 'linux' || value === 'web') return value;
+  return mapPlatform(process.platform);
+}
+
+function normalizeArch(value) {
+  if (value === 'arm64' || value === 'x64' || value === 'unknown') return value;
+  return mapArch(process.arch);
+}
+
+async function checkForUpdatesFromApi(currentVersion, options = {}) {
+  try {
+    const appType = normalizeAppType(options.appType);
+    const hostPlatform = mapPlatform(process.platform);
+    const hostArch = mapArch(process.arch);
+    const platform = appType === 'vscode' ? normalizePlatform(options.platform) : hostPlatform;
+    const arch = appType === 'vscode' ? normalizeArch(options.arch) : hostArch;
+    const payload = {
+      appType,
+      deviceClass: normalizeDeviceClass(options.deviceClass),
+      platform,
+      arch,
+      channel: 'stable',
+      currentVersion,
+      installId: getOrCreateInstallId(appType),
+      instanceMode: options.instanceMode || 'unknown',
+      reportUsage: options.reportUsage !== false,
+    };
+
+    const response = await fetch(UPDATE_CHECK_URL, {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (typeof data?.latestVersion !== 'string') return null;
+
+    return {
+      available: Boolean(data.updateAvailable),
+      version: data.latestVersion,
+      currentVersion,
+      body: typeof data.releaseNotes === 'string' ? data.releaseNotes : undefined,
+      nextSuggestedCheckInSec:
+        typeof data.nextSuggestedCheckInSec === 'number' && Number.isFinite(data.nextSuggestedCheckInSec)
+          ? data.nextSuggestedCheckInSec
+          : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect which package manager was used to install this package.
+ * Strategy:
+ * 1. Check npm_config_user_agent (set during npm/pnpm/yarn/bun install)
+ * 2. Check npm_execpath for PM binary path
+ * 3. Analyze package location path for PM-specific patterns
+ * 4. Fall back to npm
+ */
+export function detectPackageManager() {
+  if (cachedDetectedPm) {
+    return cachedDetectedPm;
+  }
+
+  const forcedPm = process.env.OPENCHAMBER_PACKAGE_MANAGER?.trim();
+  if (forcedPm && ['npm', 'pnpm', 'yarn', 'bun'].includes(forcedPm)) {
+    const forcedPmCommand = resolvePackageManagerCommand(forcedPm);
+    if (isCommandAvailable(forcedPmCommand)) {
+      cachedDetectedPm = forcedPm;
+      return cachedDetectedPm;
+    }
+  }
+
+  // Strategy 1: Detect from runtime executable path (reliable for server-side updates)
+  const runtimePm = detectPackageManagerFromRuntimePath(process.execPath);
+  if (runtimePm && isCommandAvailable(resolvePackageManagerCommand(runtimePm))) {
+    cachedDetectedPm = runtimePm;
+    return cachedDetectedPm;
+  }
+
+  // Strategy 2: Check user agent (most reliable during install)
+  const userAgent = process.env.npm_config_user_agent || '';
+  let hintedPm = null;
+  if (userAgent.startsWith('pnpm')) hintedPm = 'pnpm';
+  else if (userAgent.startsWith('yarn')) hintedPm = 'yarn';
+  else if (userAgent.startsWith('bun')) hintedPm = 'bun';
+  else if (userAgent.startsWith('npm')) hintedPm = 'npm';
+
+  // Strategy 3: Check execpath
+  const execPath = process.env.npm_execpath || '';
+  if (!hintedPm) {
+    if (execPath.includes('pnpm')) hintedPm = 'pnpm';
+    else if (execPath.includes('yarn')) hintedPm = 'yarn';
+    else if (execPath.includes('bun')) hintedPm = 'bun';
+    else if (execPath.includes('npm')) hintedPm = 'npm';
+  }
+
+  // Strategy 4: Detect from invoked binary path (works for bun global symlink installs)
+  const invokedPm = detectPackageManagerFromInvocationPath(process.argv?.[1]);
+  if (invokedPm && isCommandAvailable(resolvePackageManagerCommand(invokedPm))) {
+    cachedDetectedPm = invokedPm;
+    return cachedDetectedPm;
+  }
+  if (!hintedPm) {
+    hintedPm = invokedPm;
+  }
+
+  // Strategy 5: Analyze package location for PM-specific patterns
+  try {
+    const pkgPath = path.resolve(__dirname, '..', '..');
+    const pmFromPath = detectPackageManagerFromInstallPath(pkgPath);
+    if (pmFromPath && isCommandAvailable(resolvePackageManagerCommand(pmFromPath))) {
+      cachedDetectedPm = pmFromPath;
+      return cachedDetectedPm;
+    }
+    if (!hintedPm) {
+      hintedPm = pmFromPath;
+    }
+  } catch {
+    // Ignore path resolution errors
+  }
+
+  // Validate the hinted PM actually owns the global install.
+  // This avoids false positives (for example running via bunx while installed with npm).
+  if (hintedPm && isCommandAvailable(resolvePackageManagerCommand(hintedPm)) && isPackageInstalledWith(hintedPm)) {
+    cachedDetectedPm = hintedPm;
+    return cachedDetectedPm;
+  }
+
+  // Strategy 6: Check which PM binaries are available and preferred
+  const pmChecks = [
+    { name: 'pnpm', check: () => isCommandAvailable(resolvePackageManagerCommand('pnpm')) },
+    { name: 'yarn', check: () => isCommandAvailable(resolvePackageManagerCommand('yarn')) },
+    { name: 'bun', check: () => isCommandAvailable(resolvePackageManagerCommand('bun')) },
+    { name: 'npm', check: () => isCommandAvailable(resolvePackageManagerCommand('npm')) },
+  ];
+
+  for (const { name, check } of pmChecks) {
+    if (check()) {
+      // Verify this PM actually has the package installed globally
+      if (isPackageInstalledWith(name)) {
+        cachedDetectedPm = name;
+        return cachedDetectedPm;
+      }
+    }
+  }
+
+  cachedDetectedPm = 'npm';
+  return cachedDetectedPm;
+}
+
+function detectPackageManagerFromInstallPath(pkgPath) {
+  if (!pkgPath) return null;
+  const normalized = pkgPath.replace(/\\/g, '/').toLowerCase();
+  if (normalized.includes('/.pnpm/') || normalized.includes('/pnpm/')) return 'pnpm';
+  if (normalized.includes('/.yarn/')) return 'yarn';
+  if (normalized.includes('/.bun/') || normalized.includes('/bun/install/')) return 'bun';
+  if (normalized.includes('/node_modules/')) return 'npm';
+  return null;
+}
+
+function detectPackageManagerFromRuntimePath(runtimePath) {
+  if (!runtimePath || typeof runtimePath !== 'string') return null;
+  const normalized = runtimePath.replace(/\\/g, '/').toLowerCase();
+  if (normalized.includes('/.bun/bin/bun') || normalized.endsWith('/bun') || normalized.endsWith('/bun.exe')) {
+    return 'bun';
+  }
+  if (normalized.includes('/pnpm/')) return 'pnpm';
+  if (normalized.includes('/yarn/')) return 'yarn';
+  if (normalized.includes('/node') || normalized.endsWith('/node.exe')) return 'npm';
+  return null;
+}
+
+function detectPackageManagerFromInvocationPath(invokedPath) {
+  if (!invokedPath || typeof invokedPath !== 'string') return null;
+  const normalized = invokedPath.replace(/\\/g, '/').toLowerCase();
+  if (normalized.includes('/.bun/bin/')) return 'bun';
+  if (normalized.includes('/.pnpm/')) return 'pnpm';
+  if (normalized.includes('/.yarn/')) return 'yarn';
+  return null;
+}
+
+function getPackageManagerCommandCandidates(pm) {
+  const candidates = [];
+  if (pm === 'bun') {
+    const bunExecutable = process.platform === 'win32' ? 'bun.exe' : 'bun';
+    if (process.env.BUN_INSTALL) {
+      candidates.push(path.join(process.env.BUN_INSTALL, 'bin', bunExecutable));
+    }
+    if (process.env.HOME) {
+      candidates.push(path.join(process.env.HOME, '.bun', 'bin', bunExecutable));
+    }
+    if (process.env.USERPROFILE) {
+      candidates.push(path.join(process.env.USERPROFILE, '.bun', 'bin', bunExecutable));
+    }
+  }
+  candidates.push(pm);
+  return [...new Set(candidates.filter(Boolean))];
+}
+
+function resolvePackageManagerCommand(pm) {
+  const candidates = getPackageManagerCommandCandidates(pm);
+  for (const candidate of candidates) {
+    if (isCommandAvailable(candidate)) {
+      return candidate;
+    }
+  }
+  return pm;
+}
+
+function quoteCommand(command) {
+  if (!command) return command;
+  if (!/\s/.test(command)) return command;
+  if (process.platform === 'win32') {
+    return `"${command.replace(/"/g, '""')}"`;
+  }
+  return `'${command.replace(/'/g, "'\\''")}'`;
+}
+
+function isCommandAvailable(command) {
+  try {
+    const result = spawnSync(command, ['--version'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 5000,
+      ...getSpawnSyncBaseOptions(),
+    });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
+
+function isPackageInstalledWith(pm) {
+  try {
+    const pmCommand = resolvePackageManagerCommand(pm);
+    let args;
+    switch (pm) {
+      case 'pnpm':
+        args = ['list', '-g', '--depth=0', PACKAGE_NAME];
+        break;
+      case 'yarn':
+        args = ['global', 'list', '--depth=0'];
+        break;
+      case 'bun':
+        args = ['pm', 'ls', '-g'];
+        break;
+      default:
+        args = ['list', '-g', '--depth=0', PACKAGE_NAME];
+    }
+
+    const result = spawnSync(pmCommand, args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 10000,
+      ...getSpawnSyncBaseOptions(),
+    });
+
+    if (result.status !== 0) return false;
+    return result.stdout.includes(PACKAGE_NAME) || result.stdout.includes('archcoder');
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the update command for the detected package manager
+ */
+export function getUpdateCommand(pm = detectPackageManager()) {
+  const pmCommand = quoteCommand(resolvePackageManagerCommand(pm));
+  switch (pm) {
+    case 'pnpm':
+      return `${pmCommand} add -g ${PACKAGE_NAME}@latest`;
+    case 'yarn':
+      return `${pmCommand} global add ${PACKAGE_NAME}@latest`;
+    case 'bun':
+      return `${pmCommand} add -g ${PACKAGE_NAME}@latest`;
+    default:
+      return `${pmCommand} install -g ${PACKAGE_NAME}@latest`;
+  }
+}
+
+/**
+ * Get current installed version from package.json
+ */
+export function getCurrentVersion() {
+  try {
+    const pkgPath = path.resolve(__dirname, '..', '..', 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.version || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Fetch latest version from npm registry
+ */
+export async function getLatestVersion() {
+  try {
+    const response = await fetch(NPM_REGISTRY_URL, {
+      headers: { Accept: 'application/json' },
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Registry responded with ${response.status}`);
+    }
+
+    const data = await response.json();
+    return data['dist-tags']?.latest || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Parse semver version to numeric for comparison
+ */
+function parseVersion(version) {
+  const parts = version.replace(/^v/, '').split('.').map(Number);
+  return (parts[0] || 0) * 10000 + (parts[1] || 0) * 100 + (parts[2] || 0);
+}
+
+/**
+ * Fetch changelog notes between versions
+ */
+export async function fetchChangelogNotes(fromVersion, toVersion) {
+  try {
+    const response = await fetch(CHANGELOG_URL, {
+      signal: AbortSignal.timeout(10000),
+    });
+
+    if (!response.ok) return undefined;
+
+    const changelog = await response.text();
+    const sections = changelog.split(/^## /m).slice(1);
+
+    const fromNum = parseVersion(fromVersion);
+    const toNum = parseVersion(toVersion);
+
+    const relevantSections = sections.filter((section) => {
+      const match = section.match(/^\[(\d+\.\d+\.\d+)\]/);
+      if (!match) return false;
+      const ver = parseVersion(match[1]);
+      return ver > fromNum && ver <= toNum;
+    });
+
+    if (relevantSections.length === 0) return undefined;
+
+    return relevantSections
+      .map((s) => '## ' + s.trim())
+      .join('\n\n');
+  } catch {
+    return undefined;
+  }
+}
+
+export async function checkForUpdates(options = {}) {
+  const currentVersion = options.currentVersion || getCurrentVersion();
+  const pm = detectPackageManager();
+
+  if (currentVersion !== 'unknown') {
+    const remote = await checkForUpdatesFromApi(currentVersion, options);
+    if (remote) {
+      return {
+        ...remote,
+        packageManager: pm,
+        updateCommand: 'archcoder update',
+      };
+    }
+  }
+
+  const latestVersion = await getLatestVersion();
+
+  if (!latestVersion || currentVersion === 'unknown') {
+    return {
+      available: false,
+      currentVersion,
+      error: 'Unable to determine versions',
+    };
+  }
+
+  const currentNum = parseVersion(currentVersion);
+  const latestNum = parseVersion(latestVersion);
+  const available = latestNum > currentNum;
+  let changelog;
+  if (available) {
+    changelog = await fetchChangelogNotes(currentVersion, latestVersion);
+  }
+
+  return {
+    available,
+    version: latestVersion,
+    currentVersion,
+    body: changelog,
+    packageManager: pm,
+    // Show our CLI command, not raw package manager command
+    updateCommand: 'archcoder update',
+  };
+}
+
+/**
+ * Execute the update (used by CLI)
+ */
+export function executeUpdate(pm = detectPackageManager(), options = {}) {
+  const command = getUpdateCommand(pm);
+  if (!options?.silent) {
+    console.log(`Updating ${PACKAGE_NAME} using ${pm}...`);
+    console.log(`Running: ${command}`);
+  }
+
+  const result = spawnSync(command, {
+    stdio: 'inherit',
+    shell: true,
+    ...getSpawnSyncBaseOptions(),
+  });
+
+  return {
+    success: result.status === 0,
+    exitCode: result.status,
+  };
+}

package/server/lib/quota/DOCUMENTATION.md

@@ -0,0 +1,55 @@
+# Quota Module Documentation
+
+## Purpose
+This module fetches quota and usage signals for supported providers in the web server runtime.
+
+## Entrypoints and structure
+- `packages/web/server/lib/quota/index.js`: public entrypoint imported by `packages/web/server/index.js`.
+- `packages/web/server/lib/quota/providers/index.js`: provider registry, configured-provider list, and provider dispatcher.
+- `packages/web/server/lib/quota/providers/interface.js`: JSDoc provider contract used as implementation reference.
+- `packages/web/server/lib/quota/providers/google/`: Google-specific auth, API, and transform modules.
+- `packages/web/server/lib/quota/utils/`: shared auth, transform, and formatting helpers.
+
+## Supported provider IDs (dispatcher)
+
+These provider IDs are currently dispatchable via `fetchQuotaForProvider(providerId)` in `packages/web/server/lib/quota/providers/index.js`.
+
+| Provider ID | Display name | Module | Auth aliases/keys |
+| --- | --- | --- | --- |
+| `claude` | Claude | `providers/claude.js` | `anthropic`, `claude` |
+| `codex` | Codex | `providers/codex.js` | `openai`, `codex`, `chatgpt` |
+| `google` | Google | `providers/google/index.js` | `google`, `google.oauth`, Antigravity accounts file |
+| `github-copilot` | GitHub Copilot | `providers/copilot.js` | `github-copilot`, `copilot` |
+| `github-copilot-addon` | GitHub Copilot Add-on | `providers/copilot.js` | `github-copilot`, `copilot` |
+| `kimi-for-coding` | Kimi for Coding | `providers/kimi.js` | `kimi-for-coding`, `kimi` |
+| `nano-gpt` | NanoGPT | `providers/nanogpt.js` | `nano-gpt`, `nanogpt`, `nano_gpt` |
+| `openrouter` | OpenRouter | `providers/openrouter.js` | `openrouter` |
+| `zai-coding-plan` | z.ai | `providers/zai.js` | `zai-coding-plan`, `zai`, `z.ai` |
+| `minimax-coding-plan` | MiniMax Coding Plan (minimax.io) | `providers/minimax-coding-plan.js` | `minimax-coding-plan` |
+| `minimax-cn-coding-plan` | MiniMax Coding Plan (minimaxi.com) | `providers/minimax-cn-coding-plan.js` | `minimax-cn-coding-plan` |
+| `ollama-cloud` | Ollama Cloud | `providers/ollama-cloud.js` | Cookie file at `~/.config/ollama-quota/cookie` (raw session cookie string) |
+
+## Internal-only provider module
+- `providers/openai.js` exists for logic parity/reuse but is intentionally not registered for dispatcher ID routing.
+
+## Response contract
+All providers should return results via shared helpers to preserve API shape:
+- Required fields: `providerId`, `providerName`, `ok`, `configured`, `usage`, `fetchedAt`
+- Optional field: `error`
+- Unsupported provider requests should return `ok: false`, `configured: false`, `error: Unsupported provider`
+
+## Add a new provider (quick steps)
+1. Choose module shape based on complexity:
+   - Simple providers: create `packages/web/server/lib/quota/providers/<provider>.js`.
+   - Complex providers (multi-source auth, multiple API calls, non-trivial transforms): create `packages/web/server/lib/quota/providers/<provider>/` with split modules like Google (`index.js`, `auth.js`, `api.js`, `transforms.js`).
+2. Export `providerId`, `providerName`, `aliases`, `isConfigured`, and `fetchQuota`.
+3. Use shared helpers from `packages/web/server/lib/quota/utils/index.js` (`buildResult`, `toUsageWindow`, auth/conversion helpers) to keep payload shape consistent.
+4. Register the provider in `packages/web/server/lib/quota/providers/index.js`.
+5. If needed for direct use, export a named fetcher from `packages/web/server/lib/quota/providers/index.js` and `packages/web/server/lib/quota/index.js`.
+6. Update this file with the new provider ID, module path, and alias/auth details.
+7. Validate with `bun run type-check`, `bun run lint`, and `bun run build`.
+
+## Notes for contributors
+- Keep provider IDs stable; clients use them directly.
+- Avoid adding alias-based dispatch in `fetchQuotaForProvider`; dispatch currently expects exact provider IDs.
+- Keep Google behavior changes isolated and review `providers/google/*` together.

package/server/lib/quota/index.js

@@ -0,0 +1,24 @@
+/**
+ * Quota module
+ *
+ * Provides quota usage tracking for various AI provider services.
+ * @module quota
+ */
+
+export {
+  listConfiguredQuotaProviders,
+  fetchQuotaForProvider,
+  fetchClaudeQuota,
+  fetchOpenaiQuota,
+  fetchGoogleQuota,
+  fetchCodexQuota,
+  fetchCopilotQuota,
+  fetchCopilotAddonQuota,
+  fetchKimiQuota,
+  fetchOpenRouterQuota,
+  fetchZaiQuota,
+  fetchNanoGptQuota,
+  fetchMinimaxCodingPlanQuota,
+  fetchMinimaxCnCodingPlanQuota,
+  fetchOllamaCloudQuota
+} from './providers/index.js';

package/server/lib/quota/providers/claude.js

@@ -0,0 +1,107 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp
+} from '../utils/index.js';
+
+export const providerId = 'claude';
+export const providerName = 'Claude';
+export const aliases = ['anthropic', 'claude'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.access || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const accessToken = entry?.access ?? entry?.token;
+
+  if (!accessToken) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'anthropic-beta': 'oauth-2025-04-20'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const windows = {};
+    const fiveHour = payload?.five_hour ?? null;
+    const sevenDay = payload?.seven_day ?? null;
+    const sevenDaySonnet = payload?.seven_day_sonnet ?? null;
+    const sevenDayOpus = payload?.seven_day_opus ?? null;
+
+    if (fiveHour) {
+      windows['5h'] = toUsageWindow({
+        usedPercent: toNumber(fiveHour.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(fiveHour.resets_at)
+      });
+    }
+    if (sevenDay) {
+      windows['7d'] = toUsageWindow({
+        usedPercent: toNumber(sevenDay.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(sevenDay.resets_at)
+      });
+    }
+    if (sevenDaySonnet) {
+      windows['7d-sonnet'] = toUsageWindow({
+        usedPercent: toNumber(sevenDaySonnet.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(sevenDaySonnet.resets_at)
+      });
+    }
+    if (sevenDayOpus) {
+      windows['7d-opus'] = toUsageWindow({
+        usedPercent: toNumber(sevenDayOpus.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(sevenDayOpus.resets_at)
+      });
+    }
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};