usage-panel-opencode 0.0.0-stage → 0.1.0

package/src/rpc.ts

@@ -0,0 +1,313 @@
+import { Rpc } from '@opencode/plugin/rpc';
+import type { PanelPreferences } from './config';
+
+export type PanelState = 'loading' | 'ready' | 'stale' | 'no_subscription' | 'needs_auth' | 'error';
+
+export type CredentialKind = 'oauth' | 'key' | 'none';
+export type WindowKind = 'five_hour' | 'weekly' | 'other';
+export type WindowSource = 'service' | 'headers';
+export type WindowAvailability = 'applicable' | 'not_applicable' | 'unknown';
+export type OriginKind = 'service' | 'headers' | 'mixed' | 'none';
+export type PanelErrorKind =
+  | 'network'
+  | 'rate_limited'
+  | 'unauthorized'
+  | 'forbidden'
+  | 'malformed'
+  | 'unknown';
+
+export interface SubscriptionAccount {
+  credentialKind: CredentialKind;
+  label?: string | null;
+  /** A masked identifier: the last four characters only. */
+  accountId?: string | null;
+  planHint?: string | null;
+  organization?: boolean | null;
+  expiresAt?: number | null;
+}
+
+export interface UsageWindow {
+  kind: WindowKind;
+  label: string;
+  applicable: boolean;
+  /** Missing for older snapshots; new snapshots distinguish no evidence from not-applicable. */
+  availability?: WindowAvailability;
+  usedPercent: number | null;
+  remainingPercent: number | null;
+  resetsAt: number | null;
+  source: WindowSource;
+}
+
+export interface SnapshotOrigin {
+  kind: OriginKind;
+  fetchedAt: number | null;
+  detail: string | null;
+}
+
+export interface UsageSnapshot {
+  account: SubscriptionAccount;
+  plan: { type: string; label: string } | null;
+  windows: UsageWindow[];
+  origin: SnapshotOrigin;
+}
+
+export interface PanelError {
+  kind: PanelErrorKind;
+  message: string;
+  action?: string | null;
+}
+
+export interface RefreshNotice {
+  kind: 'limited' | 'in_progress';
+  retryAt: number;
+  message: string;
+}
+
+export interface PanelSnapshot {
+  state: PanelState;
+  snapshot: UsageSnapshot | null;
+  error?: PanelError | null;
+  refreshNotice?: RefreshNotice | null;
+  preferences: PanelPreferences;
+  ageMs?: number;
+  /** Next automatic retry, when a recoverable failure has scheduled one. */
+  retryAt?: number;
+}
+
+export interface UsageUpdateEvent {
+  instanceId: string;
+  data: PanelSnapshot;
+}
+
+export interface PreferenceUpdate {
+  enabled?: boolean;
+  intervalSeconds?: number;
+  visible?: boolean;
+}
+
+const emptyObjectSchema = {
+  type: 'object',
+  properties: {},
+  additionalProperties: false,
+} as const;
+
+const instanceInputSchema = {
+  type: 'object',
+  properties: { instanceId: { type: 'string', minLength: 1, maxLength: 128 } },
+  required: ['instanceId'],
+  additionalProperties: false,
+} as const;
+
+const nullableStringSchema = {
+  anyOf: [{ type: 'string' }, { type: 'null' }],
+} as const;
+
+const nullableNumberSchema = {
+  anyOf: [{ type: 'number' }, { type: 'null' }],
+} as const;
+
+const panelSnapshotSchema = {
+  type: 'object',
+  properties: {
+    state: {
+      type: 'string',
+      enum: ['loading', 'ready', 'stale', 'no_subscription', 'needs_auth', 'error'],
+    },
+    snapshot: {
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            account: {
+              type: 'object',
+              properties: {
+                credentialKind: { type: 'string', enum: ['oauth', 'key', 'none'] },
+                label: nullableStringSchema,
+                accountId: {
+                  // OpenCode intentionally disables JSON Schema `pattern` validation for RPCs.
+                  // The server masks identifiers before returning snapshots.
+                  anyOf: [{ type: 'string' }, { type: 'null' }],
+                },
+                planHint: nullableStringSchema,
+                organization: {
+                  anyOf: [{ type: 'boolean' }, { type: 'null' }],
+                },
+                expiresAt: nullableNumberSchema,
+              },
+              required: ['credentialKind'],
+              additionalProperties: false,
+            },
+            plan: {
+              anyOf: [
+                {
+                  type: 'object',
+                  properties: {
+                    type: { type: 'string' },
+                    label: { type: 'string' },
+                  },
+                  required: ['type', 'label'],
+                  additionalProperties: false,
+                },
+                { type: 'null' },
+              ],
+            },
+            windows: {
+              type: 'array',
+              minItems: 0,
+              maxItems: 8,
+              items: {
+                type: 'object',
+                properties: {
+                  kind: { type: 'string', enum: ['five_hour', 'weekly', 'other'] },
+                  label: { type: 'string', minLength: 1 },
+                  applicable: { type: 'boolean' },
+                  availability: {
+                    type: 'string',
+                    enum: ['applicable', 'not_applicable', 'unknown'],
+                  },
+                  usedPercent: {
+                    anyOf: [{ type: 'number', minimum: 0, maximum: 100 }, { type: 'null' }],
+                  },
+                  remainingPercent: {
+                    anyOf: [{ type: 'number', minimum: 0, maximum: 100 }, { type: 'null' }],
+                  },
+                  resetsAt: nullableNumberSchema,
+                  source: { type: 'string', enum: ['service', 'headers'] },
+                },
+                required: [
+                  'kind',
+                  'label',
+                  'applicable',
+                  'usedPercent',
+                  'remainingPercent',
+                  'resetsAt',
+                  'source',
+                ],
+                additionalProperties: false,
+              },
+            },
+            origin: {
+              type: 'object',
+              properties: {
+                kind: { type: 'string', enum: ['service', 'headers', 'mixed', 'none'] },
+                fetchedAt: nullableNumberSchema,
+                detail: nullableStringSchema,
+              },
+              required: ['kind', 'fetchedAt', 'detail'],
+              additionalProperties: false,
+            },
+          },
+          required: ['account', 'plan', 'windows', 'origin'],
+          additionalProperties: false,
+        },
+        { type: 'null' },
+      ],
+    },
+    error: {
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            kind: {
+              type: 'string',
+              enum: [
+                'network',
+                'rate_limited',
+                'unauthorized',
+                'forbidden',
+                'malformed',
+                'unknown',
+              ],
+            },
+            message: { type: 'string' },
+            action: nullableStringSchema,
+          },
+          required: ['kind', 'message'],
+          additionalProperties: false,
+        },
+        { type: 'null' },
+      ],
+    },
+    refreshNotice: {
+      anyOf: [
+        {
+          type: 'object',
+          properties: {
+            kind: { type: 'string', enum: ['limited', 'in_progress'] },
+            retryAt: { type: 'number', minimum: 0 },
+            message: { type: 'string' },
+          },
+          required: ['kind', 'retryAt', 'message'],
+          additionalProperties: false,
+        },
+        { type: 'null' },
+      ],
+    },
+    preferences: {
+      type: 'object',
+      properties: {
+        enabled: { type: 'boolean' },
+        intervalSeconds: { type: 'integer', minimum: 60 },
+        visible: { type: 'boolean' },
+      },
+      required: ['enabled', 'intervalSeconds', 'visible'],
+      additionalProperties: false,
+    },
+    ageMs: { type: 'number', minimum: 0 },
+    retryAt: { type: 'number', minimum: 0 },
+  },
+  required: ['state', 'snapshot', 'preferences'],
+  additionalProperties: false,
+} as const;
+
+const preferenceUpdateSchema = {
+  type: 'object',
+  properties: {
+    enabled: { type: 'boolean' },
+    // Deliberately no minimum here: the server normalizes integer values below 60 to 60.
+    intervalSeconds: { type: 'integer' },
+    visible: { type: 'boolean' },
+  },
+  additionalProperties: false,
+} as const;
+
+export const usageRpcDefinition = {
+  id: 'openai-usage',
+  methods: {
+    snapshot: {
+      input: instanceInputSchema,
+      output: panelSnapshotSchema,
+    },
+    refresh: {
+      input: instanceInputSchema,
+      output: panelSnapshotSchema,
+    },
+    setPreferences: {
+      input: preferenceUpdateSchema,
+      output: panelSnapshotSchema,
+    },
+    start: {
+      input: instanceInputSchema,
+      output: emptyObjectSchema,
+    },
+    stop: {
+      input: instanceInputSchema,
+      output: emptyObjectSchema,
+    },
+  },
+  events: {
+    updated: {
+      schema: {
+        type: 'object',
+        properties: {
+          instanceId: { type: 'string', minLength: 1, maxLength: 128 },
+          data: panelSnapshotSchema,
+        },
+        required: ['instanceId', 'data'],
+        additionalProperties: false,
+      },
+    },
+  },
+} as const;
+
+export const Usage = Rpc.define(usageRpcDefinition);

