@promptctl/cc-candybar 1.0.0

package/src/segments/pricing.ts

@@ -0,0 +1,452 @@
+import { debug } from "../utils/logger";
+import { get } from "node:https";
+import { URL } from "node:url";
+import { CacheManager } from "../utils/cache";
+import type { PrunedRaw } from "../utils/claude.js";
+
+export interface ModelPricing {
+  name: string;
+  input: number;
+  cache_write_5m: number;
+  cache_write_1h: number;
+  cache_read: number;
+  output: number;
+}
+const OFFLINE_PRICING_DATA: Record<string, ModelPricing> = {
+  "claude-haiku-4-5-20251001": {
+    name: "Claude Haiku 4.5",
+    input: 1.0,
+    output: 5.0,
+    cache_write_5m: 1.25,
+    cache_write_1h: 2.0,
+    cache_read: 0.1,
+  },
+  "claude-haiku-4-5": {
+    name: "Claude Haiku 4.5",
+    input: 1.0,
+    output: 5.0,
+    cache_write_5m: 1.25,
+    cache_write_1h: 2.0,
+    cache_read: 0.1,
+  },
+  "claude-opus-4-20250514": {
+    name: "Claude Opus 4",
+    input: 15.0,
+    output: 75.0,
+    cache_write_5m: 18.75,
+    cache_write_1h: 30.0,
+    cache_read: 1.5,
+  },
+  "claude-opus-4-1": {
+    name: "Claude Opus 4.1",
+    input: 15.0,
+    output: 75.0,
+    cache_write_5m: 18.75,
+    cache_write_1h: 30.0,
+    cache_read: 1.5,
+  },
+  "claude-opus-4-1-20250805": {
+    name: "Claude Opus 4.1",
+    input: 15.0,
+    output: 75.0,
+    cache_write_5m: 18.75,
+    cache_write_1h: 30.0,
+    cache_read: 1.5,
+  },
+  "claude-sonnet-4-20250514": {
+    name: "Claude Sonnet 4",
+    input: 3.0,
+    output: 15.0,
+    cache_write_5m: 3.75,
+    cache_write_1h: 6.0,
+    cache_read: 0.3,
+  },
+  "claude-4-opus-20250514": {
+    name: "Claude 4 Opus",
+    input: 15.0,
+    output: 75.0,
+    cache_write_5m: 18.75,
+    cache_write_1h: 30.0,
+    cache_read: 1.5,
+  },
+  "claude-4-sonnet-20250514": {
+    name: "Claude 4 Sonnet",
+    input: 3.0,
+    output: 15.0,
+    cache_write_5m: 3.75,
+    cache_write_1h: 6.0,
+    cache_read: 0.3,
+  },
+  "claude-sonnet-4-5": {
+    name: "Claude Sonnet 4.5",
+    input: 3.0,
+    output: 15.0,
+    cache_write_5m: 3.75,
+    cache_write_1h: 6.0,
+    cache_read: 0.3,
+  },
+  "claude-sonnet-4-5-20250929": {
+    name: "Claude Sonnet 4.5",
+    input: 3.0,
+    output: 15.0,
+    cache_write_5m: 3.75,
+    cache_write_1h: 6.0,
+    cache_read: 0.3,
+  },
+  "claude-opus-4-5": {
+    name: "Claude Opus 4.5",
+    input: 5.0,
+    output: 25.0,
+    cache_write_5m: 6.25,
+    cache_write_1h: 10.0,
+    cache_read: 0.5,
+  },
+  "claude-opus-4-5-20251101": {
+    name: "Claude Opus 4.5",
+    input: 5.0,
+    output: 25.0,
+    cache_write_5m: 6.25,
+    cache_write_1h: 10.0,
+    cache_read: 0.5,
+  },
+  "claude-opus-4-6": {
+    name: "Claude Opus 4.6",
+    input: 5.0,
+    output: 25.0,
+    cache_write_5m: 6.25,
+    cache_write_1h: 10.0,
+    cache_read: 0.5,
+  },
+  "claude-opus-4-6-20260205": {
+    name: "Claude Opus 4.6",
+    input: 5.0,
+    output: 25.0,
+    cache_write_5m: 6.25,
+    cache_write_1h: 10.0,
+    cache_read: 0.5,
+  },
+  "claude-sonnet-4-6": {
+    name: "Claude Sonnet 4.6",
+    input: 3.0,
+    output: 15.0,
+    cache_write_5m: 3.75,
+    cache_write_1h: 6.0,
+    cache_read: 0.3,
+  },
+};
+
+export class PricingService {
+  private static executionCache: Record<string, ModelPricing> | null = null;
+  private static modelPricingCache = new Map<string, ModelPricing>();
+  private static readonly GITHUB_PRICING_URL =
+    "https://raw.githubusercontent.com/promptctl/cc-candybar/main/pricing.json";
+
+  private static async loadDiskCache(): Promise<Record<
+    string,
+    ModelPricing
+  > | null> {
+    const TTL_24H = 24 * 60 * 60 * 1000;
+    const minValidTime = Date.now() - TTL_24H;
+    return (await CacheManager.getUsageCache(
+      "pricing",
+      minValidTime,
+    )) as Record<string, ModelPricing> | null;
+  }
+
+  private static async saveDiskCache(
+    data: Record<string, ModelPricing>,
+  ): Promise<void> {
+    await CacheManager.setUsageCache("pricing", data);
+  }
+
+  private static async fetchPricingData(): Promise<Record<
+    string,
+    ModelPricing
+  > | null> {
+    return new Promise((resolve) => {
+      const parsedUrl = new URL(this.GITHUB_PRICING_URL);
+
+      const request = get(
+        {
+          hostname: parsedUrl.hostname,
+          path: parsedUrl.pathname,
+          headers: {
+            "User-Agent": "cc-candybar",
+            "Cache-Control": "no-cache",
+          },
+          timeout: 5000,
+        },
+        (response) => {
+          if (response.statusCode !== 200) {
+            debug(`HTTP ${response.statusCode}: ${response.statusMessage}`);
+            resolve(null);
+            return;
+          }
+
+          let data = "";
+          let size = 0;
+          const MAX_SIZE = 1024 * 1024;
+
+          response.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > MAX_SIZE) {
+              debug("Response too large");
+              request.destroy();
+              resolve(null);
+              return;
+            }
+            data += chunk;
+          });
+
+          response.on("end", () => {
+            try {
+              const json = JSON.parse(data);
+              const dataObj = json as Record<string, unknown>;
+              const meta = dataObj._meta as { updated?: string } | undefined;
+
+              const pricingData: Record<string, unknown> = {};
+              for (const [key, value] of Object.entries(dataObj)) {
+                if (key !== "_meta") {
+                  pricingData[key] = value;
+                }
+              }
+
+              if (this.validatePricingData(pricingData)) {
+                debug(
+                  `Fetched fresh pricing from GitHub for ${Object.keys(pricingData).length} models`,
+                );
+                debug(`Pricing last updated: ${meta?.updated || "unknown"}`);
+                resolve(pricingData);
+              } else {
+                debug("Invalid pricing data structure");
+                resolve(null);
+              }
+            } catch (error) {
+              debug("Failed to parse JSON:", error);
+              resolve(null);
+            }
+          });
+
+          response.on("error", (error) => {
+            debug("Response error:", error);
+            resolve(null);
+          });
+        },
+      );
+
+      request.on("error", (error) => {
+        debug("Request error:", error);
+        resolve(null);
+      });
+
+      request.on("timeout", () => {
+        debug("Request timeout");
+        request.destroy();
+        resolve(null);
+      });
+
+      request.end();
+    });
+  }
+
+  static async getCurrentPricing(): Promise<Record<string, ModelPricing>> {
+    if (this.executionCache !== null) {
+      debug(
+        `[CACHE-HIT] Pricing execution cache: ${Object.keys(this.executionCache).length} models`,
+      );
+      return this.executionCache;
+    }
+
+    const diskCached = await this.loadDiskCache();
+    if (diskCached) {
+      debug(
+        `[CACHE-HIT] Pricing disk cache: ${Object.keys(diskCached).length} models`,
+      );
+      this.executionCache = diskCached;
+      debug(
+        `[CACHE-SET] Pricing execution cache stored: ${Object.keys(diskCached).length} models`,
+      );
+      return diskCached;
+    }
+
+    const freshData = await this.fetchPricingData();
+    if (freshData) {
+      await this.saveDiskCache(freshData);
+      debug(
+        `[CACHE-SET] Pricing disk cache stored: ${Object.keys(freshData).length} models`,
+      );
+      this.executionCache = freshData;
+      debug(
+        `[CACHE-SET] Pricing execution cache stored: ${Object.keys(freshData).length} models`,
+      );
+      return freshData;
+    }
+
+    debug(
+      `[CACHE-FALLBACK] Using offline pricing data: ${Object.keys(OFFLINE_PRICING_DATA).length} models`,
+    );
+    this.executionCache = OFFLINE_PRICING_DATA;
+    debug(
+      `[CACHE-SET] Pricing execution cache stored: ${Object.keys(OFFLINE_PRICING_DATA).length} models`,
+    );
+    return OFFLINE_PRICING_DATA;
+  }
+
+  private static validatePricingData(
+    data: unknown,
+  ): data is Record<string, ModelPricing> {
+    if (!data || typeof data !== "object") return false;
+
+    for (const [, value] of Object.entries(data)) {
+      if (!value || typeof value !== "object") return false;
+      const pricing = value as Record<string, unknown>;
+
+      if (
+        typeof pricing.input !== "number" ||
+        typeof pricing.output !== "number" ||
+        typeof pricing.cache_read !== "number"
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  static async getModelPricing(modelId: string): Promise<ModelPricing> {
+    if (this.modelPricingCache.has(modelId)) {
+      debug(`[CACHE-HIT] Model pricing cache: ${modelId}`);
+      return this.modelPricingCache.get(modelId)!;
+    }
+
+    const allPricing = await this.getCurrentPricing();
+    let pricing: ModelPricing;
+
+    if (allPricing[modelId]) {
+      pricing = allPricing[modelId];
+    } else {
+      pricing = this.fuzzyMatchModel(modelId, allPricing);
+    }
+
+    this.modelPricingCache.set(modelId, pricing);
+    debug(`[CACHE-SET] Model pricing cache: ${modelId}`);
+    return pricing;
+  }
+
+  private static fuzzyMatchModel(
+    modelId: string,
+    allPricing: Record<string, ModelPricing>,
+  ): ModelPricing {
+    const lowerModelId = modelId.toLowerCase();
+
+    for (const [key, pricing] of Object.entries(allPricing)) {
+      if (key.toLowerCase() === lowerModelId) {
+        return pricing;
+      }
+    }
+    const patterns = [
+      {
+        pattern: ["opus-4-6", "claude-opus-4-6"],
+        fallback: "claude-opus-4-6-20260205",
+      },
+      {
+        pattern: ["opus-4-5", "claude-opus-4-5"],
+        fallback: "claude-opus-4-5-20251101",
+      },
+      {
+        pattern: ["opus-4-1", "claude-opus-4-1"],
+        fallback: "claude-opus-4-1-20250805",
+      },
+      {
+        pattern: ["opus-4", "claude-opus-4"],
+        fallback: "claude-opus-4-20250514",
+      },
+      {
+        pattern: ["sonnet-4-6", "sonnet-4.6", "claude-sonnet-4-6"],
+        fallback: "claude-sonnet-4-6",
+      },
+      {
+        pattern: ["sonnet-4.5", "4-5-sonnet", "sonnet-4-5"],
+        fallback: "claude-sonnet-4-5-20250929",
+      },
+      {
+        pattern: ["sonnet-4", "claude-sonnet-4"],
+        fallback: "claude-sonnet-4-20250514",
+      },
+      {
+        pattern: ["haiku-4.5", "4-5-haiku", "haiku-4-5"],
+        fallback: "claude-haiku-4-5-20251001",
+      },
+      { pattern: ["haiku"], fallback: "claude-haiku-4-5-20251001" },
+      { pattern: ["opus"], fallback: "claude-opus-4-20250514" },
+      { pattern: ["sonnet"], fallback: "claude-sonnet-4-5-20250929" },
+    ];
+
+    for (const { pattern, fallback } of patterns) {
+      if (pattern.some((p) => lowerModelId.includes(p))) {
+        if (allPricing[fallback]) {
+          return allPricing[fallback];
+        }
+      }
+    }
+
+    return (
+      allPricing["claude-sonnet-4-5-20250929"] || {
+        name: `${modelId} (Unknown Model)`,
+        input: 3.0,
+        cache_write_5m: 3.75,
+        cache_write_1h: 6.0,
+        cache_read: 0.3,
+        output: 15.0,
+      }
+    );
+  }
+
+  static async calculateCostForEntry(entry: PrunedRaw): Promise<number> {
+    const usage = entry.message?.usage;
+    if (!usage) {
+      return 0;
+    }
+
+    const modelId = this.extractModelId(entry);
+    const pricing = await this.getModelPricing(modelId);
+
+    const inputTokens = usage.input_tokens || 0;
+    const outputTokens = usage.output_tokens || 0;
+    const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+    const cacheReadTokens = usage.cache_read_input_tokens || 0;
+
+    const inputCost = (inputTokens / 1_000_000) * pricing.input;
+    const outputCost = (outputTokens / 1_000_000) * pricing.output;
+    const cacheReadCost = (cacheReadTokens / 1_000_000) * pricing.cache_read;
+    const cacheCreationCost =
+      (cacheCreationTokens / 1_000_000) * pricing.cache_write_5m;
+
+    return inputCost + outputCost + cacheCreationCost + cacheReadCost;
+  }
+
+  private static extractModelId(entry: Record<string, unknown>): string {
+    if (entry.model && typeof entry.model === "string") {
+      return entry.model;
+    }
+
+    const message = entry.message as Record<string, unknown> | undefined;
+    if (message?.model) {
+      const model = message.model;
+      if (typeof model === "string") {
+        return model;
+      }
+      const modelObj = model as Record<string, unknown> | undefined;
+      return (
+        (typeof modelObj?.id === "string" ? modelObj.id : null) ||
+        "claude-sonnet-4-5-20250929"
+      );
+    }
+
+    if (entry.model_id && typeof entry.model_id === "string") {
+      return entry.model_id;
+    }
+
+    return "claude-sonnet-4-5-20250929";
+  }
+}

package/src/segments/session.ts

@@ -0,0 +1,188 @@
+import { debug } from "../utils/logger";
+import { PricingService } from "./pricing";
+import { failed, ok, type Outcome } from "../utils/outcome";
+import {
+  findAgentTranscripts,
+  parseJsonlFile,
+  type ParsedEntry,
+} from "../utils/claude";
+import { dirname } from "node:path";
+
+export interface SessionUsageEntry {
+  timestamp: string;
+  message: {
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      cache_creation_input_tokens?: number;
+      cache_read_input_tokens?: number;
+    };
+  };
+  costUSD?: number;
+}
+
+export interface SessionUsage {
+  totalCost: number;
+  entries: SessionUsageEntry[];
+}
+
+export interface TokenBreakdown {
+  input: number;
+  output: number;
+  cacheCreation: number;
+  cacheRead: number;
+}
+
+export interface SessionInfo {
+  cost: number | null;
+  calculatedCost: number | null;
+  officialCost: number | null;
+  tokens: number | null;
+  tokenBreakdown: TokenBreakdown | null;
+}
+
+export interface UsageInfo {
+  session: SessionInfo;
+}
+
+function convertToSessionEntry(entry: ParsedEntry): SessionUsageEntry {
+  return {
+    timestamp: entry.timestamp.toISOString(),
+    message: {
+      usage: {
+        input_tokens: entry.message?.usage?.input_tokens || 0,
+        output_tokens: entry.message?.usage?.output_tokens || 0,
+        cache_creation_input_tokens:
+          entry.message?.usage?.cache_creation_input_tokens,
+        cache_read_input_tokens: entry.message?.usage?.cache_read_input_tokens,
+      },
+    },
+    costUSD: entry.costUSD,
+  };
+}
+
+export class SessionProvider {
+  // [LAW:one-source-of-truth] The transcript path is always in hand — the
+  // daemon's SessionUsageStore holds it (hookData.transcript_path or its seed
+  // scan) and passes it straight here. There is no lookup-by-id path: recovering
+  // a path we already hold by scanning every project dir is the data-duplication
+  // this method exists to avoid.
+  // [LAW:no-silent-failure] A transcript that exists but can't be read or
+  // parsed is `failed`, not an empty session — the old catch-to-null dressed
+  // a read failure as "no usage", and the lie survived all the way to the
+  // rendered bar. An empty transcript is a real (zero-entry) usage, not
+  // absence.
+  async getSessionUsageFromPath(
+    sessionId: string,
+    transcriptPath: string,
+  ): Promise<Outcome<SessionUsage>> {
+    try {
+      debug(`Found transcript at: ${transcriptPath}`);
+
+      const mainEntries = await parseJsonlFile(transcriptPath);
+      const projectPath = dirname(transcriptPath);
+      const agentTranscripts = await findAgentTranscripts(
+        sessionId,
+        projectPath,
+      );
+
+      debug(`Found ${agentTranscripts.length} agent transcripts for session`);
+
+      // [LAW:one-source-of-truth] parseJsonlFile returns its cached entries
+      // array BY REFERENCE; the parse cache is the canonical store of a file's
+      // parsed entries and is shared across providers. Mutating that array
+      // (the old `push`) corrupted the cache — agent entries leaked into the
+      // main transcript's cached value and re-appended on every warm hit.
+      // Build a fresh combined list instead so no shared array is touched.
+      const agentEntries = (
+        await Promise.all(agentTranscripts.map((p) => parseJsonlFile(p)))
+      ).flat();
+      const parsedEntries = [...mainEntries, ...agentEntries];
+
+      if (parsedEntries.length === 0) {
+        return ok({ totalCost: 0, entries: [] });
+      }
+
+      const entries: SessionUsageEntry[] = [];
+      let totalCost = 0;
+
+      for (const entry of parsedEntries) {
+        if (entry.message?.usage) {
+          const sessionEntry = convertToSessionEntry(entry);
+
+          if (sessionEntry.costUSD !== undefined) {
+            totalCost += sessionEntry.costUSD;
+          } else {
+            const cost = await PricingService.calculateCostForEntry(entry.raw);
+            sessionEntry.costUSD = cost;
+            totalCost += cost;
+          }
+
+          entries.push(sessionEntry);
+        }
+      }
+
+      debug(
+        `Parsed ${entries.length} usage entries, total cost: $${totalCost.toFixed(4)}`,
+      );
+      return ok({ totalCost, entries });
+    } catch (error) {
+      return failed(
+        `session transcript (${sessionId}): ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  calculateTokenBreakdown(entries: SessionUsageEntry[]): TokenBreakdown {
+    return entries.reduce(
+      (breakdown, entry) => ({
+        input: breakdown.input + (entry.message.usage.input_tokens || 0),
+        output: breakdown.output + (entry.message.usage.output_tokens || 0),
+        cacheCreation:
+          breakdown.cacheCreation +
+          (entry.message.usage.cache_creation_input_tokens || 0),
+        cacheRead:
+          breakdown.cacheRead +
+          (entry.message.usage.cache_read_input_tokens || 0),
+      }),
+      { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+    );
+  }
+
+  // [LAW:types-are-the-program] Pure projection SessionUsage → SessionInfo, no
+  // I/O. The store computes it once per ingest from already-parsed usage; the
+  // empty-usage arm yields the all-null SessionInfo (which the payload drops).
+  toSessionInfo(sessionUsage: SessionUsage): SessionInfo {
+    if (sessionUsage.entries.length === 0) {
+      return {
+        cost: null,
+        calculatedCost: null,
+        officialCost: null,
+        tokens: null,
+        tokenBreakdown: null,
+      };
+    }
+
+    const tokenBreakdown = this.calculateTokenBreakdown(sessionUsage.entries);
+    const totalTokens =
+      tokenBreakdown.input +
+      tokenBreakdown.output +
+      tokenBreakdown.cacheCreation +
+      tokenBreakdown.cacheRead;
+
+    // [LAW:single-enforcer] Transcript-derived projection only. `cost` is the
+    // priced-transcript total; the authoritative native cost (officialCost =
+    // hook total_cost_usd) is overlaid by the store at READ time — it is
+    // per-render and must not be frozen into this mtime-keyed record, so it is
+    // null here by construction.
+    const calculatedCost = sessionUsage.totalCost;
+
+    return {
+      cost: calculatedCost,
+      calculatedCost,
+      officialCost: null,
+      tokens: totalTokens,
+      tokenBreakdown,
+    };
+  }
+}

package/src/segments/tmux.ts

@@ -0,0 +1,74 @@
+import { launch } from "../proc/launch";
+import { debug } from "../utils/logger";
+import { ABSENT, failed, ok, type Outcome } from "../utils/outcome";
+
+// [LAW:single-enforcer] One module-level cache of tmux session lookups, keyed
+// by the tmux *socket path* (the substring of `$TMUX` before the first comma —
+// `$TMUX` is "<socket>,<client-pid>,<session-num>"). The session ID for a
+// given socket doesn't change for the life of the daemon, so this collapses
+// N per-render `tmux display-message` spawns to one per (daemon, socket).
+//
+// [LAW:dataflow-not-control-flow] The lookup always runs the same path: read
+// the env key, look up the cached value, spawn-and-record on miss, return.
+// Variability lives in the cached values, not in whether the spawn happens.
+//
+// Value type: the resolved Outcome. `ok` is the session id; `absent` means
+// the previous resolution reported an empty session id (definitively no
+// session); `failed` means the spawn itself failed. Both non-ok outcomes are
+// durable for the daemon's lifetime — retrying every render would burn
+// subprocesses without changing the answer — but the cached `failed` still
+// flows to the payload boundary as a value, so the failure stays visible
+// instead of being demoted to absence ([LAW:no-silent-failure]). A map miss
+// (undefined) means not yet attempted — the next call will spawn.
+const sessionIdCache = new Map<string, Outcome<string>>();
+
+// [LAW:one-source-of-truth] One place that extracts the socket-path prefix
+// from `$TMUX`. Empty string means "tmux env not set" — the resolver returns
+// early before reaching the cache, but we still tolerate the empty key in
+// case a future caller invokes us without the early-return.
+function tmuxCacheKey(raw: string | undefined): string {
+  if (!raw) return "";
+  const comma = raw.indexOf(",");
+  return comma < 0 ? raw : raw.slice(0, comma);
+}
+
+// Exposed for tests only — resets the cache so each test starts cold.
+export function __resetTmuxCacheForTest(): void {
+  sessionIdCache.clear();
+}
+
+export class TmuxService {
+  async getSessionId(): Promise<Outcome<string>> {
+    if (!process.env.TMUX_PANE) {
+      return ABSENT;
+    }
+
+    const cacheKey = tmuxCacheKey(process.env.TMUX);
+    const cached = sessionIdCache.get(cacheKey);
+    if (cached !== undefined) return cached;
+
+    debug(`Getting tmux session ID, TMUX_PANE: ${process.env.TMUX_PANE}`);
+
+    const result = await launch({
+      bin: "tmux",
+      args: ["display-message", "-p", "#S"],
+      timeoutMs: 1000,
+      category: "tmux",
+    });
+
+    // A failed tmux invocation in a session that has $TMUX_PANE set is a real
+    // misconfiguration; cache it so renders don't re-spawn, and let the
+    // outcome carry the reason to the payload boundary's log site.
+    const outcome: Outcome<string> = !result.ok
+      ? failed(`tmux display-message: ${result.reason}`)
+      : result.stdout.trim()
+        ? ok(result.stdout.trim())
+        : ABSENT;
+    sessionIdCache.set(cacheKey, outcome);
+    return outcome;
+  }
+
+  isInTmux(): boolean {
+    return !!process.env.TMUX_PANE;
+  }
+}