@stanterprise/playwright-reporter 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 Stanterprise Team
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,279 @@
+# stanterprise-playwright-reporter
+
+Custom Playwright test reporter that sends test results to Stanterprise via gRPC.
+
+## Features
+
+- 📊 **Comprehensive Test Reporting**: Reports test lifecycle events including begin, end, and failures
+- 🔄 **Step Tracking**: Tracks and reports individual test steps with timing and status
+- 📎 **Attachment Support**: Handles screenshots, videos, and other test attachments
+- 🔌 **gRPC Integration**: Communicates with Stanterprise backend via gRPC protocol
+- ⚙️ **Configurable**: Supports environment variables and configuration options
+- 🛡️ **Error Resilient**: Graceful error handling that doesn't interrupt test execution
+
+## Installation
+
+```bash
+npm install stanterprise-playwright-reporter --save-dev
+```
+
+## Configuration
+
+### Basic Setup
+
+Add the reporter to your `playwright.config.ts`:
+
+```typescript
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [["stanterprise-playwright-reporter"]],
+  // ... other config
+});
+```
+
+### Advanced Configuration
+
+```typescript
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [
+    [
+      "stanterprise-playwright-reporter",
+      {
+        grpcAddress: "localhost:50051", // gRPC server address
+        grpcEnabled: true, // Enable/disable gRPC reporting
+        grpcTimeout: 1000, // Timeout for gRPC calls in milliseconds
+        verbose: false, // Enable verbose logging
+      },
+    ],
+  ],
+  // ... other config
+});
+```
+
+### Environment Variables
+
+You can also configure the reporter using environment variables:
+
+- `STANTERPRISE_GRPC_ADDRESS`: gRPC server address (default: `localhost:50051`)
+- `STANTERPRISE_GRPC_ENABLED`: Enable/disable gRPC reporting (default: `true`)
+
+Example:
+
+```bash
+STANTERPRISE_GRPC_ADDRESS=myserver.com:50051 npx playwright test
+```
+
+## Configuration Options
+
+| Option         | Type    | Default          | Description                               |
+| -------------- | ------- | ---------------- | ----------------------------------------- |
+| `grpcAddress`  | string  | `localhost:50051`| gRPC server address                       |
+| `grpcEnabled`  | boolean | `true`           | Enable/disable gRPC reporting             |
+| `grpcTimeout`  | number  | `1000`           | Timeout for gRPC calls in milliseconds    |
+| `verbose`      | boolean | `false`          | Enable verbose logging                    |
+
+## What Gets Reported
+
+### Test Events
+
+- **Test Begin**: When a test starts
+- **Test End**: When a test completes with status (passed/failed/skipped/timedOut)
+- **Test Failure**: Detailed failure information including error messages and stack traces
+
+### Step Events
+
+- **Step Begin**: When a test step starts
+- **Step End**: When a test step completes with duration and status
+
+### Attachments
+
+The reporter automatically processes and sends:
+- Screenshots
+- Videos
+- Trace files
+- Any other attachments captured during test execution
+
+## Usage Example
+
+```typescript
+// playwright.config.ts
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  use: {
+    screenshot: "only-on-failure",
+    video: "retain-on-failure",
+  },
+  reporter: [
+    ["list"], // Also show in console
+    [
+      "stanterprise-playwright-reporter",
+      {
+        grpcAddress: process.env.STANTERPRISE_GRPC_ADDRESS || "localhost:50051",
+        verbose: process.env.CI === "true",
+      },
+    ],
+  ],
+});
+```
+
+## API
+
+### StanterpriseReporter
+
+Main reporter class implementing Playwright's `Reporter` interface.
+
+```typescript
+import { StanterpriseReporter } from "stanterprise-playwright-reporter";
+
+const reporter = new StanterpriseReporter({
+  grpcAddress: "localhost:50051",
+  grpcEnabled: true,
+  grpcTimeout: 1000,
+  verbose: false,
+});
+```
+
+### Types
+
+```typescript
+import type {
+  StanterpriseReporterOptions,
+  TestExecutionContext,
+  StepExecutionContext,
+} from "stanterprise-playwright-reporter";
+```
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+### Cleaning
+
+```bash
+npm run clean
+```
+
+## How It Works
+
+1. **Test Run Initialization**: When tests start, the reporter generates a unique run ID and establishes a gRPC connection
+2. **Event Reporting**: As tests execute, the reporter sends events to the Stanterprise backend via gRPC
+3. **Fire-and-Forget**: Events are sent asynchronously to avoid slowing down test execution
+4. **Error Handling**: Connection errors are logged once and further attempts are disabled for that run
+5. **Cleanup**: When tests complete, the gRPC connection is properly closed
+
+## Architecture
+
+The reporter is organized into several modules:
+
+- **reporter.ts**: Main reporter implementation
+- **types.ts**: TypeScript type definitions and interfaces
+- **utils/statusMapper.ts**: Maps Playwright statuses to protobuf enums
+- **utils/attachmentProcessor.ts**: Processes test attachments
+- **utils/timeHelpers.ts**: Handles timestamp and duration conversions
+
+## Troubleshooting
+
+### Connection Issues
+
+If you see gRPC connection errors:
+
+1. Verify the gRPC server is running and accessible
+2. Check the `grpcAddress` configuration
+3. Ensure firewall rules allow the connection
+4. Enable verbose logging to see detailed error messages
+
+### Reporter Not Working
+
+1. Verify the reporter is properly configured in `playwright.config.ts`
+2. Check that `grpcEnabled` is not set to `false`
+3. Look for error messages in the test output
+4. Try with `verbose: true` to see detailed logs
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## For Maintainers
+
+### Publishing to NPM
+
+#### Automated Publishing (Recommended)
+
+The repository uses GitHub Actions to automatically publish to NPM when a version tag is pushed:
+
+1. Update the version following [semantic versioning](https://semver.org/):
+   ```bash
+   npm version patch  # for bug fixes (1.0.0 → 1.0.1)
+   npm version minor  # for new features (1.0.0 → 1.1.0)
+   npm version major  # for breaking changes (1.0.0 → 2.0.0)
+   ```
+
+2. Push the version tag to GitHub:
+   ```bash
+   git push --follow-tags
+   ```
+
+3. The GitHub Actions workflow will automatically:
+   - Run tests
+   - Build the package
+   - Publish to NPM with provenance
+
+**Note**: Requires `NPM_TOKEN` secret to be configured in GitHub repository settings with a valid NPM access token.
+
+#### Manual Publishing
+
+Alternatively, you can publish manually:
+
+1. Ensure all tests pass:
+   ```bash
+   npm test
+   ```
+
+2. Update the version:
+   ```bash
+   npm version patch|minor|major
+   ```
+
+3. Publish to NPM (prepublishOnly script will build automatically):
+   ```bash
+   npm publish
+   ```
+
+4. Push the tag to GitHub:
+   ```bash
+   git push --follow-tags
+   ```
+
+### What Gets Published
+
+The package includes:
+- `dist/` - Compiled JavaScript and TypeScript declarations
+- `README.md` - Documentation
+
+The following are excluded via `.npmignore`:
+- Source files (`src/`, `tests/`, `examples/`)
+- Development configuration files
+- Build artifacts and logs
+
+## License
+
+ISC - See [LICENSE](LICENSE) file for details
+
+## Support
+
+For issues and questions, please visit the [GitHub repository](https://github.com/stanterprise/stanterprise-playwright-reporter).
+

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./reporter";
+export { default as StanterpriseReporter } from "./reporter";
+export type { StanterpriseReporterOptions, TestExecutionContext, StepExecutionContext } from "./types";

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StanterpriseReporter = exports.default = void 0;
+var reporter_1 = require("./reporter");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(reporter_1).default; } });
+var reporter_2 = require("./reporter");
+Object.defineProperty(exports, "StanterpriseReporter", { enumerable: true, get: function () { return __importDefault(reporter_2).default; } });