package/src/tui.tsx

@@ -0,0 +1,158 @@
+import { Plugin } from '@opencode/plugin/tui';
+import { createSignal } from 'solid-js';
+import { DEFAULT_PREFERENCES } from './config';
+import type { PanelError, PanelSnapshot } from './rpc';
+import { Usage } from './rpc';
+import { Detail } from './ui/detail';
+import { Sidebar, sidebarRequiredRows, sidebarWidthForTerminal } from './ui/sidebar';
+
+const DETAIL_ROUTE_NAME = 'openai-usage-detail';
+
+const initialPanel: PanelSnapshot = {
+  state: 'loading',
+  snapshot: null,
+  preferences: { ...DEFAULT_PREFERENCES },
+};
+
+export function describeRefreshError(_error: unknown): PanelError {
+  return {
+    kind: 'unknown',
+    message: 'No se pudo actualizar el consumo de OpenAI.',
+    action: 'Comprueba la conexión y vuelve a intentarlo.',
+  };
+}
+
+function locationKey(directory: string): string {
+  const normalized = directory.replaceAll('\\', '/').replace(/\/+$/, '') || '/';
+  return /^[A-Za-z]:\//.test(normalized) ? normalized.toLowerCase() : normalized;
+}
+
+export default Plugin.define({
+  id: 'openai-usage.tui',
+  setup(context) {
+    const instanceId = globalThis.crypto.randomUUID();
+    const [panel, setPanel] = createSignal<PanelSnapshot>(initialPanel);
+    const [refreshing, setRefreshing] = createSignal(false);
+    const usage = context.client.rpc(Usage);
+    const location = context.location ?? context.data.location.default();
+    const rpcOptions = { location };
+    const unsubscribe = usage.events.on('updated', (event) => {
+      if (locationKey(event.location.directory) !== locationKey(location.directory)) return;
+      const update = event.data as unknown as { instanceId?: string; data?: PanelSnapshot };
+      if (update.instanceId !== instanceId || !update.data) return;
+      setPanel(update.data);
+    });
+
+    const openDetail = () => {
+      context.ui.router.navigate({ type: 'plugin', name: DETAIL_ROUTE_NAME });
+    };
+
+    const sidebarWidth = () => {
+      const terminalWidth = context.renderer.terminalWidth;
+      const terminalHeight = context.renderer.terminalHeight;
+      const availableWidth = sidebarWidthForTerminal(terminalWidth, terminalHeight, 0);
+      if (availableWidth === null) return null;
+      return sidebarWidthForTerminal(
+        terminalWidth,
+        terminalHeight,
+        sidebarRequiredRows(panel(), refreshing(), availableWidth),
+      );
+    };
+
+    const refreshNow = async () => {
+      if (refreshing()) return;
+      setRefreshing(true);
+      try {
+        const snapshot = await usage.refresh({ instanceId }, rpcOptions);
+        setPanel(snapshot as unknown as PanelSnapshot);
+      } catch (error) {
+        setPanel((current) => ({
+          ...current,
+          state: current.snapshot ? 'stale' : 'error',
+          error: describeRefreshError(error),
+        }));
+      } finally {
+        setRefreshing(false);
+      }
+    };
+
+    const unregisterRoute = context.ui.router.register({
+      name: DETAIL_ROUTE_NAME,
+      render: () => (
+        <Detail
+          panel={panel()}
+          refreshing={refreshing()}
+          onRefresh={() => void refreshNow()}
+          onBack={() => context.ui.router.navigate({ type: 'home' })}
+          theme={context.theme}
+        />
+      ),
+    });
+
+    context.keymap.layer(() => ({
+      mode: 'global',
+      commands: [
+        {
+          id: 'openai-usage.detail',
+          title: 'Abrir detalle del consumo de OpenAI',
+          description: 'Muestra el desglose y el origen de las cuotas.',
+          group: 'Consumo de OpenAI',
+          bind: false,
+          palette: true,
+          slash: { name: 'usage-detail', aliases: ['openai-usage-detail'] },
+          enabled: () => panel().preferences.enabled,
+          run: openDetail,
+        },
+        {
+          id: 'openai-usage.refresh',
+          title: 'Actualizar consumo de OpenAI',
+          description: 'Consulta ahora el consumo respetando el intervalo mínimo.',
+          group: 'Consumo de OpenAI',
+          bind: false,
+          palette: true,
+          slash: { name: 'usage-refresh', aliases: ['openai-usage-refresh'] },
+          enabled: () => panel().preferences.enabled,
+          run: refreshNow,
+        },
+      ],
+    }));
+
+    const unregisterSlot = context.ui.slot({
+      append: 'sidebar.content',
+      render: () => (
+        <Sidebar
+          panel={panel()}
+          refreshing={refreshing()}
+          theme={context.theme}
+          width={sidebarWidth()}
+          onOpenDetail={openDetail}
+        />
+      ),
+    });
+
+    void usage
+      .start({ instanceId }, rpcOptions)
+      .then(() => usage.snapshot({ instanceId }, rpcOptions))
+      .then((snapshot) => {
+        setPanel(snapshot as unknown as PanelSnapshot);
+      })
+      .catch(() => {
+        setPanel((current) => ({
+          ...current,
+          state: current.snapshot ? 'stale' : 'error',
+          error: {
+            kind: 'unknown',
+            message: 'No se pudo iniciar el panel de consumo.',
+            action: 'Comprueba que el plugin de servidor esté cargado.',
+          },
+        }));
+      });
+
+    return () => {
+      unsubscribe();
+      unregisterRoute();
+      unregisterSlot();
+      void usage.stop({ instanceId }, rpcOptions).catch(() => undefined);
+    };
+  },
+});