@toninho09/opencode-usage 1.0.0

package/lib/providers/copilot/client.ts

@@ -0,0 +1,185 @@
+import { fetchWithTimeout } from "../../shared/utils";
+import { readAuthConfig, type AuthProvider } from "../../shared/auth";
+import type { CopilotUsageResponse, CopilotTokenResponse } from "./types";
+
+const GITHUB_API_BASE_URL = "https://api.github.com";
+
+const COPILOT_VERSION = "0.35.0";
+const EDITOR_VERSION = "vscode/1.107.0";
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+
+const COPILOT_HEADERS = {
+  "User-Agent": USER_AGENT,
+  "Editor-Version": EDITOR_VERSION,
+  "Editor-Plugin-Version": EDITOR_PLUGIN_VERSION,
+  "Copilot-Integration-Id": "vscode-chat",
+};
+
+export class CopilotClient {
+  private readonly apiBaseUrl = GITHUB_API_BASE_URL;
+
+  /**
+   * Builds headers for authentication with Bearer token
+   */
+  private buildGitHubHeaders(token: string): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+      ...COPILOT_HEADERS,
+    };
+  }
+
+  /**
+   * Builds headers for legacy authentication (token prefix)
+   */
+  private buildLegacyHeaders(token: string): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `token ${token}`,
+      ...COPILOT_HEADERS,
+    };
+  }
+
+  /**
+   * Exchanges OAuth token for specific Copilot token
+   */
+  private async exchangeForCopilotToken(oauthToken: string): Promise<string | null> {
+    try {
+      const response = await fetchWithTimeout(
+        `${this.apiBaseUrl}/copilot_internal/v2/token`,
+        {
+          headers: {
+            Accept: "application/json",
+            Authorization: `Bearer ${oauthToken}`,
+            ...COPILOT_HEADERS,
+          },
+        },
+      );
+
+      if (!response.ok) {
+        return null;
+      }
+
+      const tokenData: CopilotTokenResponse = await response.json();
+      return tokenData.token;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Strategy 1: Try with cached token if still valid
+   */
+  private async fetchWithCachedToken(
+    cachedAccessToken: string,
+    tokenExpiry: number,
+    oauthToken: string,
+  ): Promise<CopilotUsageResponse | null> {
+    if (!cachedAccessToken || cachedAccessToken === oauthToken || tokenExpiry <= Date.now()) {
+      return null;
+    }
+
+    const response = await fetchWithTimeout(
+      `${this.apiBaseUrl}/copilot_internal/user`,
+      { headers: this.buildGitHubHeaders(cachedAccessToken) },
+    );
+
+    if (response.ok) {
+      return response.json() as Promise<CopilotUsageResponse>;
+    }
+
+    return null;
+  }
+
+  /**
+   * Strategy 2: Try with direct OAuth token (legacy format)
+   */
+  private async fetchWithLegacyToken(oauthToken: string): Promise<CopilotUsageResponse | null> {
+    const response = await fetchWithTimeout(
+      `${this.apiBaseUrl}/copilot_internal/user`,
+      { headers: this.buildLegacyHeaders(oauthToken) },
+    );
+
+    if (response.ok) {
+      return response.json() as Promise<CopilotUsageResponse>;
+    }
+
+    return null;
+  }
+
+  /**
+   * Strategy 3: Exchange OAuth token for Copilot token and fetch
+   */
+  private async fetchWithExchangedToken(oauthToken: string): Promise<CopilotUsageResponse> {
+    const copilotToken = await this.exchangeForCopilotToken(oauthToken);
+
+    if (!copilotToken) {
+      throw new Error("Failed to exchange OAuth token for Copilot token");
+    }
+
+    const response = await fetchWithTimeout(
+      `${this.apiBaseUrl}/copilot_internal/user`,
+      { headers: this.buildGitHubHeaders(copilotToken) },
+    );
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitHub API Error ${response.status}: ${errorText}`);
+    }
+
+    return response.json() as Promise<CopilotUsageResponse>;
+  }
+
+  /**
+   * Tries to fetch usage data using multiple authentication strategies
+   */
+  private async fetchWithAuthStrategies(authData: AuthProvider): Promise<CopilotUsageResponse> {
+    const oauthToken = authData.refresh || authData.access;
+    if (!oauthToken) {
+      throw new Error("No OAuth token found in auth data");
+    }
+
+    const cachedAccessToken = authData.access || "";
+    const tokenExpiry = authData.expires || 0;
+
+    // Strategy 1: Try with cached token
+    const cachedResult = await this.fetchWithCachedToken(cachedAccessToken, tokenExpiry, oauthToken);
+    if (cachedResult) {
+      return cachedResult;
+    }
+
+    // Strategy 2: Try with direct OAuth token
+    const legacyResult = await this.fetchWithLegacyToken(oauthToken);
+    if (legacyResult) {
+      return legacyResult;
+    }
+
+    // Strategy 3: Exchange token and try again
+    return this.fetchWithExchangedToken(oauthToken);
+  }
+
+  /**
+   * Fetches Copilot usage data
+   */
+  async fetchUsage(): Promise<CopilotUsageResponse | null> {
+    const auth = readAuthConfig();
+    const copilotAuth = auth?.["github-copilot"];
+
+    if (!copilotAuth?.refresh) {
+      return null;
+    }
+
+    return this.fetchWithAuthStrategies(copilotAuth);
+  }
+
+  /**
+   * Checks if Copilot is configured
+   */
+  isConfigured(): boolean {
+    const auth = readAuthConfig();
+    return !!auth?.["github-copilot"]?.refresh;
+  }
+}

package/lib/providers/copilot/formatter.ts

@@ -0,0 +1,65 @@
+import { formatResetLine } from "../../shared/formatting";
+import { createUsedProgressBar } from "../../shared/utils";
+import type { CopilotUsageResponse, QuotaDetail } from "./types";
+
+export class CopilotFormatter {
+  /**
+   * Formats a Copilot quota line with progress bar
+   */
+  private formatQuotaLine(name: string, quota: QuotaDetail | undefined): string {
+    if (!quota) {
+      return "";
+    }
+
+    if (quota.unlimited) {
+      return `${name.padEnd(16)} Unlimited`;
+    }
+
+    const total = quota.entitlement;
+    const used = total - quota.remaining;
+    const percentUsed = Math.round((used / total) * 100);
+    const progressBar = createUsedProgressBar(percentUsed, 20);
+
+    return `${name.padEnd(16)} ${progressBar} ${percentUsed}% (${used}/${total})`;
+  }
+
+  /**
+   * Formats Copilot usage data for display
+   */
+  format(data: CopilotUsageResponse): string {
+    const lines: string[] = [];
+
+    lines.push("╔════════════════════════════════════════╗");
+    lines.push("║         GITHUB COPILOT                 ║");
+    lines.push("╚════════════════════════════════════════╝");
+    lines.push(`Plan:            ${data.copilot_plan}`);
+
+    const premium = data.quota_snapshots.premium_interactions;
+    if (premium) {
+      const premiumLine = this.formatQuotaLine("Premium:", premium);
+      if (premiumLine) {
+        lines.push(premiumLine);
+      }
+    }
+
+    const chat = data.quota_snapshots.chat;
+    if (chat) {
+      const chatLine = this.formatQuotaLine("Chat:", chat);
+      if (chatLine) {
+        lines.push(chatLine);
+      }
+    }
+
+    const completions = data.quota_snapshots.completions;
+    if (completions) {
+      const completionsLine = this.formatQuotaLine("Completions:", completions);
+      if (completionsLine) {
+        lines.push(completionsLine);
+      }
+    }
+
+    lines.push(formatResetLine("Quota Resets:", data.quota_reset_date, 16));
+
+    return lines.join("\n");
+  }
+}

package/lib/providers/copilot/index.ts

@@ -0,0 +1,36 @@
+import type { UsageProvider, ProviderMessage } from "../base";
+import { CopilotClient } from "./client";
+import { CopilotFormatter } from "./formatter";
+
+const client = new CopilotClient();
+const formatter = new CopilotFormatter();
+
+export const copilotProvider: UsageProvider = {
+  name: "GitHub Copilot",
+  id: "copilot",
+  description: "Monitoramento de uso do GitHub Copilot",
+
+  async getUsageData(): Promise<ProviderMessage | null> {
+    try {
+      const data = await client.fetchUsage();
+      if (!data) {
+        return null;
+      }
+
+      return {
+        content: formatter.format(data),
+      };
+    } catch (error) {
+      return {
+        content: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+
+  isConfigured(): boolean {
+    return client.isConfigured();
+  },
+};
+
+export default copilotProvider;

package/lib/providers/copilot/types.ts

@@ -0,0 +1,38 @@
+export interface QuotaDetail {
+  entitlement: number;
+  overage_count: number;
+  overage_permitted: boolean;
+  percent_remaining: number;
+  quota_id: string;
+  quota_remaining: number;
+  remaining: number;
+  unlimited: boolean;
+}
+
+export interface QuotaSnapshots {
+  chat?: QuotaDetail;
+  completions?: QuotaDetail;
+  premium_interactions: QuotaDetail;
+}
+
+export interface CopilotUsageResponse {
+  access_type_sku: string;
+  analytics_tracking_id: string;
+  assigned_date: string;
+  can_signup_for_limited: boolean;
+  chat_enabled: boolean;
+  copilot_plan: string;
+  organization_login_list: unknown[];
+  organization_list: unknown[];
+  quota_reset_date: string;
+  quota_snapshots: QuotaSnapshots;
+}
+
+export interface CopilotTokenResponse {
+  token: string;
+  expires_at: number;
+  refresh_in: number;
+  endpoints: {
+    api: string;
+  };
+}

package/lib/providers/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Exporta todos os providers e componentes principais
+ */
+export { copilotProvider } from "./copilot";
+export { claudeProvider } from "./claude";
+export { zaiProvider } from "./zai";
+export { registry, ProviderRegistry } from "./registry";
+export type { UsageProvider, ProviderMessage } from "./base";

package/lib/providers/registry.ts

@@ -0,0 +1,56 @@
+import type { UsageProvider } from "./base";
+import { copilotProvider } from "./copilot";
+import { claudeProvider } from "./claude";
+import { zaiProvider } from "./zai";
+
+/**
+ * Centralized registry of all usage providers
+ */
+export class ProviderRegistry {
+  private providers: Map<string, UsageProvider> = new Map();
+
+  /**
+   * Registers a new provider
+   */
+  register(provider: UsageProvider): void {
+    this.providers.set(provider.id, provider);
+  }
+
+  /**
+   * Returns all registered providers
+   */
+  getAll(): UsageProvider[] {
+    return Array.from(this.providers.values());
+  }
+
+  /**
+   * Returns a specific provider by ID
+   */
+  getById(id: string): UsageProvider | undefined {
+    return this.providers.get(id);
+  }
+
+  /**
+   * Returns all configured providers
+   */
+  getConfigured(): UsageProvider[] {
+    return this.getAll().filter((provider) => provider.isConfigured());
+  }
+
+  /**
+   * Checks if any provider is configured
+   */
+  hasConfigured(): boolean {
+    return this.getConfigured().length > 0;
+  }
+}
+
+// Creates singleton instance of registry
+export const registry = new ProviderRegistry();
+
+// Auto-registers all providers
+registry.register(copilotProvider);
+registry.register(claudeProvider);
+registry.register(zaiProvider);
+
+export default registry;

package/lib/providers/zai/client.ts

@@ -0,0 +1,97 @@
+import { fetchWithTimeout } from "../../shared/utils";
+import { readAuthConfig, type AuthProvider } from "../../shared/auth";
+import type { ZaiUsageResponse } from "./types";
+
+const ZAI_API_BASE_URL = "https://api.z.ai";
+
+export class ZaiClient {
+  private readonly apiBaseUrl = ZAI_API_BASE_URL;
+
+  /**
+   * Builds headers for authentication with Z.ai API
+   */
+  private buildZaiHeaders(apiKey: string): Record<string, string> {
+    return {
+      "Authorization": apiKey,
+      "Content-Type": "application/json",
+      "User-Agent": "OpenCode-Status-Plugin/1.0",
+    };
+  }
+
+  /**
+   * Fetches usage data from Z.ai API
+   */
+  private async fetchZaiUsage(authData: AuthProvider): Promise<ZaiUsageResponse> {
+    const apiKey = authData.key;
+
+    if (!apiKey) {
+      throw new Error("No API key found in Z.ai auth data");
+    }
+
+    const url = `${this.apiBaseUrl}/api/monitor/usage/quota/limit`;
+    const response = await fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.buildZaiHeaders(apiKey),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Z.ai API Error ${response.status}: ${errorText}`);
+    }
+
+    const data: ZaiUsageResponse = await response.json();
+
+    if (!data.success || data.code !== 200) {
+      throw new Error(`Z.ai API Error ${data.code}: ${data.msg || "Unknown error"}`);
+    }
+
+    return data;
+  }
+
+  /**
+   * Fetches Z.ai usage data
+   */
+  async fetchUsage(): Promise<ZaiUsageResponse | null> {
+    const authConfig = readAuthConfig();
+
+    if (!authConfig) {
+      return null;
+    }
+
+    const authData = authConfig["zai-coding-plan"];
+
+    if (!authData || authData.type !== "api" || !authData.key) {
+      return null;
+    }
+
+    return this.fetchZaiUsage(authData);
+  }
+
+  /**
+   * Returns the Z.ai API key (for use in formatter)
+   */
+  getApiKey(): string | null {
+    const authConfig = readAuthConfig();
+
+    if (!authConfig) {
+      return null;
+    }
+
+    const authData = authConfig["zai-coding-plan"];
+
+    if (!authData || authData.type !== "api" || !authData.key) {
+      return null;
+    }
+
+    return authData.key;
+  }
+
+  /**
+   * Checks if Z.ai is configured
+   */
+  isConfigured(): boolean {
+    const authConfig = readAuthConfig();
+    const authData = authConfig?.["zai-coding-plan"];
+    return !!(authData && authData.type === "api" && authData.key);
+  }
+}

