ccdeck 3.26.5 → 3.27.2

package/src/server/index.mjs

@@ -309,6 +309,39 @@ export function payloadChars(raw) {
   return n;
 }
 
+async function handleLiveRadioMix(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") {
+    return send(res, 200, { ok: true, live: false, off: true });
+  }
+
+  const { fetchLiveRadioMix } = await import(
+    pathToFileURL(join(PKG_ROOT, "src/server/live-radio-mix.mjs")).href
+  );
+  const answer = await fetchLiveRadioMix();
+  send(res, answer ? 200 : 404, answer ?? { ok: false, error: "Radio Mix is not live" });
+}
+
+async function handleBestOfNostalgia(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") return send(res, 200, { ok: true, live: false, off: true });
+  const { fetchBestOfNostalgia } = await import(pathToFileURL(join(PKG_ROOT, "src/server/best-of-nostalgia.mjs")).href);
+  const answer = await fetchBestOfNostalgia();
+  send(res, answer ? 200 : 404, answer ?? { ok: false, error: "Best of Nostalgia is not live" });
+}
+
+async function handleGoodLifeRadio(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") return send(res, 200, { ok: true, live: false, off: true });
+  const { fetchGoodLifeRadio } = await import(pathToFileURL(join(PKG_ROOT, "src/server/good-life-radio.mjs")).href);
+  const answer = await fetchGoodLifeRadio();
+  send(res, answer ? 200 : 404, answer ?? { ok: false, error: "The Good Life Radio is not live" });
+}
+
+async function handleCafeMusicBgm(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") return send(res, 200, { ok: true, live: false, off: true });
+  const { fetchCafeMusicBgm } = await import(pathToFileURL(join(PKG_ROOT, "src/server/cafe-music-bgm.mjs")).href);
+  const answer = await fetchCafeMusicBgm();
+  send(res, answer ? 200 : 404, answer ?? { ok: false, error: "Cafe Music BGM is not live" });
+}
+
 // Where the charge rides. A Symbol key rather than an ordinary field, because
 // the envelope is JSON.stringify'd on the hot path into both the SSE frame and
 // the events.jsonl line, and JSON.stringify ignores symbol-keyed properties
@@ -5828,6 +5861,23 @@ async function handleClaudeFm(req, res) {
   send(res, 200, answer);
 }
 
+async function handleLofiGirl(req, res) {
+  if (process.env.AGENTS_DECK_NO_MUSIC === "1") {
+    return send(res, 200, { ok: true, live: false, off: true });
+  }
+  const url = new URL(req.url, "http://localhost");
+  const station = url.searchParams.get("station");
+  if (!["relax", "game", "vibe", "sleep"].includes(station)) {
+    return send(res, 400, { ok: false, error: "unknown Lofi Girl station" });
+  }
+  const { fetchLofiStations } = await import(
+    pathToFileURL(join(PKG_ROOT, "src/server/lofi-girl.mjs")).href
+  );
+  const stations = await fetchLofiStations();
+  const answer = stations[station];
+  send(res, answer ? 200 : 404, answer ?? { ok: false, error: "station is not live" });
+}
+
 async function handleCodexQuota(req, res) {
   const { fetchCodexQuota } = await import(
     pathToFileURL(join(PKG_ROOT, "src/server/codex-quota.mjs")).href
@@ -6065,10 +6115,49 @@ async function handleClaudeAccountSwitch(req, res) {
       pathToFileURL(join(PKG_ROOT, "src/server/quota.mjs")).href
     );
     invalidateQuotaCache();
+    // Note who became active, and when, for the account-projects report. Best
+    // effort — a failed log write must never fail the switch — so it is not
+    // awaited into the response.
+    import(pathToFileURL(join(PKG_ROOT, "src/server/swap-log.mjs")).href)
+      .then(({ recordSwap }) => recordSwap(parsed.account, "manual"))
+      .catch(() => {});
   }
   send(res, result.ok ? 200 : 400, result);
 }
 
