ccc-notifier 0.1.0

package/dist/chunk-DGXUSPS4.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+// src/env.ts
+import { readFileSync } from "fs";
+function isWSL() {
+  const forced = process.env.CCCN_FORCE_WSL;
+  if (forced === "1") return true;
+  if (forced === "0") return false;
+  if (process.platform !== "linux") return false;
+  if (process.env.WSL_DISTRO_NAME) return true;
+  try {
+    const v = readFileSync("/proc/version", "utf8").toLowerCase();
+    return v.includes("microsoft") || v.includes("wsl");
+  } catch {
+    return false;
+  }
+}
+
+export {
+  isWSL
+};

package/dist/chunk-IIYMGLV4.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+
+// src/store.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  renameSync,
+  rmSync,
+  statSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  notify: { os: true, slack: null },
+  minNotifyUSD: 0,
+  costLabel: "api_equivalent",
+  fx: { fallbackRate: 150, cacheHours: 12 },
+  includeDailyTotal: true,
+  monthlyBudgetUSD: 0,
+  dashboard: { autoRegenerate: true, autoReloadSec: 30, days: 30 }
+};
+
+// src/store.ts
+var ERROR_LOG_MAX_BYTES = 1024 * 1024;
+function paths() {
+  const home = process.env.CCCN_HOME || join(homedir(), ".ccc-notifier");
+  const cacheDir = join(home, "cache");
+  mkdirSync(home, { recursive: true });
+  mkdirSync(cacheDir, { recursive: true });
+  return {
+    home,
+    configFile: join(home, "config.json"),
+    historyFile: join(home, "history.jsonl"),
+    cursorsFile: join(home, "cursors.json"),
+    cacheDir,
+    errorLog: join(home, "error.log"),
+    lastNotifyFile: join(home, "last-notify.json"),
+    muteFile: join(home, "muted.json")
+  };
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeConfig(partial) {
+  const result = structuredClone(DEFAULT_CONFIG);
+  if (!isPlainObject(partial)) return result;
+  if (isPlainObject(partial.notify)) {
+    if ("os" in partial.notify) {
+      result.notify.os = partial.notify.os;
+    }
+    if ("slack" in partial.notify) {
+      result.notify.slack = partial.notify.slack;
+    }
+  }
+  if ("minNotifyUSD" in partial) {
+    result.minNotifyUSD = partial.minNotifyUSD;
+  }
+  if ("costLabel" in partial) {
+    result.costLabel = partial.costLabel;
+  }
+  if (isPlainObject(partial.fx)) {
+    if ("fallbackRate" in partial.fx) {
+      result.fx.fallbackRate = partial.fx.fallbackRate;
+    }
+    if ("cacheHours" in partial.fx) {
+      result.fx.cacheHours = partial.fx.cacheHours;
+    }
+  }
+  if ("includeDailyTotal" in partial) {
+    result.includeDailyTotal = partial.includeDailyTotal;
+  }
+  if ("monthlyBudgetUSD" in partial) {
+    const b = partial.monthlyBudgetUSD;
+    if (typeof b === "number" && Number.isFinite(b) && b >= 0) {
+      result.monthlyBudgetUSD = b;
+    }
+  }
+  if (isPlainObject(partial.dashboard)) {
+    if ("autoRegenerate" in partial.dashboard) {
+      result.dashboard.autoRegenerate = partial.dashboard.autoRegenerate;
+    }
+    if ("autoReloadSec" in partial.dashboard) {
+      result.dashboard.autoReloadSec = partial.dashboard.autoReloadSec;
+    }
+    if ("days" in partial.dashboard) {
+      result.dashboard.days = partial.dashboard.days;
+    }
+  }
+  return result;
+}
+function readConfig() {
+  const p = paths();
+  if (!existsSync(p.configFile)) {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  let raw;
+  try {
+    raw = readFileSync(p.configFile, "utf8");
+  } catch (err) {
+    logError("readConfig", err);
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    logError("readConfig", err);
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  return mergeConfig(parsed);
+}
+function readMuteState() {
+  const p = paths();
+  if (!existsSync(p.muteFile)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(p.muteFile, "utf8"));
+    if (!isPlainObject(parsed) || !("until" in parsed)) return null;
+    const until = parsed.until;
+    if (until === null) return { until: null };
+    if (typeof until === "string" && !Number.isNaN(new Date(until).getTime())) {
+      return { until };
+    }
+    return null;
+  } catch (err) {
+    logError("readMuteState", err);
+    return null;
+  }
+}
+function isMuted(now = /* @__PURE__ */ new Date()) {
+  const state = readMuteState();
+  if (state === null) return false;
+  if (state.until === null) return true;
+  return new Date(state.until).getTime() > now.getTime();
+}
+function writeMuteState(state) {
+  writeFileSync(paths().muteFile, `${JSON.stringify(state)}
+`, "utf8");
+}
+function clearMuteState() {
+  rmSync(paths().muteFile, { force: true });
+}
+function loadCursor(transcriptPath) {
+  const p = paths();
+  if (!existsSync(p.cursorsFile)) return null;
+  let raw;
+  try {
+    raw = readFileSync(p.cursorsFile, "utf8");
+  } catch (err) {
+    logError("loadCursor", err);
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    logError("loadCursor", err);
+    return null;
+  }
+  if (!isPlainObject(parsed)) {
+    logError("loadCursor", new Error("cursors.json root is not an object"));
+    return null;
+  }
+  const cursor = parsed[transcriptPath];
+  return cursor ?? null;
+}
+function sanitizeCursor(raw) {
+  if (!isPlainObject(raw)) return null;
+  const { offset, lastUuid, lastTs, seenMessageKeys } = 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;
+  if (!Array.isArray(seenMessageKeys)) return null;
+  const keys = [];
+  for (const key of seenMessageKeys) {
+    if (typeof key !== "string") return null;
+    keys.push(key);
+  }
+  return { offset, lastUuid, lastTs, seenMessageKeys: keys };
+}
+function saveCursor(transcriptPath, c) {
+  const p = paths();
+  let dict = {};
+  if (existsSync(p.cursorsFile)) {
+    try {
+      const raw = readFileSync(p.cursorsFile, "utf8");
+      const parsed = JSON.parse(raw);
+      if (isPlainObject(parsed)) {
+        dict = parsed;
+      }
+    } catch (err) {
+      logError("saveCursor", err);
+    }
+  }
+  dict[transcriptPath] = c;
+  const tmpFile = `${p.cursorsFile}.tmp`;
+  writeFileSync(tmpFile, JSON.stringify(dict), "utf8");
+  renameSync(tmpFile, p.cursorsFile);
+}
+function appendTurn(record) {
+  const p = paths();
+  appendFileSync(p.historyFile, JSON.stringify(record) + "\n", "utf8");
+}
+function readTurns(days) {
+  const p = paths();
+  if (!existsSync(p.historyFile)) return [];
+  let raw;
+  try {
+    raw = readFileSync(p.historyFile, "utf8");
+  } catch {
+    return [];
+  }
+  const cutoff = typeof days === "number" ? Date.now() - days * 864e5 : null;
+  const result = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let rec;
+    try {
+      rec = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (cutoff !== null) {
+      const ts = Date.parse(rec.ts);
+      if (!Number.isFinite(ts) || ts < cutoff) continue;
+    }
+    result.push(rec);
+  }
+  return result;
+}
+function todayTotalUSD() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = now.getMonth();
+  const d = now.getDate();
+  let total = 0;
+  for (const rec of readTurns()) {
+    const ts = new Date(rec.ts);
+    if (Number.isNaN(ts.getTime())) continue;
+    if (ts.getFullYear() === y && ts.getMonth() === m && ts.getDate() === d) {
+      total += rec.costUSD;
+    }
+  }
+  return total;
+}
+function currentMonthTotals() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = now.getMonth();
+  let usd = 0;
+  let jpy = 0;
+  let turns = 0;
+  for (const rec of readTurns()) {
+    const ts = new Date(rec.ts);
+    if (Number.isNaN(ts.getTime())) continue;
+    if (ts.getFullYear() === y && ts.getMonth() === m) {
+      const sa = rec.subagents?.costUSD ?? 0;
+      usd += rec.costUSD + sa;
+      jpy += rec.costJPY + sa * rec.fxRate;
+      turns += 1;
+    }
+  }
+  return { usd, jpy, turns };
+}
+function logError(context, err) {
+  try {
+    const p = paths();
+    const iso = (/* @__PURE__ */ new Date()).toISOString();
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    let entry = `[${iso}] [${context}] ${message}
+`;
+    if (stack) {
+      entry += `${stack}
+`;
+    }
+    try {
+      const stat = statSync(p.errorLog);
+      if (stat.size > ERROR_LOG_MAX_BYTES) {
+        renameSync(p.errorLog, `${p.errorLog}.old`);
+      }
+    } catch {
+    }
+    appendFileSync(p.errorLog, entry, "utf8");
+  } catch {
+  }
+}
+
+export {
+  paths,
+  readConfig,
+  readMuteState,
+  isMuted,
+  writeMuteState,
+  clearMuteState,
+  loadCursor,
+  sanitizeCursor,
+  saveCursor,
+  appendTurn,
+  readTurns,
+  todayTotalUSD,
+  currentMonthTotals,
+  logError
+};

