ccc-notifier 0.6.2 → 0.7.0

package/dist/sweep-DVOV4XIZ.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import {
+  attachSubagentGroups,
+  runSweep,
+  splitIntoTurnDrafts
+} from "./chunk-6BXD6HU5.js";
+import "./chunk-OCKZZVOG.js";
+import "./chunk-Q45AAPJY.js";
+import "./chunk-O2E4VTDR.js";
+import "./chunk-3M5UQK76.js";
+import "./chunk-PXMXEFM7.js";
+import "./chunk-6IVSZ3S4.js";
+import "./chunk-DGXUSPS4.js";
+import "./chunk-XG73C6CC.js";
+import "./chunk-WONMZ466.js";
+export {
+  attachSubagentGroups,
+  runSweep,
+  splitIntoTurnDrafts
+};

package/dist/track-P6A5WDJZ.js

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+import {
+  notifyIngestSummary,
+  runIngest
+} from "./chunk-V4IS4FXH.js";
+import {
+  notifyOS,
+  notifySlack
+} from "./chunk-JLDI4D5E.js";
+import {
+  collectSubagentUsage,
+  normalizeCodexOriginator
+} from "./chunk-6BXD6HU5.js";
+import {
+  aggregateCodexTurn,
+  aggregateNewTurn,
+  anyOf,
+  callFingerprints,
+  codexConsumedCursor,
+  codexResumePointAtTs,
+  determineClaudeSurface,
+  getUsdJpy,
+  messageKeyFilterOf,
+  setCountedCalls
+} from "./chunk-OCKZZVOG.js";
+import {
+  computeCost,
+  loadPriceTable
+} from "./chunk-Q45AAPJY.js";
+import {
+  writeDashboardHtml
+} from "./chunk-O2E4VTDR.js";
+import {
+  isFullDashboardDue,
+  makeFullDashboardState,
+  writeFullDashboardStateAtomic
+} from "./chunk-3M5UQK76.js";
+import {
+  waitForDataLock
+} from "./chunk-PXMXEFM7.js";
+import "./chunk-6IVSZ3S4.js";
+import "./chunk-DGXUSPS4.js";
+import "./chunk-XG73C6CC.js";
+import {
+  appendTurn,
+  clearPendingAppend,
+  closeCodexRootContext,
+  floorKey,
+  hasPendingAppend,
+  isMuted,
+  loadCursor,
+  loadHistoryIndex,
+  logError,
+  markPendingAppend,
+  paths,
+  readConfig,
+  readTurns,
+  sanitizeCursor,
+  saveCursor,
+  todayTotalUSD
+} from "./chunk-WONMZ466.js";
+
+// src/track.ts
+import { basename } from "path";
+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;
+    let hasMainUsage = false;
+    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));
+      const cursorMayBeStale = cursor === null || hasPendingAppend(transcriptPath);
+      let indexCache = null;
+      const history = () => indexCache ??= loadHistoryIndex();
+      const counted = () => history().countedCalls;
+      const countedFilter = () => cursorMayBeStale ? messageKeyFilterOf(counted()) : void 0;
+      const sessionKey = typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : basename(transcriptPath).replace(/\.jsonl$/, "");
+      const legacyFloorMs = (scope) => {
+        const iso = history().legacyFloors.get(floorKey(scope, sessionKey));
+        if (iso === void 0) return null;
+        const ms = Date.parse(iso);
+        return Number.isFinite(ms) ? ms + 1 : null;
+      };
+      let recoveredCursor = null;
+      let agg;
+      if (isCodex) {
+        let readFrom = cursor;
+        const scanOpts = cursorMayBeStale ? { excludeEvents: counted() } : {};
+        if (cursor === null) {
+          const floorIso = history().legacyFloors.get(floorKey("codex", sessionKey));
+          if (floorIso !== void 0) readFrom = await codexResumePointAtTs(transcriptPath, floorIso);
+        }
+        agg = await aggregateCodexTurn(transcriptPath, readFrom, scanOpts);
+        if (agg === null) {
+          if (cursorMayBeStale) {
+            const consumed = await codexConsumedCursor(transcriptPath, readFrom, scanOpts);
+            if (consumed !== null) saveCursor(transcriptPath, consumed);
+            clearPendingAppend(transcriptPath);
+          }
+          return;
+        }
+      } else if (cursorMayBeStale) {
+        const recovered = await aggregateNewTurn(transcriptPath, cursor, {
+          excludeMessageKeys: messageKeyFilterOf(counted()),
+          // 指紋を持たない旧レコードぶんのフォールバックは、先頭から読み直すときだけ効かせる。
+          minTimestampMs: cursor === null ? legacyFloorMs("claude") : null,
+          returnEmpty: true
+        });
+        if (recovered !== null && recovered.apiCalls === 0) {
+          recoveredCursor = recovered.newCursor;
+          agg = null;
+        } else {
+          agg = recovered;
+        }
+      } else {
+        agg = await aggregateNewTurn(transcriptPath, cursor);
+      }
+      hasMainUsage = agg !== null;
+      if (isCodex && agg !== null) {
+        agg = withCodexModel(agg, input.model);
+      }
+      let sa = null;
+      if (!isCodex) {
+        try {
+          const excluded = new Set(cursor?.seenMessageKeys ?? []);
+          if (agg !== null && "messageKeys" in agg) {
+            for (const key of agg.messageKeys) excluded.add(key);
+          }
+          const staleFilter = countedFilter();
+          sa = await collectSubagentUsage(transcriptPath, {
+            excludeMessageKeys: staleFilter === void 0 ? excluded : anyOf([excluded, staleFilter]),
+            // agent ファイル側のカーソルだけを失っている場合もあるので、そのファイルに限って
+            // history 由来の指紋と旧レコード向けの下限で弾く
+            // (すべてのカーソルが健全なら一度も呼ばれない = history を読まない)。
+            recovery: () => ({
+              excludeMessageKeys: messageKeyFilterOf(counted()),
+              minTimestampMs: legacyFloorMs("claude-sa")
+            })
+          });
+        } catch (err) {
+          logError("track:subagents", err);
+          sa = null;
+        }
+      }
+      if (agg === null && (sa === null || sa.apiCalls === 0)) {
+        if (recoveredCursor !== null) saveCursor(transcriptPath, recoveredCursor);
+        for (const nc of sa?.newCursors ?? []) saveCursor(nc.path, nc.cursor);
+        if (cursorMayBeStale) clearPendingAppend(transcriptPath);
+        return;
+      }
+      const main = agg?.main ?? {};
+      const sidechain = agg?.sidechain ?? {};
+      const breakdown = computeCost(main, sidechain, table);
+      const sessionId = agg?.sessionId || sa?.sessionId || (typeof input.session_id === "string" ? input.session_id : "") || "";
+      const project = agg?.cwd ?? sa?.cwd ?? (typeof input.cwd === "string" ? input.cwd : void 0) ?? "";
+      const sidechainHasModels = Object.keys(sidechain).length > 0;
+      record = {
+        schemaVersion: 1,
+        ts: agg?.lastTs ?? sa?.lastTs ?? (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId,
+        project,
+        gitBranch: agg?.gitBranch ?? sa?.gitBranch ?? null,
+        models: hasMainUsage ? collectModels(main, sidechain) : collectModels(sa?.perModel ?? {}, {}),
+        tokens: sumBuckets(main),
+        sidechainTokens: sidechainHasModels ? sumBuckets(sidechain) : null,
+        apiCalls: agg?.apiCalls ?? 0,
+        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;
+        const rawOriginator = agg?.originator;
+        record.surface = normalizeCodexOriginator(rawOriginator);
+        if (typeof rawOriginator === "string") record.originator = rawOriginator;
+      } else {
+        try {
+          record.surface = await determineClaudeSurface(transcriptPath);
+        } catch (err) {
+          logError("track:surface", err);
+        }
+      }
+      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;
+        }
+      }
+      if (isCodex) {
+        setCountedCalls(record, agg?.codexEventKeys ?? []);
+      } else {
+        const countedKeys = [];
+        if (agg !== null && "messageKeys" in agg) {
+          countedKeys.push(...agg.messageKeys);
+        }
+        for (const group of sa?.groups ?? []) countedKeys.push(...group.messageKeys);
+        setCountedCalls(record, callFingerprints(countedKeys));
+      }
+      try {
+        markPendingAppend(transcriptPath, record.ingestKey ?? "");
+      } catch (err) {
+        logError("track:pending-marker", err);
+        return;
+      }
+      appendTurn(record);
+      const mainCursor = agg?.newCursor ?? recoveredCursor;
+      if (mainCursor !== null) saveCursor(transcriptPath, mainCursor);
+      if (sa !== null) {
+        for (const nc of sa.newCursors) {
+          saveCursor(nc.path, nc.cursor);
+        }
+      }
+      clearPendingAppend(transcriptPath);
+    } finally {
+      commitLock.release();
+    }
+    const tasks = [];
+    if (hasMainUsage && (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));
+    }
+    tasks.push(
+      (async () => {
+        try {
+          const result = await runIngest({ dryRun: false, offlinePricing: true });
+          if (result.records.length > 0) {
+            await notifyIngestSummary(result, cfg);
+          }
+        } catch (err) {
+          logError("track:ingest", err);
+        }
+        if (!cfg.dashboard.autoRegenerate) return;
+        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.6.2",
+  "version": "0.7.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-HLJAJS2W.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-
-// src/codex/sessions.ts
-import { promises as fsp } from "fs";
-import { join, resolve } from "path";
-var CODEX_MAX_DEPTH = 4;
-async function listCodexRollouts(sessionsRoot) {
-  const rollouts = [];
-  let unreadableDirs = 0;
-  const root = resolve(sessionsRoot);
-  const rootStat = await fsp.lstat(root).catch(() => null);
-  if (rootStat === null || !rootStat.isDirectory()) {
-    return { rollouts, unreadableDirs: 1 };
-  }
-  const walk = async (dir, depth) => {
-    const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => null);
-    if (entries === null) {
-      unreadableDirs += 1;
-      return;
-    }
-    for (const entry of entries) {
-      const full = resolve(join(dir, entry.name));
-      if (entry.isFile()) {
-        if (entry.name.startsWith("rollout-") && entry.name.endsWith(".jsonl")) rollouts.push(full);
-      } else if (entry.isDirectory() && depth < CODEX_MAX_DEPTH) {
-        await walk(full, depth + 1);
-      }
-    }
-  };
-  await walk(root, 1);
-  return { rollouts, unreadableDirs };
-}
-async function findLatestCodexRollout(sessionsRoot) {
-  const discovery = await listCodexRollouts(sessionsRoot);
-  let latest = null;
-  let latestMtime = -Infinity;
-  let unreadableFiles = 0;
-  for (const path of discovery.rollouts) {
-    const stat = await fsp.lstat(path).catch(() => null);
-    if (stat === null || !stat.isFile()) {
-      unreadableFiles += 1;
-      continue;
-    }
-    if (stat.mtimeMs > latestMtime || stat.mtimeMs === latestMtime && (latest === null || path < latest)) {
-      latest = path;
-      latestMtime = stat.mtimeMs;
-    }
-  }
-  return { latest, unreadableDirs: discovery.unreadableDirs, unreadableFiles };
-}
-
-export {
-  listCodexRollouts,
-  findLatestCodexRollout
-};

package/dist/chunk-HTYUYKFW.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-
-// src/codex/env.ts
-import { statSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function codexHome() {
-  return process.env.CCCN_CODEX_HOME || join(homedir(), ".codex");
-}
-function detectCodex() {
-  try {
-    return statSync(codexHome()).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-export {
-  codexHome,
-  detectCodex
-};

package/dist/chunk-OYD6H3ZZ.js

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-import {
-  aggregateNewTurn
-} from "./chunk-D4D76RGQ.js";
-import {
-  loadCursor,
-  logError,
-  sanitizeCursor
-} from "./chunk-OOAC5ULQ.js";
-
-// 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 sameCursor(a, b) {
-  return a !== null && a.offset === b.offset && a.lastUuid === b.lastUuid && a.lastTs === b.lastTs && a.seenMessageKeys.length === b.seenMessageKeys.length && a.seenMessageKeys.every((key, i) => key === b.seenMessageKeys[i]);
-}
-function subagentsDirOf(mainTranscriptPath) {
-  const base = mainTranscriptPath.endsWith(".jsonl") ? mainTranscriptPath.slice(0, -".jsonl".length) : mainTranscriptPath;
-  return join(base, "subagents");
-}
-async function listAgentFiles(dir, entries, includeAllFiles) {
-  const files = entries.filter((e) => e.isFile() && e.name.startsWith("agent-") && e.name.endsWith(".jsonl")).map((e) => join(dir, e.name));
-  if (includeAllFiles || 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, opts = {}) {
-  const dir = subagentsDirOf(mainTranscriptPath);
-  let entries;
-  try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
-  } catch (err) {
-    if (opts.strictRead && err.code !== "ENOENT") throw err;
-    return null;
-  }
-  const files = await listAgentFiles(dir, entries, opts.includeAllFiles === true);
-  const perModel = {};
-  let apiCalls = 0;
-  let agentFiles = 0;
-  const newCursors = [];
-  const groups = [];
-  let sessionId = "";
-  let cwd = null;
-  let gitBranch = null;
-  let lastTs = null;
-  const excluded = new Set(opts.excludeMessageKeys ?? []);
-  if (!opts.ignoreCursors) {
-    for (const filePath of files) {
-      const prior = sanitizeCursor(loadCursor(filePath));
-      for (const key of prior?.seenMessageKeys ?? []) excluded.add(key);
-    }
-  }
-  for (const filePath of files) {
-    try {
-      if (opts.strictRead) {
-        const file = await fs.open(filePath, "r");
-        await file.close();
-      }
-      const cursor = opts.ignoreCursors ? null : sanitizeCursor(loadCursor(filePath));
-      const agg = await aggregateNewTurn(filePath, cursor, {
-        excludeMessageKeys: excluded,
-        minTimestampMs: opts.minTimestampMs,
-        returnEmpty: true
-      });
-      if (agg === null) continue;
-      if (!sameCursor(cursor, agg.newCursor)) {
-        newCursors.push({ path: filePath, cursor: agg.newCursor });
-      }
-      for (const key of agg.messageKeys) excluded.add(key);
-      if (agg.apiCalls === 0) continue;
-      mergeUsage(perModel, agg.main);
-      mergeUsage(perModel, agg.sidechain);
-      apiCalls += agg.apiCalls;
-      agentFiles += 1;
-      const groupUsage = {};
-      mergeUsage(groupUsage, agg.main);
-      mergeUsage(groupUsage, agg.sidechain);
-      groups.push({
-        perModel: groupUsage,
-        apiCalls: agg.apiCalls,
-        firstTs: agg.firstTs,
-        lastTs: agg.lastTs
-      });
-      if (agg.sessionId) sessionId = agg.sessionId;
-      if (agg.cwd !== null) cwd = agg.cwd;
-      if (agg.gitBranch !== null) gitBranch = agg.gitBranch;
-      if (agg.lastTs !== null && (lastTs === null || agg.lastTs > lastTs)) lastTs = agg.lastTs;
-    } catch (err) {
-      if (opts.strictRead) throw err;
-      logError("subagents:file", err);
-    }
-  }
-  return { perModel, apiCalls, agentFiles, newCursors, groups, sessionId, cwd, gitBranch, lastTs };
-}
-
-export {
-  collectSubagentUsage
-};