+// The account-projects rollup, started once and shared. Its timer is unref'd
+// inside start(), so holding the instance here never keeps the process alive.
+let _projectRollup = null;
+function getProjectRollup() {
+  if (!_projectRollup) {
+    _projectRollup = import(pathToFileURL(join(PKG_ROOT, "src/server/account-projects.mjs")).href)
+      .then(m => { const r = m.createProjectRollup(); r.start().catch(() => {}); return r; });
+  }
+  return _projectRollup;
+}
+
+/**
+ * The "Projects" report for one account: how many tokens it spent per project
+ * over a window. The server tallies only tokens (per model); the web side
+ * prices them with its own table, so cost never lives in two places. `num` is
+ * the account's slot, resolved to its `(email, org)` key here; `days` is 7, 30,
+ * or 0 for all tracked.
+ */
+async function handleAccountProjects(req, res) {
+  const url = new URL(req.url, "http://localhost");
+  const num = Number(url.searchParams.get("num"));
+  const d = Number(url.searchParams.get("days"));
+  const days = d === 30 ? 30 : d === 0 ? 0 : 7;
+  if (!Number.isInteger(num) || num <= 0) return send(res, 400, { ok: false, reason: "bad_account" });
+  const { identityForSlot } = await import(pathToFileURL(join(PKG_ROOT, "src/server/swap-log.mjs")).href);
+  const id = await identityForSlot(num);
+  if (!id) return send(res, 400, { ok: false, reason: "bad_account" });
+  const { accountKey } = await import(pathToFileURL(join(PKG_ROOT, "src/server/lan-sync.mjs")).href);
+  const rollup = await getProjectRollup();
+  const report = await rollup.report(accountKey(id.email, id.orgUuid), days);
+  send(res, 200, { ok: true, ...report });
+}
+
 function cswapAdminModule() {
   return import(pathToFileURL(join(PKG_ROOT, "src/server/cswap-admin.mjs")).href);
 }
@@ -6176,11 +6265,22 @@ const PINNED_MODULES = [
   "browser-watch.mjs",
   "browser-watch-store.mjs",
   "claude-fm.mjs",
+  "lofi-girl.mjs",
+  "live-radio-mix.mjs",
+  "best-of-nostalgia.mjs",
+  "good-life-radio.mjs",
+  "cafe-music-bgm.mjs",
   // system-metrics.mjs's two, on the platforms that have them, and the one
   // installer.mjs reaches for while it rewrites the hooks.
   "macmon.mjs",
   "hwmonitor.mjs",
   "retire-sound-hook.mjs",
+  // The account-projects report: the rollup and the swap log its attribution
+  // reads, plus lan-sync for the account key — all reached only through
+  // import() from the report's route.
+  "account-projects.mjs",
+  "swap-log.mjs",
+  "lan-sync.mjs",
 ];
 
 let _pinned = null;
