@promptctl/cc-candybar 1.42.1 → 1.43.0

package/src/daemon/cache/watchers.ts

@@ -1,249 +0,0 @@
-import fs from "node:fs";
-import { debug } from "../../utils/logger";
-
-// Logger callable used for watcher lifecycle / failure events. Daemon
-// injects `dlog` (writes to daemon.log at the requested level); other
-// consumers (var-system tests, demo) take the default which routes
-// through `debug` — present-but-quiet unless CC_CANDYBAR_DEBUG is set.
-// [LAW:no-defensive-null-guards] Default is always non-null; injection
-// replaces the implementation, never adds a "no logger" mode.
-export type WatcherLogger = (
-  level: "info" | "warn" | "error",
-  message: string,
-) => void;
-
-const defaultLogger: WatcherLogger = (_level, message) => debug(message);
-
-// [LAW:single-enforcer] One registry owns *all* fs watchers for any consumer
-// (git cache, config cache, ...). Scattered watchers across modules would leak
-// FDs and miss cleanup at shutdown.
-
-// [LAW:one-source-of-truth] Exported: the invalidation-debounce floor is the
-// single source consumers derive from (e.g. the load harness's git-churn
-// interval must sit above it). Restating "50" anywhere else would let the two
-// drift silently.
-export const DEBOUNCE_MS = 50;
-const DEFAULT_MAX_WATCHERS = 128;
-
-// Absolute filesystem paths the consumer wants invalidation for.
-// `files`: regular files (existence required to watch).
-// `dirs`: directories. Each may optionally restrict which child filenames
-//   should fire — without a filter every change in the dir fires (legacy
-//   git-refs behavior); with a filter only matching basenames fire (config
-//   case: avoids noise from sibling files in ~/.claude/).
-export interface DirTarget {
-  path: string;
-  // If set, only fire when fs.watch reports a filename in this list.
-  // Filenames are basenames (not paths) — that's what fs.watch supplies.
-  filenames?: readonly string[];
-}
-
-export interface WatchTargets {
-  files: readonly string[];
-  dirs: readonly DirTarget[];
-}
-
-interface WatcherSlot {
-  key: string;
-  watchers: fs.FSWatcher[];
-  refcount: number;
-  debounceTimer: NodeJS.Timeout | null;
-  onInvalidate: () => void;
-  targets: WatchTargets;
-  // Last-seen accessed-at, so LRU eviction picks the staler one.
-  lastTouched: number;
-}
-
-export interface WatcherHandle {
-  release(): void;
-}
-
-export interface WatcherCounters {
-  watchersOpened: number;
-  watchersClosed: number;
-  watchersEvicted: number;
-}
-
-export class WatcherRegistry {
-  private readonly slots = new Map<string, WatcherSlot>();
-  private readonly maxWatchers: number;
-  private readonly counters?: WatcherCounters;
-  private readonly logger: WatcherLogger;
-  private closed = false;
-
-  constructor(
-    opts: {
-      maxWatchers?: number;
-      counters?: WatcherCounters;
-      // [LAW:single-enforcer] One injection point per consumer. The daemon
-      // passes `dlog` so watcher-failure events land in daemon.log; non-
-      // daemon consumers keep the default debug-routed logger and never
-      // touch daemon log files.
-      logger?: WatcherLogger;
-    } = {},
-  ) {
-    this.maxWatchers = opts.maxWatchers ?? DEFAULT_MAX_WATCHERS;
-    this.counters = opts.counters;
-    this.logger = opts.logger ?? defaultLogger;
-  }
-
-  // Acquire (or share) a watcher set keyed by `key`. Multiple acquires on the
-  // same key share a single underlying FSWatcher set; refcount tracks active
-  // consumers. Subsequent acquires *replace* onInvalidate so the latest
-  // consumer's callback is the one that fires — by design, callers funnel into
-  // a single cache module whose callback is a stable closure over the cache map.
-  // `targets` from the first acquire wins; subsequent acquires keep the
-  // original target set (consumers must use a fresh key if they need different
-  // targets).
-  acquire(
-    key: string,
-    targets: WatchTargets,
-    onInvalidate: () => void,
-  ): WatcherHandle {
-    if (this.closed) {
-      // Registry already shut down; return a no-op handle so callers don't
-      // crash mid-shutdown.
-      return { release: () => {} };
-    }
-
-    const existing = this.slots.get(key);
-    if (existing) {
-      existing.refcount++;
-      existing.onInvalidate = onInvalidate;
-      existing.lastTouched = Date.now();
-      // LRU bump.
-      this.slots.delete(key);
-      this.slots.set(key, existing);
-      return this.makeHandle(key);
-    }
-
-    const slot: WatcherSlot = {
-      key,
-      watchers: [],
-      refcount: 1,
-      debounceTimer: null,
-      onInvalidate,
-      targets,
-      lastTouched: Date.now(),
-    };
-    this.openWatchers(slot);
-    this.slots.set(key, slot);
-    if (this.counters) this.counters.watchersOpened++;
-    this.evictIfNeeded();
-    return this.makeHandle(key);
-  }
-
-  private makeHandle(key: string): WatcherHandle {
-    let released = false;
-    return {
-      release: () => {
-        if (released) return;
-        released = true;
-        const slot = this.slots.get(key);
-        if (!slot) return;
-        slot.refcount = Math.max(0, slot.refcount - 1);
-        if (slot.refcount === 0) {
-          this.closeSlot(slot);
-          this.slots.delete(key);
-        }
-      },
-    };
-  }
-
-  private openWatchers(slot: WatcherSlot): void {
-    const fire = () => {
-      if (slot.debounceTimer) return; // already pending
-      slot.debounceTimer = setTimeout(() => {
-        slot.debounceTimer = null;
-        try {
-          slot.onInvalidate();
-        } catch (e) {
-          this.logger(
-            "warn",
-            `watcher invalidate threw: ${(e as Error).message}`,
-          );
-        }
-      }, DEBOUNCE_MS);
-      slot.debounceTimer.unref();
-    };
-
-    for (const target of slot.targets.files) {
-      try {
-        const w = fs.watch(target, { persistent: false }, fire);
-        w.on("error", (e) => {
-          this.logger("warn", `watcher error ${target}: ${e.message}`);
-        });
-        slot.watchers.push(w);
-      } catch (e) {
-        this.logger("warn", `watch failed ${target}: ${(e as Error).message}`);
-      }
-    }
-
-    for (const target of slot.targets.dirs) {
-      try {
-        const filterSet = target.filenames ? new Set(target.filenames) : null;
-        const onDirEvent = (_evt: string, filename: string | null) => {
-          // [LAW:dataflow-not-control-flow] Filter is a value (Set) — same
-          // code path every event; the Set's .has() decides whether to fire.
-          if (filterSet && (!filename || !filterSet.has(filename))) return;
-          fire();
-        };
-        const w = fs.watch(target.path, { persistent: false }, onDirEvent);
-        w.on("error", (e) => {
-          this.logger("warn", `watcher error ${target.path}: ${e.message}`);
-        });
-        slot.watchers.push(w);
-      } catch (e) {
-        this.logger(
-          "warn",
-          `watch failed ${target.path}: ${(e as Error).message}`,
-        );
-      }
-    }
-  }
-
-  private closeSlot(slot: WatcherSlot): void {
-    if (slot.debounceTimer) {
-      clearTimeout(slot.debounceTimer);
-      slot.debounceTimer = null;
-    }
-    for (const w of slot.watchers) {
-      try {
-        w.close();
-      } catch {}
-    }
-    slot.watchers = [];
-    if (this.counters) this.counters.watchersClosed++;
-  }
-
-  private evictIfNeeded(): void {
-    while (this.slots.size > this.maxWatchers) {
-      // Map iteration order = insertion order = LRU order (we re-insert on
-      // access).
-      const oldest = this.slots.keys().next().value;
-      if (oldest === undefined) break;
-      const slot = this.slots.get(oldest)!;
-      this.closeSlot(slot);
-      this.slots.delete(oldest);
-      if (this.counters) this.counters.watchersEvicted++;
-      // Force the consumer to drop their entry too — without this the cache
-      // would keep stale data with no watcher behind it.
-      try {
-        slot.onInvalidate();
-      } catch {}
-      this.logger("info", `watcher LRU evict ${oldest}`);
-    }
-  }
-
-  size(): number {
-    return this.slots.size;
-  }
-
-  closeAll(): void {
-    this.closed = true;
-    for (const slot of this.slots.values()) {
-      this.closeSlot(slot);
-    }
-    this.slots.clear();
-  }
-}

