ccc-notifier 0.6.3 → 0.8.0

package/dist/{chunk-27SJELD2.js → chunk-PXMXEFM7.js}

@@ -1,100 +1,19 @@
 #!/usr/bin/env node
 import {
   paths
-} from "./chunk-OOAC5ULQ.js";
+} from "./chunk-WONMZ466.js";
 
-// src/dashboard-state.ts
+// src/data-lock.ts
+import { randomUUID } from "crypto";
+import { hostname } from "os";
 import {
-  closeSync,
   existsSync,
-  openSync,
+  mkdirSync,
   readFileSync,
-  readSync,
   renameSync,
   rmSync,
   writeFileSync
 } from "fs";
-import { randomUUID } from "crypto";
-function localDate(now) {
-  const y = now.getFullYear();
-  const m = String(now.getMonth() + 1).padStart(2, "0");
-  const d = String(now.getDate()).padStart(2, "0");
-  return `${y}-${m}-${d}`;
-}
-function timeZone() {
-  return Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown";
-}
-function makeFullDashboardState(now = /* @__PURE__ */ new Date()) {
-  return { localDate: localDate(now), timeZone: timeZone(), generatedAt: now.toISOString() };
-}
-function readState() {
-  const file = paths().dashboardFullStateFile;
-  if (!existsSync(file)) return null;
-  try {
-    const value = JSON.parse(readFileSync(file, "utf8"));
-    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
-    const v = value;
-    if (typeof v.localDate !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v.localDate) || typeof v.timeZone !== "string" || v.timeZone.length === 0 || typeof v.generatedAt !== "string" || !Number.isFinite(Date.parse(v.generatedAt))) {
-      return null;
-    }
-    return v;
-  } catch {
-    return null;
-  }
-}
-function isFullDashboardDue(now = /* @__PURE__ */ new Date()) {
-  const p = paths();
-  if (!existsSync(p.fullDashboardFile)) return true;
-  try {
-    const fd = openSync(p.fullDashboardFile, "r");
-    try {
-      const head = Buffer.alloc(512);
-      const n = readSync(fd, head, 0, head.length, 0);
-      if (head.toString("utf8", 0, n).includes('name="cccn-placeholder"')) return true;
-    } finally {
-      closeSync(fd);
-    }
-  } catch {
-    return true;
-  }
-  const state = readState();
-  if (state === null) return true;
-  const expected = makeFullDashboardState(now);
-  if (state.timeZone !== expected.timeZone) return true;
-  if (state.localDate !== expected.localDate) return true;
-  if (state.localDate > expected.localDate) return true;
-  if (Date.parse(state.generatedAt) > now.getTime()) return true;
-  return false;
-}
-function writeFullDashboardStateAtomic(state) {
-  const file = paths().dashboardFullStateFile;
-  const tmp = `${file}.${process.pid}.${randomUUID()}.tmp`;
-  try {
-    writeFileSync(tmp, `${JSON.stringify(state)}
-`, "utf8");
-    renameSync(tmp, file);
-  } finally {
-    rmSync(tmp, { force: true });
-  }
-}
-function invalidateCanonicalDashboards() {
-  const p = paths();
-  for (const file of [p.recentDashboardFile, p.fullDashboardFile, p.dashboardFullStateFile]) {
-    rmSync(file, { force: true });
-  }
-}
-
-// src/data-lock.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { hostname } from "os";
-import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readFileSync as readFileSync2,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync2
-} from "fs";
 import { join } from "path";
 var DATA_LOCK_LEASE_MS = 3e4;
 var HEARTBEAT_MS = 5e3;
