@tokentop/ttop 0.6.1 → 0.7.0

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();
+  });
+});

package/src/pricing/models-dev.ts

@@ -8,6 +8,12 @@ interface ModelsDevCost {
   output: number;
   cache_read?: number;
   cache_write?: number;
+  context_over_200k?: {
+    input?: number;
+    output?: number;
+    cache_read?: number;
+    cache_write?: number;
+  };
 }
 
 interface ModelsDevModel {
@@ -88,6 +94,14 @@ export async function getModelPricing(
     pricing.cacheWrite = model.cost.cache_write;
   }
 
+  const lc = model.cost.context_over_200k;
+  if (lc) {
+    if (lc.input !== undefined) pricing.longContextInput = lc.input;
+    if (lc.output !== undefined) pricing.longContextOutput = lc.output;
+    if (lc.cache_read !== undefined) pricing.longContextCacheRead = lc.cache_read;
+    if (lc.cache_write !== undefined) pricing.longContextCacheWrite = lc.cache_write;
+  }
+
   return pricing;
 }
 
@@ -119,6 +133,14 @@ export async function getProviderModels(
       pricing.cacheWrite = model.cost.cache_write;
     }
 
+    const lc = model.cost.context_over_200k;
+    if (lc) {
+      if (lc.input !== undefined) pricing.longContextInput = lc.input;
+      if (lc.output !== undefined) pricing.longContextOutput = lc.output;
+      if (lc.cache_read !== undefined) pricing.longContextCacheRead = lc.cache_read;
+      if (lc.cache_write !== undefined) pricing.longContextCacheWrite = lc.cache_write;
+    }
+
     result[modelId] = pricing;
   }
 

package/src/storage/persistence-service.test.ts

