opencode-usage-report 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kaan Chinar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# opencode-usage-report
+
+[![npm version](https://img.shields.io/npm/v/opencode-usage-report)](https://www.npmjs.com/package/opencode-usage-report)
+[![CI](https://github.com/kaanchinar/opencode-usage-report/actions/workflows/ci.yml/badge.svg)](https://github.com/kaanchinar/opencode-usage-report/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/npm/l/opencode-usage-report)](./LICENSE)
+
+An [opencode](https://opencode.ai) plugin that adds a `/usage` command (and a
+`usage_report` tool) showing the quota windows (5-hour, weekly, monthly) of your
+inference subscriptions — currently **Kimi Code** (`kimi-for-coding`) and
+**OpenCode Go** (`opencode-go`). It fetches from each provider's API, caches
+results on disk, and can fall back to a local estimate when the API is
+unreachable. It also emits background low-quota warnings in the TUI.
+
+## Features
+
+- `/usage` command and `usage_report` tool for on-demand quota reports, with
+  JSON and single-provider filtering.
+- TUI sidebar panel with live progress bars, `NN%` usage, and reset countdowns
+  for each quota window.
+- On-disk caching with a configurable TTL, plus `--refresh` to bypass it.
+- Local fallback estimate when the provider API is unreachable and no cache
+  exists.
+- Background low-quota TUI warnings on startup and `session.idle`.
+- Privacy-first: API keys are never logged, cached, or rendered.
+
+## Install
+
+### Server plugin (`/usage` command + warnings)
+
+Add the plugin to `opencode.json` / `opencode.jsonc` and restart opencode:
+
+```jsonc
+{
+  "plugin": ["./path/to/opencode-usage-report"] // or an npm spec
+}
+```
+
+Credentials are read from the same places your other opencode providers already
+use (see [Data sources & privacy](#data-sources--privacy)). Optionally pass
+options in the tuple form:
+
+```jsonc
+{
+  "plugin": [["./path/to/opencode-usage-report", { "thresholdPercent": 75 }]]
+}
+```
+
+### TUI sidebar panel
+
+Add the TUI module to `tui.json` and restart opencode:
+
+```jsonc
+{
+  "plugin": ["file:///abs/path/to/opencode-usage-report/src/tui.tsx"]
+}
+```
+
+The panel renders under opencode's native Context block in the session sidebar
+(order 150) and shows a colored progress bar per quota window, `NN%`, and a
+live reset countdown — refreshed every 60s, on `session.idle`, and on demand via
+the `Usage: refresh now` command (default binding `ctrl+shift+u`). It reuses the
+same cache/fallback pipeline as the command; stale results are marked `(stale)`
+and local estimates `(est)`.
+
+TUI options (tuple form): `providers`, `cacheTtlSeconds`, `thresholdPercent`,
+`refreshIntervalSeconds` (default `60`), `barWidth` (default `14`).
+
+
+## Commands
+
+- `/usage` — show every configured provider's quota windows.
+- `/usage kimi-for-coding` — filter to a single provider. The argument must match a
+  registered provider id **exactly** (`kimi-for-coding` or `opencode-go`); an
+  unknown id (e.g. `/usage kimi`) returns a helpful error listing the known ids.
+- `/usage --json` — emit the raw `ProviderReport[]` JSON.
+- `/usage --refresh` — bypass the on-disk cache and fetch live.
+
+The command simply calls the `usage_report` tool with those arguments, so the
+tool can also be invoked directly by an agent.
+
+## Options
+
+| Option             | Type       | Default | Meaning                                                        |
+| ------------------ | ---------- | ------- | -------------------------------------------------------------- |
+| `thresholdPercent` | `number`   | `80`    | Warn when a window is at/above this percent used.              |
+| `cacheTtlSeconds`  | `number`   | `120`   | How long a cached API result is considered fresh.              |
+| `providers`        | `string[] \| null` | `null` | Providers to report; `null` = every registered adapter. |
+| `fallback`         | `boolean`  | `true`  | Use a local estimate when the API fails and no cache exists.   |
+
+Malformed option values are ignored and the defaults are kept.
+
+## Warnings
+
+On startup and again on `session.idle` (both throttled to at most once every 10
+minutes, sharing the same timer), the plugin checks the cached reports. Any
+window at or above `thresholdPercent`, or whose
+status is `rate-limited` / `frozen`, produces a TUI toast. A warning fires once
+per window until that window resets; it re-arms after usage drops below
+`thresholdPercent - 10`. Toast failures (headless/server mode) are swallowed.
+
+## Data sources & privacy
+
+- Credential resolution order: `OPENCODE_USAGE_<ID>_KEY` env override, then
+  `~/.local/share/opencode/auth.json` (`type: "api"` `.key`, or `type: "oauth"`
+  `.access`). `$OPENCODE_DATA_HOME` overrides the data directory.
+- APIs: `https://api.kimi.com/coding/v1/usages` and
+  `https://opencode.ai/zen/go/v1/usage` (custom `User-Agent` is required by the
+  latter).
+- Cache and state live in `<data-home>/usage-report/` (TTL cache, session id,
+  warn state).
+- Local fallback reads `opencode.db` read-only.
+- **API keys are never logged, cached, or rendered.** Adapter errors are
+  sanitized (key substrings replaced with `<redacted>`) before they reach any
+  output, and the live smoke script never prints credentials.
+
+## Extending
+
+New providers are trivial:
+
+1. Implement `ProviderAdapter` (`src/types.ts`) — an `id`, `displayName`, and
+   `fetch(cred, opts)` returning `{ windows, extras? }`.
+2. Register it in `src/providers/index.ts` (`adapters` array).
+3. Add fixture-driven tests under `test/`.
+
+Reference endpoints for future adapters (not built in v1):
+
+- **Gemini**: `cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota`
+  (requires Google OAuth).
+- **Claude**: `api.anthropic.com/api/oauth/usage` (requires
+  `anthropic-beta: oauth-2025-04-20`, the claude-code User-Agent, and
+  `~/.claude/.credentials.json`).
+- **Codex**: the ChatGPT backend usage endpoint.
+
+## Development
+
+```sh
+npm test                          # vitest, no network
+npm run typecheck                 # tsc --noEmit
+npm run smoke -- --yes-live       # manual live check (real keys; opt-in)
+```
+
+## License
+
+MIT © [Kaan Chinar](https://github.com/kaanchinar)

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "opencode-usage-report",
+  "version": "0.1.0",
+  "description": "opencode plugin: /usage command showing subscription quota windows for configured providers",
+  "author": "Kaan Chinar",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./tui": "./src/tui.tsx"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaanchinar/opencode-usage-report.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kaanchinar/opencode-usage-report/issues"
+  },
+  "homepage": "https://github.com/kaanchinar/opencode-usage-report#readme",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "usage",
+    "quota",
+    "rate-limit",
+    "kimi",
+    "tui"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "smoke": "tsx scripts/live-smoke.ts",
+    "prepublishOnly": "npm run typecheck && npm test"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*",
+    "@opentui/core": ">=0.5.11",
+    "@opentui/solid": ">=0.5.11",
+    "solid-js": ">=1.9.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.0",
+    "@opentui/core": "^0.5.11",
+    "@opentui/keymap": "^0.5.11",
+    "@opentui/solid": "^0.5.11",
+    "@types/node": "^22.0.0",
+    "solid-js": "1.9.12",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Credential } from "./types.js";
+import { dataHome } from "./paths.js";
+
+/** "kimi-for-coding" -> "OPENCODE_USAGE_KIMI_FOR_CODING_KEY" (non-alphanumerics become "_", uppercased). */
+export function envVarName(providerId: string): string {
+  const normalized = providerId.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
+  return `OPENCODE_USAGE_${normalized}_KEY`;
+}
+
+/**
+ * Resolves a credential for a provider id.
+ * Order: (1) env override (empty string = missing), (2) auth.json entry.
+ * Never throws; returns null when no usable credential is found.
+ */
+export function resolveCredential(
+  providerId: string,
+  opts: { env?: NodeJS.ProcessEnv; dataHomeDir?: string } = {},
+): Credential | null {
+  try {
+    const env = opts.env ?? process.env;
+
+    const override = env[envVarName(providerId)];
+    if (typeof override === "string" && override.trim() !== "") {
+      return { type: "api", key: override };
+    }
+
+    const dir = opts.dataHomeDir ?? dataHome(env);
+    const raw = readFileSync(join(dir, "auth.json"), "utf8");
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+
+    const entry = (parsed as Record<string, unknown>)[providerId];
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) return null;
+
+    const record = entry as Record<string, unknown>;
+    if (record.type === "api") {
+      const key = record.key;
+      return typeof key === "string" && key !== "" ? { type: "api", key } : null;
+    }
+    if (record.type === "oauth") {
+      const access = record.access;
+      return typeof access === "string" && access !== ""
+        ? { type: "oauth", key: access }
+        : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Replaces every occurrence of key material (len >= 8) with "<redacted>". Short/null keys are ignored. */
+export function redact(text: string, key: string | null): string {
+  if (!key || key.length < 8) return text;
+  return text.split(key).join("<redacted>");
+}

package/src/cache.ts

@@ -0,0 +1,97 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import type { AdapterResult } from "./types.js";
+import { pluginStateDir } from "./paths.js";
+
+export interface CacheEntry {
+  fetchedAt: string;
+  result: AdapterResult;
+}
+
+/** <pluginStateDir>/cache-<providerId>.json */
+function cacheFilePath(providerId: string, env?: NodeJS.ProcessEnv): string {
+  return join(pluginStateDir(env), `cache-${providerId}.json`);
+}
+
+/**
+ * Reads a cached adapter result. Returns null when the file is missing, unreadable,
+ * corrupt, or structurally invalid. `fresh` is true while age <= ttlSeconds
+ * (a negative TTL always reports stale).
+ */
+export async function readCache(
+  providerId: string,
+  ttlSeconds: number,
+  env?: NodeJS.ProcessEnv,
+): Promise<{ entry: CacheEntry; fresh: boolean } | null> {
+  try {
+    const raw = await readFile(cacheFilePath(providerId, env), "utf8");
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+
+    const candidate = parsed as { fetchedAt?: unknown; result?: unknown };
+    if (typeof candidate.fetchedAt !== "string") return null;
+    if (candidate.result === null || typeof candidate.result !== "object") return null;
+
+    const result = candidate.result as { windows?: unknown };
+    if (!Array.isArray(result.windows)) return null;
+
+    const fetchedAtMs = new Date(candidate.fetchedAt).getTime();
+    if (Number.isNaN(fetchedAtMs)) return null;
+    const ageSeconds = (Date.now() - fetchedAtMs) / 1000;
+
+    return {
+      entry: { fetchedAt: candidate.fetchedAt, result: result as AdapterResult },
+      fresh: ageSeconds <= ttlSeconds,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persists an adapter result atomically: writes a temp file next to the target
+ * then renames it into place. Best-effort: never throws.
+ */
+export async function writeCache(
+  providerId: string,
+  result: AdapterResult,
+  env?: NodeJS.ProcessEnv,
+): Promise<void> {
+  try {
+    const dir = pluginStateDir(env);
+    await mkdir(dir, { recursive: true });
+    const file = cacheFilePath(providerId, env);
+    const entry: CacheEntry = { fetchedAt: new Date().toISOString(), result };
+    const tmp = `${file}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    await writeFile(tmp, JSON.stringify(entry), "utf8");
+    await rename(tmp, file);
+  } catch {
+    // Cache writes are best-effort; callers fall back to a live fetch.
+  }
+}
+
+/**
+ * Returns a stable session id, creating and persisting a UUID on first use.
+ * Best-effort: if the id cannot be persisted, a fresh id is still returned.
+ */
+export async function ensureSessionId(env?: NodeJS.ProcessEnv): Promise<string> {
+  const dir = pluginStateDir(env);
+  const file = join(dir, "session-id");
+
+  try {
+    const existing = (await readFile(file, "utf8")).trim();
+    if (existing !== "") return existing;
+  } catch {
+    // Missing/unreadable -> create below.
+  }
+
+  const id = randomUUID();
+  try {
+    await mkdir(dir, { recursive: true });
+    await writeFile(file, id, "utf8");
+  } catch {
+    // Best-effort persistence; return the generated id regardless.
+  }
+  return id;
+}

package/src/fallback.ts

@@ -0,0 +1,175 @@
+import { existsSync } from "node:fs";
+import type { AdapterResult, UsageWindow } from "./types.js";
+import { dbPath } from "./paths.js";
+
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+
+/** Minimal structural view of the node:sqlite API we rely on (kept dependency-optional). */
+interface SqliteStatement {
+  all(...params: unknown[]): unknown[];
+}
+interface SqliteDatabase {
+  prepare(sql: string): SqliteStatement;
+  close(): void;
+}
+type DatabaseSyncCtor = new (path: string, options?: { readOnly?: boolean }) => SqliteDatabase;
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function toNum(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+/** Sums an assistant message's token counts; returns null when no token field is present. */
+function sumTokens(data: unknown): number | null {
+  const record = asRecord(data);
+  if (record === null) return null;
+  const tokens = asRecord(record.tokens);
+  if (tokens === null) return null;
+
+  const total = toNum(tokens.total);
+  if (total !== null) return total;
+
+  let sum = 0;
+  let found = false;
+  for (const key of ["input", "output", "reasoning"]) {
+    const n = toNum(tokens[key]);
+    if (n !== null) {
+      sum += n;
+      found = true;
+    }
+  }
+  const cache = asRecord(tokens.cache);
+  if (cache !== null) {
+    for (const key of ["read", "write"]) {
+      const n = toNum(cache[key]);
+      if (n !== null) {
+        sum += n;
+        found = true;
+      }
+    }
+  }
+  return found ? sum : null;
+}
+
+function isAssistantForProvider(data: unknown, providerId: string): boolean {
+  const record = asRecord(data);
+  if (record === null) return false;
+  return record.role === "assistant" && record.providerID === providerId;
+}
+
+function makeWindow(kind: "5h" | "weekly", label: string, used: number): UsageWindow {
+  return {
+    kind,
+    label,
+    usedPercent: null,
+    used,
+    limit: null,
+    remaining: null,
+    resetsAt: null,
+    status: "ok",
+  };
+}
+
+/**
+ * Best-effort local usage estimate read from opencode's SQLite database.
+ *
+ * The DB is opened READ-ONLY and every step is defensive: a missing file, an
+ * absent sqlite runtime, schema drift, malformed rows, or no matching rows all
+ * yield null. This function never throws.
+ */
+export async function localEstimate(
+  providerId: string,
+  env?: NodeJS.ProcessEnv,
+): Promise<AdapterResult | null> {
+  let db: SqliteDatabase | null = null;
+  try {
+    const file = dbPath(env);
+    if (!existsSync(file)) return null;
+
+    let Ctor: DatabaseSyncCtor | null = null;
+    try {
+      const mod = await import("node:sqlite");
+      if (typeof mod.DatabaseSync === "function") {
+        Ctor = mod.DatabaseSync as unknown as DatabaseSyncCtor;
+      }
+    } catch {
+      return null;
+    }
+    if (Ctor === null) return null;
+
+    db = new Ctor(file, { readOnly: true });
+
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+    if (!tables.some((row) => asRecord(row)?.name === "message")) return null;
+
+    const columns = db.prepare("PRAGMA table_info(message)").all();
+    const columnNames = new Set(
+      columns
+        .map((column) => asRecord(column)?.name)
+        .filter((name): name is string => typeof name === "string"),
+    );
+    if (!columnNames.has("data") || !columnNames.has("time_created")) return null;
+
+    const now = Date.now();
+    const weeklyCutoff = now - 7 * DAY_MS;
+    const rows = db
+      .prepare("SELECT time_created AS time, data AS data FROM message WHERE time_created >= ?")
+      .all(weeklyCutoff);
+
+    const candidates: Array<{ time: number; data: unknown }> = [];
+    for (const row of rows) {
+      const record = asRecord(row);
+      if (record === null) continue;
+      const time = toNum(record.time);
+      if (time === null) continue;
+      const raw = record.data;
+      if (typeof raw !== "string") continue;
+
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (!isAssistantForProvider(parsed, providerId)) continue;
+      candidates.push({ time, data: parsed });
+    }
+    if (candidates.length === 0) return null;
+
+    const anyTokens = candidates.some((candidate) => sumTokens(candidate.data) !== null);
+    const fiveHourCutoff = now - 5 * HOUR_MS;
+
+    let used5h = 0;
+    let usedWeekly = 0;
+    for (const candidate of candidates) {
+      const value = anyTokens ? (sumTokens(candidate.data) ?? 0) : 1;
+      usedWeekly += value;
+      if (candidate.time >= fiveHourCutoff) used5h += value;
+    }
+
+    return {
+      windows: [
+        makeWindow("5h", "5-hour (local estimate)", used5h),
+        makeWindow("weekly", "Weekly (local estimate)", usedWeekly),
+      ],
+      extras: {
+        source: "opencode.db",
+        metric: anyTokens ? "tokens" : "messages",
+      },
+    };
+  } catch {
+    return null;
+  } finally {
+    try {
+      db?.close();
+    } catch {
+      // ignore close failures
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,111 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
+import { DEFAULT_OPTIONS, collectReports } from "./report.js";
+import { renderJson, renderText } from "./render.js";
+import { checkWarnings } from "./warn.js";
+import { toNumber } from "./normalize.js";
+import type { PluginOptions } from "./types.js";
+
+const WARN_THROTTLE_MS = 10 * 60 * 1000;
+
+const TOOL_DESCRIPTION =
+  "Show subscription usage/quota windows (5h, weekly, monthly) for configured inference providers (kimi-for-coding, opencode-go)";
+
+const COMMAND_TEMPLATE =
+  "Call the usage_report tool with these arguments: $ARGUMENTS and present the result verbatim.";
+
+/** Merges user plugin options over defaults, defensively ignoring malformed values. */
+export function coerceOptions(raw: Record<string, unknown> | undefined): PluginOptions {
+  const opts: PluginOptions = { ...DEFAULT_OPTIONS };
+  if (raw === undefined) return opts;
+
+  const threshold = toNumber(raw.thresholdPercent);
+  if (threshold !== null) opts.thresholdPercent = threshold;
+
+  const ttl = toNumber(raw.cacheTtlSeconds);
+  if (ttl !== null) opts.cacheTtlSeconds = ttl;
+
+  if (typeof raw.fallback === "boolean") opts.fallback = raw.fallback;
+
+  if (Array.isArray(raw.providers)) {
+    const ids = raw.providers.filter((id): id is string => typeof id === "string");
+    // An empty filter means "all providers", matching `undefined`/`null`.
+    opts.providers = ids.length > 0 ? ids : null;
+  } else if (raw.providers === null) {
+    opts.providers = null;
+  }
+
+  return opts;
+}
+
+const plugin: Plugin = async ({ client }, options) => {
+  const opts = coerceOptions(options);
+  let lastWarnCheck = 0;
+
+  /** Throttled warning pass (spec §3.7). Every failure is swallowed (spec §4). */
+  const runWarnCheck = async (): Promise<void> => {
+    try {
+      if (Date.now() - lastWarnCheck < WARN_THROTTLE_MS) return;
+      lastWarnCheck = Date.now();
+
+      const reports = await collectReports({ options: opts });
+      const hits = await checkWarnings(reports, opts.thresholdPercent);
+      for (const hit of hits) {
+        try {
+          await client.tui.showToast({
+            body: { title: "Usage warning", message: hit.message, variant: "warning" },
+          });
+        } catch {
+          // Toast delivery is best-effort; it is unavailable in headless/server mode.
+        }
+      }
+    } catch {
+      // Never throw into the event bus.
+    }
+  };
+
+  // Spec §3.6: one throttled warning check at startup, fire-and-forget.
+  setTimeout(() => {
+    void runWarnCheck();
+  }, 0);
+
+  return {
+    tool: {
+      usage_report: tool({
+        description: TOOL_DESCRIPTION,
+        args: {
+          provider: tool.schema.string().optional(),
+          json: tool.schema.boolean().optional(),
+          refresh: tool.schema.boolean().optional(),
+        },
+        async execute(args) {
+          const reports = await collectReports({
+            providers: args.provider ? [args.provider] : undefined,
+            refresh: args.refresh === true,
+            options: opts,
+          });
+          return args.json ? renderJson(reports) : renderText(reports);
+        },
+      }),
+    },
+
+    async config(cfg) {
+      cfg.command ??= {};
+      cfg.command.usage ??= {
+        description: "Show subscription usage/quota windows for configured providers",
+        template: COMMAND_TEMPLATE,
+      };
+    },
+
+    async event({ event }) {
+      try {
+        if (event.type !== "session.idle") return;
+        await runWarnCheck();
+      } catch {
+        // Never throw into the event bus.
+      }
+    },
+  };
+};
+
+export default plugin;