package/dist/reporter.d.ts

@@ -0,0 +1,36 @@
+import type { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult, TestStep, TestError } from "@playwright/test/reporter";
+import { StanterpriseReporterOptions } from "./types";
+export default class StanterpriseReporter implements Reporter {
+    private grpcClient;
+    private grpcAddress;
+    private grpcEnabled;
+    private grpcTimeout;
+    private grpcFirstErrorLogged;
+    private verbose;
+    private runId;
+    private runStartTime;
+    private rootSuite;
+    private reportedSuites;
+    constructor(options?: StanterpriseReporterOptions);
+    onBegin(config: FullConfig, suite: Suite): void;
+    onExit(): Promise<void>;
+    getRunId(): string;
+    getRunStartTime(): Date;
+    onEnd(result: FullResult): Promise<{
+        status?: FullResult["status"];
+    } | undefined | void> | void;
+    onTestBegin(test: TestCase, result: TestResult): void;
+    onStepBegin(test: TestCase, result: TestResult, step: TestStep): Promise<void>;
+    onStepEnd(test: TestCase, result: TestResult, step: TestStep): void;
+    onTestEnd(test: TestCase, result: TestResult): void;
+    onTestFail(test: TestCase, result: TestResult): void;
+    onError(error: TestError): void;
+    onStdErr(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
+    onStdOut(chunk: string | Buffer, test: void | TestCase, result: void | TestResult): void;
+    private getSuiteId;
+    private reportSuiteBegin;
+    private reportSuiteEnd;
+    private mapSuiteStatus;
+    private logGrpcErrorOnce;
+    private reportUnary;
+}

package/dist/reporter.js

@@ -0,0 +1,449 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const protobuf_1 = require("@stanterprise/protobuf");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const crypto_1 = require("crypto");
+const utils_1 = require("./utils");
+class StanterpriseReporter {
+    constructor(options = {}) {
+        // Generic gRPC client (we call unary methods by path directly).
+        this.grpcClient = null;
+        this.grpcFirstErrorLogged = false;
+        // Generate a unique run ID for this test run
+        this.runId = "";
+        this.runStartTime = new Date();
+        this.rootSuite = null;
+        // Track reported suites to ensure we only report each suite once and can reference correct IDs
+        this.reportedSuites = new Map();
+        this.grpcAddress =
+            options.grpcAddress ||
+                process.env.STANTERPRISE_GRPC_ADDRESS ||
+                "localhost:50051";
+        this.grpcEnabled =
+            options.grpcEnabled ??
+                (process.env.STANTERPRISE_GRPC_ENABLED || "true").toLowerCase() !==
+                    "false";
+        this.grpcTimeout = options.grpcTimeout || 1000;
+        this.verbose = options.verbose || false;
+        if (this.verbose) {
+            console.log("Stanterprise Reporter: Initialized with options:", {
+                grpcAddress: this.grpcAddress,
+                grpcEnabled: this.grpcEnabled,
+                grpcTimeout: this.grpcTimeout,
+                verbose: this.verbose,
+            });
+        }
+    }
+    onBegin(config, suite) {
+        // Generate a UUID for runId
+        this.runId = (0, crypto_1.randomUUID)();
+        this.rootSuite = suite;
+        // Lazily create the client if enabled.
+        if (this.grpcEnabled) {
+            try {
+                this.grpcClient = new grpc.Client(this.grpcAddress, grpc.credentials.createInsecure());
+            }
+            catch (e) {
+                this.logGrpcErrorOnce("Failed to create gRPC client", e);
+            }
+        }
+        else {
+            console.log("Stanterprise Reporter: gRPC disabled via STANTERPRISE_GRPC_ENABLED=false");
+        }
+        console.log(`Stanterprise Reporter: Test run started with ID: ${this.runId}`);
+        console.log(`Number of tests: ${suite.allTests().length}`);
+        console.log(`Run started at: ${this.runStartTime.toISOString()}`);
+        // Report root suite begin and track its ID
+        const rootSuiteId = this.getSuiteId(suite);
+    }
+    async onExit() {
+        console.log(`Stanterprise Reporter: Test run completed - Run ID: ${this.runId}`);
+        // Cleanup gRPC client
+        try {
+            this.grpcClient?.close();
+        }
+        catch (e) {
+            console.error("Stanterprise Reporter: Error during gRPC client cleanup in onExit:", e);
+        }
+    }
+    // Getter to access the current run ID
+    getRunId() {
+        return this.runId;
+    }
+    // Getter to access the run start time
+    getRunStartTime() {
+        return this.runStartTime;
+    }
+    onEnd(result) {
+        const runDuration = Date.now() - this.runStartTime.getTime();
+        console.log(`Stanterprise Reporter: Test run ended - Run ID: ${this.runId}`);
+        console.log(`Final result: ${result.status}`);
+        console.log(`Run duration: ${runDuration}ms (Playwright duration: ${result.duration}ms)`);
+        console.log(`Run start time: ${this.runStartTime.toISOString()}`);
+        console.log(`Playwright start time: ${result.startTime.toISOString()}`);
+        // Report root suite end
+        if (this.rootSuite) {
+            this.reportSuiteEnd(this.rootSuite, result);
+        }
+        return Promise.resolve();
+    }
+    onTestBegin(test, result) {
+        // Create unique test execution ID combining run ID and test ID
+        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
+        console.log(`Stanterprise Reporter: Test started - ${test.title}`);
+        console.log(`  Run ID: ${this.runId}`);
+        console.log(`  Test ID (static): ${test.id}`);
+        console.log(`  Unique Execution ID: ${uniqueTestExecutionId}`);
+        // Get test suite run ID from parent suite if available, ensuring suite is reported
+        const testSuiteRunId = test.parent ? this.getSuiteId(test.parent) : "";
+        // Build metadata from test annotations
+        const metadata = new Map();
+        test.annotations.forEach((annotation, index) => {
+            metadata.set(`annotation_${index}_type`, annotation.type);
+            if (annotation.description) {
+                metadata.set(`annotation_${index}_description`, annotation.description);
+            }
+        });
+        // Build and send the TestBegin event via generic unary call.
+        const request = new protobuf_1.events.TestBeginEventRequest({
+            test_case: new protobuf_1.entities.TestCaseRun({
+                id: uniqueTestExecutionId,
+                title: test.title,
+                run_id: this.runId,
+                test_id: test.id,
+                test_suite_run_id: testSuiteRunId,
+                start_time: (0, utils_1.createTimestamp)(result.startTime),
+                metadata: metadata,
+                actual_tags: test.tags,
+            }),
+        });
+        // Fire-and-forget to avoid slowing tests; log errors once.
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report test begin", e));
+    }
+    async onStepBegin(test, result, step) {
+        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
+        const uniqueStepId = `${uniqueTestExecutionId}-${step.title}-${step.startTime.getTime()}`;
+        console.log(`Stanterprise Reporter: Step started - ${step.title}`);
+        console.log(`  Category: ${step.category}`);
+        // Build metadata from step annotations
+        const metadata = new Map();
+        metadata.set("category", step.category);
+        step.annotations.forEach((annotation, index) => {
+            metadata.set(`annotation_${index}_type`, annotation.type);
+            if (annotation.description) {
+                metadata.set(`annotation_${index}_description`, annotation.description);
+            }
+        });
+        // Get parent step ID if this step has a parent
+        const parentStepId = step.parent
+            ? `${uniqueTestExecutionId}-${step.parent.title}-${step.parent.startTime.getTime()}`
+            : "";
+        // Build and send the StepBegin event
+        const request = new protobuf_1.events.StepBeginEventRequest({
+            step: new protobuf_1.entities.StepRun({
+                id: uniqueStepId,
+                run_id: this.runId,
+                test_case_run_id: uniqueTestExecutionId,
+                title: step.title,
+                type: step.category,
+                start_time: (0, utils_1.createTimestamp)(step.startTime),
+                location: step.location
+                    ? `${step.location.file}:${step.location.line}:${step.location.column}`
+                    : "",
+                metadata: metadata,
+                parent_step_id: parentStepId,
+                worker_index: result.workerIndex.toString(),
+            }),
+        });
+        // Fire-and-forget to avoid slowing tests
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report step begin", e));
+    }
+    onStepEnd(test, result, step) {
+        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
+        const uniqueStepId = `${uniqueTestExecutionId}-${step.title}-${step.startTime.getTime()}`;
+        console.log(`Stanterprise Reporter: Step ended - ${step.title}`);
+        console.log(`  Duration: ${step.duration}ms`);
+        // Map step error to status
+        const stepStatus = (0, utils_1.mapStepStatus)(!!step.error);
+        // Build metadata from step annotations
+        const metadata = new Map();
+        metadata.set("category", step.category);
+        step.annotations.forEach((annotation, index) => {
+            metadata.set(`annotation_${index}_type`, annotation.type);
+            if (annotation.description) {
+                metadata.set(`annotation_${index}_description`, annotation.description);
+            }
+        });
+        // Get parent step ID if this step has a parent
+        const parentStepId = step.parent
+            ? `${uniqueTestExecutionId}-${step.parent.title}-${step.parent.startTime.getTime()}`
+            : "";
+        // Build and send the StepEnd event
+        const request = new protobuf_1.events.StepEndEventRequest({
+            step: new protobuf_1.entities.StepRun({
+                id: uniqueStepId,
+                run_id: this.runId,
+                test_case_run_id: uniqueTestExecutionId,
+                title: step.title,
+                type: step.category,
+                start_time: (0, utils_1.createTimestamp)(step.startTime),
+                duration: (0, utils_1.createDuration)(step.duration),
+                status: stepStatus,
+                error: step.error ? step.error.message || "" : "",
+                errors: step.error ? [step.error.message || ""] : [],
+                location: step.location
+                    ? `${step.location.file}:${step.location.line}:${step.location.column}`
+                    : "",
+                metadata: metadata,
+                parent_step_id: parentStepId,
+                worker_index: result.workerIndex.toString(),
+            }),
+        });
+        // Fire-and-forget to avoid slowing tests
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report step end", e));
+    }
+    onTestEnd(test, result) {
+        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
+        console.log(`Stanterprise Reporter: Test ended - ${test.title}`);
+        console.log(`  Status: ${result.status}`);
+        console.log(`  Duration: ${result.duration}ms`);
+        // Map Playwright test status to protobuf TestStatus
+        const testStatus = (0, utils_1.mapTestStatus)(result.status);
+        // Process attachments (screenshots, videos, etc.)
+        const attachments = (0, utils_1.processAttachments)(result);
+        // Extract error information if the test failed
+        const { errorMessage, stackTrace, errors } = (0, utils_1.extractErrorInfo)(result);
+        // Get test suite run ID from parent suite if available, ensuring suite is reported
+        const testSuiteRunId = test.parent ? this.getSuiteId(test.parent) : "";
+        // Build metadata from test annotations and result metadata
+        const metadata = new Map();
+        test.annotations.forEach((annotation, index) => {
+            metadata.set(`annotation_${index}_type`, annotation.type);
+            if (annotation.description) {
+                metadata.set(`annotation_${index}_description`, annotation.description);
+            }
+        });
+        result.annotations.forEach((annotation, index) => {
+            metadata.set(`result_annotation_${index}_type`, annotation.type);
+            if (annotation.description) {
+                metadata.set(`result_annotation_${index}_description`, annotation.description);
+            }
+        });
+        // Build and send the TestEnd event
+        const request = new protobuf_1.events.TestEndEventRequest({
+            test_case: new protobuf_1.entities.TestCaseRun({
+                id: uniqueTestExecutionId,
+                title: test.title,
+                run_id: this.runId,
+                test_id: test.id,
+                test_suite_run_id: testSuiteRunId,
+                status: testStatus,
+                start_time: (0, utils_1.createTimestamp)(result.startTime),
+                attachments: attachments,
+                error_message: errorMessage,
+                stack_trace: stackTrace,
+                errors: errors,
+                metadata: metadata,
+                actual_tags: test.tags,
+            }),
+        });
+        // Fire-and-forget to avoid slowing tests
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportTestEnd", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report test end", e));
+    }
+    onTestFail(test, result) {
+        const uniqueTestExecutionId = `${this.runId}-${test.id}`;
+        if (this.verbose) {
+            console.log(`Stanterprise Reporter: Test failed - ${test.title}`);
+        }
+        // Extract failure details
+        const { errorMessage: failureMessage, stackTrace } = (0, utils_1.extractErrorInfo)(result);
+        // Process attachments for failed tests
+        const attachments = (0, utils_1.processAttachments)(result);
+        // Build and send the TestFailure event
+        const request = new protobuf_1.events.TestFailureEventRequest({
+            test_id: uniqueTestExecutionId,
+            failure_message: failureMessage,
+            stack_trace: stackTrace,
+            timestamp: (0, utils_1.createTimestampFromMs)(Date.now()),
+            attachments: attachments,
+        });
+        // Fire-and-forget to avoid slowing tests
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report test failure", e));
+    }
+    onError(error) {
+        console.error("Stanterprise Reporter: An error occurred during the test run");
+        console.error(`Error: ${error.message}`);
+        if (error.stack) {
+            console.error(`Stack trace: ${error.stack}`);
+        }
+    }
+    onStdErr(chunk, test, result) {
+        console.error(`Stanterprise Reporter: Standard error output - ${chunk.toString()}`);
+    }
+    onStdOut(chunk, test, result) {
+        // console.log(`Stanterprise Reporter: Standard output - ${chunk.toString()}`);
+    }
+    // Helper: Get suite ID for a suite, ensuring it's been reported
+    getSuiteId(suite) {
+        // Check if we've already reported this suite
+        if (this.reportedSuites.has(suite)) {
+            return this.reportedSuites.get(suite);
+        }
+        // Generate a unique suite ID based on suite hierarchy
+        const titlePath = suite.titlePath().join('/') || 'root';
+        const suiteId = `${this.runId}-suite-${titlePath}`;
+        // Report the suite begin event
+        this.reportSuiteBegin(suite, suiteId);
+        // Track that we've reported this suite
+        this.reportedSuites.set(suite, suiteId);
+        return suiteId;
+    }
+    // Helper: Report suite begin event
+    reportSuiteBegin(suite, suiteId) {
+        const id = suiteId || `${this.runId}-suite-${suite.title || 'root'}`;
+        console.log(`Stanterprise Reporter: Suite started - ${suite.title || 'root'}`);
+        console.log(`  Suite type: ${suite.type}`);
+        // Build metadata from suite location
+        const metadata = new Map();
+        metadata.set("suite_type", suite.type);
+        if (suite.location) {
+            metadata.set("location_file", suite.location.file);
+            metadata.set("location_line", suite.location.line.toString());
+            metadata.set("location_column", suite.location.column.toString());
+        }
+        // Build and send the SuiteBegin event
+        const request = new protobuf_1.events.SuiteBeginEventRequest({
+            suite: new protobuf_1.entities.TestSuiteRun({
+                id: id,
+                name: suite.title || 'root',
+                start_time: (0, utils_1.createTimestamp)(this.runStartTime),
+                metadata: metadata,
+            }),
+        });
+        // Fire-and-forget to avoid slowing tests
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportSuiteBegin", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report suite begin", e));
+    }
+    // Helper: Report suite end event
+    reportSuiteEnd(suite, result) {
+        const suiteId = `${this.runId}-suite-${suite.title || 'root'}`;
+        const endTime = new Date();
+        const duration = endTime.getTime() - this.runStartTime.getTime();
+        console.log(`Stanterprise Reporter: Suite ended - ${suite.title || 'root'}`);
+        console.log(`  Duration: ${duration}ms`);
+        // Map result status to protobuf TestStatus
+        const suiteStatus = this.mapSuiteStatus(result.status);
+        // Build metadata from suite location
+        const metadata = new Map();
+        metadata.set("suite_type", suite.type);
+        metadata.set("final_result", result.status);
+        if (suite.location) {
+            metadata.set("location_file", suite.location.file);
+            metadata.set("location_line", suite.location.line.toString());
+            metadata.set("location_column", suite.location.column.toString());
+        }
+        // Build and send the SuiteEnd event
+        const request = new protobuf_1.events.SuiteEndEventRequest({
+            suite: new protobuf_1.entities.TestSuiteRun({
+                id: suiteId,
+                name: suite.title || 'root',
+                start_time: (0, utils_1.createTimestamp)(this.runStartTime),
+                end_time: (0, utils_1.createTimestamp)(endTime),
+                duration: (0, utils_1.createDuration)(duration),
+                status: suiteStatus,
+                metadata: metadata,
+            }),
+        });
+        // Fire-and-forget to avoid slowing tests
+        this.reportUnary("/testsystem.v1.observer.TestEventCollector/ReportSuiteEnd", request, this.grpcTimeout).catch((e) => this.logGrpcErrorOnce("Failed to report suite end", e));
+    }
+    // Helper: Map FullResult status to protobuf TestStatus
+    mapSuiteStatus(status) {
+        switch (status) {
+            case "passed":
+                return protobuf_1.common.TestStatus.PASSED;
+            case "failed":
+                return protobuf_1.common.TestStatus.FAILED;
+            case "timedout":
+                return protobuf_1.common.TestStatus.FAILED;
+            case "interrupted":
+                return protobuf_1.common.TestStatus.BROKEN;
+            default:
+                return protobuf_1.common.TestStatus.UNKNOWN;
+        }
+    }
+    // Helper: log first gRPC error once and disable further attempts
+    logGrpcErrorOnce(prefix, err) {
+        if (this.grpcFirstErrorLogged)
+            return;
+        this.grpcFirstErrorLogged = true;
+        const details = err instanceof Error ? `${err.message}` : String(err);
+        console.warn(`${prefix}. gRPC disabled for the remainder of the run. Address=${this.grpcAddress}. Details: ${details}`);
+        this.grpcEnabled = false;
+    }
+    // Helper: generic unary call using raw method path
+    async reportUnary(path, message, deadlineMs = 1000) {
+        if (!this.grpcEnabled || !this.grpcClient) {
+            return Buffer.alloc(0);
+        }
+        const reqSerialize = (arg) => {
+            const m = arg;
+            const bytes = m?.serializeBinary
+                ? m.serializeBinary()
+                : m?.serialize
+                    ? m.serialize()
+                    : new Uint8Array(0);
+            return Buffer.from(bytes);
+        };
+        const resDeserialize = (bytes) => bytes;
+        const metadata = new grpc.Metadata();
+        const callOptions = {
+            deadline: new Date(Date.now() + deadlineMs),
+        };
+        return new Promise((resolve, reject) => {
+            try {
+                this.grpcClient.makeUnaryRequest(path, reqSerialize, resDeserialize, message, metadata, callOptions, (err, response) => {
+                    if (err)
+                        return reject(err);
+                    resolve(response);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }
+}
+exports.default = StanterpriseReporter;

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Type definitions for Stanterprise Playwright Reporter
+ */
+/**
+ * Configuration options for the Stanterprise Reporter
+ */
+export interface StanterpriseReporterOptions {
+    /**
+     * gRPC server address
+     * @default "localhost:50051" or process.env.STANTERPRISE_GRPC_ADDRESS
+     */
+    grpcAddress?: string;
+    /**
+     * Whether gRPC reporting is enabled
+     * @default true or process.env.STANTERPRISE_GRPC_ENABLED !== "false"
+     */
+    grpcEnabled?: boolean;
+    /**
+     * Timeout for gRPC calls in milliseconds
+     * @default 1000
+     */
+    grpcTimeout?: number;
+    /**
+     * Whether to include verbose logging
+     * @default false
+     */
+    verbose?: boolean;
+}
+/**
+ * Internal type for managing test execution state
+ */
+export interface TestExecutionContext {
+    /**
+     * Unique ID combining run ID and test ID
+     */
+    uniqueTestExecutionId: string;
+    /**
+     * The global run ID for this test execution
+     */
+    runId: string;
+    /**
+     * The test ID from Playwright
+     */
+    testId: string;
+}
+/**
+ * Internal type for managing step execution state
+ */
+export interface StepExecutionContext extends TestExecutionContext {
+    /**
+     * Unique ID for the step
+     */
+    uniqueStepId: string;
+    /**
+     * Step title
+     */
+    stepTitle: string;
+    /**
+     * Step start time
+     */
+    stepStartTime: Date;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for Stanterprise Playwright Reporter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/attachmentProcessor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utility functions for processing test attachments
+ */
+import type { TestResult } from "@playwright/test/reporter";
+import { common } from "@stanterprise/protobuf";
+/**
+ * Process Playwright test attachments into protobuf Attachment objects
+ */
+export declare function processAttachments(result: TestResult): InstanceType<typeof common.Attachment>[];
+/**
+ * Extract error information from test results
+ */
+export declare function extractErrorInfo(result: TestResult): {
+    errorMessage: string;
+    stackTrace: string;
+    errors: string[];
+};

package/dist/utils/attachmentProcessor.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAttachments = processAttachments;
+exports.extractErrorInfo = extractErrorInfo;
+const protobuf_1 = require("@stanterprise/protobuf");
+/**
+ * Process Playwright test attachments into protobuf Attachment objects
+ */
+function processAttachments(result) {
+    const attachments = [];
+    if (!result.attachments || result.attachments.length === 0) {
+        return attachments;
+    }
+    for (const attachment of result.attachments) {
+        const att = new protobuf_1.common.Attachment({
+            name: attachment.name,
+            mime_type: attachment.contentType,
+        });
+        // Use path as URI if available, otherwise use the body content
+        if (attachment.path) {
+            att.uri = attachment.path;
+        }
+        else if (attachment.body) {
+            att.content = attachment.body;
+        }
+        attachments.push(att);
+    }
+    return attachments;
+}
+/**
+ * Extract error information from test results
+ */
+function extractErrorInfo(result) {
+    let errorMessage = "";
+    let stackTrace = "";
+    const errors = [];
+    if (result.errors && result.errors.length > 0) {
+        errorMessage = result.errors.map((e) => e.message || "").join("\n");
+        stackTrace = result.errors.map((e) => e.stack || "").join("\n");
+        errors.push(...result.errors.map((e) => e.message || ""));
+    }
+    return { errorMessage, stackTrace, errors };
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utility exports - centralized access to all utility functions
+ */
+export * from "./statusMapper";
+export * from "./attachmentProcessor";
+export * from "./timeHelpers";

package/dist/utils/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Utility exports - centralized access to all utility functions
+ */
+__exportStar(require("./statusMapper"), exports);
+__exportStar(require("./attachmentProcessor"), exports);
+__exportStar(require("./timeHelpers"), exports);

package/dist/utils/statusMapper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Utility functions for mapping Playwright types to protobuf types
+ */
+import type { TestResult } from "@playwright/test/reporter";
+/**
+ * Map Playwright test status to protobuf TestStatus
+ */
+export declare function mapTestStatus(status: TestResult["status"]): number;
+/**
+ * Map step error to test status
+ */
+export declare function mapStepStatus(hasError: boolean): number;

package/dist/utils/statusMapper.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTestStatus = mapTestStatus;
+exports.mapStepStatus = mapStepStatus;
+const protobuf_1 = require("@stanterprise/protobuf");
+/**
+ * Map Playwright test status to protobuf TestStatus
+ */
+function mapTestStatus(status) {
+    switch (status) {
+        case "passed":
+            return protobuf_1.common.TestStatus.PASSED;
+        case "failed":
+            return protobuf_1.common.TestStatus.FAILED;
+        case "skipped":
+            return protobuf_1.common.TestStatus.SKIPPED;
+        case "timedOut":
+            return protobuf_1.common.TestStatus.FAILED; // Treat timeout as failed
+        default:
+            return protobuf_1.common.TestStatus.UNKNOWN;
+    }
+}
+/**
+ * Map step error to test status
+ */
+function mapStepStatus(hasError) {
+    return hasError ? protobuf_1.common.TestStatus.FAILED : protobuf_1.common.TestStatus.PASSED;
+}

package/dist/utils/timeHelpers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utility functions for creating timestamps and durations
+ */
+import { google } from "@stanterprise/protobuf";
+import type { google as googleTypes } from "@stanterprise/protobuf/dist/lib/google/protobuf/duration";
+/**
+ * Create a protobuf Timestamp from a JavaScript Date
+ */
+export declare function createTimestamp(date: Date): InstanceType<typeof google.protobuf.Timestamp>;
+/**
+ * Create a protobuf Timestamp from milliseconds since epoch
+ */
+export declare function createTimestampFromMs(ms: number): InstanceType<typeof google.protobuf.Timestamp>;
+/**
+ * Create a duration object from milliseconds.
+ *
+ * NOTE: google.protobuf.Duration is defined in the @stanterprise/protobuf schema
+ * but not exported in the package's main barrel export. Since Duration and Timestamp
+ * have identical structure (seconds: number, nanos: number) and the protobuf serialization
+ * is wire-compatible, we use Timestamp as a Duration substitute. This works correctly at runtime.
+ * The return type is cast to Duration for proper type checking with the schema.
+ *
+ * @param durationMs Duration in milliseconds
+ * @returns A Duration object (implemented as Timestamp due to export limitations)
+ */
+export declare function createDuration(durationMs: number): googleTypes.protobuf.Duration;

package/dist/utils/timeHelpers.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTimestamp = createTimestamp;
+exports.createTimestampFromMs = createTimestampFromMs;
+exports.createDuration = createDuration;
+/**
+ * Utility functions for creating timestamps and durations
+ */
+const protobuf_1 = require("@stanterprise/protobuf");
+/**
+ * Create a protobuf Timestamp from a JavaScript Date
+ */
+function createTimestamp(date) {
+    return new protobuf_1.google.protobuf.Timestamp({
+        seconds: Math.floor(date.getTime() / 1000),
+        nanos: (date.getTime() % 1000) * 1000000,
+    });
+}
+/**
+ * Create a protobuf Timestamp from milliseconds since epoch
+ */
+function createTimestampFromMs(ms) {
+    return new protobuf_1.google.protobuf.Timestamp({
+        seconds: Math.floor(ms / 1000),
+        nanos: (ms % 1000) * 1000000,
+    });
+}
+/**
+ * Create a duration object from milliseconds.
+ *
+ * NOTE: google.protobuf.Duration is defined in the @stanterprise/protobuf schema
+ * but not exported in the package's main barrel export. Since Duration and Timestamp
+ * have identical structure (seconds: number, nanos: number) and the protobuf serialization
+ * is wire-compatible, we use Timestamp as a Duration substitute. This works correctly at runtime.
+ * The return type is cast to Duration for proper type checking with the schema.
+ *
+ * @param durationMs Duration in milliseconds
+ * @returns A Duration object (implemented as Timestamp due to export limitations)
+ */
+function createDuration(durationMs) {
+    return new protobuf_1.google.protobuf.Timestamp({
+        seconds: Math.floor(durationMs / 1000),
+        nanos: (durationMs % 1000) * 1000000,
+    });
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@stanterprise/playwright-reporter",
+  "version": "1.0.0",
+  "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
+  "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
+  "bugs": {
+    "url": "https://github.com/stanterprise/stanterprise-playwright-reporter/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stanterprise/stanterprise-playwright-reporter.git"
+  },
+  "license": "ISC",
+  "author": "Stanterprise Team",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md"
+  ],
+  "keywords": [
+    "playwright",
+    "reporter",
+    "test",
+    "testing",
+    "stanterprise",
+    "grpc",
+    "playwright-reporter"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.20.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.52.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.15.29",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.14.1",
+    "@protobuf-ts/grpc-transport": "^2.11.1",
+    "@protobuf-ts/grpcweb-transport": "^2.11.1",
+    "@stanterprise/protobuf": "^0.0.9"
+  }
+}