package/lib/providers/zai/formatter.ts

@@ -0,0 +1,77 @@
+import { formatResetLine, formatTokens, maskApiKey } from "../../shared/formatting";
+import { createUsedProgressBar } from "../../shared/utils";
+import type { ZaiUsageResponse, UsageLimitItem } from "./types";
+
+export class ZaiFormatter {
+  /**
+   * Calculates usage display based on available fields from API
+   */
+  private calculateUsageDisplay(limit: UsageLimitItem): string {
+    const { usage, currentValue, remaining } = limit;
+
+    // Case 1: API returns usage and currentValue (when already used)
+    if (currentValue !== undefined && usage !== undefined) {
+      return ` (${formatTokens(currentValue)}/${formatTokens(usage)})`;
+    }
+
+    // Case 2: API returns remaining and usage (calculate currentValue)
+    if (remaining !== undefined && usage !== undefined) {
+      const used = usage - remaining;
+      return ` (${formatTokens(used)}/${formatTokens(usage)})`;
+    }
+
+    // Case 3: Only remaining available
+    if (remaining !== undefined) {
+      return ` (0/${formatTokens(remaining)})`;
+    }
+
+    return "";
+  }
+
+  /**
+   * Formats Z.ai usage data for display
+   */
+  format(data: ZaiUsageResponse, apiKey: string): string {
+    const lines: string[] = [];
+    const limits = data.data.limits;
+
+    const maskedKey = maskApiKey(apiKey);
+    lines.push("╔════════════════════════════════════════╗");
+    lines.push("║       Z.AI CODING PLAN                 ║");
+    lines.push("╚════════════════════════════════════════╝");
+    lines.push(`Account:         ${maskedKey} (Z.AI Coding Plan)`);
+
+    if (!limits || limits.length === 0) {
+      lines.push("No quota data available");
+      return lines.join("\n");
+    }
+
+    const tokensLimit = limits.find((l) => l.type === "TOKENS_LIMIT");
+    if (tokensLimit) {
+      const percentUsed = tokensLimit.percentage;
+      const progressBar = createUsedProgressBar(percentUsed, 20);
+      const usageDisplay = this.calculateUsageDisplay(tokensLimit);
+
+      lines.push(`Tokens:          ${progressBar} ${percentUsed}%${usageDisplay}`);
+
+      if (tokensLimit.nextResetTime) {
+        lines.push(formatResetLine("5h Resets:", tokensLimit.nextResetTime, 16));
+      }
+    }
+
+    const timeLimit = limits.find((l) => l.type === "TIME_LIMIT");
+    if (timeLimit) {
+      const percentUsed = timeLimit.percentage;
+      const progressBar = createUsedProgressBar(percentUsed, 20);
+
+      const currentValue = timeLimit.currentValue ?? 0;
+      const total = timeLimit.usage ?? (timeLimit.remaining ?? 0);
+
+      lines.push(
+        `MCP Searches:    ${progressBar} ${percentUsed}% (${currentValue}/${total})`,
+      );
+    }
+
+    return lines.join("\n");
+  }
+}

