hrpc-inspector 0.1.1 → 0.1.2

package/dist/index.js

@@ -117,10 +117,21 @@ function monitorStream(report, endpoint, corrId, stream, t0, preview, tag) {
     report({ type: "request.end", method: endpoint, corrId, status, count: n, dur: Date.now() - t0, t: Date.now(), ...tag, ...extra || {} });
   };
   try {
-    stream.on("data", (item) => report({ type: "stream.data", method: endpoint, corrId, seq: ++n, item: preview(item), t: Date.now(), ...tag }));
-    stream.on("error", (err) => settle("error", { error: String(err) }));
-    stream.on("end", () => settle("closed"));
-    stream.on("close", () => settle("closed"));
+    const original = stream.emit;
+    if (typeof original !== "function") return;
+    stream.emit = function patched(name, ...args) {
+      try {
+        if (name === "data") {
+          report({ type: "stream.data", method: endpoint, corrId, seq: ++n, item: preview(args[0]), t: Date.now(), ...tag });
+        } else if (name === "error") {
+          settle("error", { error: String(args[0]) });
+        } else if (name === "end" || name === "close") {
+          settle("closed");
+        }
+      } catch {
+      }
+      return original.apply(this, [name, ...args]);
+    };
   } catch (e) {
     report({ type: "request.end", method: endpoint, corrId, status: "error", error: "monitor-failed: " + String(e), dur: 0, t: Date.now(), ...tag });
   }
