opencode-tweaks 0.0.0-stage → 0.4.0

package/src/quota/parse.ts

@@ -0,0 +1,101 @@
+import type { QuotaWindowKey, QuotaWindowSnapshot } from "../rpc"
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+export function text(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined
+}
+
+export function numeric(value: unknown): number | null {
+  const parsed =
+    typeof value === "string" ? Number(value) : typeof value === "number" ? value : Number.NaN
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+function resetIso(value: unknown): string | undefined {
+  const raw = text(value)
+  if (!raw) return undefined
+
+  const time = Date.parse(raw)
+  return Number.isFinite(time) ? new Date(time).toISOString() : undefined
+}
+
+function consoleWindow(
+  key: QuotaWindowKey,
+  value: unknown,
+  fallbackReset: string | undefined,
+): QuotaWindowSnapshot | undefined {
+  if (!isRecord(value)) return undefined
+
+  const limit = numeric(value.limitMicroCents)
+  const used = numeric(value.usedMicroCents)
+  if (limit === null || used === null || limit < 0 || used < 0) return undefined
+
+  const usedShare =
+    limit === 0 ? (used > 0 ? 100 : 0) : Math.min(100, Math.max(0, (used / limit) * 100))
+  const percentUsed = Math.round(usedShare)
+  const resetsAt = resetIso(value.resetsAt) ?? resetIso(fallbackReset)
+  if (!resetsAt) return undefined
+
+  return {
+    key,
+    percentRemaining: 100 - percentUsed,
+    percentRemainingExact: 100 - usedShare,
+    resetsAt,
+  }
+}
+
+function keyWindow(key: QuotaWindowKey, value: unknown): QuotaWindowSnapshot | undefined {
+  if (!isRecord(value)) return undefined
+
+  const percent = numeric(value.percent)
+  if (percent === null || percent < 0 || percent > 100) return undefined
+
+  const resetsAt = resetIso(value.resetsAt)
+  if (!resetsAt) return undefined
+
+  const remaining = value.status === "rate-limited" ? 0 : 100 - percent
+  return {
+    key,
+    percentRemaining: remaining,
+    percentRemainingExact: remaining,
+    resetsAt,
+  }
+}
+
+/** The Console `access.meters` response, in the order the sidebar shows. */
+export function consoleWindows(
+  meters: Record<string, unknown>,
+  endsAt: string | undefined,
+): QuotaWindowSnapshot[] {
+  const windows: QuotaWindowSnapshot[] = []
+
+  for (const [key, meter] of [
+    ["5h", "fiveHour"],
+    ["7d", "week"],
+    ["30d", "month"],
+  ] as const) {
+    const window = consoleWindow(key, meters[meter], endsAt)
+    if (window) windows.push(window)
+  }
+
+  return windows
+}
+
+/** The Zen `/v1/usage` response, in the order the sidebar shows. */
+export function keyWindows(usage: Record<string, unknown>): QuotaWindowSnapshot[] {
+  const windows: QuotaWindowSnapshot[] = []
+
+  for (const [key, meter] of [
+    ["5h", "rolling"],
+    ["7d", "weekly"],
+    ["30d", "monthly"],
+  ] as const) {
+    const window = keyWindow(key, usage[meter])
+    if (window) windows.push(window)
+  }
+
+  return windows
+}

package/src/quota/service.ts

@@ -0,0 +1,224 @@
+import type { Plugin } from "@opencode/plugin"
+import type { QuotaSnapshot, QuotaWindowSnapshot } from "../rpc"
+import { errorText } from "./format"
+import { consoleWindows, isRecord, keyWindows, text } from "./parse"
+
+const PROVIDER = "OpenCode Go"
+const CONSOLE_URL = "https://opencode.ai/console"
+const ZEN_USAGE_URL = "https://opencode.ai/zen/go/v1/usage"
+const REQUEST_TIMEOUT_MS = 15_000
+
+type ConsoleAuth = {
+  readonly kind: "console"
+  readonly access: string
+  readonly server: string
+  readonly orgID?: string
+}
+
+type KeyAuth = {
+  readonly kind: "key"
+  readonly key: string
+}
+
+type Auth = ConsoleAuth | KeyAuth
+
+type Connection = NonNullable<
+  Awaited<ReturnType<Plugin.Context["integration"]["connection"]["active"]>>
+>
+type Credential = NonNullable<
+  Awaited<ReturnType<Plugin.Context["integration"]["connection"]["resolve"]>>
+>
+
+async function activeConnection(
+  context: Plugin.Context,
+  integrationID: string,
+): Promise<Connection | undefined> {
+  try {
+    return await context.integration.connection.active(integrationID)
+  } catch {
+    return undefined
+  }
+}
+
+async function resolveConnection(
+  context: Plugin.Context,
+  connection: Connection,
+): Promise<Credential | undefined> {
+  try {
+    return await context.integration.connection.resolve(connection)
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The active OpenCode Console OAuth login authorizes the Go status endpoint.
+ * Without one, an OpenCode Go or OpenCode API key uses the public usage
+ * endpoint. The environment variable stays as a last fallback.
+ */
+async function readAuth(context: Plugin.Context): Promise<Auth | null> {
+  const consoleConnection = await activeConnection(context, "opencode")
+  const consoleValue = consoleConnection
+    ? await resolveConnection(context, consoleConnection)
+    : undefined
+
+  if (consoleValue?.type === "oauth") {
+    const access = text(consoleValue.access)
+    const metadata = isRecord(consoleValue.metadata) ? consoleValue.metadata : undefined
+    if (access) {
+      return {
+        kind: "console",
+        access,
+        server: text(metadata?.server) ?? CONSOLE_URL,
+        orgID: text(metadata?.orgID),
+      }
+    }
+  }
+
+  for (const integrationID of ["opencode-go", "opencode"]) {
+    const connection = await activeConnection(context, integrationID)
+    const value = connection ? await resolveConnection(context, connection) : undefined
+    if (value?.type !== "key") continue
+
+    const key = value.key.trim()
+    if (key) return { kind: "key", key }
+  }
+
+  const envKey = text(process.env.OPENCODE_API_KEY)?.trim()
+  return envKey ? { kind: "key", key: envKey } : null
+}
+
+async function withTimeout<T>(
+  signal: AbortSignal,
+  run: (signal: AbortSignal) => Promise<T>,
+): Promise<T> {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS)
+  const abort = () => controller.abort()
+
+  if (signal.aborted) controller.abort()
+  else signal.addEventListener("abort", abort, { once: true })
+
+  try {
+    return await run(controller.signal)
+  } finally {
+    clearTimeout(timer)
+    signal.removeEventListener("abort", abort)
+  }
+}
+
+async function readConsole(auth: ConsoleAuth, signal: AbortSignal) {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${auth.access}`,
+    Accept: "application/json",
+  }
+  if (auth.orgID) headers["x-org-id"] = auth.orgID
+
+  const response = await fetch(`${auth.server.replace(/\/+$/u, "")}/api/go/status`, {
+    headers,
+    signal,
+  })
+  if (response.status === 404) throw new Error("OpenCode Go is not active for this account")
+  if (!response.ok) throw new Error(`OpenCode Console API error ${response.status}`)
+
+  const payload: unknown = await response.json()
+  const access = isRecord(payload) && isRecord(payload.access) ? payload.access : undefined
+  const meters = access && isRecord(access.meters) ? access.meters : undefined
+  if (!access || !meters) throw new Error("OpenCode Go is not active for this account")
+
+  return consoleWindows(meters, text(access.endsAt))
+}
+
+async function readKey(auth: KeyAuth, signal: AbortSignal) {
+  const response = await fetch(ZEN_USAGE_URL, {
+    headers: {
+      Authorization: `Bearer ${auth.key}`,
+      Accept: "application/json",
+    },
+    signal,
+  })
+  if (response.status === 403) throw new Error("OpenCode Go is not active for this key")
+  if (!response.ok) throw new Error(`OpenCode Go API error ${response.status}`)
+
+  const payload: unknown = await response.json()
+  const usage = isRecord(payload) && isRecord(payload.usage) ? payload.usage : undefined
+  if (!usage) throw new Error("OpenCode Go usage is unavailable")
+
+  return keyWindows(usage)
+}
+
+/** Reads the active OpenCode Go quota and always returns a snapshot, including failures. */
+async function readGo(
+  context: Plugin.Context,
+  signal: AbortSignal,
+): Promise<QuotaWindowSnapshot[]> {
+  const auth = await readAuth(context)
+  if (!auth) throw new Error("OpenCode Go is not signed in")
+
+  return withTimeout(signal, (requestSignal) =>
+    auth.kind === "console" ? readConsole(auth, requestSignal) : readKey(auth, requestSignal),
+  )
+}
+
+interface QuotaSource {
+  /** Display name, and the credential the source knows how to read. */
+  readonly name: string
+  read(context: Plugin.Context, signal: AbortSignal): Promise<QuotaWindowSnapshot[]>
+}
+
+/**
+ * Providers whose quota this plugin can read, keyed by the model catalog ID so
+ * the TUI never names a provider. Adding one is a reader plus an entry here.
+ * Providers missing from the map publish no quota, and the panel stays hidden
+ * for them instead of showing an empty box.
+ */
+const SOURCES: Readonly<Record<string, QuotaSource>> = {
+  "opencode-go": { name: PROVIDER, read: readGo },
+}
+
+/** The provider IDs this plugin can read a quota for. */
+export function supportedProviders(): readonly string[] {
+  return Object.keys(SOURCES)
+}
+
+/**
+ * Reads one provider's quota, or every provider that has a source when no ID is
+ * given. Unknown IDs are skipped so an unsupported provider renders nothing.
+ */
+export async function readQuotas(
+  context: Plugin.Context,
+  providerID: string | undefined,
+  signal: AbortSignal,
+): Promise<QuotaSnapshot[]> {
+  const ids = providerID ? [providerID] : supportedProviders()
+  const snapshots: QuotaSnapshot[] = []
+
+  for (const id of ids) {
+    const source = SOURCES[id]
+    if (source) snapshots.push(await readSource(context, id, source, signal))
+  }
+
+  return snapshots
+}
+
+async function readSource(
+  context: Plugin.Context,
+  providerID: string,
+  source: QuotaSource,
+  signal: AbortSignal,
+): Promise<QuotaSnapshot> {
+  try {
+    const windows = await source.read(context, signal)
+    if (windows.length === 0) throw new Error(`${source.name} returned no quota windows`)
+
+    return { providerID, provider: source.name, capturedAt: Date.now(), windows }
+  } catch (error) {
+    return {
+      providerID,
+      provider: source.name,
+      capturedAt: Date.now(),
+      windows: [],
+      error: errorText(error),
+    }
+  }
+}

package/src/rpc.ts

@@ -0,0 +1,84 @@
+import { Rpc } from "@opencode/plugin/rpc"
+
+export type QuotaWindowKey = "5h" | "7d" | "30d"
+
+export interface QuotaWindowSnapshot {
+  readonly key: QuotaWindowKey
+  readonly percentRemaining: number
+  /**
+   * The same share without the rounding shown in the panel. Pacing reads it so
+   * the daily bar moves with real spending instead of jumping a whole percent
+   * at a time. Providers that only publish a whole percent return the same
+   * value as `percentRemaining`.
+   */
+  readonly percentRemainingExact?: number
+  readonly resetsAt: string
+}
+
+/**
+ * One provider's quota. `providerID` is the model catalog ID (`opencode-go`),
+ * so the panel can follow the selected model without knowing any provider name.
+ */
+export interface QuotaSnapshot {
+  readonly providerID: string
+  readonly provider: string
+  readonly capturedAt: number
+  readonly windows: readonly QuotaWindowSnapshot[]
+  readonly error?: string
+}
+
+const windowSchema = {
+  type: "object",
+  properties: {
+    key: { type: "string", enum: ["5h", "7d", "30d"] },
+    percentRemaining: { type: "number" },
+    percentRemainingExact: { type: "number" },
+    resetsAt: { type: "string" },
+  },
+  required: ["key", "percentRemaining", "resetsAt"],
+  additionalProperties: false,
+} as const
+
+const snapshotSchema = {
+  type: "object",
+  properties: {
+    providerID: { type: "string" },
+    provider: { type: "string" },
+    capturedAt: { type: "number" },
+    windows: {
+      type: "array",
+      items: windowSchema,
+    },
+    error: { type: "string" },
+  },
+  required: ["providerID", "provider", "capturedAt", "windows"],
+  additionalProperties: false,
+} as const
+
+export const Quota = Rpc.define({
+  id: "opencode-tweaks.quota",
+  methods: {
+    snapshot: {
+      /** A provider ID reads that provider; omitting it reads every source. */
+      input: {
+        type: "object",
+        properties: {
+          providerID: { type: "string" },
+        },
+        additionalProperties: false,
+      } as const,
+      output: {
+        type: "object",
+        properties: {
+          snapshots: {
+            type: "array",
+            items: snapshotSchema,
+          },
+        },
+        required: ["snapshots"],
+        additionalProperties: false,
+      } as const,
+    },
+  },
+  events: {},
+} as const)

package/src/tui.tsx

@@ -0,0 +1,66 @@
+import { Plugin } from "@opencode/plugin/tui"
+import { openTweaksMenu } from "./tweaks/menu"
+import { QuotaPanel } from "./tweaks/quota-panel"
+import { createSettingsStore } from "./tweaks/settings"
+import { createTokenInjector } from "./tweaks/token-inject"
+import { TokenInline, TokenStatus } from "./tweaks/token-slots"
+
+export default Plugin.define({
+  id: "opencode-tweaks.tui",
+  setup(context) {
+    const store = createSettingsStore(context)
+    const tokens = createTokenInjector(context)
+    let menuOpen = false
+
+    context.ui.slot({
+      append: "sidebar.content",
+      render: () => <QuotaPanel context={context} store={store} />,
+    })
+
+    context.ui.slot({
+      append: "session.composer.top",
+      render: (input) => (
+        <TokenInline context={context} input={input} store={store} injector={tokens} />
+      ),
+    })
+
+    context.ui.slot({
+      after: "prompt.footer.status",
+      render: (input) => (
+        <TokenStatus context={context} input={input} store={store} injector={tokens} />
+      ),
+    })
+
+    context.keymap.layer(() => ({
+      mode: "global",
+      commands: [
+        {
+          id: "opencode-tweaks.tweaks",
+          title: "Tweaks",
+          description: "Open the opencode-tweaks settings menu",
+          group: "Tweaks",
+          palette: true,
+          slash: { name: "tweaks" },
+          run: async () => {
+            if (menuOpen) return
+
+            menuOpen = true
+            try {
+              await openTweaksMenu(context, store)
+            } catch (error) {
+              context.ui.toast.show({
+                variant: "error",
+                title: "Tweaks",
+                message: error instanceof Error ? error.message : String(error),
+              })
+            } finally {
+              menuOpen = false
+            }
+          },
+        },
+      ],
+    }))
+
+    return () => tokens.dispose()
+  },
+})