@buoy-gg/console 7.0.29 → 7.0.30

package/src/store/sanitize.ts

@@ -1,83 +0,0 @@
-/**
- * sanitizeArgs — deep-convert captured console arguments into JSON-safe values.
- *
- * Captured `args` can hold Errors, functions, bigints, symbols, and circular
- * references. Both the external-sync snapshot (device → desktop) and the
- * preserve-log persistence need plain JSON, so this produces a structural copy
- * (objects/arrays preserved so they stay expandable) with cycles broken.
- *
- * Strings are capped: a single `console.log` of a multi-MB payload (API dump,
- * base64, …) used to ride every snapshot uncapped and drop the whole console
- * panel at the 2MB emit budget.
- */
-
-const MAX_DEPTH = 6;
-const MAX_ARRAY = 100;
-const MAX_KEYS = 100;
-
-/** Max chars of one string on the wire / in the persisted buffer. */
-export const SNAPSHOT_STRING_LIMIT = 2 * 1024;
-
-export function capString(
-  value: string,
-  limit: number = SNAPSHOT_STRING_LIMIT,
-): string {
-  if (value.length <= limit) return value;
-  return `${value.slice(0, limit)}… [${value.length - limit} more]`;
-}
-
-function sanitizeValue(value: unknown, depth: number, seen: WeakSet<object>): unknown {
-  if (value === null) return null;
-  // Checked inline rather than through a `const t = typeof value` alias: the
-  // alias does not narrow `value`, so the string branch could not be handed to
-  // a `(s: string)` function without a cast — which is how this file stopped
-  // compiling.
-  if (typeof value === "string") return capString(value);
-  if (typeof value === "boolean") return value;
-  if (typeof value === "number") return Number.isFinite(value) ? value : String(value);
-  if (typeof value === "undefined") return "undefined";
-  if (typeof value === "bigint") return `${String(value)}n`;
-  if (typeof value === "function") {
-    return `ƒ ${(value as { name?: string }).name || "(anonymous)"}`;
-  }
-  if (typeof value === "symbol") return value.toString();
-
-  if (value instanceof Error) {
-    return {
-      name: value.name,
-      message: capString(value.message),
-      stack: value.stack ? capString(value.stack, 4 * 1024) : value.stack,
-    };
-  }
-
-  if (depth >= MAX_DEPTH) return Array.isArray(value) ? "[Array]" : "{…}";
-
-  const obj = value as object;
-  if (seen.has(obj)) return "[Circular]";
-  seen.add(obj);
-
-  try {
-    if (Array.isArray(value)) {
-      const out = value.slice(0, MAX_ARRAY).map((v) => sanitizeValue(v, depth + 1, seen));
-      if (value.length > MAX_ARRAY) out.push(`… ${value.length - MAX_ARRAY} more`);
-      return out;
-    }
-    const out: Record<string, unknown> = {};
-    for (const key of Object.keys(obj).slice(0, MAX_KEYS)) {
-      try {
-        out[key] = sanitizeValue((obj as Record<string, unknown>)[key], depth + 1, seen);
-      } catch {
-        out[key] = "[Unserializable]";
-      }
-    }
-    return out;
-  } finally {
-    seen.delete(obj);
-  }
-}
-
-/** Deep-sanitize an array of console arguments into JSON-safe values. */
-export function sanitizeArgs(args: unknown[]): unknown[] {
-  const seen = new WeakSet<object>();
-  return args.map((arg) => sanitizeValue(arg, 0, seen));
-}

package/src/sync/consoleSyncAdapter.ts

