@testdino/playwright 1.0.4 → 1.0.6

package/dist/index.js

@@ -57,6 +57,7 @@ function isQuotaError(error) {
 
 // src/streaming/websocket.ts
 var HANDSHAKE_TIMEOUT_MS = 1e4;
+var DEFAULT_ACK_TIMEOUT_MS = 5e3;
 var WebSocketClient = class {
   ws = null;
   options;
@@ -65,11 +66,16 @@ var WebSocketClient = class {
   isConnecting = false;
   isClosed = false;
   pingInterval = null;
+  pendingAcks = /* @__PURE__ */ new Map();
+  ackTimeout = DEFAULT_ACK_TIMEOUT_MS;
+  debug;
   constructor(options) {
+    this.debug = options.debug ?? false;
     this.options = {
       sessionId: "",
       maxRetries: 5,
       retryDelay: 1e3,
+      debug: false,
       onConnected: () => {
       },
       onDisconnected: () => {
@@ -100,9 +106,11 @@ var WebSocketClient = class {
         let serverReady = false;
         const handshakeTimeout = setTimeout(() => {
           if (!serverReady) {
-            console.warn(
-              `\u26A0\uFE0F  TestDino: WebSocket handshake timeout \u2014 server did not send 'connected' within ${HANDSHAKE_TIMEOUT_MS}ms. Resolving anyway.`
-            );
+            if (this.debug) {
+              console.warn(
+                `\u26A0\uFE0F  TestDino: WebSocket handshake timeout \u2014 server did not send 'connected' within ${HANDSHAKE_TIMEOUT_MS}ms. Resolving anyway.`
+              );
+            }
             serverReady = true;
             this.isConnecting = false;
             this.options.onConnected();
@@ -173,6 +181,7 @@ var WebSocketClient = class {
   }
   /**
    * Send multiple events in batch (parallel for speed)
+   * Note: Uses Promise.all intentionally - if one send fails, connection is broken
    */
   async sendBatch(events) {
     if (!this.ws || this.ws.readyState !== WebSocket__default.default.OPEN) {
@@ -180,6 +189,36 @@ var WebSocketClient = class {
     }
     await Promise.all(events.map((event) => this.send(event)));
   }
+  /**
+   * Send event and wait for server ACK
+   * Use this for critical events like run:end where delivery must be confirmed
+   */
+  async sendAndWaitForAck(event, timeout = this.ackTimeout) {
+    if (!this.ws || this.ws.readyState !== WebSocket__default.default.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    const sequence = event.sequence;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingAcks.delete(sequence);
+        reject(new Error(`ACK timeout for sequence ${sequence} after ${timeout}ms`));
+      }, timeout);
+      this.pendingAcks.set(sequence, { resolve, reject, timer });
+      this.ws.send(JSON.stringify(event), (error) => {
+        if (error) {
+          clearTimeout(timer);
+          this.pendingAcks.delete(sequence);
+          reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * Set ACK timeout for sendAndWaitForAck
+   */
+  setAckTimeout(timeout) {
+    this.ackTimeout = timeout;
+  }
   /**
    * Check if WebSocket is connected
    */
@@ -193,11 +232,22 @@ var WebSocketClient = class {
     this.isClosed = true;
     this.stopPing();
     this.clearReconnectTimer();
+    this.clearPendingAcks();
     if (this.ws) {
       this.ws.close();
       this.ws = null;
     }
   }
+  /**
+   * Clear all pending ACKs (reject them with connection closed error)
+   */
+  clearPendingAcks() {
+    for (const [sequence, pending] of this.pendingAcks) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error(`Connection closed while waiting for ACK on sequence ${sequence}`));
+    }
+    this.pendingAcks.clear();
+  }
   /**
    * Handle incoming messages
    */
@@ -206,6 +256,16 @@ var WebSocketClient = class {
       const message = JSON.parse(data);
       if (message.type === "connected") {
       } else if (message.type === "ack") {
+        const sequence = typeof message.sequence === "number" ? message.sequence : void 0;
+        if (sequence === void 0) {
+          return;
+        }
+        if (this.pendingAcks.has(sequence)) {
+          const pending = this.pendingAcks.get(sequence);
+          clearTimeout(pending.timer);
+          this.pendingAcks.delete(sequence);
+          pending.resolve();
+        }
       } else if (message.type === "nack") {
         const nack = message;
         if (isServerError(nack.error)) {
@@ -247,7 +307,9 @@ var WebSocketClient = class {
         }
       }
     } catch (error) {
-      console.error("Failed to parse WebSocket message:", error);
+      if (this.debug) {
+        console.error("Failed to parse WebSocket message:", error);
+      }
     }
   }
   /**
@@ -255,6 +317,7 @@ var WebSocketClient = class {
    */
   handleClose(_code, _reason) {
     this.stopPing();
+    this.clearPendingAcks();
     this.options.onDisconnected();
     if (this.isClosed) {
       return;
@@ -274,7 +337,9 @@ var WebSocketClient = class {
     this.reconnectAttempts++;
     this.reconnectTimer = setTimeout(() => {
       this.connect().catch((error) => {
-        console.error("Reconnection failed:", error);
+        if (this.debug) {
+          console.error("Reconnection failed:", error);
+        }
       });
     }, delay);
   }
@@ -308,6 +373,16 @@ var WebSocketClient = class {
     }
   }
 };
+
+// src/utils/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isDebugEnabled() {
+  return process.env.TESTDINO_DEBUG === "true" || process.env.TESTDINO_DEBUG === "1" || process.env.DEBUG === "true";
+}
+
+// src/streaming/http.ts
 var HttpClient = class {
   client;
   options;
@@ -354,7 +429,7 @@ var HttpClient = class {
         lastError = new Error(this.getErrorMessage(error));
         if (attempt < this.options.maxRetries - 1) {
           const delay = this.options.retryDelay * Math.pow(2, attempt);
-          await this.sleep(delay);
+          await sleep(delay);
         }
       }
     }
@@ -378,12 +453,6 @@ var HttpClient = class {
     }
     return String(error);
   }
-  /**
-   * Sleep utility for retry delays
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
 };
 
 // src/streaming/buffer.ts
@@ -571,7 +640,7 @@ var GitMetadataCollector = class extends BaseMetadataCollector {
     if (!isGitRepo) {
       return this.getEmptyMetadata();
     }
-    const results = await Promise.all([
+    const results = await Promise.allSettled([
       this.getBranch(),
       this.getCommitHash(),
       this.getCommitMessage(),
@@ -581,9 +650,15 @@ var GitMetadataCollector = class extends BaseMetadataCollector {
       this.getRepoUrl(),
       this.isDirtyWorkingTree()
     ]);
-    let [branch, hash, message, author, email, timestamp] = results;
-    const repoUrl = results[6];
-    const isDirty = results[7];
+    const extractedValues = results.map((r) => r.status === "fulfilled" ? r.value : void 0);
+    let branch = extractedValues[0];
+    let hash = extractedValues[1];
+    let message = extractedValues[2];
+    let author = extractedValues[3];
+    let email = extractedValues[4];
+    let timestamp = extractedValues[5];
+    const repoUrl = extractedValues[6];
+    const isDirty = extractedValues[7];
     let prMetadata;
     if (process.env.GITHUB_EVENT_NAME === "pull_request") {
       const eventData = await this.readGitHubEventFile();
@@ -1249,9 +1324,13 @@ var PlaywrightMetadataCollector = class extends BaseMetadataCollector {
       metadata.workers = config.workers;
     }
     if (Array.isArray(config.projects) && config.projects.length > 0) {
-      const projectNames = config.projects.map((project) => project.name).filter((name) => this.isNonEmptyString(name));
-      if (projectNames.length > 0) {
-        metadata.projects = projectNames;
+      const projectConfigs = config.projects.filter((project) => this.isNonEmptyString(project.name)).map((project) => this.extractProjectConfig(project));
+      if (projectConfigs.length > 0) {
+        metadata.projects = projectConfigs;
+        const browsers = this.extractBrowsersFromProjects(config.projects);
+        if (browsers.length > 0) {
+          metadata.browsers = browsers;
+        }
       }
     }
     if (config.reportSlowTests && typeof config.reportSlowTests === "object") {
@@ -1277,6 +1356,151 @@ var PlaywrightMetadataCollector = class extends BaseMetadataCollector {
     }
     return metadata;
   }
+  /**
+   * Extract project configuration from FullProject
+   */
+  extractProjectConfig(project) {
+    const config = {
+      name: project.name || ""
+    };
+    if (this.isNonEmptyString(project.testDir)) {
+      config.testDir = project.testDir;
+    }
+    if (typeof project.timeout === "number") {
+      config.timeout = project.timeout;
+    }
+    if (typeof project.retries === "number") {
+      config.retries = project.retries;
+    }
+    if (typeof project.repeatEach === "number" && project.repeatEach > 1) {
+      config.repeatEach = project.repeatEach;
+    }
+    if (Array.isArray(project.dependencies) && project.dependencies.length > 0) {
+      config.dependencies = project.dependencies;
+    }
+    if (project.grep) {
+      const patterns = Array.isArray(project.grep) ? project.grep : [project.grep];
+      const grepStrings = patterns.map((p) => p.source);
+      if (grepStrings.length > 0) {
+        config.grep = grepStrings;
+      }
+    }
+    if (project.use) {
+      const useOptions = this.extractUseOptions(project.use);
+      if (Object.keys(useOptions).length > 0) {
+        config.use = useOptions;
+      }
+    }
+    return config;
+  }
+  /**
+   * Extract use options from project.use
+   */
+  extractUseOptions(use) {
+    const options = {};
+    if (!use) return options;
+    if (this.isNonEmptyString(use.channel)) {
+      options.channel = use.channel;
+    }
+    const browserName = this.resolveBrowserName(use.browserName, use.defaultBrowserType, use.channel);
+    if (browserName) {
+      options.browserName = browserName;
+    }
+    if (typeof use.headless === "boolean") {
+      options.headless = use.headless;
+    }
+    if (use.viewport && typeof use.viewport === "object") {
+      options.viewport = {
+        width: use.viewport.width,
+        height: use.viewport.height
+      };
+    } else if (use.viewport === null) {
+      options.viewport = null;
+    }
+    if (this.isNonEmptyString(use.baseURL)) {
+      options.baseURL = use.baseURL;
+    }
+    const trace = this.normalizeArtifactMode(use.trace);
+    if (trace) {
+      options.trace = trace;
+    }
+    const screenshot = this.normalizeArtifactMode(use.screenshot);
+    if (screenshot) {
+      options.screenshot = screenshot;
+    }
+    const video = this.normalizeArtifactMode(use.video);
+    if (video) {
+      options.video = video;
+    }
+    if (typeof use.isMobile === "boolean") {
+      options.isMobile = use.isMobile;
+    }
+    if (this.isNonEmptyString(use.locale)) {
+      options.locale = use.locale;
+    }
+    return options;
+  }
+  /**
+   * Normalize artifact mode (trace/screenshot/video can be string or { mode: string })
+   */
+  normalizeArtifactMode(value) {
+    if (!value) return void 0;
+    if (typeof value === "string" && value !== "off") {
+      return value;
+    }
+    if (typeof value === "object" && value !== null && "mode" in value) {
+      const mode = value.mode;
+      if (mode && mode !== "off") {
+        return mode;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Resolve browserName from explicit value, defaultBrowserType (device presets), or channel
+   * Priority: browserName > defaultBrowserType > channel inference
+   */
+  resolveBrowserName(browserName, defaultBrowserType, channel) {
+    const validBrowsers = ["chromium", "firefox", "webkit"];
+    if (browserName && validBrowsers.includes(browserName)) {
+      return browserName;
+    }
+    if (defaultBrowserType && validBrowsers.includes(defaultBrowserType)) {
+      return defaultBrowserType;
+    }
+    if (channel) {
+      if ([
+        "chrome",
+        "chrome-beta",
+        "chrome-dev",
+        "chrome-canary",
+        "msedge",
+        "msedge-beta",
+        "msedge-dev",
+        "msedge-canary"
+      ].includes(channel)) {
+        return "chromium";
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Extract unique browsers from all projects
+   */
+  extractBrowsersFromProjects(projects) {
+    const browsers = /* @__PURE__ */ new Set();
+    for (const project of projects) {
+      const browserName = this.resolveBrowserName(
+        project.use?.browserName,
+        project.use?.defaultBrowserType,
+        project.use?.channel
+      );
+      if (browserName) {
+        browsers.add(browserName);
+      }
+    }
+    return Array.from(browsers);
+  }
   /**
    * Build skeleton from Suite
    */
@@ -1383,9 +1607,6 @@ var MetadataAggregator = class {
    */
   async collectAll() {
     const startTime = Date.now();
-    if (this.options.debug) {
-      console.log(`\u{1F50D} TestDino: Starting metadata collection with ${this.collectors.length} collectors`);
-    }
     const settledResults = await Promise.allSettled(
       this.collectors.map(
         (collector) => this.withTimeout(collector.collectWithResult(), this.options.timeout, "Metadata collection")
@@ -1413,11 +1634,6 @@ var MetadataAggregator = class {
     const totalDuration = Date.now() - startTime;
     const successCount = results.filter((r) => r.success).length;
     const failureCount = results.length - successCount;
-    if (this.options.debug) {
-      console.log(
-        `\u2705 TestDino: Metadata collection completed in ${totalDuration}ms (${successCount}/${results.length} successful)`
-      );
-    }
     return {
       metadata,
       results,
@@ -1516,7 +1732,7 @@ var SASTokenClient = class {
         lastError = new Error(this.getErrorMessage(error));
         if (attempt < this.options.maxRetries - 1) {
           const delay = this.options.retryDelay * Math.pow(2, attempt);
-          await this.sleep(delay);
+          await sleep(delay);
         }
       }
     }
@@ -1543,12 +1759,6 @@ var SASTokenClient = class {
     }
     return String(error);
   }
-  /**
-   * Sleep utility for retry delays
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
 };
 var ArtifactUploader = class {
   sasToken;
@@ -1683,7 +1893,7 @@ var ArtifactUploader = class {
         lastError = error instanceof Error ? error : new Error(String(error));
         if (attempt < this.options.maxRetries - 1) {
           const delay = 1e3 * Math.pow(2, attempt);
-          await this.sleep(delay);
+          await sleep(delay);
         }
       }
     }
@@ -1706,12 +1916,6 @@ var ArtifactUploader = class {
       maxBodyLength: Infinity
     });
   }
-  /**
-   * Sleep utility for retry delays
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
   /**
    * Check if SAS token is still valid
    */
@@ -1728,6 +1932,19 @@ var ArtifactUploader = class {
   }
 };
 
+// src/reporter/log.ts
+var createReporterLog = (options) => ({
+  success: (msg) => console.log(`\u2705 TestDino: ${msg}`),
+  warn: (msg) => console.warn(`\u26A0\uFE0F  TestDino: ${msg}`),
+  error: (msg) => console.error(`\u274C TestDino: ${msg}`),
+  info: (msg) => console.log(`\u2139\uFE0F TestDino: ${msg}`),
+  debug: (msg) => {
+    if (options.debug) {
+      console.log(`\u{1F50D} TestDino: ${msg}`);
+    }
+  }
+});
+
 // src/reporter/index.ts
 var MAX_CONSOLE_CHUNK_SIZE = 1e4;
 var MAX_BUFFER_SIZE = 10;
@@ -1759,10 +1976,13 @@ var TestdinoReporter = class {
   initFailed = false;
   // Promises for onTestEnd; must be awaited in onEnd to prevent data loss
   pendingTestEndPromises = /* @__PURE__ */ new Set();
+  // Logger for consistent output
+  log;
   constructor(config = {}) {
     const cliConfig = this.loadCliConfig();
     this.config = { ...config, ...cliConfig };
     this.runId = crypto.randomUUID();
+    this.log = createReporterLog({ debug: this.config.debug ?? false });
     this.buffer = new EventBuffer({
       maxSize: MAX_BUFFER_SIZE,
       onFlush: async (events) => {
@@ -1806,7 +2026,7 @@ var TestdinoReporter = class {
       }
       return mappedConfig;
     } catch (error) {
-      if (process.env.TESTDINO_DEBUG === "true" || process.env.TESTDINO_DEBUG === "1") {
+      if (isDebugEnabled()) {
         console.warn(
           "\u26A0\uFE0F  TestDino: Failed to load CLI config:",
           error instanceof Error ? error.message : String(error)
@@ -1821,7 +2041,7 @@ var TestdinoReporter = class {
   async onBegin(config, suite) {
     if (config && this.isDuplicateInstance(config.reporter)) {
       if (this.config.debug) {
-        console.log("\u26A0\uFE0F  TestDino: Reporter already configured in playwright.config, skipping duplicate instance");
+        this.log.debug("Reporter already configured in playwright.config, skipping duplicate instance");
       }
       return;
     }
@@ -1861,19 +2081,20 @@ var TestdinoReporter = class {
       this.httpClient = new HttpClient({ token, serverUrl });
       const auth = await this.httpClient.authenticate();
       this.sessionId = auth.sessionId;
-      console.log("\u2705 TestDino: Authenticated successfully");
+      this.log.success("Authenticated successfully");
       if (this.config.debug) {
-        console.log(`\u{1F50C} TestDino: Session ${this.sessionId} \u2014 reusing for WebSocket`);
+        this.log.debug(`Session ${this.sessionId} \u2014 reusing for WebSocket`);
       }
       this.wsClient = new WebSocketClient({
         token,
         sessionId: this.sessionId ?? void 0,
         serverUrl: this.getWebSocketUrl(),
+        debug: this.config.debug,
         onConnected: () => {
-          console.log("\u{1F50C} TestDino: WebSocket connected");
+          this.log.debug("WebSocket connected");
         },
         onDisconnected: () => {
-          console.log("\u{1F50C} TestDino: WebSocket disconnected");
+          this.log.debug("WebSocket disconnected");
         },
         onError: (error) => {
           if (isQuotaError(error)) {
@@ -1883,14 +2104,14 @@ var TestdinoReporter = class {
               this.printQuotaError(error);
             }
           } else {
-            console.error("\u274C TestDino: WebSocket error:", error.message);
+            this.log.error(`WebSocket error: ${error.message}`);
           }
         }
       });
       try {
         await this.wsClient.connect();
       } catch {
-        console.warn("\u26A0\uFE0F  TestDino: WebSocket connection failed, using HTTP fallback");
+        this.log.warn("WebSocket connection failed, using HTTP fallback");
         this.useHttpFallback = true;
       }
       this.artifactsEnabled = this.config.artifacts !== false;
@@ -1906,18 +2127,13 @@ var TestdinoReporter = class {
         ...this.getEventMetadata()
       };
       if (this.config.debug) {
-        console.log(`\u{1F50D} TestDino: run:begin event details:`);
-        console.log(`   runId: ${this.runId}`);
-        console.log(`   ciRunId: ${this.config.ciRunId ?? "(not set)"}`);
-        console.log(`   shard: ${config?.shard ? `${config.shard.current}/${config.shard.total}` : "(not sharded)"}`);
-        if (metadata.skeleton) {
-          console.log(`   skeleton.totalTests: ${metadata.skeleton.totalTests}`);
-          console.log(`   skeleton.suites: ${metadata.skeleton.suites?.length ?? 0}`);
-          console.log(`   skeleton: ${JSON.stringify(metadata.skeleton, null, 2)}`);
-        } else {
-          console.log(`   skeleton: (not available)`);
-        }
+        const shardInfo = config?.shard ? `${config.shard.current}/${config.shard.total}` : "none";
+        const skeletonInfo = metadata.skeleton ? `${metadata.skeleton.totalTests} tests, ${metadata.skeleton.suites?.length ?? 0} suites` : "not available";
+        this.log.debug(
+          `run:begin runId=${this.runId} ciRunId=${this.config.ciRunId ?? "none"} shard=${shardInfo} skeleton=(${skeletonInfo})`
+        );
       }
+      console.log("[TEMP DEBUG] run:begin metadata:", JSON.stringify(metadata, null, 2));
       await this.sendEvents([beginEvent]);
       this.registerSignalHandlers();
       return true;
@@ -2058,10 +2274,9 @@ var TestdinoReporter = class {
     await this.buffer.add(event);
   }
   /**
-   /**
-    * Called after each test.
-    * Playwright does not await onTestEnd promises—pending work is awaited in onEnd.
-    */
+   * Called after each test.
+   * Playwright does not await onTestEnd promises—pending work is awaited in onEnd.
+   */
   onTestEnd(test, result) {
     if (!this.initPromise || this.initFailed) return;
     const workPromise = this.processTestEnd(test, result);
@@ -2110,10 +2325,7 @@ var TestdinoReporter = class {
       };
       await this.buffer.add(event);
     } catch (error) {
-      console.error(
-        "\u274C TestDino: Failed to process test:end event:",
-        error instanceof Error ? error.message : String(error)
-      );
+      this.log.error(`Failed to process test:end event: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   /**
@@ -2124,7 +2336,7 @@ var TestdinoReporter = class {
       if (this.pendingTestEndPromises.size > 0) {
         await Promise.allSettled(Array.from(this.pendingTestEndPromises));
       }
-      console.log("\u2705 TestDino: Tests completed (quota limit reached; not streamed to TestDino)");
+      this.log.success("Tests completed (quota limit reached; not streamed to TestDino)");
       this.wsClient?.close();
       this.removeSignalHandlers();
       return;
@@ -2139,9 +2351,7 @@ var TestdinoReporter = class {
       return;
     }
     if (this.pendingTestEndPromises.size > 0) {
-      if (this.config.debug) {
-        console.log(`\u{1F50D} TestDino: Waiting for ${this.pendingTestEndPromises.size} pending test:end events...`);
-      }
+      this.log.debug(`Waiting for ${this.pendingTestEndPromises.size} pending test:end events...`);
       await Promise.allSettled(Array.from(this.pendingTestEndPromises));
     }
     const event = {
@@ -2156,12 +2366,43 @@ var TestdinoReporter = class {
       // Shard information
       shard: this.shardInfo
     };
-    await this.buffer.add(event);
     try {
       await this.buffer.flush();
-      console.log("\u2705 TestDino: All events sent successfully");
     } catch (error) {
-      console.error("\u274C TestDino: Failed to flush final events:", error);
+      this.log.error(`Failed to flush buffered events: ${error}`);
+    }
+    let delivered = false;
+    try {
+      if (this.wsClient?.isConnected()) {
+        await this.wsClient.sendAndWaitForAck(event);
+        this.log.success("All events delivered (server acknowledged)");
+        delivered = true;
+      } else if (this.httpClient) {
+        await this.httpClient.sendEvents([event]);
+        this.log.success("All events sent");
+        delivered = true;
+      } else {
+        this.log.warn("No connection available to send run:end event");
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("ACK timeout") || errorMessage.includes("Connection closed")) {
+        if (this.httpClient && !delivered) {
+          try {
+            this.log.warn("WebSocket ACK timeout, retrying via HTTP...");
+            await this.httpClient.sendEvents([event]);
+            this.log.success("All events sent (HTTP fallback)");
+            delivered = true;
+          } catch (httpError) {
+            const httpErrorMessage = httpError instanceof Error ? httpError.message : String(httpError);
+            this.log.error(`HTTP fallback also failed: ${httpErrorMessage}`);
+          }
+        } else if (!delivered) {
+          this.log.warn("Server did not acknowledge run:end in time, events may be pending");
+        }
+      } else {
+        this.log.error(`Failed to send run:end event: ${errorMessage}`);
+      }
     }
     this.wsClient?.close();
     this.removeSignalHandlers();
@@ -2236,16 +2477,16 @@ var TestdinoReporter = class {
       for (const event of events) {
         if (event.type === "test:begin") {
           const testBeginEvent = event;
-          console.log(
-            `\u{1F50D} TestDino: Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId} testId=${testBeginEvent.testId} retry=${testBeginEvent.retry} parallelIndex=${testBeginEvent.parallelIndex} title=${testBeginEvent.title}`
+          this.log.debug(
+            `Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId} testId=${testBeginEvent.testId} retry=${testBeginEvent.retry} parallelIndex=${testBeginEvent.parallelIndex} title=${testBeginEvent.title}`
           );
         } else if (event.type === "test:end") {
           const testEndEvent = event;
-          console.log(
-            `\u{1F50D} TestDino: Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId} testId=${testEndEvent.testId} retry=${testEndEvent.retry} parallelIndex=${testEndEvent.parallelIndex}`
+          this.log.debug(
+            `Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId} testId=${testEndEvent.testId} retry=${testEndEvent.retry} parallelIndex=${testEndEvent.parallelIndex}`
           );
         } else {
-          console.log(`\u{1F50D} TestDino: Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId}`);
+          this.log.debug(`Sending event type=${event.type} sequence=${event.sequence} runId=${event.runId}`);
         }
       }
     }
@@ -2254,7 +2495,7 @@ var TestdinoReporter = class {
         await this.wsClient.sendBatch(events);
         return;
       } catch {
-        console.warn("\u26A0\uFE0F  TestDino: WebSocket send failed, switching to HTTP fallback");
+        this.log.warn("WebSocket send failed, switching to HTTP fallback");
         this.useHttpFallback = true;
       }
     }
@@ -2262,7 +2503,7 @@ var TestdinoReporter = class {
       try {
         await this.httpClient.sendEvents(events);
       } catch (error) {
-        console.error("\u274C TestDino: Failed to send events via HTTP:", error);
+        this.log.error(`Failed to send events via HTTP: ${error}`);
         throw error;
       }
     }
@@ -2293,7 +2534,7 @@ var TestdinoReporter = class {
       const metadataCollector = createMetadataCollector(playwrightConfig, playwrightSuite);
       const result = await metadataCollector.collectAll();
       if (result.failureCount > 0) {
-        console.warn(`\u26A0\uFE0F  TestDino: ${result.failureCount}/${result.results.length} metadata collectors failed`);
+        this.log.warn(`${result.failureCount}/${result.results.length} metadata collectors failed`);
       }
       const skeleton = metadataCollector.buildSkeleton(playwrightSuite);
       return {
@@ -2301,7 +2542,7 @@ var TestdinoReporter = class {
         skeleton
       };
     } catch (error) {
-      console.warn("\u26A0\uFE0F  TestDino: Metadata collection failed:", error instanceof Error ? error.message : String(error));
+      this.log.warn(`Metadata collection failed: ${error instanceof Error ? error.message : String(error)}`);
       return {};
     }
   }
@@ -2603,8 +2844,7 @@ var TestdinoReporter = class {
   handleInterruption(signal, exitCode) {
     if (this.isShuttingDown) return;
     this.isShuttingDown = true;
-    console.log(`
-\u26A0\uFE0F  TestDino: Received ${signal}, sending interruption event...`);
+    this.log.warn(`Received ${signal}, sending interruption event...`);
     if (!this.initPromise) {
       process.exit(exitCode);
     }
@@ -2632,7 +2872,7 @@ var TestdinoReporter = class {
     }, 100);
     const forceExitTimer = setTimeout(() => {
       clearInterval(keepAlive);
-      console.error("\u274C TestDino: Force exit - send timeout exceeded");
+      this.log.error("Force exit - send timeout exceeded");
       this.wsClient?.close();
       process.exit(exitCode);
     }, 3e3);
@@ -2640,10 +2880,10 @@ var TestdinoReporter = class {
       try {
         await waitForPending();
         await Promise.race([this.sendInterruptionEvent(event), this.timeoutPromise(2500, "Send timeout")]);
-        console.log("\u2705 TestDino: Interruption event sent");
+        this.log.success("Interruption event sent");
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        console.error(`\u274C TestDino: Failed to send interruption event: ${errorMsg}`);
+        this.log.error(`Failed to send interruption event: ${errorMsg}`);
       } finally {
         clearTimeout(forceExitTimer);
         clearInterval(keepAlive);
@@ -2667,7 +2907,7 @@ var TestdinoReporter = class {
         await this.wsClient.send(event);
         return;
       } catch {
-        console.warn("\u26A0\uFE0F  WebSocket send failed, trying HTTP");
+        this.log.warn("WebSocket send failed, trying HTTP");
       }
     }
     if (this.httpClient) {
@@ -2703,11 +2943,9 @@ var TestdinoReporter = class {
       this.artifactUploader = new ArtifactUploader(sasToken, {
         debug: this.config.debug
       });
-      if (this.config.debug) {
-        console.log("\u{1F4E4} TestDino: Artifact uploads enabled");
-      }
+      this.log.debug("Artifact uploads enabled");
     } catch (error) {
-      console.warn("\u26A0\uFE0F  TestDino: Artifact uploads disabled -", error instanceof Error ? error.message : String(error));
+      this.log.warn(`Artifact uploads disabled - ${error instanceof Error ? error.message : String(error)}`);
       this.artifactsEnabled = false;
       this.artifactUploader = null;
     }