@reshotdev/screenshot 0.0.1-beta.1 → 0.0.1-beta.10

package/src/lib/capture-engine.js

@@ -20,7 +20,7 @@ const {
   scaleRegionByDPR,
   isSharpAvailable,
 } = require("./image-crop");
-const { sanitizeStorageState } = require("./record-cdp");
+const { sanitizeStorageState, assessSessionHealth } = require("./record-cdp");
 const {
   injectPrivacyMasking,
   removePrivacyMasking,
@@ -98,6 +98,9 @@ class CaptureEngine {
     this.capturedAssets = [];
     this.logger = options.logger || console.log;
     this.headless = options.headless !== false; // Default to headless
+    this.injectWorkspaceStore = options.injectWorkspaceStore !== false;
+    this.diagnostics = [];
+    this.sessionHealth = null;
 
     // Storage state path for authenticated sessions
     // If provided, loads cookies/localStorage from file to preserve auth state
@@ -226,6 +229,36 @@ class CaptureEngine {
       }
       this.logger(chalk.gray(`  → Using pre-loaded auth session`));
     } else if (this.storageStatePath && fs.existsSync(this.storageStatePath)) {
+      this.sessionHealth = assessSessionHealth(
+        this.storageStatePath,
+        this.baseUrl,
+      );
+
+      if (!this.sessionHealth.compatible) {
+        this.logger(
+          chalk.yellow(
+            `  ⚠ Skipping cached auth session because it does not match ${this.baseUrl || "the current target"}`,
+          ),
+        );
+        for (const issue of this.sessionHealth.issues) {
+          this.logger(chalk.gray(`    ${issue}`));
+        }
+        this.diagnostics.push({
+          type: "auth-session-mismatch",
+          sessionPath: this.storageStatePath,
+          issues: [...this.sessionHealth.issues],
+        });
+        return contextOptions;
+      }
+
+      if (this.sessionHealth.stale) {
+        this.logger(
+          chalk.yellow(
+            `  ⚠ Cached auth session is ${this.sessionHealth.ageMinutes}m old; validating it during startup.`,
+          ),
+        );
+      }
+
       // Read and sanitize instead of passing raw file path (Playwright would read it unsanitized)
       try {
         const rawState = JSON.parse(fs.readFileSync(this.storageStatePath, "utf-8"));
@@ -245,6 +278,10 @@ class CaptureEngine {
           )}`
         )
       );
+
+      for (const warning of this.sessionHealth.warnings) {
+        this.logger(chalk.gray(`    ${warning}`));
+      }
     }
 
     return contextOptions;
@@ -289,7 +326,9 @@ class CaptureEngine {
       logVariantSummary(this.variantConfig, this.logger);
     }
 
-    await this._injectWorkspaceStore();
+    if (this.injectWorkspaceStore) {
+      await this._injectWorkspaceStore();
+    }
 
     // Inject privacy masking CSS (after variant injection, before captures)
     this._privacyInjectionOk = true;
@@ -306,24 +345,76 @@ class CaptureEngine {
     this._authResponseDetected = false;
     this.page.on("response", (response) => {
       const status = response.status();
+      const url = response.url();
       if (
         (status === 401 || status === 403) &&
         response.request().resourceType() === "document"
       ) {
         this._authResponseDetected = true;
       }
+
+      if (status >= 400 && response.request().resourceType() === "document") {
+        this._recordDiagnostic("response_error", "error", {
+          url,
+          status,
+          resourceType: response.request().resourceType(),
+        });
+      }
     });
 
     // Set up error handling
     this.page.on("pageerror", (err) => {
       const firstLine = (err.message || '').split('\n')[0].slice(0, 200);
+      this._recordDiagnostic("pageerror", "error", {
+        message: err.message || String(err),
+      });
       this.logger(chalk.yellow(`  [Page Error] ${firstLine}`));
     });
+    this.page.on("console", (message) => {
+      const type = message.type();
+      const text = message.text();
+      const severity =
+        type === "error"
+          ? "error"
+          : type === "warning"
+            ? "warning"
+            : "info";
+
+      if (severity === "error" || severity === "warning") {
+        this._recordDiagnostic("console", severity, {
+          message: text,
+          consoleType: type,
+          cspViolation: /content security policy|csp/i.test(text),
+        });
+      }
+    });
+    this.page.on("requestfailed", (request) => {
+      this._recordDiagnostic("requestfailed", "error", {
+        url: request.url(),
+        method: request.method(),
+        resourceType: request.resourceType(),
+        message: request.failure()?.errorText || "Request failed",
+      });
+    });
 
     this.logger(chalk.green("  ✔ Browser initialized"));
     return this;
   }
 
+  _recordDiagnostic(kind, severity, details = {}) {
+    this.diagnostics.push({
+      id: `${Date.now()}-${this.diagnostics.length + 1}`,
+      kind,
+      severity,
+      ...details,
+      capturedAt: new Date().toISOString(),
+    });
+  }
+
+  getDiagnostics() {
+    return [...this.diagnostics];
+  }
+
   /**
    * Hide development overlays (Next.js devtools, Vercel toolbar, etc.)
    * Injects CSS to hide common development UI elements before each navigation
@@ -412,11 +503,11 @@ class CaptureEngine {
       projectId = settings.urlVariables?.PROJECT_ID;
       // 2. Check settings projectId
       if (!projectId) projectId = settings.projectId;
-      // 3. Check docsync.config.json urlVariables
+      // 3. Check reshot.config.json urlVariables
       if (!projectId) {
         try {
-          const docsyncConfig = config.readConfig() || {};
-          projectId = docsyncConfig.urlVariables?.PROJECT_ID;
+          const reshotConfig = config.readConfig() || {};
+          projectId = reshotConfig.urlVariables?.PROJECT_ID;
         } catch (_e) {
           // Config may not exist
         }
@@ -512,10 +603,15 @@ class CaptureEngine {
     }
 
     // Check for auth redirect after navigation (URL patterns + HTTP 401/403)
+    // Skip the check if the scenario explicitly targeted this URL (e.g. capturing /login)
     const currentUrl = this.page.url();
+    const targetPath = url.startsWith("http") ? new URL(url).pathname : url;
+    const currentPath = (() => { try { return new URL(currentUrl).pathname; } catch { return currentUrl; } })();
+    const isIntentionalTarget = currentPath === targetPath;
     const isAuthRedirect =
-      isAuthRedirectUrl(currentUrl, this._customAuthPatterns) ||
-      this._authResponseDetected;
+      !isIntentionalTarget &&
+      (isAuthRedirectUrl(currentUrl, this._customAuthPatterns) ||
+      this._authResponseDetected);
     if (isAuthRedirect) {
       const errorMsg = `Auth redirect detected: navigated to ${currentUrl}. Session may be expired. Re-run \`reshot record\` to refresh session, or export a fresh Playwright storage state to .reshot/auth-state.json.`;
       this.logger(chalk.red(`  ✖ ${errorMsg}`));