codymaster 4.8.0 → 7.0.0

package/dist/browse/error-collector.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * ErrorCollector — Structured error classification for browser sessions.
+ * Classifies, deduplicates, and exports browser errors.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCollector = void 0;
+const crypto_1 = require("crypto");
+const SEVERITY_MAP = {
+    'crash': 'critical',
+    'js-error': 'error',
+    'network-fail': 'error',
+    'console-error': 'error',
+    'timeout': 'warning',
+    'a11y-violation': 'warning',
+};
+class ErrorCollector {
+    constructor(opts) {
+        var _a, _b;
+        this.errors = [];
+        this.seen = new Map(); // fingerprint → last timestamp ms
+        this.maxErrors = (_a = opts === null || opts === void 0 ? void 0 : opts.maxErrors) !== null && _a !== void 0 ? _a : 1000;
+        this.dedupWindowMs = (_b = opts === null || opts === void 0 ? void 0 : opts.dedupWindowMs) !== null && _b !== void 0 ? _b : 2000;
+    }
+    /**
+     * Add a raw error. Classifies severity and deduplicates.
+     */
+    add(input) {
+        var _a;
+        const fp = this.fingerprint(input);
+        const now = Date.now();
+        const lastSeen = this.seen.get(fp);
+        // Dedup within window
+        if (lastSeen !== undefined && now - lastSeen < this.dedupWindowMs) {
+            return null;
+        }
+        this.seen.set(fp, now);
+        const error = {
+            id: (0, crypto_1.randomUUID)(),
+            type: input.type,
+            severity: (_a = SEVERITY_MAP[input.type]) !== null && _a !== void 0 ? _a : 'error',
+            source: input.source,
+            message: input.message,
+            stack: input.stack,
+            timestamp: new Date().toISOString(),
+            context: input.context,
+        };
+        this.errors.push(error);
+        // Evict oldest if over limit
+        if (this.errors.length > this.maxErrors) {
+            this.errors.shift();
+        }
+        return error;
+    }
+    /**
+     * Convenience: classify a console message.
+     */
+    addConsole(type, text, source) {
+        if (type !== 'error' && type !== 'warning')
+            return null;
+        return this.add({
+            type: type === 'error' ? 'console-error' : 'a11y-violation',
+            source: source !== null && source !== void 0 ? source : 'console',
+            message: text,
+        });
+    }
+    /**
+     * Convenience: classify a network failure.
+     */
+    addNetworkFailure(url, method, status, failure) {
+        return this.add({
+            type: 'network-fail',
+            source: url,
+            message: `${method} ${url} → ${status !== null && status !== void 0 ? status : 'failed'}${failure ? `: ${failure}` : ''}`,
+            context: { method, status, failure },
+        });
+    }
+    /**
+     * Convenience: classify a page crash.
+     */
+    addCrash(message) {
+        return this.add({
+            type: 'crash',
+            source: 'page',
+            message,
+        });
+    }
+    /**
+     * Get all collected errors, optionally filtered.
+     */
+    getAll(filter) {
+        let result = this.errors;
+        if (filter === null || filter === void 0 ? void 0 : filter.type)
+            result = result.filter(e => e.type === filter.type);
+        if (filter === null || filter === void 0 ? void 0 : filter.severity)
+            result = result.filter(e => e.severity === filter.severity);
+        return result;
+    }
+    /**
+     * Get error count by severity.
+     */
+    stats() {
+        const counts = { critical: 0, error: 0, warning: 0, info: 0 };
+        for (const e of this.errors) {
+            counts[e.severity]++;
+        }
+        return counts;
+    }
+    /**
+     * Export errors as JSON-serializable array.
+     */
+    exportJSON() {
+        return [...this.errors];
+    }
+    /**
+     * Clear all errors.
+     */
+    clear() {
+        this.errors = [];
+        this.seen.clear();
+    }
+    /**
+     * Get total count.
+     */
+    get size() {
+        return this.errors.length;
+    }
+    fingerprint(input) {
+        return `${input.type}:${input.source}:${input.message.slice(0, 200)}`;
+    }
+}
+exports.ErrorCollector = ErrorCollector;