@@ -257,6 +268,8 @@ function observe(opts = {}) {
   const source = resolveSource(opts.source, info.runtime);
   const redactOn = opts.redact ?? (opts.websocket ? false : true);
   const redactor = opts.redactor ?? (redactOn ? new Redactor({ bodyAllowlist: opts.bodyAllowlist }) : null);
+  const redactMethods = new Set(opts.redactMethods ?? []);
+  const methodRedactor = !redactor && redactMethods.size > 0 ? new Redactor() : null;
   const wireSource = redactor ? redactSource(source, redactor) : source;
   const invokeEnabled = opts.allowInvoke === true && !!opts.websocket;
   const replayLogMax = opts.replayLogMax ?? 2e3;
@@ -296,7 +309,9 @@ function observe(opts = {}) {
   const flusher = new BatchFlusher({
     intervalMs: opts.intervalMs ?? 200,
     onFlush: (batch) => {
-      const out = redactor ? redactor.redactBatch(batch) : batch;
+      const out = redactor ? redactor.redactBatch(batch) : methodRedactor ? batch.map(
+        (e) => redactMethods.has(String(e.method)) ? methodRedactor.redact(e) : e
+      ) : batch;
       exporter.export(out.map((e) => ({ ...e, src: wireSource.id })));
     }
   });

package/dist/observe.d.ts

@@ -42,6 +42,15 @@ export interface ObserveOptions {
      * Set false ONLY for a purely-local view that never leaves the machine (F3/F4/F9).
      */
     redact?: boolean;
+    /**
+     * Per-`method` FORCED redaction, for when global `redact` is off (the local viewer default).
+     * A listed method still appears in the GUI — you see it fired, when, how long it took, whether
+     * it errored, and the SHAPE of its payload (`{phrase: 'string'}`) — but its values are replaced
+     * by a content summary. Use it for methods that carry secrets you never want rendered, e.g.
+     * a recovery phrase. This is a denylist: a newly added secret-bearing method must be listed.
+     * Ignored when `redact` is on, because everything is redacted already.
+     */
+    redactMethods?: Iterable<string>;
     /** Supply a shared Redactor (e.g. to reuse its local peer reverse-map). Default: a fresh one. */
     redactor?: Redactor;
     /** Per-`method` opt-in allowlist for full payload bodies (default: none — bodies summarised). */

package/dist/observe.js

@@ -117,10 +117,21 @@ function monitorStream(report, endpoint, corrId, stream, t0, preview, tag) {
     report({ type: "request.end", method: endpoint, corrId, status, count: n, dur: Date.now() - t0, t: Date.now(), ...tag, ...extra || {} });
   };
   try {
-    stream.on("data", (item) => report({ type: "stream.data", method: endpoint, corrId, seq: ++n, item: preview(item), t: Date.now(), ...tag }));
-    stream.on("error", (err) => settle("error", { error: String(err) }));
-    stream.on("end", () => settle("closed"));
-    stream.on("close", () => settle("closed"));
+    const original = stream.emit;
+    if (typeof original !== "function") return;
+    stream.emit = function patched(name, ...args) {
+      try {
+        if (name === "data") {
+          report({ type: "stream.data", method: endpoint, corrId, seq: ++n, item: preview(args[0]), t: Date.now(), ...tag });
+        } else if (name === "error") {
+          settle("error", { error: String(args[0]) });
+        } else if (name === "end" || name === "close") {
+          settle("closed");
+        }
+      } catch {
+      }
+      return original.apply(this, [name, ...args]);
+    };
   } catch (e) {
     report({ type: "request.end", method: endpoint, corrId, status: "error", error: "monitor-failed: " + String(e), dur: 0, t: Date.now(), ...tag });
   }
@@ -257,6 +268,8 @@ function observe(opts = {}) {
   const source = resolveSource(opts.source, info.runtime);
   const redactOn = opts.redact ?? (opts.websocket ? false : true);
   const redactor = opts.redactor ?? (redactOn ? new Redactor({ bodyAllowlist: opts.bodyAllowlist }) : null);
+  const redactMethods = new Set(opts.redactMethods ?? []);
+  const methodRedactor = !redactor && redactMethods.size > 0 ? new Redactor() : null;
   const wireSource = redactor ? redactSource(source, redactor) : source;
   const invokeEnabled = opts.allowInvoke === true && !!opts.websocket;
   const replayLogMax = opts.replayLogMax ?? 2e3;
@@ -296,7 +309,9 @@ function observe(opts = {}) {
   const flusher = new BatchFlusher({
     intervalMs: opts.intervalMs ?? 200,
     onFlush: (batch) => {
-      const out = redactor ? redactor.redactBatch(batch) : batch;
+      const out = redactor ? redactor.redactBatch(batch) : methodRedactor ? batch.map(
+        (e) => redactMethods.has(String(e.method)) ? methodRedactor.redact(e) : e
+      ) : batch;
       exporter.export(out.map((e) => ({ ...e, src: wireSource.id })));
     }
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hrpc-inspector",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "hrpc based debugging and observability for Bare. Tap an RPC client or a raw transport and read endpoint, request, response, latency and live subscription streams in a local GUI, or merge multi-peer timelines over a Hyperswarm hub.",
   "type": "module",
   "main": "./dist/index.js",
@@ -63,6 +63,7 @@
   },
   "devDependencies": {
     "esbuild": "^0.28.2",
+    "streamx": "^2.28.1",
     "typescript": "^7.0.2"
   }
 }

package/src/observe.ts

@@ -128,6 +128,15 @@ export interface ObserveOptions {
    * Set false ONLY for a purely-local view that never leaves the machine (F3/F4/F9).
    */
   redact?: boolean;
+  /**
+   * Per-`method` FORCED redaction, for when global `redact` is off (the local viewer default).
+   * A listed method still appears in the GUI — you see it fired, when, how long it took, whether
+   * it errored, and the SHAPE of its payload (`{phrase: 'string'}`) — but its values are replaced
+   * by a content summary. Use it for methods that carry secrets you never want rendered, e.g.
+   * a recovery phrase. This is a denylist: a newly added secret-bearing method must be listed.
+   * Ignored when `redact` is on, because everything is redacted already.
+   */
+  redactMethods?: Iterable<string>;
   /** Supply a shared Redactor (e.g. to reuse its local peer reverse-map). Default: a fresh one. */
   redactor?: Redactor;
   /** Per-`method` opt-in allowlist for full payload bodies (default: none — bodies summarised). */
@@ -249,6 +258,10 @@ export function observe(opts: ObserveOptions = {}): ObserveHandle {
   const redactOn = opts.redact ?? (opts.websocket ? false : true);
   const redactor: Redactor | null =
     opts.redactor ?? (redactOn ? new Redactor({ bodyAllowlist: opts.bodyAllowlist }) : null);
+  // Only meaningful while global redaction is off; when it is on these methods are covered anyway.
+  const redactMethods = new Set(opts.redactMethods ?? []);
+  const methodRedactor: Redactor | null =
+    !redactor && redactMethods.size > 0 ? new Redactor() : null;
   // Identity ON THE WIRE — hashed ids / no human labels when redaction is on. `handle.source`
   // keeps the original for the app's own use.
   const wireSource = redactor ? redactSource(source, redactor) : source;
@@ -306,7 +319,15 @@ export function observe(opts: ObserveOptions = {}): ObserveHandle {
   const flusher = new BatchFlusher<L2Event>({
     intervalMs: opts.intervalMs ?? 200,
     onFlush: (batch) => {
-      const out = redactor ? redactor.redactBatch(batch) : batch;
+      const out = redactor
+        ? redactor.redactBatch(batch)
+        : methodRedactor
+          ? batch.map((e) =>
+              redactMethods.has(String((e as Record<string, unknown>).method))
+                ? (methodRedactor.redact(e as Record<string, unknown>) as L2Event)
+                : e,
+            )
+          : batch;
       // Stamp the (wire) source id so the GUI can group/select by device.
       exporter.export(out.map((e) => ({ ...(e as object), src: wireSource.id })));
     },

package/src/wrap-client.ts

@@ -57,10 +57,16 @@ function defaultPreview(v: unknown): unknown {
   }
 }
 
-// Attach PASSIVE listeners to a subscription stream. Non-destructive when the app also uses
-// `.on('data')` (every listener receives each item). If a consumer instead uses `.read()` /
-// async-iteration, adding a data listener flips it to flowing mode — opt out with
-// monitorStreams:false for those.
+// Observe a subscription stream WITHOUT changing its behaviour.
+//
+// This wraps `emit` instead of calling `.on('data', ...)`. Registering a data listener is not
+// passive: it puts the stream into flowing mode immediately, so anything emitted before the app
+// attaches its own listener is delivered to us and LOST to the app. That is a debug-only data
+// loss — the app silently misses items, with no error — and it is real: keet's RPC subscriptions
+// return their stream synchronously, while the consumer attaches a tick later.
+//
+// Wrapping `emit` cannot cause that: we only see events the stream was already delivering. If
+// nothing consumes the stream, nothing is emitted and we report nothing, which is the truth.
 function monitorStream(report: Report, endpoint: string, corrId: string, stream: any, t0: number, preview: (v: unknown) => unknown, tag: Record<string, unknown>): void {
   report({ type: 'stream.open', method: endpoint, corrId, t: Date.now(), ...tag });
   let n = 0;
@@ -71,10 +77,24 @@ function monitorStream(report: Report, endpoint: string, corrId: string, stream:
     report({ type: 'request.end', method: endpoint, corrId, status, count: n, dur: Date.now() - t0, t: Date.now(), ...tag, ...(extra || {}) });
   };
   try {
-    stream.on('data', (item: unknown) => report({ type: 'stream.data', method: endpoint, corrId, seq: ++n, item: preview(item), t: Date.now(), ...tag }));
-    stream.on('error', (err: unknown) => settle('error', { error: String(err) }));
-    stream.on('end', () => settle('closed'));
-    stream.on('close', () => settle('closed'));
+    const original = stream.emit;
+    if (typeof original !== 'function') return;
+    stream.emit = function patched(this: unknown, name: string, ...args: unknown[]): unknown {
+      // Observation must never affect delivery: record, then hand off unchanged. A throw in the
+      // reporting path would surface as a stream error in the app, so it is swallowed.
+      try {
+        if (name === 'data') {
+          report({ type: 'stream.data', method: endpoint, corrId, seq: ++n, item: preview(args[0]), t: Date.now(), ...tag });
+        } else if (name === 'error') {
+          settle('error', { error: String(args[0]) });
+        } else if (name === 'end' || name === 'close') {
+          settle('closed');
+        }
+      } catch {
+        /* never break the stream */
+      }
+      return original.apply(this, [name, ...args] as never);
+    };
   } catch (e) {
     report({ type: 'request.end', method: endpoint, corrId, status: 'error', error: 'monitor-failed: ' + String(e), dur: 0, t: Date.now(), ...tag });
   }