ccc-notifier 0.3.0 → 0.4.0

package/dist/chunk-J6Y3RMMC.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import {
+  paths
+} from "./chunk-26CISNOE.js";
+
+// src/data-lock.ts
+import { randomUUID } from "crypto";
+import { hostname } from "os";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+var DATA_LOCK_LEASE_MS = 3e4;
+var HEARTBEAT_MS = 5e3;
+function ownerFile(dir) {
+  return join(dir, "owner.json");
+}
+function readOwner(dir) {
+  try {
+    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 {
+    return null;
+  }
+}
+function writeOwner(dir, owner) {
+  const tmp = join(dir, `owner.${owner.token}.${randomUUID()}.tmp`);
+  try {
+    writeFileSync(tmp, `${JSON.stringify(owner)}
+`, "utf8");
+    renameSync(tmp, ownerFile(dir));
+  } finally {
+    rmSync(tmp, { force: true });
+  }
+}
+function quarantineOwned(dir, token, label) {
+  const before = readOwner(dir);
+  if (before?.token !== token) return false;
+  const quarantine = `${dir}.${label}-${token}-${randomUUID()}`;
+  try {
+    renameSync(dir, quarantine);
+  } catch {
+    return false;
+  }
+  const moved = readOwner(quarantine);
+  if (moved?.token !== token) {
+    return false;
+  }
+  rmSync(quarantine, { recursive: true, force: true });
+  return true;
+}
+function claimDir(fixed, label, now, metadataWriter = writeOwner) {
+  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);
+    renameSync(staging, fixed);
+    return { token, owner };
+  } catch {
+    rmSync(staging, { recursive: true, force: true });
+    return null;
+  }
+}
+function processDefinitelyDead(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (err) {
+    return err.code === "ESRCH";
+  }
+}
+function reclaimerGuardBlocks(now, leaseMs) {
+  const owner = readOwner(paths().dataReclaimDir);
+  if (owner === null) return true;
+  if (owner.hostname !== hostname()) return true;
+  const heartbeat = Date.parse(owner.heartbeatAt);
+  if (!Number.isFinite(heartbeat) || now.getTime() - heartbeat <= leaseMs) return true;
+  return !processDefinitelyDead(owner.pid);
+}
+function tryReclaim(now, leaseMs) {
+  const p = paths();
+  const guard = claimDir(p.dataReclaimDir, "claim", now);
+  if (guard === null) return false;
+  try {
+    const first = readOwner(p.dataLockDir);
+    if (first === null || first.hostname !== hostname()) return false;
+    const heartbeatMs = Date.parse(first.heartbeatAt);
+    if (!Number.isFinite(heartbeatMs) || now.getTime() - heartbeatMs <= leaseMs) return false;
+    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}-${randomUUID()}`;
+    try {
+      renameSync(p.dataLockDir, orphan);
+    } catch {
+      return false;
+    }
+    const moved = readOwner(orphan);
+    if (moved?.token !== first.token || moved.heartbeatAt !== first.heartbeatAt) return false;
+    rmSync(orphan, { recursive: true, force: true });
+    return true;
+  } finally {
+    quarantineOwned(p.dataReclaimDir, guard.token, "released");
+  }
+}
+function acquireDataLock(opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const leaseMs = opts.leaseMs ?? DATA_LOCK_LEASE_MS;
+  const p = paths();
+  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 (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) return null;
+    claim = claimDir(p.dataLockDir, "acquire", now, opts.metadataWriter);
+    if (claim === null) return null;
+  }
+  if (existsSync(p.dataReclaimDir) && reclaimerGuardBlocks(now, leaseMs)) {
+    quarantineOwned(p.dataLockDir, claim.token, "yielded");
+    return null;
+  }
+  let released = false;
+  const heartbeat = () => {
+    if (released) return false;
+    const current = readOwner(p.dataLockDir);
+    if (current?.token !== claim.token) return false;
+    writeOwner(p.dataLockDir, { ...current, heartbeatAt: (/* @__PURE__ */ new Date()).toISOString() });
+    return readOwner(p.dataLockDir)?.token === claim.token;
+  };
+  const timer = setInterval(() => {
+    try {
+      heartbeat();
+    } catch {
+    }
+  }, HEARTBEAT_MS);
+  timer.unref();
+  return {
+    token: claim.token,
+    heartbeat,
+    release() {
+      if (released) return;
+      released = true;
+      clearInterval(timer);
+      quarantineOwned(p.dataLockDir, claim.token, "released");
+    }
+  };
+}
+async function waitForDataLock(timeoutMs, pollMs = 25) {
+  const envTimeout = Number.parseInt(process.env.CCCN_LOCK_TIMEOUT_MS ?? "", 10);
+  timeoutMs = timeoutMs ?? (Number.isFinite(envTimeout) && envTimeout >= 0 ? envTimeout : 5e3);
+  const deadline = Date.now() + timeoutMs;
+  do {
+    const lock = acquireDataLock();
+    if (lock !== null) return lock;
+    if (Date.now() >= deadline) return null;
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  } while (true);
+}
+
+export {
+  waitForDataLock
+};

package/dist/{chunk-4RZ6OGTD.js → chunk-TUZVISLD.js}

@@ -4,7 +4,7 @@ import {
   isMuted,
   readMuteState,
   writeMuteState
-} from "./chunk-ECADO26T.js";
+} from "./chunk-26CISNOE.js";
 
 // src/mute.ts
 function parseDuration(arg) {

package/dist/chunk-ZHIZZ6V5.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import {
+  paths
+} from "./chunk-26CISNOE.js";
+
+// src/dashboard-state.ts
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  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 });
+  }
+}
+
+export {
+  makeFullDashboardState,
+  isFullDashboardDue,
+  writeFullDashboardStateAtomic,
+  invalidateCanonicalDashboards
+};

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   fmtMuteUntil
-} from "./chunk-4RZ6OGTD.js";
+} from "./chunk-TUZVISLD.js";
 import {
   codexHooksFile,
   matchesMarker
-} from "./chunk-7KVOQ4UZ.js";
+} from "./chunk-5LHZOZZO.js";
 import {
   notifyOS,
   notifySlack,
@@ -35,7 +35,7 @@ import {
   readConfig,
   readMuteState,
   readTurns
-} from "./chunk-ECADO26T.js";
+} from "./chunk-26CISNOE.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";
@@ -586,7 +586,7 @@ var COMMANDS = [
     en: "Print an aggregated cost report"
   },
   {
-    cmd: "dashboard [--days N] [--no-open] [--out <path>] [--refresh <sec>|--no-refresh]",
+    cmd: "dashboard [--all|--days N] [--no-open] [--out <path>] [--refresh <sec>|--no-refresh]",
     ja: "HTML\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u3092\u751F\u6210\u3057\u3066\u30D6\u30E9\u30A6\u30B6\u3067\u958B\u304F",
     en: "Generate and open the HTML dashboard"
   },
@@ -683,18 +683,18 @@ async function main(argv) {
         const text = await readStdin();
         const codex = rest.includes("--codex");
         try {
-          const trackMod = await import("./track-PXFSGMGL.js");
+          const trackMod = await import("./track-QT2U3E2R.js");
           await trackMod.runTrack(text, { codex });
         } catch {
         }
         return 0;
       }
       case "init": {
-        const { runInit } = await import("./setup-PTO5N46B.js");
+        const { runInit } = await import("./setup-W3CSTHJC.js");
         return await runInit(rest);
       }
       case "uninstall": {
-        const { runUninstall } = await import("./setup-PTO5N46B.js");
+        const { runUninstall } = await import("./setup-W3CSTHJC.js");
         return await runUninstall(rest);
       }
       case "doctor":
@@ -702,27 +702,27 @@ async function main(argv) {
       case "report":
         return await runReport(rest);
       case "dashboard": {
-        const { runDashboard } = await import("./dashboard-TH3NOVT3.js");
+        const { runDashboard } = await import("./dashboard-GYKABTTN.js");
         return await runDashboard(rest);
       }
       case "sweep": {
-        const { runSweep } = await import("./sweep-25EZAOGC.js");
+        const { runSweep } = await import("./sweep-IBSV4LRD.js");
         return await runSweep(rest);
       }
       case "history": {
-        const { runHistory } = await import("./history-DLFYQJFM.js");
+        const { runHistory } = await import("./history-6OUJLXJT.js");
         return await runHistory(rest);
       }
       case "budget": {
-        const { runBudget } = await import("./budget-KKTFYAXH.js");
+        const { runBudget } = await import("./budget-EHWPEYXY.js");
         return runBudget(rest);
       }
       case "mute": {
-        const { runMute } = await import("./mute-EPLYH67P.js");
+        const { runMute } = await import("./mute-GBDNN5PB.js");
         return runMute(rest);
       }
       case "unmute": {
-        const { runUnmute } = await import("./mute-EPLYH67P.js");
+        const { runUnmute } = await import("./mute-GBDNN5PB.js");
         return runUnmute();
       }
       case "--version":

package/dist/{dashboard-TH3NOVT3.js → dashboard-GYKABTTN.js}

@@ -3,10 +3,12 @@ import {
   browserOpenPlan,
   runDashboard,
   writeDashboardHtml
-} from "./chunk-QX5KIRSU.js";
+} from "./chunk-2VPBBIDW.js";
 import "./chunk-DGXUSPS4.js";
+import "./chunk-ZHIZZ6V5.js";
+import "./chunk-J6Y3RMMC.js";
 import "./chunk-J5QAYTFE.js";
-import "./chunk-ECADO26T.js";
+import "./chunk-26CISNOE.js";
 export {
   browserOpenPlan,
   runDashboard,

package/dist/history-6OUJLXJT.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import {
+  invalidateCanonicalDashboards
+} from "./chunk-ZHIZZ6V5.js";
+import {
+  waitForDataLock
+} from "./chunk-J6Y3RMMC.js";
+import {
+  paths
+} from "./chunk-26CISNOE.js";
+
+// src/history.ts
+import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from "fs";
+import { createHash } from "crypto";
+import * as p from "@clack/prompts";
+function parseFlags(argv) {
+  let days = null;
+  let yes = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--yes" || a === "-y") {
+      yes = true;
+    } else if (a === "--days") {
+      const n = Number.parseInt(argv[i + 1] ?? "", 10);
+      if (Number.isFinite(n) && n > 0) days = n;
+      i++;
+    } else if (a.startsWith("--days=")) {
+      const n = Number.parseInt(a.slice("--days=".length), 10);
+      if (Number.isFinite(n) && n > 0) days = n;
+    }
+  }
+  return { days, yes };
+}
+function readLines(file) {
+  const raw = readFileSync(file, "utf8");
+  const lines = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let rec = null;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      rec = null;
+    }
+    lines.push({ raw: line, rec });
+  }
+  return lines;
+}
+function isTargeted(rec, cutoffMs) {
+  if (cutoffMs === null) return true;
+  const ts = Date.parse(rec.ts);
+  if (!Number.isFinite(ts)) return false;
+  return ts < cutoffMs;
+}
+function atomicWrite(file, content) {
+  const tmp = `${file}.tmp`;
+  writeFileSync(tmp, content, "utf8");
+  renameSync(tmp, file);
+}
+function collectTargets(lines, sub, cutoff) {
+  const targetSet = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const rec = lines[i].rec;
+    if (!rec || !isTargeted(rec, cutoff)) continue;
+    if (sub === "redact" && !(typeof rec.prompt === "string" && rec.prompt.length > 0)) continue;
+    targetSet.add(i);
+  }
+  return targetSet;
+}
+function targetFingerprint(lines, targets) {
+  const hash = createHash("sha256");
+  hash.update(`count:${targets.size}
+`);
+  for (const i of [...targets].sort((a, b) => a - b)) {
+    hash.update(`${i}:${lines[i]?.raw ?? ""}
+`);
+  }
+  return hash.digest("hex");
+}
+async function runHistory(argv, deps = {}) {
+  const [sub, ...rest] = argv;
+  if (sub !== "clear" && sub !== "redact") {
+    console.error(
+      "\u4F7F\u3044\u65B9 / Usage: ccc-notifier history <clear|redact> [--days N] [--yes]\n  clear  \u2026 \u30EC\u30B3\u30FC\u30C9\u3054\u3068\u524A\u9664(\u30C1\u30E3\u30FC\u30C8\u30FB\u96C6\u8A08\u304B\u3089\u3082\u6D88\u3048\u308B) / delete records\n  redact \u2026 \u30D7\u30ED\u30F3\u30D7\u30C8\u5168\u6587\u3060\u3051\u6D88\u3059(\u30B3\u30B9\u30C8\u30FB\u30C1\u30E3\u30FC\u30C8\u306F\u6B8B\u3059) / strip prompts only"
+    );
+    return 1;
+  }
+  const flags = parseFlags(rest);
+  const file = paths().historyFile;
+  let lines = existsSync(file) ? readLines(file) : [];
+  const cutoff = flags.days !== null ? Date.now() - flags.days * 864e5 : null;
+  const scope = flags.days !== null ? `${flags.days}\u65E5\u3088\u308A\u524D` : "\u5168\u671F\u9593";
+  let targetSet = collectTargets(lines, sub, cutoff);
+  const initialFingerprint = targetFingerprint(lines, targetSet);
+  const action = sub === "clear" ? "\u30EC\u30B3\u30FC\u30C9\u3054\u3068\u524A\u9664" : "\u30D7\u30ED\u30F3\u30D7\u30C8\u5168\u6587\u3092\u6D88\u53BB";
+  if (targetSet.size > 0 && !flags.yes) {
+    const confirmed = await (deps.confirm ?? p.confirm)({
+      message: `${scope}\u306E\u5C65\u6B74 ${targetSet.size} \u4EF6\u3092${action}\u3057\u307E\u3059\u3002\u5143\u306B\u623B\u305B\u307E\u305B\u3093\u3002\u3088\u308D\u3057\u3044\u3067\u3059\u304B?`,
+      initialValue: false
+    });
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.cancel("\u30AD\u30E3\u30F3\u30BB\u30EB\u3057\u307E\u3057\u305F");
+      return 0;
+    }
+  }
+  const lock = await waitForDataLock();
+  if (lock === null) {
+    console.error("\u5C65\u6B74\u306E\u66F4\u65B0\u30ED\u30C3\u30AF\u3092\u53D6\u5F97\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u5F8C\u3067\u3082\u3046\u4E00\u5EA6\u304A\u8A66\u3057\u304F\u3060\u3055\u3044 / history lock is busy");
+    return 1;
+  }
+  try {
+    lines = existsSync(file) ? readLines(file) : [];
+    targetSet = collectTargets(lines, sub, cutoff);
+    if (!flags.yes && targetFingerprint(lines, targetSet) !== initialFingerprint) {
+      console.error(
+        "\u78BA\u8A8D\u4E2D\u306B\u5C65\u6B74\u304C\u5909\u66F4\u3055\u308C\u305F\u305F\u3081\u51E6\u7406\u3057\u307E\u305B\u3093\u3067\u3057\u305F\u3002\u3082\u3046\u4E00\u5EA6\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044 / history changed; retry"
+      );
+      return 1;
+    }
+    invalidateCanonicalDashboards();
+    if (!existsSync(file)) {
+      console.log("\u5C65\u6B74\u304C\u3042\u308A\u307E\u305B\u3093(history.jsonl \u306F\u672A\u4F5C\u6210\u3067\u3059)\u3002");
+      return 0;
+    }
+    if (targetSet.size === 0) {
+      console.log(`\u5BFE\u8C61\u304C\u3042\u308A\u307E\u305B\u3093(${scope})\u3002`);
+      return 0;
+    }
+    try {
+      if (sub === "clear") {
+        const kept = lines.filter((_, i) => !targetSet.has(i)).map((l) => l.raw);
+        if (kept.length === 0) {
+          rmSync(file, { force: true });
+        } else {
+          atomicWrite(file, kept.join("\n") + "\n");
+        }
+        console.log(`\u5C65\u6B74 ${targetSet.size} \u4EF6\u3092\u524A\u9664\u3057\u307E\u3057\u305F(${scope})\u3002`);
+      } else {
+        const out = lines.map((l, i) => {
+          if (!targetSet.has(i) || l.rec === null) return l.raw;
+          return JSON.stringify({ ...l.rec, prompt: "" });
+        });
+        atomicWrite(file, out.join("\n") + "\n");
+        console.log(
+          `\u30D7\u30ED\u30F3\u30D7\u30C8\u5168\u6587\u3092 ${targetSet.size} \u4EF6\u6D88\u53BB\u3057\u307E\u3057\u305F(${scope}\u3002\u30B3\u30B9\u30C8\u96C6\u8A08\u30FB\u30C1\u30E3\u30FC\u30C8\u306F\u4FDD\u6301\u3055\u308C\u307E\u3059)\u3002`
+        );
+      }
+    } catch (err) {
+      console.error(
+        `\u5C65\u6B74\u306E\u66F4\u65B0\u306B\u5931\u6557\u3057\u307E\u3057\u305F / failed to update history: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return 1;
+    }
+    invalidateCanonicalDashboards();
+    return 0;
+  } finally {
+    lock.release();
+  }
+}
+export {
+  runHistory
+};

package/dist/{mute-EPLYH67P.js → mute-GBDNN5PB.js}

@@ -3,8 +3,8 @@ import {
   fmtMuteUntil,
   runMute,
   runUnmute
-} from "./chunk-4RZ6OGTD.js";
-import "./chunk-ECADO26T.js";
+} from "./chunk-TUZVISLD.js";
+import "./chunk-26CISNOE.js";
 export {
   fmtMuteUntil,
   runMute,

package/dist/{setup-PTO5N46B.js → setup-W3CSTHJC.js}

@@ -3,12 +3,12 @@ import {
   matchesMarker,
   runInit,
   runUninstall
-} from "./chunk-7KVOQ4UZ.js";
+} from "./chunk-5LHZOZZO.js";
 import "./chunk-NV5UOHJA.js";
 import "./chunk-DGXUSPS4.js";
 import "./chunk-HTYUYKFW.js";
 import "./chunk-J5QAYTFE.js";
-import "./chunk-ECADO26T.js";
+import "./chunk-26CISNOE.js";
 export {
   matchesMarker,
   runInit,