@tokentop/ttop 0.6.0 → 0.7.0

package/src/plugins/notification-bus.ts

@@ -18,6 +18,16 @@ class NotificationBus {
   private plugins: NotificationPlugin[] = [];
   private recentEvents = new Map<string, DedupEntry>();
   private pluginConfigs = new Map<string, Record<string, unknown>>();
+  private toastHandler: ((event: NotificationEvent) => void) | null = null;
+  private flashHandler: ((severity: NotificationEvent["severity"]) => void) | null = null;
+
+  setToastHandler(handler: ((event: NotificationEvent) => void) | null): void {
+    this.toastHandler = handler;
+  }
+
+  setFlashHandler(handler: ((severity: NotificationEvent["severity"]) => void) | null): void {
+    this.flashHandler = handler;
+  }
 
   registerPlugins(plugins: NotificationPlugin[]): void {
     this.plugins = plugins;
@@ -124,6 +134,23 @@ class NotificationBus {
         );
       }),
     );
+
+    this.toastHandler?.(event);
+    this.flashHandler?.(event.severity);
+  }
+
+  async testNotification(): Promise<void> {
+    const event: NotificationEvent = {
+      type: "budget.thresholdCrossed",
+      severity: "warning",
+      title: "Test Notification",
+      message: "This is a test notification from tokentop.",
+      timestamp: Date.now(),
+      data: {},
+    };
+    // Bypass dedup for test
+    await this.emit("__test__", event);
+    this.recentEvents.delete("__test__");
   }
 
   private isDuplicate(key: string): boolean {

package/src/plugins/notifications/terminal-bell.ts

@@ -4,6 +4,80 @@ import type {
   NotificationPlugin,
 } from "@tokentop/plugin-sdk";
 
+const SEVERITY_ORDER = ["info", "warning", "critical"];
+
+/**
+ * Write directly to stderr so the escape sequences bypass OpenTUI's
+ * stdout render pipeline. Most terminals still interpret BEL and OSC
+ * sequences arriving on fd 2.
+ */
+function writeEsc(data: string): void {
+  process.stderr.write(data);
+}
+
+/**
+ * OSC 777 (notify;title;body) — supported by iTerm2, Kitty, WezTerm, rxvt-unicode.
+ * OSC 9 (notify;body)         — supported by Windows Terminal, ConEmu.
+ * BEL (\x07)                  — universal fallback (if terminal has bell enabled).
+ *
+ * We send all three; unsupported sequences are silently ignored.
+ */
+function sendDesktopNotification(title: string, body: string): void {
+  writeEsc(`\x1b]777;notify;${title};${body}\x07`);
+  writeEsc(`\x1b]9;${title}: ${body}\x07`);
+  writeEsc("\x07");
+}
+
+/**
+ * macOS: afplay with system sounds (Ping, Funk, Glass, etc.)
+ * Linux: paplay → aplay → canberra-gtk-play (first available)
+ *
+ * Fire-and-forget — errors are silently ignored so a missing
+ * sound binary never breaks notifications.
+ */
+const SEVERITY_SOUNDS: Record<string, string> = {
+  critical: "Funk.aiff",
+  warning: "Ping.aiff",
+  info: "Pop.aiff",
+};
+
+function playSystemSound(severity: string): void {
+  const platform = process.platform;
+
+  if (platform === "darwin") {
+    const sound = SEVERITY_SOUNDS[severity] ?? "Ping.aiff";
+    Bun.spawn(["afplay", `/System/Library/Sounds/${sound}`], {
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    return;
+  }
+
+  if (platform === "linux") {
+    const xdgSound =
+      severity === "critical"
+        ? "dialog-error"
+        : severity === "warning"
+          ? "dialog-warning"
+          : "dialog-information";
+
+    Bun.spawn(["canberra-gtk-play", "-i", xdgSound], {
+      stdout: "ignore",
+      stderr: "ignore",
+    }).exited.then((code) => {
+      if (code !== 0) {
+        Bun.spawn(["paplay", "/usr/share/sounds/freedesktop/stereo/bell.oga"], {
+          stdout: "ignore",
+          stderr: "ignore",
+        });
+      }
+    });
+    return;
+  }
+
+  // Windows / other — BEL only (already sent via sendDesktopNotification)
+}
+
 export const terminalBellPlugin: NotificationPlugin = {
   apiVersion: 2,
   id: "terminal-bell",
@@ -12,7 +86,7 @@ export const terminalBellPlugin: NotificationPlugin = {
   version: "1.0.0",
 
   meta: {
-    description: "Simple terminal bell (BEL character) for alerts",
+    description: "Desktop notification + system sound alerts",
   },
 
   permissions: {},
@@ -50,30 +124,20 @@ export const terminalBellPlugin: NotificationPlugin = {
   },
 
   async notify(ctx: NotificationContext, event: NotificationEvent): Promise<void> {
-    const severityOrder = ["info", "warning", "critical"];
     const minSeverity = (ctx.config.minSeverity as string) ?? "warning";
 
-    if (severityOrder.indexOf(event.severity) < severityOrder.indexOf(minSeverity)) {
+    if (SEVERITY_ORDER.indexOf(event.severity) < SEVERITY_ORDER.indexOf(minSeverity)) {
       return;
     }
 
-    const bellCount = event.severity === "critical" ? 3 : 1;
-
-    for (let i = 0; i < bellCount; i++) {
-      process.stdout.write("\x07");
-      if (i < bellCount - 1) {
-        await sleep(200);
-      }
-    }
+    sendDesktopNotification(event.title, event.message);
+    playSystemSound(event.severity);
   },
 
   async test(ctx: NotificationContext): Promise<boolean> {
     ctx.logger.info("Testing terminal bell...");
-    process.stdout.write("\x07");
+    sendDesktopNotification("tokentop", "Test notification");
+    playSystemSound("warning");
     return true;
   },
 };
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/plugins/notifications/visual-flash.ts

@@ -12,7 +12,7 @@ export const visualFlashPlugin: NotificationPlugin = {
   version: "1.0.0",
 
   meta: {
-    description: "Visual screen flash using ANSI escape sequences",
+    description: "Visual screen flash for alerts (rendered via TUI overlay)",
   },
 
   permissions: {},
@@ -27,7 +27,7 @@ export const visualFlashPlugin: NotificationPlugin = {
     duration: {
       type: "number",
       label: "Flash duration (ms)",
-      default: 100,
+      default: 150,
       description: "Flash duration in milliseconds",
     },
   },
@@ -44,26 +44,13 @@ export const visualFlashPlugin: NotificationPlugin = {
     ctx.logger.debug("Visual flash notification plugin initialized");
   },
 
-  async notify(ctx: NotificationContext, event: NotificationEvent): Promise<void> {
-    const duration = (ctx.config.duration as number) ?? 100;
-
-    const colorCode =
-      event.severity === "critical" ? "41" : event.severity === "warning" ? "43" : "42";
-
-    process.stdout.write(`\x1b[${colorCode}m`);
-    await sleep(duration);
-    process.stdout.write("\x1b[0m");
+  async notify(_ctx: NotificationContext, _event: NotificationEvent): Promise<void> {
+    // Flash is handled by the NotificationFlash React component via
+    // notificationBus.flashHandler — raw ANSI escapes conflict with OpenTUI.
   },
 
   async test(ctx: NotificationContext): Promise<boolean> {
     ctx.logger.info("Testing visual flash...");
-    process.stdout.write("\x1b[44m");
-    await sleep(100);
-    process.stdout.write("\x1b[0m");
     return true;
   },
 };
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/plugins/plugin-context-factory.ts

@@ -39,13 +39,21 @@ export function createPluginContext(
   permissions: PluginPermissions,
   signal?: AbortSignal,
 ): PluginContext {
+  // Lazily create the AbortSignal only when accessed to avoid accumulating
+  // dangling 30s timers from AbortSignal.timeout() on every context creation.
+  let _signal = signal;
   const ctx: PluginContext = {
     config: {},
     logger: createPluginLogger(pluginId),
     http: createSandboxedHttpClient(pluginId, permissions),
     authSources: createAuthSources(pluginId, permissions),
     storage: createPluginStorage(pluginId),
-    signal: signal ?? AbortSignal.timeout(30_000),
+    get signal() {
+      if (!_signal) {
+        _signal = AbortSignal.timeout(30_000);
+      }
+      return _signal;
+    },
   };
   deepFreeze(ctx.config);
   return ctx;

package/src/plugins/providers/anthropic.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, test } from "bun:test";
 import type {
   Credentials,
+  OpenCodeAuthEntry,
+  PluginContext,
   PluginHttpClient,
   PluginLogger,
   ProviderFetchContext,
@@ -200,3 +202,146 @@ describe("anthropic fetchUsage — success", () => {
     expect(result.error).toBeUndefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// auth.discover — credential source fallthrough
+// ---------------------------------------------------------------------------
+
+function createDiscoverContext(options: {
+  opencodeEntry?: OpenCodeAuthEntry | null;
+  files?: Record<string, string>;
+  env?: Record<string, string>;
+  platformOs?: "darwin" | "linux" | "win32";
+  homedir?: string;
+}): PluginContext {
+  const files = options.files ?? {};
+  const env = options.env ?? {};
+  return {
+    config: {},
+    logger: createMockLogger(),
+    http: { fetch: async () => new Response(null, { status: 404 }) },
+    storage: {
+      get: async () => null,
+      set: async () => {},
+      delete: async () => {},
+      has: async () => false,
+    },
+    signal: new AbortController().signal,
+    authSources: {
+      env: { get: (name) => env[name] },
+      files: {
+        readText: async (path) => files[path] ?? null,
+        readJson: async <T = unknown>(path: string): Promise<T | null> => {
+          const raw = files[path];
+          if (!raw) return null;
+          try {
+            return JSON.parse(raw) as T;
+          } catch {
+            return null;
+          }
+        },
+        exists: async (path) => path in files,
+      },
+      opencode: {
+        getProviderEntry: async () => options.opencodeEntry ?? null,
+      },
+      platform: {
+        os: options.platformOs ?? "linux",
+        homedir: options.homedir ?? "/home/test",
+        arch: "x64",
+      },
+    },
+  };
+}
+
+describe("anthropic auth.discover — OpenCode OAuth expiry", () => {
+  // Regression: an expired OpenCode OAuth entry used to be returned as-is,
+  // blocking fallthrough to fresher Claude Code credentials and causing the
+  // TUI to show "needs auth" even when Claude Code had a valid token.
+  test("falls through to Claude Code credentials when OpenCode OAuth is expired", async () => {
+    const now = Date.now();
+    const ctx = createDiscoverContext({
+      opencodeEntry: {
+        type: "oauth",
+        access: "stale-opencode-token",
+        refresh: "stale-refresh",
+        expires: now - 60_000,
+      },
+      files: {
+        "/home/test/.claude/.credentials.json": JSON.stringify({
+          claudeAiOauth: {
+            accessToken: "fresh-claude-code-token",
+            refreshToken: "fresh-refresh",
+            expiresAt: now + 3_600_000,
+            subscriptionType: "max",
+          },
+        }),
+      },
+    });
+
+    const result = await anthropicPlugin.auth.discover(ctx);
+
+    expect(result.ok).toBe(true);
+    expect(result.credentials?.oauth?.accessToken).toBe("fresh-claude-code-token");
+    expect(result.credentials?.source).toBe("external");
+  });
+
+  test("treats near-expiry OpenCode token (within 5-minute buffer) as expired", async () => {
+    const now = Date.now();
+    const ctx = createDiscoverContext({
+      opencodeEntry: {
+        type: "oauth",
+        access: "near-expiry-opencode-token",
+        expires: now + 60_000,
+      },
+      env: { ANTHROPIC_API_KEY: "sk-ant-api-key" },
+    });
+
+    const result = await anthropicPlugin.auth.discover(ctx);
+
+    expect(result.ok).toBe(true);
+    expect(result.credentials?.apiKey).toBe("sk-ant-api-key");
+    expect(result.credentials?.source).toBe("env");
+  });
+
+  test("uses OpenCode entry when token is comfortably in the future", async () => {
+    const now = Date.now();
+    const ctx = createDiscoverContext({
+      opencodeEntry: {
+        type: "oauth",
+        access: "valid-opencode-token",
+        refresh: "valid-refresh",
+        expires: now + 3_600_000,
+      },
+      files: {
+        "/home/test/.claude/.credentials.json": JSON.stringify({
+          claudeAiOauth: {
+            accessToken: "claude-code-token",
+            expiresAt: now + 3_600_000,
+          },
+        }),
+      },
+    });
+
+    const result = await anthropicPlugin.auth.discover(ctx);
+
+    expect(result.ok).toBe(true);
+    expect(result.credentials?.oauth?.accessToken).toBe("valid-opencode-token");
+    expect(result.credentials?.source).toBe("opencode");
+  });
+
+  test("uses OpenCode entry with no expires field (treated as non-expiring)", async () => {
+    const ctx = createDiscoverContext({
+      opencodeEntry: {
+        type: "oauth",
+        access: "no-expiry-token",
+      },
+    });
+
+    const result = await anthropicPlugin.auth.discover(ctx);
+
+    expect(result.ok).toBe(true);
+    expect(result.credentials?.oauth?.accessToken).toBe("no-expiry-token");
+    expect(result.credentials?.source).toBe("opencode");
+  });
+});

package/src/plugins/providers/anthropic.ts

@@ -155,18 +155,22 @@ export const anthropicPlugin: ProviderPlugin = {
     async discover(ctx: PluginContext): Promise<CredentialResult> {
       const entry = await ctx.authSources.opencode.getProviderEntry("anthropic");
       if (entry?.type === "oauth" && entry.access) {
-        return {
-          ok: true,
-          credentials: {
-            oauth: buildOAuthCredentials(
-              entry.access,
-              entry.refresh,
-              entry.expires,
-              entry.accountId,
-            ),
-            source: "opencode",
-          },
-        };
+        const expired =
+          entry.expires != null && entry.expires <= Date.now() + TOKEN_EXPIRY_BUFFER_MS;
+        if (!expired) {
+          return {
+            ok: true,
+            credentials: {
+              oauth: buildOAuthCredentials(
+                entry.access,
+                entry.refresh,
+                entry.expires,
+                entry.accountId,
+              ),
+              source: "opencode",
+            },
+          };
+        }
       }
 
       const claudeCodeResult = await discoverClaudeCode(ctx);
@@ -233,6 +237,8 @@ export const anthropicPlugin: ProviderPlugin = {
 
       if (!response.ok) {
         log.warn("Failed to fetch Anthropic usage", { status: response.status });
+        // Drain the response body to prevent memory leaks in Bun's fetch implementation
+        response.body?.cancel();
 
         if (response.status === 429) {
           const retryAfterHeader = response.headers.get("retry-after");

package/src/plugins/providers/chutes.ts

@@ -108,6 +108,8 @@ export const chutesPlugin: ProviderPlugin = {
 
       if (!response.ok) {
         log.warn("Failed to fetch Chutes usage", { status: response.status });
+        // Drain the response body to prevent memory leaks in Bun's fetch implementation
+        response.body?.cancel();
 
         if (response.status === 429) {
           const retryAfterHeader = response.headers.get("retry-after");

package/src/plugins/providers/github-copilot.ts

@@ -134,6 +134,9 @@ export const githubCopilotPlugin: ProviderPlugin = {
       });
 
       if (!response.ok) {
+        // Drain the response body to prevent memory leaks in Bun's fetch implementation
+        response.body?.cancel();
+
         if (response.status === 429) {
           const retryAfterHeader = response.headers.get("retry-after");
           const parsedRetryAfter = retryAfterHeader

package/src/plugins/providers/minimax.ts

@@ -150,6 +150,8 @@ function createMinimaxPlugin(id: string, name: string): ProviderPlugin {
 
         if (!response.ok) {
           log.warn("Failed to fetch MiniMax usage", { status: response.status });
+          // Drain the response body to prevent memory leaks in Bun's fetch implementation
+          response.body?.cancel();
 
           if (response.status === 429) {
             const retryAfterHeader = response.headers.get("retry-after");

package/src/plugins/providers/openai-api.ts

@@ -270,6 +270,8 @@ async function fetchCompletionsUsage(
   });
 
   if (!response.ok) {
+    // Drain the response body to prevent memory leaks in Bun's fetch implementation
+    response.body?.cancel();
     if (response.status === 429) {
       const retryAfterHeader = response.headers.get("retry-after");
       const parsedRetryAfter = retryAfterHeader
@@ -303,6 +305,8 @@ async function fetchCosts(
   });
 
   if (!response.ok) {
+    // Drain the response body to prevent memory leaks in Bun's fetch implementation
+    response.body?.cancel();
     if (response.status === 429) {
       const retryAfterHeader = response.headers.get("retry-after");
       const parsedRetryAfter = retryAfterHeader

package/src/plugins/providers/zai.ts

@@ -123,6 +123,8 @@ export const zaiCodingPlanPlugin: ProviderPlugin = {
 
       if (!response.ok) {
         log.warn("Failed to fetch Z.ai usage", { status: response.status });
+        // Drain the response body to prevent memory leaks in Bun's fetch implementation
+        response.body?.cancel();
 
         if (response.status === 429) {
           const retryAfterHeader = response.headers.get("retry-after");

package/src/pricing/estimator.ts

@@ -1,5 +1,7 @@
 import type { CostBreakdown, ModelPricing } from "@tokentop/plugin-sdk";
 
+export const LONG_CONTEXT_THRESHOLD = 200_000;
+
 export interface TokenUsage {
   input: number;
   output: number;
@@ -36,6 +38,11 @@ export function estimateCost(usage: TokenUsage, pricing: ModelPricing): CostBrea
   return breakdown;
 }
 
+/**
+ * @deprecated This function sums tokens before pricing, which is incompatible with
+ * tiered context-based pricing. Use per-request costing via priceStream() instead.
+ * Kept for backward compatibility — not called at runtime.
+ */
 export function estimateSessionCost(sessions: TokenUsage[], pricing: ModelPricing): CostBreakdown {
   const totals = sessions.reduce<TokenUsage>(
     (acc, session) => ({

package/src/pricing/index.ts

@@ -68,5 +68,10 @@ export function clearPricingCache(): void {
 }
 
 export type { TokenUsage } from "./estimator.ts";
+/**
+ * @deprecated This function sums tokens before pricing, which is incompatible with
+ * tiered context-based pricing. Use per-request costing via priceStream() instead.
+ * Kept for backward compatibility — not called at runtime.
+ */
 export { estimateCost, estimateSessionCost, formatCost, formatTokenCount } from "./estimator.ts";
 export { FALLBACK_PRICING } from "./fallback.ts";

package/src/pricing/models-dev.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, describe, expect, mock, test } from "bun:test";
+import { clearCache, getModelPricing, getProviderModels } from "./models-dev.ts";
+
+const mockFetch = mock(() => Promise.resolve(new Response("null")));
+globalThis.fetch = mockFetch as unknown as typeof fetch;
+
+function makeApiResponse(costOverride?: Record<string, unknown>) {
+  return {
+    anthropic: {
+      id: "anthropic",
+      name: "Anthropic",
+      models: {
+        "claude-sonnet-4-20250514": {
+          id: "claude-sonnet-4-20250514",
+          name: "Claude Sonnet 4",
+          family: "claude",
+          cost: {
+            input: 3,
+            output: 15,
+            cache_read: 0.3,
+            cache_write: 3.75,
+            ...costOverride,
+          },
+        },
+      },
+    },
+  };
+}
+
+function mockApiResponse(data: unknown) {
+  mockFetch.mockImplementation(() =>
+    Promise.resolve(new Response(JSON.stringify(data), { status: 200 })),
+  );
+}
+
+afterEach(() => {
+  clearCache();
+  mockFetch.mockClear();
+});
+
+describe("getModelPricing() — context_over_200k", () => {
+  test("returns all longContext fields when API has full context_over_200k", async () => {
+    mockApiResponse(
+      makeApiResponse({
+        context_over_200k: {
+          input: 6,
+          output: 22.5,
+          cache_read: 0.6,
+          cache_write: 7.5,
+        },
+      }),
+    );
+
+    const pricing = await getModelPricing("anthropic", "claude-sonnet-4-20250514");
+
+    expect(pricing).not.toBeNull();
+    expect(pricing!.longContextInput).toBe(6);
+    expect(pricing!.longContextOutput).toBe(22.5);
+    expect(pricing!.longContextCacheRead).toBe(0.6);
+    expect(pricing!.longContextCacheWrite).toBe(7.5);
+  });
+
+  test("returns undefined longContext fields when API lacks context_over_200k", async () => {
+    mockApiResponse(makeApiResponse());
+
+    const pricing = await getModelPricing("anthropic", "claude-sonnet-4-20250514");
+
+    expect(pricing).not.toBeNull();
+    expect(pricing!.longContextInput).toBeUndefined();
+    expect(pricing!.longContextOutput).toBeUndefined();
+    expect(pricing!.longContextCacheRead).toBeUndefined();
+    expect(pricing!.longContextCacheWrite).toBeUndefined();
+    expect(pricing!.input).toBe(3);
+    expect(pricing!.output).toBe(15);
+  });
+
+  test("handles partial context_over_200k (only input+output, no cache)", async () => {
+    mockApiResponse(
+      makeApiResponse({
+        context_over_200k: {
+          input: 6,
+          output: 22.5,
+        },
+      }),
+    );
+
+    const pricing = await getModelPricing("anthropic", "claude-sonnet-4-20250514");
+
+    expect(pricing).not.toBeNull();
+    expect(pricing!.longContextInput).toBe(6);
+    expect(pricing!.longContextOutput).toBe(22.5);
+    expect(pricing!.longContextCacheRead).toBeUndefined();
+    expect(pricing!.longContextCacheWrite).toBeUndefined();
+  });
+
+  test("getProviderModels() passes through longContext fields", async () => {
+    mockApiResponse(
+      makeApiResponse({
+        context_over_200k: {
+          input: 6,
+          output: 22.5,
+          cache_read: 0.6,
+        },
+      }),
+    );
+
+    const models = await getProviderModels("anthropic");
+
+    expect(models).not.toBeNull();
+    const pricing = models!["claude-sonnet-4-20250514"]!;
+    expect(pricing).toBeDefined();
+    expect(pricing.longContextInput).toBe(6);
+    expect(pricing.longContextOutput).toBe(22.5);
+    expect(pricing.longContextCacheRead).toBe(0.6);
+    expect(pricing.longContextCacheWrite).toBeUndefined();
+  });
+});