@tandryukha/aidemo 0.15.0 → 0.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tandryukha/aidemo",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "license": "MIT",
   "description": "AI Demo Engine — turn a storyboard into a narrated, captioned product demo video",
   "type": "module",
@@ -36,7 +36,7 @@
     "@modelcontextprotocol/sdk": "1.30.0",
     "commander": "^12.1.0",
     "openai": "^4.67.0",
-    "playwright": "^1.48.0",
+    "playwright": "^1.55.1",
     "tsx": "^4.23.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "3.25.2"

package/src/player.ts

@@ -1,6 +1,7 @@
 import type { Page, Locator, Frame, Request, Response, Dialog } from "playwright";
 import { scanInteractive, rankCandidates, type DriftCandidate } from "./inspect.js";
 import { compileUserRegex } from "./safe-regex.js";
+import { redactUrl, redactSecrets } from "./redact.js";
 import { promises as fs } from "node:fs";
 import { basename, isAbsolute, join, resolve } from "node:path";
 import { existsSync } from "node:fs";
@@ -242,39 +243,51 @@ class NetworkWatch {
     private readonly page: Page,
     private readonly t0: number
   ) {
+    // A listener that throws surfaces as an unhandled rejection on the page
+    // and can abort a take, so each one is wrapped: diagnostics are strictly
+    // best-effort and must never take the recording down with them.
     this.onResponse = (res: Response) => {
-      if (res.status() < 400) return;
-      const req = res.request();
-      const entry: FailedRequest = {
-        tMs: Date.now() - t0,
-        method: req.method(),
-        url: truncateUrl(res.url(), 200),
-        status: res.status(),
-        resourceType: req.resourceType(),
-      };
-      this.push(entry);
-      if (/^(xhr|fetch)$/.test(entry.resourceType)) {
-        res
-          .text()
-          .then((b) => {
-            const snippet = b.replace(/\s+/g, " ").trim().slice(0, NET_BODY_MAX);
-            if (snippet) entry.body = snippet;
-          })
-          .catch(() => {});
+      try {
+        if (res.status() < 400) return;
+        const req = res.request();
+        const entry: FailedRequest = {
+          tMs: Date.now() - t0,
+          method: req.method(),
+          url: redactUrl(res.url(), 200),
+          status: res.status(),
+          resourceType: req.resourceType(),
+        };
+        this.push(entry);
+        if (/^(xhr|fetch)$/.test(entry.resourceType)) {
+          res
+            .text()
+            .then((b) => {
+              const snippet = redactSecrets(b.replace(/\s+/g, " ").trim()).slice(0, NET_BODY_MAX);
+              if (snippet) entry.body = snippet;
+            })
+            // The body is gone once the page navigates; that's expected.
+            .catch(() => {});
+        }
+      } catch {
+        /* diagnostics only — a broken response record is not a take failure */
       }
     };
     this.onFailed = (req: Request) => {
-      const err = req.failure()?.errorText ?? "failed";
-      // Navigations cancel in-flight requests; that's not an app failure.
-      if (/ERR_ABORTED/.test(err)) return;
-      this.push({
-        tMs: Date.now() - t0,
-        method: req.method(),
-        url: truncateUrl(req.url(), 200),
-        status: null,
-        error: err,
-        resourceType: req.resourceType(),
-      });
+      try {
+        const err = req.failure()?.errorText ?? "failed";
+        // Navigations cancel in-flight requests; that's not an app failure.
+        if (/ERR_ABORTED/.test(err)) return;
+        this.push({
+          tMs: Date.now() - t0,
+          method: req.method(),
+          url: redactUrl(req.url(), 200),
+          status: null,
+          error: err,
+          resourceType: req.resourceType(),
+        });
+      } catch {
+        /* diagnostics only */
+      }
     };
   }
 
@@ -1900,7 +1913,9 @@ async function waitForChange(
 // ---------------------------------------------------------------------------
 
 function truncateUrl(url: string, n = 90): string {
-  return url.length > n ? url.slice(0, n) + "…" : url;
+  // Same masking as the network watch: every URL that reaches a log or a
+  // fail-*.json goes through redaction, not just the ones from failed requests.
+  return redactUrl(url, n);
 }
 
 /** Never returns — enriches the error with scene/action context + diagnostics. */

package/src/redact.ts

@@ -0,0 +1,72 @@
+/**
+ * Redaction for diagnostics.
+ *
+ * A failed take writes `logs/fail-*.json` (and log lines) containing live URLs
+ * and, for XHR/fetch failures, a snippet of the response body. Those come from
+ * whatever app was being recorded — a magic-link callback, an OAuth redirect or
+ * an error payload can easily carry a session token. The logs are meant to be
+ * pasted into an issue, so anything that looks like a credential is masked
+ * before it is written. This is a best-effort net, not a guarantee: it never
+ * throws, and it errs toward masking.
+ */
+
+const MASK = "REDACTED";
+
+/** Query/form parameter names whose *value* is never printed. */
+const SECRET_PARAM =
+  /^(?:.*[-_])?(?:token|access[-_]?token|id[-_]?token|refresh[-_]?token|secret|password|passwd|pwd|api[-_]?key|apikey|key|auth|authorization|session|sig|signature|code|credential|assertion)$/i;
+
+/** Free-text shapes that are credentials wherever they appear. */
+const SECRET_SHAPES: Array<[RegExp, string]> = [
+  [/\b(bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, `$1 ${MASK}`],
+  // Provider-prefixed keys (sk-…, ghp_…, xoxb-…, AKIA…).
+  [/\b(?:sk|pk|rk)-[A-Za-z0-9_-]{16,}/g, MASK],
+  [/\bgh[pousr]_[A-Za-z0-9]{16,}/g, MASK],
+  [/\bxox[abposr]-[A-Za-z0-9-]{10,}/g, MASK],
+  [/\bAKIA[0-9A-Z]{16}\b/g, MASK],
+  // JWTs.
+  [/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, MASK],
+  // JSON/pair values under a secret-looking name.
+  [
+    /("?)([A-Za-z0-9_-]*(?:token|secret|password|passwd|api[-_]?key|apikey|authorization|credential)[A-Za-z0-9_-]*)\1(\s*[:=]\s*)("?)[^"\s,}&]+\4/gi,
+    `$1$2$1$3$4${MASK}$4`,
+  ],
+];
+
+/** Mask credential-shaped substrings in free text (response bodies, errors). */
+export function redactSecrets(text: string): string {
+  if (!text) return text;
+  let out = text;
+  for (const [re, to] of SECRET_SHAPES) out = out.replace(re, to);
+  return out;
+}
+
+/**
+ * Mask secret-bearing query/fragment parameters, then truncate to `n` chars.
+ * Anything that doesn't parse as a URL still goes through {@link redactSecrets}.
+ */
+export function redactUrl(url: string, n = 90): string {
+  let safe: string;
+  try {
+    const u = new URL(url);
+    for (const params of [u.searchParams, new URLSearchParams(u.hash.replace(/^#/, ""))]) {
+      let touched = false;
+      for (const name of [...params.keys()]) {
+        if (SECRET_PARAM.test(name)) {
+          params.set(name, MASK);
+          touched = true;
+        }
+      }
+      if (touched && params !== u.searchParams) u.hash = params.toString();
+    }
+    if (u.username || u.password) {
+      u.username = "";
+      u.password = "";
+    }
+    safe = redactSecrets(u.toString());
+  } catch {
+    // Not an absolute URL (about:blank, a relative href, a data: blob).
+    safe = redactSecrets(url);
+  }
+  return safe.length > n ? safe.slice(0, n) + "…" : safe;
+}

package/src/safe-regex.ts

@@ -30,7 +30,15 @@ export function isUnsafeRegexSource(pattern: string): string | null {
  * field so the author can see which matcher to fix.
  */
 export function compileUserRegex(pattern: string, flags: string, where: string): RegExp {
+  if (typeof pattern !== "string" || pattern === "")
+    throw new Error(`${where}: regex must be a non-empty string`);
   const unsafe = isUnsafeRegexSource(pattern);
   if (unsafe) throw new Error(`${where}: unsafe regex — ${unsafe}`);
-  return new RegExp(pattern, flags);
+  try {
+    return new RegExp(pattern, flags);
+  } catch (e) {
+    // A raw SyntaxError names neither the field nor the storyboard, which is
+    // the only thing the author can act on.
+    throw new Error(`${where}: invalid regex ${JSON.stringify(pattern)} — ${(e as Error).message}`);
+  }
 }