ccc-notifier 0.4.0 → 0.6.0

package/dist/chunk-D4D76RGQ.js

@@ -0,0 +1,547 @@
+#!/usr/bin/env node
+
+// src/fx.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var FETCH_TIMEOUT_MS = 1500;
+var CACHE_FILE_NAME = "fx.json";
+var FX_SOURCES = [
+  "https://api.frankfurter.dev/v1/latest?base=USD&symbols=JPY",
+  "https://open.er-api.com/v6/latest/USD"
+];
+function cacheFilePath(cacheDir) {
+  return join(cacheDir, CACHE_FILE_NAME);
+}
+function isPositiveFiniteNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+function parseFxCache(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  if (!isPositiveFiniteNumber(obj.rate)) return null;
+  if (typeof obj.fetchedAt !== "string") return null;
+  return { rate: obj.rate, fetchedAt: obj.fetchedAt };
+}
+async function readFxCache(cacheDir) {
+  try {
+    const raw = await readFile(cacheFilePath(cacheDir), "utf8");
+    return parseFxCache(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+async function writeFxCache(cacheDir, cache) {
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(cacheFilePath(cacheDir), JSON.stringify(cache), "utf8");
+  } catch {
+  }
+}
+function isFresh(fetchedAt, cacheHours) {
+  const fetchedMs = Date.parse(fetchedAt);
+  if (Number.isNaN(fetchedMs)) return false;
+  const ageMs = Date.now() - fetchedMs;
+  return ageMs <= cacheHours * 60 * 60 * 1e3;
+}
+function extractJpyRate(json) {
+  if (typeof json !== "object" || json === null) return null;
+  const rates = json.rates;
+  if (typeof rates !== "object" || rates === null) return null;
+  const jpy = rates.JPY;
+  return isPositiveFiniteNumber(jpy) ? jpy : null;
+}
+async function fetchJpyRate(url) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, { signal: controller.signal });
+    const json = await res.json();
+    return extractJpyRate(json);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getUsdJpy(cfg, cacheDir) {
+  const cache = await readFxCache(cacheDir);
+  if (cache && isFresh(cache.fetchedAt, cfg.fx.cacheHours)) {
+    return { rate: cache.rate, source: "cache", fetchedAt: cache.fetchedAt };
+  }
+  for (const url of FX_SOURCES) {
+    const rate = await fetchJpyRate(url);
+    if (rate !== null) {
+      const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writeFxCache(cacheDir, { rate, fetchedAt });
+      return { rate, source: "live", fetchedAt };
+    }
+  }
+  if (cache) {
+    return { rate: cache.rate, source: "cache", fetchedAt: cache.fetchedAt };
+  }
+  return { rate: cfg.fx.fallbackRate, source: "fixed", fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+
+// src/codex/transcript.ts
+import { readFile as readFile2 } 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 readFile2(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 isSubagentRollout = false;
+  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;
+      const source = payload.source;
+      if (isRecord(source) && Object.hasOwn(source, "subagent")) isSubagentRollout = true;
+      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),
+    isSubagentRollout,
+    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)) {
+    picked.push(scan.open);
+  }
+  const lastIndex = picked.length - 1;
+  return picked.map((s, i) => ({
+    isSubagentRollout: scan.isSubagentRollout,
+    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/transcript.ts
+import { readFile as readFile3 } from "fs/promises";
+var NEWLINE2 = 10;
+var MAX_SEEN_KEYS = 500;
+var SYNTHETIC_MODEL = "<synthetic>";
+function isRecord2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function numOf2(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function strOrNull2(v) {
+  return typeof v === "string" ? v : null;
+}
+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 extractBucket(usage) {
+  const input = numOf2(usage.input_tokens);
+  const output = numOf2(usage.output_tokens);
+  const cacheRead = numOf2(usage.cache_read_input_tokens);
+  let cacheWrite5m;
+  let cacheWrite1h;
+  const cc = usage.cache_creation;
+  if (isRecord2(cc)) {
+    cacheWrite5m = numOf2(cc.ephemeral_5m_input_tokens);
+    cacheWrite1h = numOf2(cc.ephemeral_1h_input_tokens);
+  } else {
+    cacheWrite5m = numOf2(usage.cache_creation_input_tokens);
+    cacheWrite1h = 0;
+  }
+  return { input, output, cacheWrite5m, cacheWrite1h, cacheRead };
+}
+function promptCandidate(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    let hasToolResult = false;
+    const texts = [];
+    for (const block of content) {
+      if (!isRecord2(block)) continue;
+      if (block.type === "tool_result") hasToolResult = true;
+      else if (block.type === "text" && typeof block.text === "string") texts.push(block.text);
+    }
+    if (hasToolResult) return null;
+    return texts.join("\n");
+  }
+  return null;
+}
+async function readAll2(path) {
+  try {
+    return await readFile3(path);
+  } catch {
+    return null;
+  }
+}
+async function aggregateNewTurn(transcriptPath, cursor, opts = {}) {
+  const buffer = await readAll2(transcriptPath);
+  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] === NEWLINE2) {
+    startOffset = cursor.offset;
+    rescan = false;
+  } else {
+    startOffset = 0;
+    rescan = cursor !== null;
+  }
+  const seenKeys = new Set(cursor?.seenMessageKeys ?? []);
+  const tsFloor = cursor?.lastTs ?? null;
+  const pending = /* @__PURE__ */ new Map();
+  const consumedKeys = /* @__PURE__ */ new Set();
+  let sessionId = "";
+  let cwd = null;
+  let gitBranch = null;
+  let firstTs = null;
+  let lastTs = null;
+  let lastUuid = null;
+  let prompt = null;
+  const handleLine = (raw) => {
+    if (raw.trim().length === 0) return;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!isRecord2(obj)) return;
+    const ts = strOrNull2(obj.timestamp);
+    if (rescan && tsFloor !== null && ts !== null && ts <= tsFloor) return;
+    const isSide = obj.isSidechain === true;
+    const sid = strOrNull2(obj.sessionId);
+    if (sid !== null) sessionId = sid;
+    if (!isSide) {
+      const c = strOrNull2(obj.cwd);
+      if (c !== null) cwd = c;
+      const gb = strOrNull2(obj.gitBranch);
+      if (gb !== null) gitBranch = gb;
+    }
+    if (ts !== null) {
+      if (firstTs === null || ts < firstTs) firstTs = ts;
+      if (lastTs === null || ts > lastTs) lastTs = ts;
+    }
+    const uuid = strOrNull2(obj.uuid);
+    if (uuid !== null) lastUuid = uuid;
+    const type = obj.type;
+    const message = isRecord2(obj.message) ? obj.message : null;
+    if (type === "user" && !isSide && message !== null) {
+      const cand = promptCandidate(message.content);
+      if (cand !== null) {
+        const t = cand.trim();
+        if (t.length > 0 && !t.startsWith("<")) prompt = t;
+      }
+    }
+    if (type === "assistant" && message !== null) {
+      const usage = message.usage;
+      if (isRecord2(usage)) {
+        const rawModel = message.model;
+        if (rawModel !== SYNTHETIC_MODEL) {
+          const id = strOrNull2(message.id) ?? "";
+          const reqId = strOrNull2(obj.requestId) ?? "";
+          const key = `${id}:${reqId}`;
+          if (!seenKeys.has(key)) {
+            const tsMs = ts === null ? NaN : Date.parse(ts);
+            const outsidePeriod = typeof opts.minTimestampMs === "number" && (!Number.isFinite(tsMs) || tsMs < opts.minTimestampMs);
+            if (opts.excludeMessageKeys?.has(key) || outsidePeriod) {
+              consumedKeys.add(key);
+              pending.delete(key);
+              return;
+            }
+            const model = strOrNull2(rawModel) ?? "unknown";
+            pending.set(key, { model, isSidechain: isSide, bucket: extractBucket(usage) });
+          }
+        }
+      }
+    }
+  };
+  let lineStart = startOffset;
+  for (let pos = startOffset; pos < fileSize; pos++) {
+    if (buffer[pos] !== NEWLINE2) continue;
+    handleLine(buffer.toString("utf8", lineStart, pos));
+    lineStart = pos + 1;
+  }
+  const newOffset = lineStart;
+  if (pending.size === 0 && !opts.returnEmpty) return null;
+  const main = {};
+  const sidechain = {};
+  const newKeys = [];
+  for (const [key, pm] of pending) {
+    newKeys.push(key);
+    if (pm.isSidechain) addToModel(sidechain, pm.model, pm.bucket);
+    else addToModel(main, pm.model, pm.bucket);
+  }
+  const combined = [...cursor?.seenMessageKeys ?? [], ...consumedKeys, ...newKeys];
+  const seenMessageKeys = combined.length > MAX_SEEN_KEYS ? combined.slice(combined.length - MAX_SEEN_KEYS) : combined;
+  return {
+    sessionId,
+    main,
+    sidechain,
+    apiCalls: pending.size,
+    messageKeys: newKeys,
+    prompt,
+    cwd,
+    gitBranch,
+    firstTs,
+    lastTs,
+    newCursor: {
+      offset: newOffset,
+      lastUuid: lastUuid ?? cursor?.lastUuid ?? null,
+      lastTs: lastTs ?? cursor?.lastTs ?? null,
+      seenMessageKeys
+    }
+  };
+}
+
+export {
+  getUsdJpy,
+  aggregateCodexTurn,
+  splitIntoCodexTurnDrafts,
+  extractBucket,
+  promptCandidate,
+  aggregateNewTurn
+};

package/dist/chunk-HLJAJS2W.js

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