package/dist/chunk-KUJZYZSG.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import {
+  clearMuteState,
+  isMuted,
+  readMuteState,
+  writeMuteState
+} from "./chunk-IIYMGLV4.js";
+
+// src/mute.ts
+function parseDuration(arg) {
+  const m = /^(\d+)([mhd])$/.exec(arg);
+  if (!m) return null;
+  const n = Number.parseInt(m[1], 10);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unitMs = m[2] === "m" ? 6e4 : m[2] === "h" ? 36e5 : 864e5;
+  return n * unitMs;
+}
+function fmtMuteUntil(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  const pad = (v) => String(v).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function runMute(args) {
+  const duration = args[0];
+  if (duration === void 0) {
+    writeMuteState({ until: null });
+    console.log("\u901A\u77E5\u3092\u505C\u6B62\u3057\u307E\u3057\u305F(\u7121\u671F\u9650)\u3002\u518D\u958B\u3059\u308B\u306B\u306F ccc-notifier unmute \u3092\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+    console.log("Notifications muted indefinitely. Run `ccc-notifier unmute` to resume.");
+    console.log("\u203B \u30B3\u30B9\u30C8\u306E\u8A18\u9332\u30FB\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u66F4\u65B0\u306F\u7D9A\u304D\u307E\u3059 / cost tracking continues.");
+    return 0;
+  }
+  const ms = parseDuration(duration);
+  if (ms === null) {
+    console.error(`\u671F\u9593\u306E\u5F62\u5F0F\u304C\u4E0D\u6B63\u3067\u3059: ${duration}(\u4F8B: 30m / 2h / 1d)`);
+    console.error(`Invalid duration: ${duration} (examples: 30m / 2h / 1d)`);
+    return 1;
+  }
+  const until = new Date(Date.now() + ms).toISOString();
+  writeMuteState({ until });
+  console.log(`\u901A\u77E5\u3092\u505C\u6B62\u3057\u307E\u3057\u305F(${fmtMuteUntil(until)} \u307E\u3067)\u3002\u305D\u308C\u4EE5\u964D\u306F\u81EA\u52D5\u3067\u518D\u958B\u3057\u307E\u3059\u3002`);
+  console.log(`Notifications muted until ${fmtMuteUntil(until)} (local time), then resume automatically.`);
+  console.log("\u203B \u30B3\u30B9\u30C8\u306E\u8A18\u9332\u30FB\u30C0\u30C3\u30B7\u30E5\u30DC\u30FC\u30C9\u66F4\u65B0\u306F\u7D9A\u304D\u307E\u3059 / cost tracking continues.");
+  return 0;
+}
+function runUnmute() {
+  const state = readMuteState();
+  if (state === null) {
+    console.log("\u901A\u77E5\u306F\u505C\u6B62\u3055\u308C\u3066\u3044\u307E\u305B\u3093(\u30DF\u30E5\u30FC\u30C8\u306A\u3057)\u3002/ Notifications are not muted.");
+    return 0;
+  }
+  const wasActive = isMuted();
+  clearMuteState();
+  if (wasActive) {
+    console.log("\u901A\u77E5\u3092\u518D\u958B\u3057\u307E\u3057\u305F\u3002/ Notifications resumed.");
+  } else {
+    console.log("\u671F\u9650\u5207\u308C\u306E\u30DF\u30E5\u30FC\u30C8\u3092\u524A\u9664\u3057\u307E\u3057\u305F(\u901A\u77E5\u306F\u3059\u3067\u306B\u518D\u958B\u3057\u3066\u3044\u307E\u3059)\u3002/ Cleared an expired mute.");
+  }
+  return 0;
+}
+
+export {
+  fmtMuteUntil,
+  runMute,
+  runUnmute
+};