ccc-notifier 0.2.0 → 0.3.0

package/dist/chunk-DSV75EF7.js

@@ -0,0 +1,357 @@
+#!/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
+};

package/dist/{chunk-IIYMGLV4.js → chunk-ECADO26T.js}

@@ -170,7 +170,7 @@ function loadCursor(transcriptPath) {
 }
 function sanitizeCursor(raw) {
   if (!isPlainObject(raw)) return null;
-  const { offset, lastUuid, lastTs, seenMessageKeys } = raw;
+  const { offset, lastUuid, lastTs, seenMessageKeys, codexTotals } = raw;
   if (typeof offset !== "number" || !Number.isFinite(offset)) return null;
   if (lastUuid !== null && typeof lastUuid !== "string") return null;
   if (lastTs !== null && typeof lastTs !== "string") return null;
@@ -180,7 +180,14 @@ function sanitizeCursor(raw) {
     if (typeof key !== "string") return null;
     keys.push(key);
   }
-  return { offset, lastUuid, lastTs, seenMessageKeys: keys };
+  const cursor = { offset, lastUuid, lastTs, seenMessageKeys: keys };
+  if (isPlainObject(codexTotals)) {
+    const { input, cached, output } = codexTotals;
+    if (typeof input === "number" && Number.isFinite(input) && input >= 0 && typeof cached === "number" && Number.isFinite(cached) && cached >= 0 && typeof output === "number" && Number.isFinite(output) && output >= 0) {
+      cursor.codexTotals = { input, cached, output };
+    }
+  }
+  return cursor;
 }
 function saveCursor(transcriptPath, c) {
   const p = paths();

package/dist/chunk-HTYUYKFW.js

@@ -0,0 +1,21 @@
+#!/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-TBFKGFZX.js → chunk-J5QAYTFE.js}

@@ -29,6 +29,9 @@ function capitalize(token) {
 var ALPHA_ONLY = /^[A-Za-z]+$/;
 var NUMERIC_ONLY = /^\d+$/;
 function modelDisplayName(id) {
+  if (id.startsWith("gpt-")) {
+    return `GPT-${id.slice(4)}`.replace(/-codex$/, " Codex");
+  }
   let s = id;
   s = s.replace(/^claude-/, "");
   s = s.replace(/-20\d{6}/, "");

package/dist/{chunk-OEG3AVU6.js → chunk-LHKBGA5K.js}

@@ -29,7 +29,14 @@ function builtinPriceTable() {
     "claude-3-5-sonnet": price(3, 15, 3.75, 6, 0.3, "builtin"),
     "claude-haiku-4-5": price(1, 5, 1.25, 2, 0.1, "builtin"),
     "claude-3-5-haiku": price(0.8, 4, 1, 1.6, 0.08, "builtin"),
-    "claude-3-haiku": price(0.25, 1.25, 0.3125, 0.5, 0.025, "builtin")
+    "claude-3-haiku": price(0.25, 1.25, 0.3125, 0.5, 0.025, "builtin"),
+    // OpenAI Codex CLI 対応(公式レートに基づく単価。キャッシュ書き込み課金は無いため 0)
+    "gpt-5.5": price(5, 30, 0, 0, 0.5, "builtin"),
+    "gpt-5.1": price(1.25, 10, 0, 0, 0.125, "builtin"),
+    "gpt-5": price(1.25, 10, 0, 0, 0.125, "builtin"),
+    "gpt-5-codex": price(1.25, 10, 0, 0, 0.125, "builtin"),
+    "gpt-5.1-codex": price(1.25, 10, 0, 0, 0.125, "builtin"),
+    "o3": price(2, 8, 0, 0, 0.5, "builtin")
   };
 }
 function normalizeModelId(modelId) {
@@ -104,6 +111,7 @@ function isCacheFresh(fetchedAt) {
 function toFiniteNumber(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : null;
 }
+var LITELLM_OPENAI_KEY_RE = /^(gpt-|o3($|-)|codex-)/;
 function convertLiteLLMPayload(payload) {
   if (payload === null || typeof payload !== "object") {
     throw new Error("invalid litellm payload: not an object");
@@ -113,6 +121,24 @@ function convertLiteLLMPayload(payload) {
     if (rawEntry === null || typeof rawEntry !== "object") continue;
     const entry = rawEntry;
     const provider = entry.litellm_provider;
+    if (provider === "openai") {
+      const key2 = rawKey.toLowerCase();
+      if (!LITELLM_OPENAI_KEY_RE.test(key2)) continue;
+      const inputRaw2 = toFiniteNumber(entry.input_cost_per_token);
+      const outputRaw2 = toFiniteNumber(entry.output_cost_per_token);
+      if (inputRaw2 === null || inputRaw2 <= 0) continue;
+      if (outputRaw2 === null || outputRaw2 <= 0) continue;
+      const cacheReadRaw2 = toFiniteNumber(entry.cache_read_input_token_cost);
+      table[key2] = {
+        input: inputRaw2 * 1e6,
+        output: outputRaw2 * 1e6,
+        cacheRead: cacheReadRaw2 !== null ? cacheReadRaw2 * 1e6 : 0,
+        cacheWrite5m: 0,
+        cacheWrite1h: 0,
+        source: "litellm"
+      };
+      continue;
+    }
     if (typeof provider === "string" && provider !== "anthropic") continue;
     let key = rawKey.toLowerCase();
     if (key.startsWith("anthropic/")) key = key.slice("anthropic/".length);

package/dist/{chunk-4JNZ7BHO.js → chunk-NV5UOHJA.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-DGXUSPS4.js";
 import {
   formatSummary
-} from "./chunk-TBFKGFZX.js";
+} from "./chunk-J5QAYTFE.js";
 
 // src/notify/os.ts
 import { spawn } from "child_process";