@@ -7127,6 +7227,9 @@ const GUARDED_READS = new Set([
   "/api/browser-watch",
   "/api/lan",
   "/api/prefs",
+  // Per-account, per-project token spend — the user's own work, the same class
+  // of secret as the accounts list it hangs off.
+  "/api/account-projects",
 ]);
 
 function isAuthorizedMutation(req) {
@@ -7483,6 +7586,7 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     if (req.method === "GET"  && url.pathname === "/api/browser-watch") return guard(handleBrowserWatch(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/browser-watch") return guard(handleBrowserWatchSettings(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/browser-watch/dismiss") return guard(handleBrowserWatchDismiss(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/account-projects") return guard(handleAccountProjects(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/claude-accounts") return guard(handleClaudeAccounts(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/claude-accounts/switch") return guard(handleClaudeAccountSwitch(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/claude-accounts/login")  return guard(handleAccountLoginState(req, res), res);
@@ -7490,6 +7594,11 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     if (req.method === "GET"  && url.pathname === "/api/cswap-auto")  return guard(handleCswapAuto(req, res), res);
     if (req.method === "POST" && url.pathname === "/api/cswap-auto")  return guard(handleCswapAutoAction(req, res), res);
     if (req.method === "GET"  && url.pathname === "/api/claude-fm")   return guard(handleClaudeFm(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/lofi-girl")   return guard(handleLofiGirl(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/live-radio-mix") return guard(handleLiveRadioMix(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/best-of-nostalgia") return guard(handleBestOfNostalgia(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/good-life-radio") return guard(handleGoodLifeRadio(req, res), res);
+    if (req.method === "GET"  && url.pathname === "/api/cafe-music-bgm") return guard(handleCafeMusicBgm(req, res), res);
 
     // Through writeJsonArray rather than `send`, and through `guard` like every
     // route above it: this is the one answer whose size is the ring's size, and
@@ -7603,6 +7712,11 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
       // being installed or upgraded underneath them (#1043) — null from every
       // caller with nothing to wait for.
       cswapAutoModule().then(m => m.initCswapAuto({ after: cswapQuiet })).catch(() => {});
+      // The account-projects rollup: fold Claude transcripts into a per-account,
+      // per-project token tally, incrementally. Claude only — it reads Claude
+      // transcripts — best effort, and its timer is unref'd so it never holds
+      // the process open.
+      if (claude) getProjectRollup().catch(() => {});
       return server;
     } catch (err) {
       lastErr = err;

package/src/server/live-radio-mix.mjs

@@ -0,0 +1,56 @@
+const RADIO_MIX_URL = "https://www.youtube.com/@liveradiomix";
+const CACHE_MS = 600_000;
+const MISS_CACHE_MS = 60_000;
+const READ_LIMIT = 2_000_000;
+const TIMEOUT_MS = 6_000;
+const BROWSER_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+
+let cache = null;
+let cacheAt = 0;
+let cacheTtl = 0;
+let inflight = null;
+
+function currentLiveVideo(html) {
+  const live = html.indexOf('"liveBadgeText":"LIVE"');
+  if (live < 0) return null;
+  const window = html.slice(Math.max(0, live - 2_000), live + 2_000);
+  return window.match(/"videoId":"([\w-]{11})"/)?.[1] ?? null;
+}
+
+export async function fetchLiveRadioMix({ fetchImpl } = {}) {
+  const now = Date.now();
+  if (cache && now - cacheAt < cacheTtl) return cache;
+  if (inflight) return inflight;
+  const get = fetchImpl ?? fetch;
+  inflight = (async () => {
+    try {
+      const response = await get(RADIO_MIX_URL, {
+        headers: { "User-Agent": BROWSER_UA, "Accept-Language": "en-US,en;q=0.9" },
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+        redirect: "follow",
+      });
+      if (!response.ok) return settle(null);
+      const video = currentLiveVideo((await response.text()).slice(0, READ_LIMIT));
+      return settle(video ? { id: "radio-mix", label: "Radio Mix — Live", video } : null);
+    } catch {
+      return settle(null);
+    } finally {
+      inflight = null;
+    }
+  })();
+  return inflight;
+}
+
+function settle(value) {
+  cache = value;
+  cacheAt = Date.now();
+  cacheTtl = value ? CACHE_MS : MISS_CACHE_MS;
+  return value;
+}
+
+export function forgetLiveRadioMix() {
+  cache = null;
+  cacheAt = 0;
+  cacheTtl = 0;
+  inflight = null;
+}

package/src/server/lofi-girl.mjs

@@ -0,0 +1,76 @@
+const LOFI_GIRL_URL = "https://www.youtube.com/@LofiGirl";
+const CACHE_MS = 600_000;
+const MISS_CACHE_MS = 60_000;
+const READ_LIMIT = 2_000_000;
+const TIMEOUT_MS = 6_000;
+const BROWSER_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36";
+
+export const LOFI_STATIONS = {
+  relax: { label: "Lofi Girl — relax/study" , terms: ["relax/study"] },
+  game: { label: "Lofi Girl — chill/game", terms: ["chill/game"] },
+  vibe: { label: "Lofi Girl — vibe/chill", terms: ["vibe/chill"] },
+  sleep: { label: "Lofi Girl — sleep/chill", terms: ["sleep/chill"] },
+};
+
+let cache = null;
+let cacheAt = 0;
+let cacheTtl = 0;
+let inflight = null;
+
+function stationVideo(html, terms) {
+  for (const term of terms) {
+    const index = html.toLowerCase().indexOf(term);
+    if (index < 0) continue;
+    const start = Math.max(0, index - 4_000);
+    const window = html.slice(start, index + 4_000);
+    const ids = [...window.matchAll(/"videoId":"([\w-]{11})"/g)];
+    if (ids.length) {
+      ids.sort((a, b) => Math.abs(start + a.index - index) - Math.abs(start + b.index - index));
+      return ids[0][1];
+    }
+  }
+  return null;
+}
+
+export async function fetchLofiStations({ fetchImpl } = {}) {
+  const now = Date.now();
+  if (cache && now - cacheAt < cacheTtl) return cache;
+  if (inflight) return inflight;
+  const get = fetchImpl ?? fetch;
+  inflight = (async () => {
+    try {
+      const response = await get(LOFI_GIRL_URL, {
+        headers: { "User-Agent": BROWSER_UA, "Accept-Language": "en-US,en;q=0.9" },
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+        redirect: "follow",
+      });
+      if (!response.ok) return settle({});
+      const html = (await response.text()).slice(0, READ_LIMIT);
+      const stations = Object.fromEntries(
+        Object.entries(LOFI_STATIONS)
+          .map(([id, station]) => [id, { id, label: station.label, video: stationVideo(html, station.terms) }])
+          .filter(([, station]) => station.video),
+      );
+      return settle(stations);
+    } catch {
+      return settle({});
+    } finally {
+      inflight = null;
+    }
+  })();
+  return inflight;
+}
+
+function settle(value) {
+  cache = value;
+  cacheAt = Date.now();
+  cacheTtl = Object.keys(value).length ? CACHE_MS : MISS_CACHE_MS;
+  return value;
+}
+
+export function forgetLofiStations() {
+  cache = null;
+  cacheAt = 0;
+  cacheTtl = 0;
+  inflight = null;
+}

package/src/server/swap-log.mjs

@@ -0,0 +1,188 @@
+// The timeline of which account was active, and when.
+//
+// Nothing in claude-swap or the deck ever recorded this. sequence.json holds a
+// single `activeAccountNumber` — who is active *now* — and overwrites it on
+// every switch, so the moment a swap happens the previous truth is gone. The
+// account-projects report needs the opposite: a durable, append-only record of
+// "at time T the active account became X", so a transcript message written at
+// some past instant can be attributed to whoever was active *then*.
+//
+// The deck is the one thing that performs a swap (it drives `cswap switch` and
+// the auto tick), so it does not have to reconstruct or guess: it writes one
+// line each time it moves the live account. The past before this file existed
+// is unrecoverable — there is no timestamped history anywhere to mine — so the
+// report is honest only from the first line here onward, and everything earlier
+// is left unattributed.
+//
+// One line per swap, JSON:
+//   { "at": <ms>, "slot": <n>, "email": "...", "orgUuid": "...", "source": "manual"|"auto"|"start" }
+// `source` "start" is the anchor the rollup writes once at boot for whoever is
+// already active, so a machine that never swaps still attributes its work.
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { backupRoot } from "./claude-accounts.mjs";
+
+/** The log the deck appends swaps to. Under ~/.agents-deck like cswap-auto's
+ *  own state, not under the claude-swap store — this is the deck's record, not
+ *  claude-swap's. */
+export function swapLogPath(home = homedir()) {
+  return join(home, ".agents-deck", "log", "account-active.jsonl");
+}
+
+/** Read one JSON value from a file, or null if it is missing or unparseable. */
+async function readJsonSafe(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/** The `(email, organizationUuid)` a slot number points at right now, read from
+ *  claude-swap's sequence.json. Null when the store or the slot is not there. */
+export async function identityForSlot(slot, root = backupRoot()) {
+  const seq = await readJsonSafe(join(root, "sequence.json"));
+  const acc = seq?.accounts?.[String(slot)];
+  if (!acc) return null;
+  return {
+    email: typeof acc.email === "string" ? acc.email : "",
+    orgUuid: typeof acc.organizationUuid === "string" ? acc.organizationUuid : "",
+  };
+}
+
+/** The slot claude-swap says is active right now, or null. */
+export async function currentActiveSlot(root = backupRoot()) {
+  const seq = await readJsonSafe(join(root, "sequence.json"));
+  const n = Number(seq?.activeAccountNumber);
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+/** Parse the log into swap entries sorted oldest-first. A truncated or garbage
+ *  last line (a crash mid-append) is skipped, never fatal. */
+export async function readSwapLog(path = swapLogPath()) {
+  const text = await readFile(path, "utf8").catch(() => "");
+  const out = [];
+  for (const line of text.split("\n")) {
+    if (!line) continue;
+    let obj = null;
+    try { obj = JSON.parse(line); } catch { continue; }
+    if (!obj || typeof obj !== "object") continue;
+    const at = Number(obj.at);
+    if (!Number.isFinite(at)) continue;
+    out.push({
+      at,
+      slot: Number(obj.slot) || 0,
+      email: typeof obj.email === "string" ? obj.email : "",
+      orgUuid: typeof obj.orgUuid === "string" ? obj.orgUuid : "",
+      source: typeof obj.source === "string" ? obj.source : "",
+    });
+  }
+  out.sort((a, b) => a.at - b.at);
+  return out;
+}
+
+/** Append one swap line. Creates the log directory on first use. Best-effort:
+ *  a failure to record must never break a switch, so callers ignore rejection. */
+export async function appendSwap(entry, path = swapLogPath()) {
+  await mkdir(join(path, ".."), { recursive: true });
+  await appendFile(path, JSON.stringify(entry) + "\n", "utf8");
+}
+
+/**
+ * Record that `slot` became the active account, resolving its identity from the
+ * store. `source` says which path moved it. Returns the entry written, or null
+ * when the slot has no identity (nothing worth attributing to).
+ *
+ * Best-effort by contract: every caller sits on a hot path (a click, an auto
+ * tick) that must not fail because a log write did. Errors are swallowed here
+ * so callers can `void recordSwap(...)` without a catch.
+ */
+export async function recordSwap(slot, source, { now = Date.now, root, path } = {}) {
+  try {
+    const store = root ?? backupRoot();
+    // Trust the store's own idea of who is active over a caller-supplied slot
+    // when that slot is missing or malformed — after a switch, sequence.json's
+    // activeAccountNumber is the authoritative new slot, so the auto tick can
+    // record without threading the number through cswap's JSON.
+    let n = Number(slot);
+    if (!Number.isInteger(n) || n <= 0) n = await currentActiveSlot(store);
+    if (!n) return null;
+    const id = await identityForSlot(n, store);
+    if (!id) return null;
+    const entry = { at: now(), slot: n, email: id.email, orgUuid: id.orgUuid, source };
+    await appendSwap(entry, path ?? swapLogPath());
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Seed an anchor for the currently-active account, once, if the log does not
+ * already end on that account. Called at boot so a deck that never swaps still
+ * attributes its work to the account it launched on, and so the very first
+ * upgrade writes a "tracked since" point.
+ *
+ * Deduped against the last entry's `(email, orgUuid)`: a restart on the same
+ * account adds nothing, but a manual switch made while the deck was down (so no
+ * line was written for it) is still captured here on the next boot.
+ */
+export async function seedActive({ now = Date.now, root, path } = {}) {
+  try {
+    const logPath = path ?? swapLogPath();
+    const slot = await currentActiveSlot(root ?? backupRoot());
+    if (!slot) return null;
+    const id = await identityForSlot(slot, root ?? backupRoot());
+    if (!id) return null;
+    const entries = await readSwapLog(logPath);
+    const last = entries[entries.length - 1];
+    if (last && last.email === id.email && last.orgUuid === id.orgUuid) return null;
+    const entry = { at: now(), slot, email: id.email, orgUuid: id.orgUuid, source: "start" };
+    await appendSwap(entry, logPath);
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Which account was active at millisecond `ts`: the last entry at or before it.
+ * Null when `ts` precedes every entry — before tracking began — OR when the
+ * governing entry is a `stop` marker, which the rollup writes to fence off the
+ * time the deck was not running: nothing recorded who was active then, so work
+ * with a timestamp inside a stop→start gap is honestly unattributable rather
+ * than charged to whichever account happened to be active when the deck closed.
+ * `entries` must be sorted oldest-first, as `readSwapLog` returns them.
+ */
+export function accountAtTime(entries, ts) {
+  if (!Array.isArray(entries) || !entries.length) return null;
+  if (ts < entries[0].at) return null;
+  // Binary search for the rightmost entry with at <= ts.
+  let lo = 0, hi = entries.length - 1, ans = 0;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    if (entries[mid].at <= ts) { ans = mid; lo = mid + 1; }
+    else hi = mid - 1;
+  }
+  const e = entries[ans];
+  if (e.source === "stop") return null;   // inside a gap the deck was not running
+  return { email: e.email, orgUuid: e.orgUuid, slot: e.slot };
+}
+
+/** Fence off a stretch of time as "the deck was not running" from `at`, so
+ *  work timestamped after it is unattributed until the next real entry. */
+export async function markGap(at, path = swapLogPath()) {
+  try {
+    await appendSwap({ at, slot: 0, email: "", orgUuid: "", source: "stop" }, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The earliest instant the log covers — what the report shows as "tracked
+ *  since". Null on an empty log. */
+export function trackedSince(entries) {
+  return Array.isArray(entries) && entries.length ? entries[0].at : null;
+}