ccdeck 3.36.7 → 3.36.9

package/dist/web/index.html

@@ -64,7 +64,7 @@
           stored === "light" || (stored !== "dark" && light) ? "light" : "dark");
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-B1ngNkKH.js"></script>
+    <script type="module" crossorigin src="/assets/index-tVBMXvDv.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BkXTN4dZ.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccdeck",
-  "version": "3.36.7",
+  "version": "3.36.9",
   "description": "Local dashboard for Claude Code and Codex CLI sessions: which Claude Code session needs input, every tool call and Claude Code subagent live, token cost and quota, several Claude accounts. Run npx ccdeck.",
   "type": "module",
   "bin": {

package/release-notes.json

@@ -66,7 +66,9 @@
     "3.36.4",
     "3.36.5",
     "3.36.6",
-    "3.36.7"
+    "3.36.7",
+    "3.36.8",
+    "3.36.9"
   ],
   "3.36.3": [
     {

package/src/server/feature-use.mjs

@@ -0,0 +1,42 @@
+// Which features got used today, for the "active" report's `features` (see
+// usage-day.mjs for the list and reports.mjs for what leaves).
+//
+// Two doors in. The page names what it saw opened — a panel shown, a dialog
+// opened — through POST /api/feature, once per name per day (feature-use.ts).
+// The server names what a request did: the routes below are actions somebody
+// takes on purpose, never something a page polls, so the request is the use.
+// Either way only a name off FEATURES is kept, and only as "used today".
+import { readBody, send } from "./http-io.mjs";
+import { usageDay } from "./usage-day.mjs";
+
+/** The requests that are a feature being used. Only actions: a read the page
+ *  makes on its own (the quota, the roster, a radio probe) says nothing about
+ *  what somebody chose to do. */
+const ROUTE_FEATURES = new Map([
+  ["POST /api/claude-accounts/switch", "account-switch"],
+  ["POST /api/claude-accounts/admin", "accounts-manage"],
+  ["POST /api/cswap-auto", "auto-switch"],
+  ["POST /api/lan/invite", "lan-pairing"],
+  ["POST /api/lan/peer", "lan-pairing"],
+  ["POST /api/feedback", "feedback-sent"],
+  ["POST /api/upgrade", "self-update"],
+  ["POST /api/clear", "clear-board"],
+]);
+
+/** Note the feature a request is, if it is one. Called for requests that got
+ *  past the deck's own gates. */
+export function noteRouteFeature(method, pathname) {
+  const name = ROUTE_FEATURES.get(`${method} ${pathname}`);
+  if (name) usageDay.noteFeature(name);
+}
+
+/** POST /api/feature — the page saying it showed or opened something.
+ *  `{ name }`; a name off the list is a 400, and nothing about it is kept. */
+export async function handleFeature(req, res) {
+  const raw = await readBody(req).catch(() => null);
+  let body = null;
+  try { body = JSON.parse(raw ?? ""); } catch { /* handled below */ }
+  const name = typeof body?.name === "string" ? body.name : "";
+  if (!usageDay.noteFeature(name)) return send(res, 400, { ok: false, reason: "unknown_feature" });
+  return send(res, 200, { ok: true });
+}

package/src/server/index.mjs

@@ -63,6 +63,8 @@ import { serveStatic } from "./static-serve.mjs";
 // transcript watch between hook events, and POST /api/forget. See
 // session-tracking.mjs.
 import { handleForget, startOutputWatch } from "./session-tracking.mjs";
+// Which features were used today, for the usage reports — see feature-use.mjs.
+import { handleFeature, noteRouteFeature } from "./feature-use.mjs";
 // Exported from this file before it moved, and still.
 export { HARD_TRACKED_SESSIONS } from "./session-tracking.mjs";
 // The desktop app's update as its window sees it — the state the app reports
@@ -285,6 +287,11 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
       return send(res, 401, { error: "unauthenticated" });
     }
 
+    // A request that is somebody using a feature on purpose — switching an
+    // account, pairing a deck — counts as that feature used today. Past the
+    // gates above, so only the deck's own callers count. See feature-use.mjs.
+    noteRouteFeature(req.method, url.pathname);
+
     // `?persist=0` — another deck was elected to write this event to the log
     // the two of them share. Absent, this deck writes it.
     if (req.method === "POST" && url.pathname === "/api/event") return guard(handleEventIngest(req, res, url.searchParams.get("persist") !== "0"), res);
@@ -387,6 +394,10 @@ export async function startServer({ port = 4317, host = "127.0.0.1", persist = n
     // Above the 404 below, which is what every real route has to be.
     if (req.method === "POST" && url.pathname === "/api/forget") return guard(handleForget(req, res), res);
 
+    // POST /api/feature — the page saying it showed a panel or opened a dialog,
+    // once per name per day. A name, never what was in it. See feature-use.mjs.
+    if (req.method === "POST" && url.pathname === "/api/feature") return guard(handleFeature(req, res), res);
+
     // AN UNMATCHED /api/ PATH IS A 404, not the SPA shell.
     //
     // serveStatic falls back to index.html for a path it cannot find, which is

package/src/server/reports.mjs

@@ -13,7 +13,12 @@
 //     ccdeck gets counted without counting anything else about them, and which
 //     alone also carries coarse counts of how much: how many sessions,
 //     subagents and projects the deck heard from on the last day it was used,
-//     and that day's date — numbers, never their names (see usage-day.mjs),
+//     and that day's date — numbers, never their names (see usage-day.mjs) —
+//     and which of the deck's features were used that day, as fixed names
+//     ("usage-history", "account-switch") and nothing about what was done
+//     with them (feature-use.mjs),
+//   - an "uninstall" event when somebody runs `ccdeck --uninstall`, with the
+//     reason they picked from a short list if they picked one (bin/cli/leaving.js),
 //   - an "activated" event, once, when a new install's first session arrives:
 //     how long after the install it came, as a bucket ("5m", "1h", "1d", "7d",
 //     "later"), and whether it was a Claude or a Codex session (activation.mjs),
@@ -69,7 +74,7 @@ import { reportsVetoed } from "./deck-prefs.mjs";
 import { isGitCheckout } from "./install-layout.mjs";
 import { heldPrefs, prefsRead } from "./prefs-state.mjs";
 import { RUNNING_VERSION } from "./running-version.mjs";
-import { usageDay, utcDay } from "./usage-day.mjs";
+import { FEATURES, usageDay, utcDay } from "./usage-day.mjs";
 import { setupFacts, sinceInstallBucket, whenSetupKnown } from "./activation.mjs";
 
 export const REPORTS_API = "https://api.ccdeck.dev";
@@ -89,6 +94,10 @@ const SAME_ERROR_QUIET_MS = 60 * 60 * 1000;
 const MESSAGE_MAX = 500;
 const STACK_MAX = 4000;
 
+/** Why somebody uninstalled, when they said: the answers `ccdeck --uninstall`
+ *  offers (bin/cli/leaving.js), and nothing else ever leaves as a reason. */
+export const UNINSTALL_REASONS = Object.freeze(["not-useful", "too-noisy", "broken", "other-tool", "privacy", "other"]);
+
 const EMPTY_REPORT = Object.freeze({
   installId: "", lastVersion: "", lastActiveDay: "", forget: "", usage: null,
   installedAt: "", firstSessionAt: "", firstProvider: "", activationSent: false,
@@ -394,6 +403,9 @@ export function createReporter({
       addIf(out, "sessions", count(raw.sessions));
       addIf(out, "subagents", count(raw.subagents));
       addIf(out, "projects", count(raw.projects));
+      // The features used that day, as names off the fixed list — an empty list
+      // is a real answer (the deck ran, nothing was opened), not a missing one.
+      out.features = Array.isArray(raw.features) ? raw.features.filter(f => FEATURES.includes(f)) : [];
       return out;
     } catch {
       return {};
@@ -537,6 +549,33 @@ export function createReporter({
     if (await call("POST", "/v1/app/events", body)) await remember(r.installId, { activationSent: true });
   }
 
+  /** Whether a report would go out right now: reports on, the machine not
+   *  vetoing them, and an install id to send under. `ccdeck --uninstall` asks
+   *  before it asks the person anything. Never throws. */
+  async function willReport() {
+    try {
+      await Promise.resolve(ready).catch(() => {});
+      const p = prefs.current();
+      return reportsOn(p, env) && Boolean(p.report.installId);
+    } catch {
+      return false;
+    }
+  }
+
+  /** The install leaving: `ccdeck --uninstall`, with the reason picked off
+   *  UNINSTALL_REASONS if one was. The id stays: a deck run again later is the
+   *  same install coming back. Resolves to whether it got through; never throws. */
+  async function reportUninstall(reason) {
+    try {
+      if (!(await willReport())) return false;
+      const body = { installId: prefs.current().report.installId, kind: "uninstall", ...factsNow() };
+      addIf(body, "reason", UNINSTALL_REASONS.includes(reason) ? reason : undefined);
+      return await call("POST", "/v1/app/events", body);
+    } catch {
+      return false;
+    }
+  }
+
   /** The first session this run heard, sent the moment it lands rather than at
    *  the next check-in, hours later or on a next launch that may never come. */
   async function onFirstSession() {
@@ -637,7 +676,7 @@ export function createReporter({
     pingTimer = null;
   }
 
-  return { checkIn, ping, setReports, reportError, restoreUsage, saveUsage, sendActivation, start, stop };
+  return { checkIn, ping, setReports, reportError, restoreUsage, saveUsage, sendActivation, willReport, reportUninstall, start, stop };
 }
 
 // ── the deck's own providers ─────────────────────────────────────────────────

package/src/server/usage-day.mjs

@@ -12,7 +12,9 @@
 // WHAT IS KEPT. In memory, the session ids, the subagent ids and the folders the
 // transcripts sit in, so a session heard from a hundred times counts once. They
 // never leave this module: what is saved between runs (prefs.json, beside the
-// install id) and what is sent are three counts and the day they belong to.
+// install id) and what is sent are three counts, the day they belong to, and
+// the names of the features used that day — fixed tokens off FEATURES, a yes
+// for each, never what was done with them.
 //
 // A RESTART MID-DAY. The saved counts come back as a floor and the new run
 // counts on top of them, so a session that was running across the restart is
@@ -24,6 +26,34 @@
 // watches (its first scan skips every file's history). Replayed lines and the
 // deck's own synthetic events are not use.
 
+/**
+ * The features a day can say were used — fixed tokens, never anything a caller
+ * makes up. The page names the ones it sees opened (POST /api/feature, through
+ * feature-use.ts), the server the ones a route or a session shows. A name not on
+ * this list is dropped wherever it comes from.
+ */
+export const FEATURES = Object.freeze([
+  // Panels the page showed that day (each can be closed, and the choice is kept).
+  "usage-panel", "machine-panel", "detail-panel", "accounts-panel",
+  // Dialogs somebody opened.
+  "tool-detail", "session-summary", "context-window", "usage-history", "browser-watch",
+  "feedback", "keyboard-help", "share-accounts", "account-projects", "add-account",
+  "process-list", "lan-setup", "claude-fm",
+  // What the server saw done.
+  "account-switch", "accounts-manage", "auto-switch", "lan-pairing", "feedback-sent",
+  "self-update", "clear-board",
+  // Which CLI the day's sessions came from.
+  "claude-sessions", "codex-sessions",
+]);
+const FEATURE_SET = new Set(FEATURES);
+
+/** Only known feature names, once each, in the list's order. */
+function knownFeatures(list) {
+  if (!Array.isArray(list)) return [];
+  const have = new Set(list.filter(f => FEATURE_SET.has(f)));
+  return FEATURES.filter(f => have.has(f));
+}
+
 /** The day as the reporter says it: the UTC date, "2026-10-01". */
 export function utcDay(date) {
   return date.toISOString().slice(0, 10);
@@ -36,10 +66,13 @@ function whole(n) {
   return Number.isInteger(n) && n >= 0 ? n : 0;
 }
 
-/** Saved totals, coerced: a day and three counts, or null for anything else. */
+/** Saved totals, coerced: a day, three counts and the features used, or null for anything else. */
 function savedTotals(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.day !== "string" || !DAY.test(raw.day)) return null;
-  return { day: raw.day, sessions: whole(raw.sessions), subagents: whole(raw.subagents), projects: whole(raw.projects) };
+  return {
+    day: raw.day, sessions: whole(raw.sessions), subagents: whole(raw.subagents), projects: whole(raw.projects),
+    features: knownFeatures(raw.features),
+  };
 }
 
 /** What prefs.json keeps for this, coerced — deck-prefs.mjs normalises with it. */
@@ -79,10 +112,11 @@ export function createUsageDay({ now = () => new Date() } = {}) {
   function fresh(day, floor = null) {
     return {
       day,
-      floor: floor ?? { sessions: 0, subagents: 0, projects: 0 },
+      floor: floor ?? { sessions: 0, subagents: 0, projects: 0, features: [] },
       sessions: new Set(),
       subagents: new Set(),
       projects: new Set(),
+      features: new Set(),
     };
   }
 
@@ -92,6 +126,7 @@ export function createUsageDay({ now = () => new Date() } = {}) {
       sessions: c.floor.sessions + c.sessions.size,
       subagents: c.floor.subagents + c.subagents.size,
       projects: c.floor.projects + c.projects.size,
+      features: knownFeatures([...c.floor.features, ...c.features]),
     };
   }
 
@@ -118,6 +153,7 @@ export function createUsageDay({ now = () => new Date() } = {}) {
     const c = today();
     add(c.sessions, sid);
     if (typeof raw.agent_id === "string" && raw.agent_id) add(c.subagents, `${sid}\u0000${raw.agent_id}`);
+    add(c.features, raw.provider === "codex" ? "codex-sessions" : "claude-sessions");
     if (!first) {
       first = { at: now().toISOString(), provider: raw.provider === "codex" ? "codex" : "claude" };
       for (const fn of firstListeners) {
@@ -133,6 +169,13 @@ export function createUsageDay({ now = () => new Date() } = {}) {
     add(today().projects, folderOf(path));
   }
 
+  /** A feature somebody used today — a name off FEATURES, or nothing. */
+  function noteFeature(name) {
+    if (!FEATURE_SET.has(name)) return false;
+    add(today().features, name);
+    return true;
+  }
+
   /** A Codex session's working directory, which is its project. */
   function noteFolder(dir) {
     if (!dir || typeof dir !== "string") return;
@@ -187,7 +230,7 @@ export function createUsageDay({ now = () => new Date() } = {}) {
       if (!t) continue;
       const c = today();
       if (t.day === c.day) {
-        c.floor = { sessions: t.sessions, subagents: t.subagents, projects: t.projects };
+        c.floor = { sessions: t.sessions, subagents: t.subagents, projects: t.projects, features: t.features };
       } else if (t.day < c.day && (!done || t.day > done.day)) {
         done = t;
       }
@@ -200,7 +243,7 @@ export function createUsageDay({ now = () => new Date() } = {}) {
     return changes;
   }
 
-  return { noteUse, noteProject, noteFolder, firstUse, onFirstUse, finished, markSent, saved, restore, version };
+  return { noteUse, noteProject, noteFolder, noteFeature, firstUse, onFirstUse, finished, markSent, saved, restore, version };
 }
 
 /** The deck's own tally, which the event pipeline feeds and the reporter reads. */