@@ -0,0 +1,201 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+import type {
+  AgentSessionSnapshotInsert,
+  AgentSessionStreamSnapshotRow,
+  AgentSessionUpsert,
+  UsageEventInsert,
+} from "./types.ts";
+
+mock.module("./db.ts", () => ({
+  isDatabaseInitialized: () => true,
+}));
+
+let upsertCalls: AgentSessionUpsert[] = [];
+let snapshotCalls: Array<{
+  snapshot: AgentSessionSnapshotInsert;
+  streams: Omit<AgentSessionStreamSnapshotRow, "agentSessionSnapshotId">[];
+}> = [];
+let usageEventCalls: UsageEventInsert[][] = [];
+
+let seededSnapshots: Array<{
+  agentId: string;
+  sessionId: string;
+  timestamp: number;
+  totalCostUsd: number;
+  requestCount: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+}> = [];
+
+mock.module("./repos/agentSessions.ts", () => ({
+  getLatestSnapshotsForAllSessions: () => seededSnapshots,
+  getLatestStreamTotalsForAllSessions: () => [],
+  upsertAgentSession: (session: AgentSessionUpsert) => {
+    upsertCalls.push(session);
+    return upsertCalls.length;
+  },
+  insertAgentSessionSnapshot: (
+    snapshot: AgentSessionSnapshotInsert,
+    streams: Omit<AgentSessionStreamSnapshotRow, "agentSessionSnapshotId">[],
+  ) => {
+    snapshotCalls.push({ snapshot, streams });
+  },
+}));
+
+mock.module("./repos/usageEvents.ts", () => ({
+  insertUsageEventBatch: (events: UsageEventInsert[]) => {
+    usageEventCalls.push(events);
+  },
+}));
+
+const { persistSessions, seedPreviousTotals } = await import("./persistence-service.ts");
+
+beforeEach(() => {
+  upsertCalls = [];
+  snapshotCalls = [];
+  usageEventCalls = [];
+  seededSnapshots = [];
+  (globalThis as { __tokentopPersistence?: unknown }).__tokentopPersistence = undefined;
+});
+
+function makePersistData(overrides: {
+  agentId?: string;
+  sessionId?: string;
+  totalCostUsd?: number;
+  requestCount?: number;
+  totalInputTokens?: number;
+  totalOutputTokens?: number;
+  timestamp?: number;
+}) {
+  const now = overrides.timestamp ?? Date.now();
+  return {
+    session: {
+      agentId: overrides.agentId ?? "claude-code",
+      sessionId: overrides.sessionId ?? "s1",
+      projectPath: null,
+      startedAt: null,
+      lastSeenAt: now,
+    },
+    snapshot: {
+      timestamp: now,
+      lastActivityAt: now,
+      status: null,
+      totalInputTokens: overrides.totalInputTokens ?? 1000,
+      totalOutputTokens: overrides.totalOutputTokens ?? 500,
+      totalCacheReadTokens: 0,
+      totalCacheWriteTokens: 0,
+      totalCostUsd: overrides.totalCostUsd ?? 1.5,
+      requestCount: overrides.requestCount ?? 10,
+    },
+    streams: [],
+  };
+}
+
+describe("seedPreviousTotals", () => {
+  test("skips persist for session whose fingerprint matches seeded DB snapshot", () => {
+    seededSnapshots = [
+      {
+        agentId: "claude-code",
+        sessionId: "s1",
+        timestamp: Date.now() - 60_000,
+        totalCostUsd: 1.5,
+        requestCount: 10,
+        totalInputTokens: 1000,
+        totalOutputTokens: 500,
+      },
+    ];
+
+    seedPreviousTotals();
+
+    const persistedCount = persistSessions([
+      makePersistData({
+        agentId: "claude-code",
+        sessionId: "s1",
+        totalCostUsd: 1.5,
+        requestCount: 10,
+        totalInputTokens: 1000,
+        totalOutputTokens: 500,
+      }),
+    ]);
+
+    expect(persistedCount).toBe(0);
+    expect(upsertCalls).toHaveLength(0);
+    expect(snapshotCalls).toHaveLength(0);
+  });
+
+  test("persists session whose usage changed since seeded snapshot", () => {
+    seededSnapshots = [
+      {
+        agentId: "claude-code",
+        sessionId: "s1",
+        timestamp: Date.now() - 10 * 60 * 1000,
+        totalCostUsd: 1.5,
+        requestCount: 10,
+        totalInputTokens: 1000,
+        totalOutputTokens: 500,
+      },
+    ];
+
+    seedPreviousTotals();
+
+    const persistedCount = persistSessions([
+      makePersistData({
+        agentId: "claude-code",
+        sessionId: "s1",
+        totalCostUsd: 2.0,
+        requestCount: 12,
+        totalInputTokens: 1200,
+        totalOutputTokens: 600,
+      }),
+    ]);
+
+    expect(persistedCount).toBe(1);
+    expect(upsertCalls).toHaveLength(1);
+    expect(snapshotCalls).toHaveLength(1);
+  });
+
+  test("persists brand-new session not present in seed", () => {
+    seededSnapshots = [];
+
+    seedPreviousTotals();
+
+    const persistedCount = persistSessions([
+      makePersistData({ agentId: "claude-code", sessionId: "new-session" }),
+    ]);
+
+    expect(persistedCount).toBe(1);
+    expect(upsertCalls).toHaveLength(1);
+  });
+
+  test("skips thousands of unchanged sessions after seed (regression for startup freeze)", () => {
+    const baseTs = Date.now() - 60_000;
+    seededSnapshots = Array.from({ length: 5000 }, (_, i) => ({
+      agentId: "claude-code",
+      sessionId: `s${i}`,
+      timestamp: baseTs + i,
+      totalCostUsd: i * 0.01,
+      requestCount: i,
+      totalInputTokens: i * 100,
+      totalOutputTokens: i * 50,
+    }));
+
+    seedPreviousTotals();
+
+    const persistData = seededSnapshots.map((s) =>
+      makePersistData({
+        agentId: s.agentId,
+        sessionId: s.sessionId,
+        totalCostUsd: s.totalCostUsd,
+        requestCount: s.requestCount,
+        totalInputTokens: s.totalInputTokens,
+        totalOutputTokens: s.totalOutputTokens,
+      }),
+    );
+
+    const persistedCount = persistSessions(persistData);
+
+    expect(persistedCount).toBe(0);
+    expect(upsertCalls).toHaveLength(0);
+    expect(snapshotCalls).toHaveLength(0);
+  });
+});