ccc-notifier 0.3.0 → 0.5.0

package/dist/track-KEZON6KI.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import {
+  notifyOS,
+  notifySlack
+} from "./chunk-NV5UOHJA.js";
+import {
+  writeDashboardHtml
+} from "./chunk-QWBQN4XY.js";
+import "./chunk-DGXUSPS4.js";
+import {
+  collectSubagentUsage
+} from "./chunk-O2AR4PXU.js";
+import {
+  aggregateCodexTurn,
+  aggregateNewTurn,
+  computeCost,
+  getUsdJpy,
+  loadPriceTable
+} from "./chunk-LVMKY6JB.js";
+import "./chunk-J5QAYTFE.js";
+import {
+  isFullDashboardDue,
+  makeFullDashboardState,
+  writeFullDashboardStateAtomic
+} from "./chunk-ENGUOLTD.js";
+import {
+  waitForDataLock
+} from "./chunk-O34L3NSI.js";
+import {
+  appendTurn,
+  closeCodexRootContext,
+  isMuted,
+  loadCursor,
+  logError,
+  paths,
+  readConfig,
+  readTurns,
+  sanitizeCursor,
+  saveCursor,
+  todayTotalUSD
+} from "./chunk-5PH7PPD6.js";
+
+// src/track.ts
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function emptyBuckets() {
+  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
+}
+function sumBuckets(usage) {
+  const total = emptyBuckets();
+  for (const b of Object.values(usage)) {
+    total.input += b.input;
+    total.output += b.output;
+    total.cacheWrite5m += b.cacheWrite5m;
+    total.cacheWrite1h += b.cacheWrite1h;
+    total.cacheRead += b.cacheRead;
+  }
+  return total;
+}
+function collectModels(main, sidechain) {
+  const models = [];
+  for (const m of Object.keys(main)) {
+    if (!models.includes(m)) models.push(m);
+  }
+  for (const m of Object.keys(sidechain)) {
+    if (!models.includes(m)) models.push(m);
+  }
+  return models;
+}
+function withCodexModel(agg, payloadModel) {
+  const model = typeof payloadModel === "string" && payloadModel.length > 0 ? payloadModel : null;
+  if (model === null) return agg;
+  const buckets = Object.values(agg.main)[0] ?? emptyBuckets();
+  return { ...agg, main: { [model]: buckets } };
+}
+async function runTrack(stdinText, opts) {
+  try {
+    let parsed;
+    try {
+      parsed = JSON.parse(stdinText);
+    } catch {
+      return;
+    }
+    if (!isRecord(parsed)) return;
+    const input = parsed;
+    const isCodex = opts?.codex === true;
+    let activityProjectionKey = null;
+    if (isCodex) {
+      try {
+        activityProjectionKey = closeCodexRootContext(parsed);
+      } catch {
+        logError("track:codex-subagent-projection", new Error("activity projection was not attached"));
+      }
+    }
+    const transcriptPath = input.transcript_path;
+    if (typeof transcriptPath !== "string") return;
+    const cfg = readConfig();
+    const cacheDir = paths().cacheDir;
+    const table = await loadPriceTable(cacheDir, { offline: true });
+    const fx = await getUsdJpy(cfg, cacheDir);
+    let record;
+    const commitLock = await waitForDataLock(1e3);
+    if (commitLock === null) {
+      logError("track:data-lock", new Error("data lock timeout; turn was not consumed"));
+      return;
+    }
+    try {
+      const cursor = sanitizeCursor(loadCursor(transcriptPath));
+      let agg = isCodex ? await aggregateCodexTurn(transcriptPath, cursor) : await aggregateNewTurn(transcriptPath, cursor);
+      if (agg === null) return;
+      if (isCodex) {
+        agg = withCodexModel(agg, input.model);
+      }
+      let sa = null;
+      if (!isCodex) {
+        try {
+          sa = await collectSubagentUsage(transcriptPath);
+        } catch (err) {
+          logError("track:subagents", err);
+          sa = null;
+        }
+      }
+      const breakdown = computeCost(agg.main, agg.sidechain, table);
+      const sessionId = agg.sessionId || (typeof input.session_id === "string" ? input.session_id : "") || "";
+      const project = agg.cwd ?? (typeof input.cwd === "string" ? input.cwd : void 0) ?? "";
+      const sidechainHasModels = Object.keys(agg.sidechain).length > 0;
+      record = {
+        schemaVersion: 1,
+        ts: agg.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId,
+        project,
+        gitBranch: agg.gitBranch,
+        models: collectModels(agg.main, agg.sidechain),
+        tokens: sumBuckets(agg.main),
+        sidechainTokens: sidechainHasModels ? sumBuckets(agg.sidechain) : null,
+        apiCalls: agg.apiCalls,
+        costUSD: breakdown.usd,
+        costByModel: breakdown.byModel,
+        // モデル別 USD(main+sidechain 合算、丸めない)
+        costJPY: breakdown.usd * fx.rate,
+        // 丸めない(表示時に丸める)
+        fxRate: fx.rate,
+        fxSource: fx.source,
+        prompt: agg.prompt ?? ""
+      };
+      if (isCodex) {
+        record.source = "codex";
+        if (activityProjectionKey !== null) record.activityProjectionKey = activityProjectionKey;
+      }
+      if (breakdown.unknownModels.length > 0) {
+        record.unknownModels = breakdown.unknownModels;
+      }
+      if (sa !== null && sa.apiCalls > 0) {
+        const saBreakdown = computeCost(sa.perModel, {}, table);
+        record.subagents = {
+          costUSD: saBreakdown.usd,
+          costByModel: saBreakdown.byModel,
+          tokens: sumBuckets(sa.perModel),
+          apiCalls: sa.apiCalls,
+          agentFiles: sa.agentFiles
+        };
+        if (saBreakdown.unknownModels.length > 0) {
+          const merged = record.unknownModels ? [...record.unknownModels] : [];
+          for (const m of saBreakdown.unknownModels) {
+            if (!merged.includes(m)) merged.push(m);
+          }
+          record.unknownModels = merged;
+        }
+      }
+      appendTurn(record);
+      saveCursor(transcriptPath, agg.newCursor);
+      if (sa !== null) {
+        for (const nc of sa.newCursors) {
+          saveCursor(nc.path, nc.cursor);
+        }
+      }
+    } finally {
+      commitLock.release();
+    }
+    const tasks = [];
+    if ((cfg.notify.os || cfg.notify.slack !== null) && record.costUSD >= cfg.minNotifyUSD && !isMuted()) {
+      const todayUSD = cfg.includeDailyTotal ? todayTotalUSD() : void 0;
+      tasks.push(notifyOS(record, cfg, todayUSD));
+      tasks.push(notifySlack(record, cfg, todayUSD));
+    }
+    if (cfg.dashboard.autoRegenerate) {
+      tasks.push(
+        (async () => {
+          const now = /* @__PURE__ */ new Date();
+          const dashboardLock = await waitForDataLock(1e3);
+          if (dashboardLock === null) {
+            logError("track:dashboard-lock", new Error("data lock timeout; dashboard skipped"));
+            return;
+          }
+          try {
+            let allTurns;
+            try {
+              allTurns = readTurns();
+            } catch (err) {
+              logError("track:dashboard-read", err);
+              return;
+            }
+            try {
+              writeDashboardHtml({
+                days: cfg.dashboard.days,
+                outPath: paths().recentDashboardFile,
+                autoReloadSec: cfg.dashboard.autoReloadSec,
+                allTurns,
+                variant: "recent"
+              });
+            } catch (err) {
+              logError("track:dashboard-recent", err);
+            }
+            if (isFullDashboardDue(now)) {
+              try {
+                writeDashboardHtml({
+                  days: null,
+                  outPath: paths().fullDashboardFile,
+                  autoReloadSec: cfg.dashboard.autoReloadSec,
+                  allTurns,
+                  variant: "full",
+                  generatedAt: now.toISOString()
+                });
+                writeFullDashboardStateAtomic(makeFullDashboardState(now));
+              } catch (err) {
+                logError("track:dashboard-full", err);
+              }
+            }
+          } finally {
+            dashboardLock.release();
+          }
+        })()
+      );
+    }
+    if (tasks.length > 0) {
+      await Promise.allSettled(tasks);
+    }
+  } catch (err) {
+    logError("track", err);
+  }
+}
+export {
+  runTrack
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccc-notifier",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Claude Code Cost notifier (now also covers Codex CLI): per-prompt cost notifications (USD/JPY) with local history and HTML dashboard",
   "keywords": [
     "claude",

package/dist/chunk-DSV75EF7.js

@@ -1,357 +0,0 @@
-#!/usr/bin/env node
-import {
-  aggregateNewTurn
-} from "./chunk-LHKBGA5K.js";
-import {
-  loadCursor,
-  logError,
-  sanitizeCursor
-} from "./chunk-ECADO26T.js";
-
-// src/codex/transcript.ts
-import { readFile } from "fs/promises";
-import { basename } from "path";
-var NEWLINE = 10;
-function isRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function numOf(v) {
-  return typeof v === "number" && Number.isFinite(v) ? v : 0;
-}
-function strOrNull(v) {
-  return typeof v === "string" ? v : null;
-}
-function zeroTotals() {
-  return { input: 0, cached: 0, output: 0 };
-}
-function isZeroTotals(t) {
-  return t.input === 0 && t.cached === 0 && t.output === 0;
-}
-function addTotals(target, d) {
-  target.input += d.input;
-  target.cached += d.cached;
-  target.output += d.output;
-}
-function readTotals(v) {
-  if (!isRecord(v)) return null;
-  return {
-    input: numOf(v.input_tokens),
-    cached: numOf(v.cached_input_tokens),
-    output: numOf(v.output_tokens)
-  };
-}
-function totalsToBuckets(acc) {
-  return {
-    input: Math.max(0, acc.input - acc.cached),
-    output: acc.output,
-    cacheWrite5m: 0,
-    cacheWrite1h: 0,
-    cacheRead: acc.cached
-  };
-}
-function sessionIdFromFilename(rolloutPath) {
-  const m = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i.exec(
-    basename(rolloutPath)
-  );
-  return m !== null ? m[1] : "";
-}
-async function readAll(path) {
-  try {
-    return await readFile(path);
-  } catch {
-    return null;
-  }
-}
-function newSegmentBuf() {
-  return {
-    acc: zeroTotals(),
-    apiCalls: 0,
-    prompt: null,
-    turnCtxCwd: null,
-    firstTs: null,
-    endTs: null,
-    hasLines: false
-  };
-}
-async function scanWindow(rolloutPath, cursor) {
-  const buffer = await readAll(rolloutPath);
-  if (buffer === null) return null;
-  const fileSize = buffer.length;
-  let startOffset;
-  let rescan;
-  if (cursor !== null && cursor.offset > 0 && cursor.offset <= fileSize && buffer[cursor.offset - 1] === NEWLINE) {
-    startOffset = cursor.offset;
-    rescan = false;
-  } else {
-    startOffset = 0;
-    rescan = cursor !== null;
-  }
-  const tsFloor = cursor?.lastTs ?? null;
-  const initTotals = cursor?.codexTotals;
-  let prev = initTotals !== void 0 ? { ...initTotals } : zeroTotals();
-  const acc = zeroTotals();
-  let apiCalls = 0;
-  let lastModel = null;
-  let windowPrompt = null;
-  let windowTurnCtxCwd = null;
-  let sessionMetaCwd = null;
-  let sessionMetaSid = null;
-  let firstTs = null;
-  let lastTs = null;
-  const segments = [];
-  let seg = newSegmentBuf();
-  const snapshotSegment = (endOffset) => ({
-    acc: seg.acc,
-    apiCalls: seg.apiCalls,
-    prompt: seg.prompt,
-    model: lastModel,
-    cwd: seg.turnCtxCwd ?? sessionMetaCwd,
-    firstTs: seg.firstTs,
-    endTs: seg.endTs,
-    endOffset,
-    prevAtEnd: { ...prev },
-    lastTsAtEnd: lastTs
-  });
-  const handleLine = (raw, endOffset) => {
-    if (raw.trim().length === 0) return;
-    let obj;
-    try {
-      obj = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if (!isRecord(obj)) return;
-    const ts = strOrNull(obj.timestamp);
-    if (rescan && tsFloor !== null && ts !== null && ts <= tsFloor) return;
-    if (ts !== null) {
-      if (firstTs === null || ts < firstTs) firstTs = ts;
-      if (lastTs === null || ts > lastTs) lastTs = ts;
-      if (seg.firstTs === null || ts < seg.firstTs) seg.firstTs = ts;
-      seg.endTs = ts;
-    }
-    seg.hasLines = true;
-    const payload = isRecord(obj.payload) ? obj.payload : null;
-    if (payload === null) return;
-    const type = obj.type;
-    if (type === "session_meta") {
-      const sid = strOrNull(payload.session_id);
-      if (sid !== null) sessionMetaSid = sid;
-      const c = strOrNull(payload.cwd);
-      if (c !== null) sessionMetaCwd = c;
-      return;
-    }
-    if (type === "turn_context") {
-      const m = strOrNull(payload.model);
-      if (m !== null) lastModel = m;
-      const c = strOrNull(payload.cwd);
-      if (c !== null) {
-        seg.turnCtxCwd = c;
-        windowTurnCtxCwd = c;
-      }
-      return;
-    }
-    if (type !== "event_msg") return;
-    const kind = payload.type;
-    if (kind === "user_message") {
-      const msg = strOrNull(payload.message);
-      if (msg !== null) {
-        seg.prompt = msg;
-        windowPrompt = msg;
-      }
-      return;
-    }
-    if (kind === "token_count") {
-      const info = isRecord(payload.info) ? payload.info : null;
-      if (info === null) return;
-      const total = readTotals(info.total_token_usage);
-      if (total === null) return;
-      let step = {
-        input: total.input - prev.input,
-        cached: total.cached - prev.cached,
-        output: total.output - prev.output
-      };
-      if (step.input < 0 || step.cached < 0 || step.output < 0) {
-        step = readTotals(info.last_token_usage) ?? zeroTotals();
-      }
-      addTotals(acc, step);
-      addTotals(seg.acc, step);
-      prev = total;
-      if (!isZeroTotals(step)) {
-        apiCalls++;
-        seg.apiCalls++;
-      }
-      return;
-    }
-    if (kind === "task_complete") {
-      segments.push(snapshotSegment(endOffset));
-      seg = newSegmentBuf();
-    }
-  };
-  let lineStart = startOffset;
-  for (let pos = startOffset; pos < fileSize; pos++) {
-    if (buffer[pos] !== NEWLINE) continue;
-    handleLine(buffer.toString("utf8", lineStart, pos), pos + 1);
-    lineStart = pos + 1;
-  }
-  const newOffset = lineStart;
-  const open = seg.hasLines ? snapshotSegment(newOffset) : null;
-  return {
-    segments,
-    open,
-    acc,
-    prev,
-    apiCalls,
-    model: lastModel,
-    prompt: windowPrompt,
-    cwd: windowTurnCtxCwd ?? sessionMetaCwd,
-    sessionId: sessionMetaSid ?? sessionIdFromFilename(rolloutPath),
-    firstTs,
-    lastTs,
-    newOffset
-  };
-}
-function windowCursor(scan) {
-  return {
-    offset: scan.newOffset,
-    lastUuid: null,
-    // rollout に uuid 行は無い
-    lastTs: scan.lastTs,
-    seenMessageKeys: [],
-    // 去重は codexTotals の差分方式が担う
-    codexTotals: { ...scan.prev }
-  };
-}
-async function aggregateCodexTurn(rolloutPath, cursor) {
-  const scan = await scanWindow(rolloutPath, cursor);
-  if (scan === null || isZeroTotals(scan.acc)) return null;
-  return {
-    sessionId: scan.sessionId,
-    main: { [scan.model ?? "unknown"]: totalsToBuckets(scan.acc) },
-    sidechain: {},
-    // Codex にサブエージェント概念は無い
-    apiCalls: scan.apiCalls,
-    prompt: scan.prompt,
-    cwd: scan.cwd,
-    gitBranch: null,
-    // rollout に無い
-    firstTs: scan.firstTs,
-    lastTs: scan.lastTs,
-    newCursor: windowCursor(scan)
-  };
-}
-async function splitIntoCodexTurnDrafts(rolloutPath, cursor) {
-  const scan = await scanWindow(rolloutPath, cursor);
-  if (scan === null || isZeroTotals(scan.acc)) return null;
-  const picked = scan.segments.filter((s) => !isZeroTotals(s.acc));
-  if (scan.open !== null && !isZeroTotals(scan.open.acc)) {
-    const last = picked[picked.length - 1];
-    if (last !== void 0) {
-      addTotals(last.acc, scan.open.acc);
-      last.apiCalls += scan.open.apiCalls;
-      if (scan.open.endTs !== null) last.endTs = scan.open.endTs;
-    } else {
-      picked.push(scan.open);
-    }
-  }
-  const lastIndex = picked.length - 1;
-  return picked.map((s, i) => ({
-    agg: {
-      sessionId: scan.sessionId,
-      // session_meta はファイル先頭にしか無いので全ドラフト共通
-      main: { [s.model ?? "unknown"]: totalsToBuckets(s.acc) },
-      sidechain: {},
-      apiCalls: s.apiCalls,
-      prompt: s.prompt,
-      cwd: s.cwd,
-      gitBranch: null,
-      firstTs: s.firstTs,
-      lastTs: s.endTs,
-      // 最後のドラフトはウィンドウ全体を消費した状態(= aggregateCodexTurn の newCursor と同一。
-      // 末尾の usage ゼロな行の読み捨てもここに含まれる)。途中のドラフトはそのセグメント末尾を
-      // 指す有効な再開点(そこから読み直せば残りが差分になる)。
-      newCursor: i === lastIndex ? windowCursor(scan) : {
-        offset: s.endOffset,
-        lastUuid: null,
-        lastTs: s.lastTsAtEnd,
-        seenMessageKeys: [],
-        codexTotals: { ...s.prevAtEnd }
-      }
-    },
-    endTs: s.endTs
-  }));
-}
-
-// src/subagents.ts
-import { promises as fs } from "fs";
-import { join } from "path";
-var MAX_AGENT_FILES = 200;
-function emptyBuckets() {
-  return { input: 0, output: 0, cacheWrite5m: 0, cacheWrite1h: 0, cacheRead: 0 };
-}
-function addToModel(target, model, b) {
-  const cur = target[model] ?? emptyBuckets();
-  cur.input += b.input;
-  cur.output += b.output;
-  cur.cacheWrite5m += b.cacheWrite5m;
-  cur.cacheWrite1h += b.cacheWrite1h;
-  cur.cacheRead += b.cacheRead;
-  target[model] = cur;
-}
-function mergeUsage(target, src) {
-  for (const [model, b] of Object.entries(src)) addToModel(target, model, b);
-}
-function subagentsDirOf(mainTranscriptPath) {
-  const base = mainTranscriptPath.endsWith(".jsonl") ? mainTranscriptPath.slice(0, -".jsonl".length) : mainTranscriptPath;
-  return join(base, "subagents");
-}
-async function listAgentFiles(dir, entries) {
-  const files = entries.filter((e) => e.isFile() && e.name.startsWith("agent-") && e.name.endsWith(".jsonl")).map((e) => join(dir, e.name));
-  if (files.length <= MAX_AGENT_FILES) return files;
-  const withMtime = [];
-  for (const p of files) {
-    let mtime = 0;
-    try {
-      mtime = (await fs.stat(p)).mtimeMs;
-    } catch {
-      mtime = 0;
-    }
-    withMtime.push({ path: p, mtime });
-  }
-  withMtime.sort((a, b) => b.mtime - a.mtime);
-  return withMtime.slice(0, MAX_AGENT_FILES).map((x) => x.path);
-}
-async function collectSubagentUsage(mainTranscriptPath) {
-  const dir = subagentsDirOf(mainTranscriptPath);
-  let entries;
-  try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-  const files = await listAgentFiles(dir, entries);
-  const perModel = {};
-  let apiCalls = 0;
-  let agentFiles = 0;
-  const newCursors = [];
-  for (const filePath of files) {
-    try {
-      const cursor = sanitizeCursor(loadCursor(filePath));
-      const agg = await aggregateNewTurn(filePath, cursor);
-      if (agg === null) continue;
-      mergeUsage(perModel, agg.main);
-      mergeUsage(perModel, agg.sidechain);
-      apiCalls += agg.apiCalls;
-      agentFiles += 1;
-      newCursors.push({ path: filePath, cursor: agg.newCursor });
-    } catch (err) {
-      logError("subagents:file", err);
-    }
-  }
-  return { perModel, apiCalls, agentFiles, newCursors };
-}
-
-export {
-  aggregateCodexTurn,
-  splitIntoCodexTurnDrafts,
-  collectSubagentUsage
-};