package/src/daemon/client-debug.ts

@@ -1,120 +0,0 @@
-// [LAW:single-enforcer] The `vars` / `segments` / `config` CLIs are ONE behavior
-// — fetch a debug snapshot from the running daemon and render it — parameterized
-// by `what`, not three commands. The daemon's `debug` protocol message is the
-// single introspection authority (src/daemon/debug.ts produces DebugSnapshot);
-// this is its client binding, the mirror of client-stats.ts. Like daemon-stats,
-// it does NOT spawn a daemon: introspecting a dead daemon is meaningless.
-
-import process from "node:process";
-import { describeFailure, requestOutcome } from "./client-transport";
-import type { RoundTripBudgets, RoundTripOutcome } from "./client-transport";
-import type {
-  DebugSnapshot,
-  DebugWhat,
-  SegmentSnapshot,
-  VarSnapshot,
-} from "./debug-types";
-import type { DslConfig } from "../config/dsl-types";
-
-// Operator-driven introspection path: legitimately slower budgets than the
-// render hot path, carried as this caller's values through the shared
-// round-trip in ./client-transport. [LAW:dataflow-not-control-flow]
-const BUDGETS: RoundTripBudgets = { connectMs: 200, budgetMs: 500 };
-
-// `cc-candybar <vars|segments|config> [--json]` — `what` selects the projection.
-export async function runDebug(
-  what: DebugWhat,
-  args: readonly string[],
-): Promise<void> {
-  const wantJson = args.includes("--json");
-
-  const outcome = await fetchDebug(what);
-  if (outcome.kind !== "ok") {
-    process.stderr.write(`${what}: ${describeFailure(outcome)}\n`);
-    process.exit(1);
-  }
-
-  if (wantJson) {
-    process.stdout.write(JSON.stringify(outcome.value, null, 2) + "\n");
-    return;
-  }
-
-  process.stdout.write(formatDebug(outcome.value));
-}
-
-function fetchDebug(what: DebugWhat): Promise<RoundTripOutcome<DebugSnapshot>> {
-  // [LAW:no-defensive-null-guards] exception: trust boundary. The response is
-  // an unchecked cast from socket JSON; the presence check is the explicit
-  // narrowing at the wire edge (an ok response without `debug` classifies as
-  // permanent/malformed_response in the transport).
-  return requestOutcome({ kind: "debug", what }, BUDGETS, (resp) =>
-    "debug" in resp ? resp.debug : undefined,
-  );
-}
-
-// [LAW:types-are-the-program] One total fold over the DebugSnapshot union; each
-// arm renders its own shape. The switch is exhaustive (the `never` default makes
-// a new `what` a compile error here), so the renderer can never fall out of
-// lockstep with the protocol's `what` set — the projection is residue of the
-// union, not a hand-maintained dispatch.
-export function formatDebug(s: DebugSnapshot): string {
-  switch (s.what) {
-    case "vars":
-      return formatVars(s.vars);
-    case "segments":
-      return formatSegments(s.segments);
-    case "config":
-      return formatConfig(s.config);
-    default: {
-      const _exhaustive: never = s;
-      return _exhaustive;
-    }
-  }
-}
-
-function formatVars(vars: readonly VarSnapshot[]): string {
-  if (vars.length === 0) return "no variables (DSL not active)\n";
-  const lines: string[] = [`variables (${vars.length})`, ``];
-  const nameW = vars.reduce((w, v) => Math.max(w, v.name.length), 4);
-  const srcW = vars.reduce((w, v) => Math.max(w, (v.source ?? "—").length), 6);
-  for (const v of vars) {
-    const age = v.ageMs === null ? "" : `  ${fmtAge(v.ageMs)}`;
-    const err = v.lastError ? `  ✗ ${v.lastError.message}` : "";
-    lines.push(
-      `  ${v.name.padEnd(nameW)}  ${(v.source ?? "—").padEnd(srcW)}  ${v.type.padEnd(7)}  ${fmtValue(v.value)}${age}${err}`,
-    );
-  }
-  return lines.join("\n") + "\n";
-}
-
-function formatSegments(segments: readonly SegmentSnapshot[]): string {
-  if (segments.length === 0) return "no segments (DSL not active)\n";
-  const lines: string[] = [`segments (${segments.length})`, ``];
-  for (const seg of segments) {
-    lines.push(`  ${seg.name}`);
-    lines.push(`    template  ${seg.template}`);
-    if (seg.referencedVars.length > 0) {
-      lines.push(`    vars      ${seg.referencedVars.join(", ")}`);
-    }
-    if (seg.lastRender !== null) {
-      lines.push(`    last      ${seg.lastRender}`);
-    }
-  }
-  return lines.join("\n") + "\n";
-}
-
-function formatConfig(config: DslConfig | null): string {
-  if (config === null) return "config: DSL not active\n";
-  return JSON.stringify(config, null, 2) + "\n";
-}
-
-function fmtValue(v: unknown): string {
-  const s = typeof v === "string" ? v : JSON.stringify(v);
-  return s.length > 60 ? s.slice(0, 57) + "…" : s;
-}
-
-function fmtAge(ms: number): string {
-  if (ms < 1000) return `${ms}ms`;
-  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
-  return `${Math.floor(ms / 60_000)}m`;
-}