@@ -103,7 +22,7 @@ function ownerFile(dir) {
 }
 function readOwner(dir) {
   try {
-    const v = JSON.parse(readFileSync2(ownerFile(dir), "utf8"));
+    const v = JSON.parse(readFileSync(ownerFile(dir), "utf8"));
     if (typeof v.token !== "string" || typeof v.pid !== "number" || typeof v.hostname !== "string" || typeof v.acquiredAt !== "string" || typeof v.heartbeatAt !== "string") return null;
     return v;
   } catch {
@@ -111,21 +30,21 @@ function readOwner(dir) {
   }
 }
 function writeOwner(dir, owner) {
-  const tmp = join(dir, `owner.${owner.token}.${randomUUID2()}.tmp`);
+  const tmp = join(dir, `owner.${owner.token}.${randomUUID()}.tmp`);
   try {
-    writeFileSync2(tmp, `${JSON.stringify(owner)}
+    writeFileSync(tmp, `${JSON.stringify(owner)}
 `, "utf8");
-    renameSync2(tmp, ownerFile(dir));
+    renameSync(tmp, ownerFile(dir));
   } finally {
-    rmSync2(tmp, { force: true });
+    rmSync(tmp, { force: true });
   }
 }
 function quarantineOwned(dir, token, label) {
   const before = readOwner(dir);
   if (before?.token !== token) return false;
-  const quarantine = `${dir}.${label}-${token}-${randomUUID2()}`;
+  const quarantine = `${dir}.${label}-${token}-${randomUUID()}`;
   try {
-    renameSync2(dir, quarantine);
+    renameSync(dir, quarantine);
   } catch {
     return false;
   }
@@ -133,21 +52,21 @@ function quarantineOwned(dir, token, label) {
   if (moved?.token !== token) {
     return false;
   }
-  rmSync2(quarantine, { recursive: true, force: true });
+  rmSync(quarantine, { recursive: true, force: true });
   return true;
 }
 function claimDir(fixed, label, now, metadataWriter = writeOwner) {
-  const token = randomUUID2();
+  const token = randomUUID();
   const staging = `${fixed}.${label}-${token}`;
   const iso = now.toISOString();
   const owner = { token, pid: process.pid, hostname: hostname(), acquiredAt: iso, heartbeatAt: iso };
   try {
     mkdirSync(staging);
     metadataWriter(staging, owner);
-    renameSync2(staging, fixed);
+    renameSync(staging, fixed);
     return { token, owner };
   } catch {
-    rmSync2(staging, { recursive: true, force: true });
+    rmSync(staging, { recursive: true, force: true });
     return null;
   }
 }
@@ -180,15 +99,15 @@ function tryReclaim(now, leaseMs) {
     if (!processDefinitelyDead(first.pid)) return false;
     const second = readOwner(p.dataLockDir);
     if (second === null || second.token !== first.token || second.heartbeatAt !== first.heartbeatAt) return false;
-    const orphan = `${p.dataLockDir}.orphan-${first.token}-${randomUUID2()}`;
+    const orphan = `${p.dataLockDir}.orphan-${first.token}-${randomUUID()}`;
     try {
-      renameSync2(p.dataLockDir, orphan);
+      renameSync(p.dataLockDir, orphan);
     } catch {
       return false;
     }
     const moved = readOwner(orphan);
     if (moved?.token !== first.token || moved.heartbeatAt !== first.heartbeatAt) return false;
-    rmSync2(orphan, { recursive: true, force: true });
+    rmSync(orphan, { recursive: true, force: true });
     return true;
   } finally {
     quarantineOwned(p.dataReclaimDir, guard.token, "released");
@@ -198,15 +117,15 @@ function acquireDataLock(opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const leaseMs = opts.leaseMs ?? DATA_LOCK_LEASE_MS;
   const p = paths();
-  if (existsSync2(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
+  if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
   let claim = claimDir(p.dataLockDir, "acquire", now, opts.metadataWriter);
   if (claim === null) {
     if (!tryReclaim(now, leaseMs)) return null;
-    if (existsSync2(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
+    if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
     claim = claimDir(p.dataLockDir, "acquire", now, opts.metadataWriter);
     if (claim === null) return null;
   }
-  if (existsSync2(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) {
+  if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) {
     quarantineOwned(p.dataLockDir, claim.token, "yielded");
     return null;
   }
@@ -249,9 +168,5 @@ async function waitForDataLock(timeoutMs, pollMs = 25) {
 }
 
 export {
-  makeFullDashboardState,
-  isFullDashboardDue,
-  writeFullDashboardStateAtomic,
-  invalidateCanonicalDashboards,
   waitForDataLock
 };

package/dist/{chunk-6HTETN26.js → chunk-Q45AAPJY.js}

@@ -220,7 +220,24 @@ async function loadPriceTable(cacheDir, opts) {
   }
 }
 
+// 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 {
   computeCost,
-  loadPriceTable
+  loadPriceTable,
+  codexHome,
+  detectCodex
 };

package/dist/{chunk-OXXDZZPJ.js → chunk-RE72XBXB.js}

@@ -2,19 +2,17 @@
 import {
   notifyOS,
   notifySlack
-} from "./chunk-NV5UOHJA.js";
+} from "./chunk-TTD3BGOL.js";
 import {
   codexHome,
-  detectCodex
-} from "./chunk-HTYUYKFW.js";
-import {
+  detectCodex,
   loadPriceTable
-} from "./chunk-6HTETN26.js";
+} from "./chunk-Q45AAPJY.js";
 import {
   configFilePath,
   paths,
   readConfig
-} from "./chunk-OOAC5ULQ.js";
+} from "./chunk-WONMZ466.js";
 
 // src/setup.ts
 import {

package/dist/{chunk-NV5UOHJA.js → chunk-TTD3BGOL.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-DGXUSPS4.js";
 import {
   formatSummary
-} from "./chunk-J5QAYTFE.js";
+} from "./chunk-XOGYLFX3.js";
 
 // src/notify/os.ts
 import { spawn } from "child_process";
@@ -181,10 +181,10 @@ function spawnNotifyChild(title, body) {
   }
   return { child: spawnLinuxNotify(title, body), swallowError: backend.swallowError };
 }
-async function notifyOS(record, cfg, todayUSD) {
+async function notifyOS(record, cfg, todayUSD, summaryOverride) {
   try {
     if (!cfg?.notify?.os) return;
-    const { title, body } = formatSummary(record, cfg, todayUSD);
+    const { title, body } = summaryOverride ?? formatSummary(record, cfg, todayUSD);
     if (process.env.CCCN_DRY_RUN === "1") {
       writeDryRun("os", { title, body });
       return;
@@ -221,12 +221,12 @@ async function notifyOS(record, cfg, todayUSD) {
 
 // src/notify/slack.ts
 var SEND_TIMEOUT_MS = 3e3;
-async function notifySlack(record, cfg, todayUSD) {
+async function notifySlack(record, cfg, todayUSD, summaryOverride) {
   try {
     const slackCfg = cfg?.notify?.slack;
     const webhookUrl = slackCfg?.webhookUrl;
     if (!webhookUrl) return;
-    const { title, body } = formatSummary(record, cfg, todayUSD);
+    const { title, body } = summaryOverride ?? formatSummary(record, cfg, todayUSD);
     const line1 = body.split("\n")[0] ?? "";
     const rawPrompt = record.prompt ?? "";
     let promptText;

package/dist/{chunk-OOAC5ULQ.js → chunk-WONMZ466.js}

@@ -28,6 +28,7 @@ import {
   rmSync,
   statSync
 } from "fs";
+import { randomUUID } from "crypto";
 import { join } from "path";
 import { homedir } from "os";
 
@@ -216,9 +217,21 @@ function loadCursor(transcriptPath) {
   const cursor = parsed[transcriptPath];
   return cursor ?? null;
 }
+function cursorPaths() {
+  const p = paths();
+  if (!existsSync(p.cursorsFile)) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(readFileSync(p.cursorsFile, "utf8"));
+    if (!isPlainObject(parsed)) return /* @__PURE__ */ new Set();
+    return new Set(Object.keys(parsed));
+  } catch (err) {
+    logError("cursorPaths", err);
+    return /* @__PURE__ */ new Set();
+  }
+}
 function sanitizeCursor(raw) {
   if (!isPlainObject(raw)) return null;
-  const { offset, lastUuid, lastTs, seenMessageKeys, codexTotals } = raw;
+  const { offset, lastUuid, lastTs, seenMessageKeys, codexTotals, codexOriginator, codexModel } = 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;
@@ -235,8 +248,44 @@ function sanitizeCursor(raw) {
       cursor.codexTotals = { input, cached, output };
     }
   }
+  if (Object.hasOwn(raw, "codexOriginator")) {
+    if (codexOriginator === null || typeof codexOriginator === "string") {
+      cursor.codexOriginator = codexOriginator;
+    }
+  }
+  if (Object.hasOwn(raw, "codexModel")) {
+    if (codexModel === null || typeof codexModel === "string") {
+      cursor.codexModel = codexModel;
+    }
+  }
   return cursor;
 }
+function loadAllCursors() {
+  const p = paths();
+  if (!existsSync(p.cursorsFile)) return {};
+  try {
+    const raw = readFileSync(p.cursorsFile, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) {
+      logError("loadAllCursors", new Error("cursors.json root is not an object"));
+      return {};
+    }
+    return parsed;
+  } catch (err) {
+    logError("loadAllCursors", err);
+    return {};
+  }
+}
+function saveAllCursors(dict) {
+  const p = paths();
+  const tmpFile = `${p.cursorsFile}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmpFile, JSON.stringify(dict), "utf8");
+    renameSync(tmpFile, p.cursorsFile);
+  } finally {
+    rmSync(tmpFile, { force: true });
+  }
+}
 function saveCursor(transcriptPath, c) {
   const p = paths();
   let dict = {};
@@ -252,9 +301,83 @@ function saveCursor(transcriptPath, c) {
     }
   }
   dict[transcriptPath] = c;
-  const tmpFile = `${p.cursorsFile}.tmp`;
-  writeFileSync(tmpFile, JSON.stringify(dict), "utf8");
-  renameSync(tmpFile, p.cursorsFile);
+  const tmpFile = `${p.cursorsFile}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmpFile, JSON.stringify(dict), "utf8");
+    renameSync(tmpFile, p.cursorsFile);
+  } finally {
+    rmSync(tmpFile, { force: true });
+  }
+}
+function pendingAppendPath() {
+  return join(paths().cacheDir, "pending-append.json");
+}
+function readPendingAppends() {
+  let raw;
+  try {
+    raw = readFileSync(pendingAppendPath(), "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") return { dict: {}, trusted: true };
+    logError("readPendingAppends", err);
+    return { dict: {}, trusted: false };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) {
+      logError("readPendingAppends", new Error("pending-append.json root is not an object"));
+      return { dict: {}, trusted: false };
+    }
+    return { dict: parsed, trusted: true };
+  } catch (err) {
+    logError("readPendingAppends", err);
+    return { dict: {}, trusted: false };
+  }
+}
+function writePendingAppends(dict) {
+  const file = pendingAppendPath();
+  const tmp = `${file}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(dict), "utf8");
+    renameSync(tmp, file);
+  } finally {
+    rmSync(tmp, { force: true });
+  }
+}
+var PENDING_ALL = "*";
+function hasPendingAppend(transcriptPath) {
+  try {
+    const { dict, trusted } = readPendingAppends();
+    if (!trusted) return true;
+    return Object.hasOwn(dict, PENDING_ALL) || Object.hasOwn(dict, transcriptPath);
+  } catch (err) {
+    logError("hasPendingAppend", err);
+    return true;
+  }
+}
+function markPendingAppend(transcriptPath, ingestKey) {
+  const { dict, trusted } = readPendingAppends();
+  if (!trusted) dict[PENDING_ALL] = "unreadable-marker";
+  dict[transcriptPath] = ingestKey;
+  writePendingAppends(dict);
+}
+function clearPendingAppend(transcriptPath) {
+  try {
+    const { dict, trusted } = readPendingAppends();
+    if (!trusted) return;
+    if (!Object.hasOwn(dict, transcriptPath)) return;
+    delete dict[transcriptPath];
+    writePendingAppends(dict);
+  } catch (err) {
+    logError("clearPendingAppend", err);
+  }
+}
+function hasUnresolvedPendingMarker() {
+  try {
+    const { dict, trusted } = readPendingAppends();
+    return !trusted || Object.hasOwn(dict, PENDING_ALL);
+  } catch {
+    return true;
+  }
 }
 function appendTurn(record) {
   const p = paths();
@@ -309,6 +432,53 @@ function readTurns(days) {
   }
   return result;
 }
