feat(expo): console collector with sentinel-guarded patching

Author: Ripwords

packages/expo/src/collectors/console.test.ts

@@ -0,0 +1,58 @@
+import { test, expect, beforeEach, afterEach } from "bun:test"
+import { createConsoleCollector } from "./console"
+
+let originalConsole: typeof console
+
+beforeEach(() => {
+  originalConsole = { ...console }
+})
+
+afterEach(() => {
+  Object.assign(console, originalConsole)
+})
+
+test("patches console.log and records the call", () => {
+  const c = createConsoleCollector({ max: 10 })
+  c.start()
+  console.log("hi", 1)
+  const entries = c.snapshot()
+  expect(entries).toHaveLength(1)
+  expect(entries[0]?.level).toBe("log")
+  expect(entries[0]?.args).toEqual(["hi", "1"])
+  c.stop()
+})
+
+test("captures stack on warn + error only", () => {
+  const c = createConsoleCollector({ max: 10 })
+  c.start()
+  console.log("no stack")
+  console.warn("with stack")
+  console.error("with stack")
+  const entries = c.snapshot()
+  expect(entries.find((e) => e.level === "log")?.stack).toBeUndefined()
+  expect(entries.find((e) => e.level === "warn")?.stack).toBeDefined()
+  expect(entries.find((e) => e.level === "error")?.stack).toBeDefined()
+  c.stop()
+})
+
+test("stop restores the original console functions", () => {
+  const original = console.log
+  const c = createConsoleCollector({ max: 10 })
+  c.start()
+  expect(console.log).not.toBe(original)
+  c.stop()
+  expect(console.log).toBe(original)
+})
+
+test("fails open if host code throws inside patched log", () => {
+  const c = createConsoleCollector({ max: 10 })
+  c.start()
+  // Stub the ring push to throw — collector must still call through to the original.
+  const originalPush = (c as unknown as { __buf: { push: (v: unknown) => void } }).__buf.push
+  ;(c as unknown as { __buf: { push: (v: unknown) => void } }).__buf.push = () => {
+    throw new Error("boom")
+  }
+  expect(() => console.log("x")).not.toThrow()
+  ;(c as unknown as { __buf: { push: (v: unknown) => void } }).__buf.push = originalPush
+  c.stop()
+})

packages/expo/src/collectors/console.ts

@@ -0,0 +1,83 @@
+import { RingBuffer } from "@reprojs/sdk-utils"
+
+export interface ConsoleEntry {
+  level: "log" | "info" | "warn" | "error" | "debug"
+  ts: number
+  args: string[]
+  stack?: string
+}
+
+const LEVELS = ["log", "info", "warn", "error", "debug"] as const
+const SENTINEL = "__reprojs_patched"
+
+function stringifyArg(v: unknown): string {
+  if (typeof v === "string") return v
+  try {
+    return JSON.stringify(v)
+  } catch {
+    return String(v)
+  }
+}
+
+export interface ConsoleCollector {
+  start: () => void
+  stop: () => void
+  snapshot: () => ConsoleEntry[]
+  clear: () => void
+}
+
+export function createConsoleCollector(opts: { max: number }): ConsoleCollector {
+  const buf = new RingBuffer<ConsoleEntry>(opts.max)
+  const originals: Partial<Record<(typeof LEVELS)[number], (...args: unknown[]) => void>> = {}
+  let started = false
+
+  function start() {
+    if (started) return
+    started = true
+    for (const level of LEVELS) {
+      const existing = console[level] as ((...args: unknown[]) => void) & {
+        [SENTINEL]?: boolean
+      }
+      if (existing?.[SENTINEL]) continue
+      originals[level] = existing
+      const wrapped = ((...args: unknown[]) => {
+        try {
+          buf.push({
+            level,
+            ts: Date.now(),
+            args: args.map(stringifyArg),
+            stack:
+              level === "warn" || level === "error"
+                ? new Error().stack?.split("\n").slice(2).join("\n")
+                : undefined,
+          })
+        } catch {
+          // fail-open
+        }
+        existing.apply(console, args)
+      }) as ((...args: unknown[]) => void) & { [SENTINEL]?: boolean }
+      wrapped[SENTINEL] = true
+      console[level] = wrapped as (typeof console)[typeof level]
+    }
+  }
+
+  function stop() {
+    if (!started) return
+    started = false
+    for (const level of LEVELS) {
+      const original = originals[level]
+      if (original) {
+        console[level] = original as (typeof console)[typeof level]
+      }
+    }
+  }
+
+  return {
+    start,
+    stop,
+    snapshot: () => buf.peek(),
+    clear: () => buf.clear(),
+    // Test-only access to the underlying buffer for fail-open test:
+    __buf: buf,
+  } as ConsoleCollector & { __buf: RingBuffer<ConsoleEntry> }
+}