package/src/daemon/client-stats.ts

@@ -1,130 +0,0 @@
-import process from "node:process";
-import { describeFailure, requestOutcome } from "./client-transport";
-import type { RoundTripBudgets, RoundTripOutcome } from "./client-transport";
-import type { StatsSnapshot } from "./stats";
-
-// Operator-driven introspection path: legitimately slower budgets than the
-// render hot path, carried as this caller's values through the shared
-// round-trip in ./client-transport. [LAW:dataflow-not-control-flow]
-const BUDGETS: RoundTripBudgets = { connectMs: 200, budgetMs: 500 };
-
-// Query the running daemon for stats. Does NOT spawn a daemon — stats on a
-// dead daemon is meaningless. Exits non-zero on failure with a clear message.
-export async function runDaemonStats(args: readonly string[]): Promise<void> {
-  const wantJson = args.includes("--json");
-
-  const outcome = await fetchStats();
-  if (outcome.kind !== "ok") {
-    process.stderr.write(`daemon-stats: ${describeFailure(outcome)}\n`);
-    process.exit(1);
-  }
-
-  if (wantJson) {
-    process.stdout.write(JSON.stringify(outcome.value, null, 2) + "\n");
-    return;
-  }
-
-  process.stdout.write(formatStats(outcome.value));
-}
-
-function fetchStats(): Promise<RoundTripOutcome<StatsSnapshot>> {
-  // [LAW:no-defensive-null-guards] exception: trust boundary. The response is
-  // an unchecked cast from socket JSON; the presence check is the explicit
-  // narrowing at the wire edge (an ok response without `stats` classifies as
-  // permanent/malformed_response in the transport).
-  return requestOutcome({ kind: "stats" }, BUDGETS, (resp) =>
-    "stats" in resp ? resp.stats : undefined,
-  );
-}
-
-function fmtBytes(n: number): string {
-  if (n < 1024) return `${n}B`;
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
-  return `${(n / 1024 / 1024).toFixed(1)}MB`;
-}
-
-function fmtRate(hits: number, misses: number): string {
-  const total = hits + misses;
-  if (total === 0) return "n/a";
-  return `${((hits / total) * 100).toFixed(1)}%`;
-}
-
-function fmtUptime(sec: number): string {
-  if (sec < 60) return `${sec}s`;
-  if (sec < 3600) return `${Math.floor(sec / 60)}m${sec % 60}s`;
-  const h = Math.floor(sec / 3600);
-  const m = Math.floor((sec % 3600) / 60);
-  return `${h}h${m}m`;
-}
-
-export function formatStats(s: StatsSnapshot): string {
-  const lines: string[] = [];
-  lines.push(`cc-candybar daemon stats`);
-  lines.push(``);
-  lines.push(`process`);
-  lines.push(`  pid           ${s.pid}`);
-  lines.push(`  version       ${s.version}`);
-  lines.push(`  protocol      ${s.protocolVersion}`);
-  lines.push(`  startedAt     ${s.startedAt}`);
-  lines.push(`  uptime        ${fmtUptime(s.uptimeSec)}`);
-  lines.push(`  rss           ${fmtBytes(s.rssBytes)}`);
-  lines.push(`  heapUsed      ${fmtBytes(s.heapUsedBytes)}`);
-  lines.push(`  heapTotal     ${fmtBytes(s.heapTotalBytes)}`);
-  lines.push(`  external      ${fmtBytes(s.externalBytes)}`);
-  lines.push(`  arrayBuffers  ${fmtBytes(s.arrayBuffersBytes)}`);
-  lines.push(``);
-  lines.push(`requests`);
-  lines.push(`  total         ${s.requests.total}`);
-  lines.push(`  errored       ${s.requests.errored}`);
-  lines.push(`  timedOut      ${s.requests.timedOut}`);
-  lines.push(`  inFlight      ${s.requests.inFlight}`);
-  lines.push(``);
-  lines.push(`gitCache`);
-  lines.push(`  size          ${s.gitCache.size}`);
-  lines.push(
-    `  hit rate      ${fmtRate(s.gitCache.hits, s.gitCache.misses)} (${s.gitCache.hits} / ${s.gitCache.hits + s.gitCache.misses})`,
-  );
-  lines.push(`  invalidations ${s.gitCache.invalidations}`);
-  lines.push(``);
-  lines.push(`usageCache`);
-  lines.push(`  size          ${s.usageCache.size}`);
-  lines.push(
-    `  hit rate      ${fmtRate(s.usageCache.hits, s.usageCache.misses)} (${s.usageCache.hits} / ${s.usageCache.hits + s.usageCache.misses})`,
-  );
-  lines.push(`  sweeps        ${s.usageCache.sweeps}`);
-  lines.push(``);
-  lines.push(`renderCache`);
-  lines.push(`  size          ${s.renderCache.size}`);
-  lines.push(`watchers`);
-  lines.push(`  active        ${s.watchers.active}`);
-  lines.push(`  opened        ${s.watchers.opened}`);
-  lines.push(`  closed        ${s.watchers.closed}`);
-  lines.push(`  evicted       ${s.watchers.evicted}`);
-  lines.push(``);
-  lines.push(`subprocesses`);
-  lines.push(`  total         ${s.subprocesses.total}`);
-  lines.push(`  inFlight      ${s.subprocesses.inFlight}`);
-  lines.push(`  lastMinute    ${s.subprocesses.lastMinute}`);
-  // Snapshot already includes only executed categories (stats.ts:
-  // snapshotSubprocesses keeps byCategory and the histograms symmetric).
-  const activeCats = Object.entries(s.subprocesses.byCategory);
-  // [LAW:dataflow-not-control-flow] Column width is a function of the data,
-  // not a hardcoded constant that drifts when new categories are added. The
-  // padEnd(13) baseline matches the "  pid           " etc. columns above so
-  // short categories still line up; longer ones expand the column.
-  const colWidth = activeCats.reduce((w, [cat]) => Math.max(w, cat.length), 13);
-  for (const [cat, n] of activeCats) {
-    const p50 = s.subprocesses.p50DurationMs[cat];
-    const p99 = s.subprocesses.p99DurationMs[cat];
-    const timing =
-      p50 !== undefined && p99 !== undefined
-        ? `  (p50 ${p50}ms · p99 ${p99}ms)`
-        : "";
-    lines.push(`  ${cat.padEnd(colWidth)} ${n}${timing}`);
-  }
-  if (s.nextRestartReason) {
-    lines.push(``);
-    lines.push(`nextRestart    ${s.nextRestartReason}`);
-  }
-  return lines.join("\n") + "\n";
-}