package/lib/providers/zai/index.ts

@@ -0,0 +1,41 @@
+import type { UsageProvider, ProviderMessage } from "../base";
+import { ZaiClient } from "./client";
+import { ZaiFormatter } from "./formatter";
+
+const client = new ZaiClient();
+const formatter = new ZaiFormatter();
+
+export const zaiProvider: UsageProvider = {
+  name: "Z.ai Coding Plan",
+  id: "zai",
+  description: "Monitoramento de uso do Z.ai Coding Plan",
+
+  async getUsageData(): Promise<ProviderMessage | null> {
+    try {
+      const data = await client.fetchUsage();
+      if (!data) {
+        return null;
+      }
+
+      const apiKey = client.getApiKey();
+      if (!apiKey) {
+        return null;
+      }
+
+      return {
+        content: formatter.format(data, apiKey),
+      };
+    } catch (error) {
+      return {
+        content: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+
+  isConfigured(): boolean {
+    return client.isConfigured();
+  },
+};
+
+export default zaiProvider;

package/lib/providers/zai/types.ts

@@ -0,0 +1,23 @@
+export interface UsageLimitItem {
+  type: "TIME_LIMIT" | "TOKENS_LIMIT";
+  usage?: number;
+  currentValue?: number;
+  remaining?: number;
+  percentage: number;
+  nextResetTime?: number;
+  unit?: number;
+  number?: number;
+  usageDetails?: Array<{
+    modelCode: string;
+    usage: number;
+  }>;
+}
+
+export interface ZaiUsageResponse {
+  code: number;
+  msg: string;
+  data: {
+    limits: UsageLimitItem[];
+  };
+  success: boolean;
+}

package/lib/shared/auth.ts

@@ -0,0 +1,49 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+
+const AUTH_CONFIG_PATH = path.join(
+  os.homedir(),
+  ".local",
+  "share",
+  "opencode",
+  "auth.json",
+);
+
+export interface AuthProvider {
+  type?: string;
+  access?: string;
+  refresh?: string;
+  expires?: number;
+  username?: string;
+  key?: string;
+}
+
+export interface AuthConfig {
+  "github-copilot"?: AuthProvider;
+  "anthropic"?: AuthProvider;
+  "zai-coding-plan"?: AuthProvider;
+}
+
+/**
+ * Reads the OpenCode authentication configuration file
+ * Returns null if file doesn't exist or error reading
+ */
+export function readAuthConfig(): AuthConfig | null {
+  try {
+    if (!fs.existsSync(AUTH_CONFIG_PATH)) {
+      return null;
+    }
+    const content = fs.readFileSync(AUTH_CONFIG_PATH, "utf-8");
+    return JSON.parse(content) as AuthConfig;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Returns the authentication configuration file path
+ */
+export function getAuthConfigPath(): string {
+  return AUTH_CONFIG_PATH;
+}