ccc-notifier 0.6.2 → 0.7.0

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-OXXDZZPJ.js → chunk-X7U63BZG.js}

@@ -2,19 +2,17 @@
 import {
   notifyOS,
   notifySlack
-} from "./chunk-NV5UOHJA.js";
+} from "./chunk-JLDI4D5E.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-J5QAYTFE.js → chunk-XG73C6CC.js}

@@ -80,11 +80,20 @@ 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 body = `${bySurfaceLine}
+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
 };