+function floorKey(scope, sessionId) {
+  return `${scope}\0${sessionId}`;
+}
+function loadHistoryIndex() {
+  const index = { countedCalls: /* @__PURE__ */ new Set(), ingestKeys: /* @__PURE__ */ new Set(), legacyFloors: /* @__PURE__ */ new Map() };
+  let raw;
+  try {
+    raw = readFileSync(paths().historyFile, "utf8");
+  } catch {
+    return index;
+  }
+  for (const line of raw.split("\n")) {
+    if (line.length === 0) continue;
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    let hasFingerprints = false;
+    if (Array.isArray(rec.countedCalls)) {
+      for (const fp of rec.countedCalls) {
+        if (typeof fp === "string" && fp.length > 0) {
+          index.countedCalls.add(fp);
+          hasFingerprints = true;
+        }
+      }
+    }
+    if (typeof rec.ingestKey === "string" && rec.ingestKey.length > 0) index.ingestKeys.add(rec.ingestKey);
+    if (hasFingerprints) continue;
+    const { sessionId, ts } = rec;
+    if (typeof sessionId !== "string" || sessionId.length === 0) continue;
+    if (typeof ts !== "string") continue;
+    const ms = Date.parse(ts);
+    if (!Number.isFinite(ms)) continue;
+    const iso = new Date(ms).toISOString();
+    const isCodex = rec.source === "codex";
+    const scopes = isCodex ? ["codex"] : ["claude"];
+    if (!isCodex && rec.subagents !== void 0 && rec.subagents !== null) scopes.push("claude-sa");
+    for (const scope of scopes) {
+      const key = floorKey(scope, sessionId);
+      const cur = index.legacyFloors.get(key);
+      if (cur === void 0 || cur < iso) index.legacyFloors.set(key, iso);
+    }
+  }
+  return index;
+}
 function todayTotalUSD() {
   const now = /* @__PURE__ */ new Date();
   const y = now.getFullYear();
@@ -1090,11 +1260,21 @@ export {
   writeMuteState,
   clearMuteState,
   loadCursor,
+  cursorPaths,
   sanitizeCursor,
+  loadAllCursors,
+  saveAllCursors,
   saveCursor,
+  pendingAppendPath,
+  hasPendingAppend,
+  markPendingAppend,
+  clearPendingAppend,
+  hasUnresolvedPendingMarker,
   appendTurn,
   resetHistoryAndCursors,
   readTurns,
+  floorKey,
+  loadHistoryIndex,
   todayTotalUSD,
   currentMonthTotals,
   logError

package/dist/{chunk-J5QAYTFE.js → chunk-XOGYLFX3.js}

@@ -80,11 +80,22 @@ function formatSummary(record, cfg, todayUSD) {
   return { title, body: `${line1}
 ${line2}` };
 }
+function formatIngestSummary(input, cfg) {
+  const label = cfg.costLabel === "api_equivalent" ? "API\u63DB\u7B97 " : "";
+  const title = `\u{1F4B0} ${label}${formatUSD(input.totalUSD)}(${formatJPY(input.totalJPY)})| hook\u975E\u4F9D\u5B58\u306E\u53D6\u308A\u8FBC\u307F ${input.recordCount}\u4EF6`;
+  const bySurfaceLine = Object.entries(input.bySurface).sort((a, b) => b[1].usd - a[1].usd).map(([surface, v]) => `${surface}: ${v.turns}\u4EF6 ${formatUSD(v.usd)}`).join(" / ");
+  const cachePct = input.totalTokens > 0 ? Math.round(input.cacheTokens / input.totalTokens * 100) : 0;
+  const tokensPart = input.totalTokens > 0 ? ` \xB7 \u8A08 ${formatTokens(input.totalTokens)} tokens(cache ${cachePct}%)` : "";
+  const body = `${bySurfaceLine}${tokensPart}
+hook \u975E\u4F9D\u5B58\u306E\u5897\u5206\u53D6\u308A\u8FBC\u307F(scan)\u306B\u3088\u308B\u65B0\u898F\u5206\u3067\u3059`;
+  return { title, body };
+}
 
 export {
   formatUSD,
   formatJPY,
   formatTokens,
   modelDisplayName,
-  formatSummary
+  formatSummary,
+  formatIngestSummary
 };