@@ -1,115 +0,0 @@
-/**
- * consoleSyncAdapter — streams captured console entries from the device to the
- * desktop dashboard via @buoy-gg/external-sync.
- *
- * Structurally matches external-sync's `ToolSyncAdapter` WITHOUT importing the
- * package (so console has no hard dependency on external-sync, matching how the
- * other tools' adapters are written). Auto-discovery in @buoy-gg/core picks it
- * up by the export name and announces the "console" capability.
- *
- * Snapshots MUST be JSON-serializable. Captured `args` can hold Errors,
- * functions, bigints, and circular references, so we deep-sanitize them into
- * plain JSON values (objects/arrays preserved so they stay expandable on the
- * dashboard). Oversized strings and the pre-rendered `message` are capped so
- * a single fat `console.log` cannot drop the whole panel at the 2MB emit
- * budget; the on-device store keeps the raw args.
- */
-
-import {
-  subscribe,
-  getEntries,
-  clearEntries,
-  type ConsoleLogEntry,
-} from "../store/consoleLogStore";
-import { approxJsonSize } from "@buoy-gg/shared-ui";
-import { capString, sanitizeArgs } from "../store/sanitize";
-
-interface ConsoleSnapshot {
-  entries: ConsoleLogEntry[];
-}
-
-/** Soft cap so a burst of fat logs still fits under the 2MB emit budget. */
-const MAX_SNAPSHOT_BYTES = 1.5 * 1024 * 1024;
-/** One entry's args/message after string caps; fatter args collapse to a stub. */
-const MAX_ENTRY_BYTES = 16 * 1024;
-
-const ARGS_OMITTED = Object.freeze({
-  __buoyTruncated: true,
-  note: "Log payload omitted — inspect it on-device.",
-});
-
-interface WireEntry {
-  entry: ConsoleLogEntry;
-  bytes: number;
-}
-
-/**
- * Per-entry wire cache. A captured entry is never mutated — the store only
- * appends and trims — so keying on identity is correct and self-invalidating.
- *
- * This is the whole cost of the tool. `sanitizeArgs` deep-copies every arg to
- * make it JSON-safe, and without a cache that copy is redone for all 1000
- * entries on every snapshot, ~5x/sec: measured at 12.6ms per tick on ordinary
- * object logs, and it was that expensive BEFORE any of the size guards
- * existed. Converting each entry once removes it from the hot path entirely.
- */
-const wireCache = new WeakMap<ConsoleLogEntry, WireEntry>();
-
-function toWireEntry(entry: ConsoleLogEntry): WireEntry {
-  const cached = wireCache.get(entry);
-  if (cached) return cached;
-
-  const wired: ConsoleLogEntry = {
-    ...entry,
-    args: sanitizeArgs(entry.args),
-    message: capString(entry.message),
-    stack: entry.stack ? capString(entry.stack, 4 * 1024) : entry.stack,
-  };
-  // One walk decides both "is this entry too fat" and what it costs the
-  // snapshot budget — the previous code walked every entry twice.
-  const size = approxJsonSize(wired, MAX_ENTRY_BYTES);
-  const result: WireEntry =
-    size.bytes <= MAX_ENTRY_BYTES
-      ? { entry: wired, bytes: size.bytes }
-      : (() => {
-          const stub = { ...wired, args: [ARGS_OMITTED] };
-          return {
-            entry: stub,
-            bytes: approxJsonSize(stub, MAX_ENTRY_BYTES).bytes,
-          };
-        })();
-  wireCache.set(entry, result);
-  return result;
-}
-
-function newestFitting(entries: ConsoleLogEntry[]): ConsoleLogEntry[] {
-  const out: ConsoleLogEntry[] = [];
-  let bytes = 16; // {"entries":[]}
-  for (let i = entries.length - 1; i >= 0; i--) {
-    const wired = toWireEntry(entries[i]);
-    if (bytes + wired.bytes > MAX_SNAPSHOT_BYTES && out.length > 0) break;
-    out.push(wired.entry);
-    bytes += wired.bytes;
-  }
-  out.reverse();
-  return out;
-}
-
-export const consoleSyncAdapter = {
-  version: 1,
-
-  getSnapshot(): ConsoleSnapshot {
-    return { entries: newestFitting(getEntries()) };
-  },
-
-  subscribe(onChange: () => void): () => void {
-    return subscribe(onChange);
-  },
-
-  actions: {
-    clearEntries(): { cleared: true } {
-      clearEntries();
-      return { cleared: true };
-    },
-  },
-};