@browserbasehq/orca 3.4.0-preview-4 → 3.4.0-preview-5

package/dist/cjs/tests/integration/logger-initialization.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cjs/tests/integration/logger-initialization.spec.js

@@ -1,597 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const test_1 = require("@playwright/test");
-const logger_js_1 = require("../../lib/v3/logger.js");
-test_1.test.describe("V3 Logger Instance Routing", () => {
-    test_1.test.afterEach(() => {
-        // Clean up is handled by unbindInstanceLogger calls in tests
-    });
-    (0, test_1.test)("bindInstanceLogger routes logs to correct instance", () => {
-        const instanceId = "test-instance-001";
-        const capturedLogs = [];
-        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => {
-            capturedLogs.push(line);
-        });
-        try {
-            // Log within context
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Test message for instance",
-                    level: 1,
-                });
-            });
-            // Should have captured the log
-            (0, test_1.expect)(capturedLogs.length).toBe(1);
-            (0, test_1.expect)(capturedLogs[0].message).toBe("Test message for instance");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("unbindInstanceLogger stops routing", () => {
-        const instanceId = "test-instance-002";
-        const capturedLogs = [];
-        const consoleOutput = [];
-        const originalConsoleLog = console.log;
-        try {
-            console.log = (msg) => {
-                consoleOutput.push(msg);
-            };
-            (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => {
-                capturedLogs.push(line);
-            });
-            // Unbind immediately
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-            // Log - should fall back to console
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "After unbind",
-                    level: 1,
-                });
-            });
-            // Should not have captured via instance logger
-            (0, test_1.expect)(capturedLogs.length).toBe(0);
-            // But should have logged to console
-            (0, test_1.expect)(consoleOutput.length).toBeGreaterThan(0);
-        }
-        finally {
-            console.log = originalConsoleLog;
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("multiple instances have isolated log routing", () => {
-        const instance1Id = "test-instance-1";
-        const instance2Id = "test-instance-2";
-        const instance1Logs = [];
-        const instance2Logs = [];
-        (0, logger_js_1.bindInstanceLogger)(instance1Id, (line) => instance1Logs.push(line));
-        (0, logger_js_1.bindInstanceLogger)(instance2Id, (line) => instance2Logs.push(line));
-        try {
-            // Log from instance 1
-            (0, logger_js_1.withInstanceLogContext)(instance1Id, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "From instance 1",
-                    level: 1,
-                });
-            });
-            // Log from instance 2
-            (0, logger_js_1.withInstanceLogContext)(instance2Id, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "From instance 2",
-                    level: 1,
-                });
-            });
-            // Each instance should have only its own log
-            (0, test_1.expect)(instance1Logs.length).toBe(1);
-            (0, test_1.expect)(instance2Logs.length).toBe(1);
-            (0, test_1.expect)(instance1Logs[0].message).toBe("From instance 1");
-            (0, test_1.expect)(instance2Logs[0].message).toBe("From instance 2");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instance1Id);
-            (0, logger_js_1.unbindInstanceLogger)(instance2Id);
-        }
-    });
-    (0, test_1.test)("v3Logger falls back to console when no instance context", () => {
-        const capturedLogs = [];
-        const originalConsoleLog = console.log;
-        try {
-            console.log = (msg) => {
-                capturedLogs.push(msg);
-            };
-            // Log without any instance context
-            (0, logger_js_1.v3Logger)({
-                category: "test",
-                message: "Console fallback log",
-                level: 1,
-            });
-            // Should have used console logger
-            (0, test_1.expect)(capturedLogs.length).toBeGreaterThan(0);
-            const logOutput = capturedLogs.join("\n");
-            (0, test_1.expect)(logOutput).toContain("Console fallback log");
-        }
-        finally {
-            console.log = originalConsoleLog;
-        }
-    });
-    (0, test_1.test)("v3Logger falls back to console when instance logger throws", () => {
-        const instanceId = "failing-instance";
-        const capturedConsoleLogs = [];
-        const originalConsoleLog = console.log;
-        try {
-            console.log = (msg) => {
-                capturedConsoleLogs.push(msg);
-            };
-            // Bind a logger that throws
-            (0, logger_js_1.bindInstanceLogger)(instanceId, () => {
-                throw new Error("Instance logger failed");
-            });
-            // Should fall back to console without throwing
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, test_1.expect)(() => {
-                    (0, logger_js_1.v3Logger)({
-                        category: "test",
-                        message: "Test with failing instance logger",
-                        level: 1,
-                    });
-                }).not.toThrow();
-            });
-            // Console should have received the log as fallback
-            (0, test_1.expect)(capturedConsoleLogs.length).toBeGreaterThan(0);
-            const logOutput = capturedConsoleLogs.join("\n");
-            (0, test_1.expect)(logOutput).toContain("Test with failing instance logger");
-        }
-        finally {
-            console.log = originalConsoleLog;
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("withInstanceLogContext nests properly", () => {
-        const outerInstanceId = "outer-instance";
-        const innerInstanceId = "inner-instance";
-        const outerLogs = [];
-        const innerLogs = [];
-        (0, logger_js_1.bindInstanceLogger)(outerInstanceId, (line) => outerLogs.push(line));
-        (0, logger_js_1.bindInstanceLogger)(innerInstanceId, (line) => innerLogs.push(line));
-        try {
-            (0, logger_js_1.withInstanceLogContext)(outerInstanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Outer context",
-                    level: 1,
-                });
-                (0, logger_js_1.withInstanceLogContext)(innerInstanceId, () => {
-                    (0, logger_js_1.v3Logger)({
-                        category: "test",
-                        message: "Inner context",
-                        level: 1,
-                    });
-                });
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Back to outer context",
-                    level: 1,
-                });
-            });
-            // Outer instance should have 2 logs
-            (0, test_1.expect)(outerLogs.length).toBe(2);
-            (0, test_1.expect)(outerLogs[0].message).toBe("Outer context");
-            (0, test_1.expect)(outerLogs[1].message).toBe("Back to outer context");
-            // Inner instance should have 1 log
-            (0, test_1.expect)(innerLogs.length).toBe(1);
-            (0, test_1.expect)(innerLogs[0].message).toBe("Inner context");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(outerInstanceId);
-            (0, logger_js_1.unbindInstanceLogger)(innerInstanceId);
-        }
-    });
-    (0, test_1.test)("withInstanceLogContext returns function result", () => {
-        const instanceId = "return-test-instance";
-        (0, logger_js_1.bindInstanceLogger)(instanceId, () => { });
-        try {
-            const result = (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                return { success: true, value: 42 };
-            });
-            (0, test_1.expect)(result).toEqual({ success: true, value: 42 });
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("withInstanceLogContext works with async functions", async () => {
-        const instanceId = "async-test-instance";
-        const capturedLogs = [];
-        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => capturedLogs.push(line));
-        try {
-            const asyncResult = await (0, logger_js_1.withInstanceLogContext)(instanceId, async () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Log from async context",
-                    level: 1,
-                });
-                await new Promise((resolve) => setTimeout(resolve, 10));
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Log after await",
-                    level: 1,
-                });
-                return "async result";
-            });
-            (0, test_1.expect)(asyncResult).toBe("async result");
-            (0, test_1.expect)(capturedLogs.length).toBe(2);
-            (0, test_1.expect)(capturedLogs[0].message).toBe("Log from async context");
-            (0, test_1.expect)(capturedLogs[1].message).toBe("Log after await");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("console fallback formats different log levels correctly", () => {
-        const consoleOutput = [];
-        const originalConsoleLog = console.log;
-        const originalConsoleError = console.error;
-        const originalConsoleDebug = console.debug;
-        try {
-            console.log = (msg) => {
-                consoleOutput.push({ level: "log", msg });
-            };
-            console.error = (msg) => {
-                consoleOutput.push({ level: "error", msg });
-            };
-            console.debug = (msg) => {
-                consoleOutput.push({ level: "debug", msg });
-            };
-            // Test error level (0)
-            (0, logger_js_1.v3Logger)({
-                category: "test",
-                message: "Error message",
-                level: 0,
-            });
-            // Test info level (1)
-            (0, logger_js_1.v3Logger)({
-                category: "test",
-                message: "Info message",
-                level: 1,
-            });
-            // Test debug level (2)
-            (0, logger_js_1.v3Logger)({
-                category: "test",
-                message: "Debug message",
-                level: 2,
-            });
-            (0, test_1.expect)(consoleOutput.length).toBe(3);
-            (0, test_1.expect)(consoleOutput[0].level).toBe("error");
-            (0, test_1.expect)(consoleOutput[0].msg).toContain("ERROR");
-            (0, test_1.expect)(consoleOutput[0].msg).toContain("Error message");
-            (0, test_1.expect)(consoleOutput[1].level).toBe("log");
-            (0, test_1.expect)(consoleOutput[1].msg).toContain("INFO");
-            (0, test_1.expect)(consoleOutput[1].msg).toContain("Info message");
-            (0, test_1.expect)(consoleOutput[2].level).toBe("debug");
-            (0, test_1.expect)(consoleOutput[2].msg).toContain("DEBUG");
-            (0, test_1.expect)(consoleOutput[2].msg).toContain("Debug message");
-        }
-        finally {
-            console.log = originalConsoleLog;
-            console.error = originalConsoleError;
-            console.debug = originalConsoleDebug;
-        }
-    });
-    (0, test_1.test)("console fallback formats auxiliary data", () => {
-        const consoleOutput = [];
-        const originalConsoleLog = console.log;
-        try {
-            console.log = (msg) => {
-                consoleOutput.push(msg);
-            };
-            (0, logger_js_1.v3Logger)({
-                category: "test",
-                message: "Message with auxiliary",
-                level: 1,
-                auxiliary: {
-                    stringValue: { value: "test", type: "string" },
-                    integerValue: { value: "42", type: "integer" },
-                    objectValue: {
-                        value: JSON.stringify({ nested: "data" }),
-                        type: "object",
-                    },
-                },
-            });
-            (0, test_1.expect)(consoleOutput.length).toBe(1);
-            const output = consoleOutput[0];
-            (0, test_1.expect)(output).toContain("Message with auxiliary");
-            (0, test_1.expect)(output).toContain("stringValue");
-            (0, test_1.expect)(output).toContain("integerValue");
-            (0, test_1.expect)(output).toContain("objectValue");
-        }
-        finally {
-            console.log = originalConsoleLog;
-        }
-    });
-    (0, test_1.test)("concurrent instances don't interfere", () => {
-        const instances = Array.from({ length: 10 }, (_, i) => `instance-${i}`);
-        const logsByInstance = new Map();
-        // Bind all instances
-        instances.forEach((id) => {
-            const logs = [];
-            logsByInstance.set(id, logs);
-            (0, logger_js_1.bindInstanceLogger)(id, (line) => logs.push(line));
-        });
-        try {
-            // Log from each instance
-            instances.forEach((id, index) => {
-                (0, logger_js_1.withInstanceLogContext)(id, () => {
-                    (0, logger_js_1.v3Logger)({
-                        category: "test",
-                        message: `Message from ${id}`,
-                        level: 1,
-                        auxiliary: {
-                            index: { value: String(index), type: "integer" },
-                        },
-                    });
-                });
-            });
-            // Verify each instance received only its own log
-            instances.forEach((id) => {
-                const logs = logsByInstance.get(id);
-                (0, test_1.expect)(logs.length).toBe(1);
-                (0, test_1.expect)(logs[0].message).toBe(`Message from ${id}`);
-            });
-        }
-        finally {
-            instances.forEach((id) => (0, logger_js_1.unbindInstanceLogger)(id));
-        }
-    });
-});
-test_1.test.describe("V3 Logger with External Logger (Production Pattern)", () => {
-    test_1.test.afterEach(() => {
-        // Clean up instance loggers
-    });
-    (0, test_1.test)("external logger receives all logs from v3Logger", () => {
-        const instanceId = "v3-instance-with-external";
-        const externalLogs = [];
-        // Simulate V3 constructor behavior with external logger
-        const externalLogger = (line) => {
-            externalLogs.push(line);
-        };
-        (0, logger_js_1.bindInstanceLogger)(instanceId, externalLogger);
-        try {
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "a11y/snapshot",
-                    message: "Capturing hybrid snapshot",
-                    level: 0,
-                });
-                (0, logger_js_1.v3Logger)({
-                    category: "handlers/act",
-                    message: "Executing action",
-                    level: 1,
-                    auxiliary: {
-                        action: { value: "click", type: "string" },
-                    },
-                });
-                (0, logger_js_1.v3Logger)({
-                    category: "debug",
-                    message: "Debug details",
-                    level: 2,
-                });
-            });
-            // All logs should be captured by external logger
-            (0, test_1.expect)(externalLogs.length).toBe(3);
-            (0, test_1.expect)(externalLogs[0].message).toBe("Capturing hybrid snapshot");
-            (0, test_1.expect)(externalLogs[1].message).toBe("Executing action");
-            (0, test_1.expect)(externalLogs[2].message).toBe("Debug details");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("StagehandLogger wrapper forwards to external logger", () => {
-        const instanceId = "v3-with-stagehand-wrapper";
-        const externalLogs = [];
-        // Simulate V3's stagehandLogger.log() wrapping pattern
-        const mockStagehandLogger = {
-            log: (line) => {
-                // This simulates StagehandLogger.log() which internally calls externalLogger
-                externalLogs.push(line);
-            },
-        };
-        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => mockStagehandLogger.log(line));
-        try {
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Log through StagehandLogger wrapper",
-                    level: 1,
-                });
-            });
-            (0, test_1.expect)(externalLogs.length).toBe(1);
-            (0, test_1.expect)(externalLogs[0].message).toBe("Log through StagehandLogger wrapper");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("multiple V3 instances with different external loggers", () => {
-        const instance1Id = "v3-instance-1";
-        const instance2Id = "v3-instance-2";
-        const external1Logs = [];
-        const external2Logs = [];
-        // Simulate two V3 instances with different external loggers
-        (0, logger_js_1.bindInstanceLogger)(instance1Id, (line) => external1Logs.push(line));
-        (0, logger_js_1.bindInstanceLogger)(instance2Id, (line) => external2Logs.push(line));
-        try {
-            // Instance 1 logs
-            (0, logger_js_1.withInstanceLogContext)(instance1Id, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "instance1",
-                    message: "Instance 1 activity",
-                    level: 1,
-                });
-            });
-            // Instance 2 logs
-            (0, logger_js_1.withInstanceLogContext)(instance2Id, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "instance2",
-                    message: "Instance 2 activity",
-                    level: 1,
-                });
-            });
-            // Each external logger should only have its instance's logs
-            (0, test_1.expect)(external1Logs.length).toBe(1);
-            (0, test_1.expect)(external2Logs.length).toBe(1);
-            (0, test_1.expect)(external1Logs[0].message).toBe("Instance 1 activity");
-            (0, test_1.expect)(external2Logs[0].message).toBe("Instance 2 activity");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instance1Id);
-            (0, logger_js_1.unbindInstanceLogger)(instance2Id);
-        }
-    });
-    (0, test_1.test)("external logger receives logs with auxiliary data preserved", () => {
-        const instanceId = "v3-with-auxiliary";
-        const externalLogs = [];
-        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => externalLogs.push(line));
-        try {
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "extract",
-                    message: "Extracting data",
-                    level: 1,
-                    auxiliary: {
-                        selector: { value: "xpath=/html/body", type: "string" },
-                        timeout: { value: "5000", type: "integer" },
-                        retries: { value: "3", type: "integer" },
-                        metadata: {
-                            value: JSON.stringify({ key: "value" }),
-                            type: "object",
-                        },
-                    },
-                });
-            });
-            (0, test_1.expect)(externalLogs.length).toBe(1);
-            const log = externalLogs[0];
-            (0, test_1.expect)(log.auxiliary).toBeDefined();
-            (0, test_1.expect)(log.auxiliary?.selector?.value).toBe("xpath=/html/body");
-            (0, test_1.expect)(log.auxiliary?.timeout?.value).toBe("5000");
-            (0, test_1.expect)(log.auxiliary?.retries?.value).toBe("3");
-            (0, test_1.expect)(log.auxiliary?.metadata?.type).toBe("object");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("external logger handles rapid concurrent logs", () => {
-        const instanceId = "v3-rapid-logs";
-        const externalLogs = [];
-        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => externalLogs.push(line));
-        try {
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                // Simulate rapid logging like during snapshot capture
-                for (let i = 0; i < 50; i++) {
-                    (0, logger_js_1.v3Logger)({
-                        category: "perf",
-                        message: `Operation ${i}`,
-                        level: 2,
-                        auxiliary: {
-                            iteration: { value: String(i), type: "integer" },
-                        },
-                    });
-                }
-            });
-            // All logs should be captured
-            (0, test_1.expect)(externalLogs.length).toBe(50);
-            (0, test_1.expect)(externalLogs[0].message).toBe("Operation 0");
-            (0, test_1.expect)(externalLogs[49].message).toBe("Operation 49");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("external logger can filter by log level", () => {
-        const instanceId = "v3-with-filtering";
-        const errorLogs = [];
-        // External logger that only captures errors
-        const filteringLogger = (line) => {
-            if (line.level === 0) {
-                errorLogs.push(line);
-            }
-        };
-        (0, logger_js_1.bindInstanceLogger)(instanceId, filteringLogger);
-        try {
-            (0, logger_js_1.withInstanceLogContext)(instanceId, () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Info message",
-                    level: 1,
-                });
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Error message",
-                    level: 0,
-                });
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Debug message",
-                    level: 2,
-                });
-                (0, logger_js_1.v3Logger)({
-                    category: "test",
-                    message: "Another error",
-                    level: 0,
-                });
-            });
-            // Only error logs should be captured
-            (0, test_1.expect)(errorLogs.length).toBe(2);
-            (0, test_1.expect)(errorLogs[0].message).toBe("Error message");
-            (0, test_1.expect)(errorLogs[1].message).toBe("Another error");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-    (0, test_1.test)("external logger persists across async operations", async () => {
-        const instanceId = "v3-async-ops";
-        const externalLogs = [];
-        (0, logger_js_1.bindInstanceLogger)(instanceId, (line) => externalLogs.push(line));
-        try {
-            await (0, logger_js_1.withInstanceLogContext)(instanceId, async () => {
-                (0, logger_js_1.v3Logger)({
-                    category: "async",
-                    message: "Before async operation",
-                    level: 1,
-                });
-                await new Promise((resolve) => setTimeout(resolve, 50));
-                (0, logger_js_1.v3Logger)({
-                    category: "async",
-                    message: "After async operation",
-                    level: 1,
-                });
-                await Promise.all([
-                    Promise.resolve().then(() => (0, logger_js_1.v3Logger)({
-                        category: "async",
-                        message: "Parallel operation 1",
-                        level: 1,
-                    })),
-                    Promise.resolve().then(() => (0, logger_js_1.v3Logger)({
-                        category: "async",
-                        message: "Parallel operation 2",
-                        level: 1,
-                    })),
-                ]);
-            });
-            // All logs should be captured despite async boundaries
-            (0, test_1.expect)(externalLogs.length).toBe(4);
-            (0, test_1.expect)(externalLogs[0].message).toBe("Before async operation");
-            (0, test_1.expect)(externalLogs[1].message).toBe("After async operation");
-        }
-        finally {
-            (0, logger_js_1.unbindInstanceLogger)(instanceId);
-        }
-    });
-});
-//# sourceMappingURL=logger-initialization.spec.js.map