package/dist/browse/event-log.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * EventLog — Upgraded ring buffer with structured events, filtering, and export.
+ * Replaces the simple RingBuffer in BrowseDaemon.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLog = void 0;
+let _idCounter = 0;
+function nextId() {
+    return `evt_${++_idCounter}_${Date.now().toString(36)}`;
+}
+class EventLog {
+    constructor(opts) {
+        var _a;
+        this.entries = [];
+        this.maxSize = (_a = opts === null || opts === void 0 ? void 0 : opts.maxSize) !== null && _a !== void 0 ? _a : 1000;
+    }
+    /**
+     * Push a new event.
+     */
+    push(entry) {
+        var _a;
+        const full = {
+            id: nextId(),
+            timestamp: (_a = entry.timestamp) !== null && _a !== void 0 ? _a : new Date().toISOString(),
+            category: entry.category,
+            type: entry.type,
+            message: entry.message,
+            severity: entry.severity,
+            source: entry.source,
+            metadata: entry.metadata,
+        };
+        this.entries.push(full);
+        // Evict oldest
+        while (this.entries.length > this.maxSize) {
+            this.entries.shift();
+        }
+        return full;
+    }
+    /**
+     * Get all entries, optionally filtered.
+     */
+    query(filter) {
+        let result = this.entries;
+        if (filter === null || filter === void 0 ? void 0 : filter.category)
+            result = result.filter(e => e.category === filter.category);
+        if (filter === null || filter === void 0 ? void 0 : filter.type)
+            result = result.filter(e => e.type === filter.type);
+        if (filter === null || filter === void 0 ? void 0 : filter.severity)
+            result = result.filter(e => e.severity === filter.severity);
+        if (filter === null || filter === void 0 ? void 0 : filter.source)
+            result = result.filter(e => e.source === filter.source);
+        if (filter === null || filter === void 0 ? void 0 : filter.since) {
+            const sinceMs = new Date(filter.since).getTime();
+            result = result.filter(e => new Date(e.timestamp).getTime() >= sinceMs);
+        }
+        if (filter === null || filter === void 0 ? void 0 : filter.until) {
+            const untilMs = new Date(filter.until).getTime();
+            result = result.filter(e => new Date(e.timestamp).getTime() <= untilMs);
+        }
+        if ((filter === null || filter === void 0 ? void 0 : filter.limit) && filter.limit > 0) {
+            result = result.slice(-filter.limit);
+        }
+        return result;
+    }
+    /**
+     * Get the last N entries.
+     */
+    recent(n) {
+        return this.entries.slice(-n);
+    }
+    /**
+     * Snapshot — returns copy of all entries (backward compat with RingBuffer).
+     */
+    snapshot() {
+        return [...this.entries];
+    }
+    /**
+     * Export as JSON-serializable array.
+     */
+    exportJSON(filter) {
+        return this.query(filter);
+    }
+    /**
+     * Get counts by category.
+     */
+    stats() {
+        const counts = {
+            console: 0, network: 0, error: 0, session: 0, interaction: 0,
+        };
+        for (const e of this.entries) {
+            counts[e.category]++;
+        }
+        return counts;
+    }
+    /**
+     * Clear all entries.
+     */
+    clear() {
+        this.entries = [];
+    }
+    /**
+     * Total entry count.
+     */
+    get size() {
+        return this.entries.length;
+    }
+}
+exports.EventLog = EventLog;

package/dist/browse/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Browse Hybrid Bridge — public API.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLog = exports.ErrorCollector = exports.checkEngines = exports.createAdapter = exports.AgentBrowserAdapter = exports.PlaywrightAdapter = void 0;
+var playwright_adapter_1 = require("./adapters/playwright-adapter");
+Object.defineProperty(exports, "PlaywrightAdapter", { enumerable: true, get: function () { return playwright_adapter_1.PlaywrightAdapter; } });
+var agent_browser_adapter_1 = require("./adapters/agent-browser-adapter");
+Object.defineProperty(exports, "AgentBrowserAdapter", { enumerable: true, get: function () { return agent_browser_adapter_1.AgentBrowserAdapter; } });
+var adapter_factory_1 = require("./adapter-factory");
+Object.defineProperty(exports, "createAdapter", { enumerable: true, get: function () { return adapter_factory_1.createAdapter; } });
+Object.defineProperty(exports, "checkEngines", { enumerable: true, get: function () { return adapter_factory_1.checkEngines; } });
+var error_collector_1 = require("./error-collector");
+Object.defineProperty(exports, "ErrorCollector", { enumerable: true, get: function () { return error_collector_1.ErrorCollector; } });
+var event_log_1 = require("./event-log");
+Object.defineProperty(exports, "EventLog", { enumerable: true, get: function () { return event_log_1.EventLog; } });