@sentinelqa/uploader 0.1.3 → 0.1.6

package/README.md

@@ -26,7 +26,7 @@ If you want to run without installing, use:
 npx @sentinelqa/uploader playwright
 ```
 
-### Minimal GitLab CI
+### Minimal GitLab CI (preserves test exit code)
 
 ```yaml
 e2e:
@@ -34,8 +34,12 @@ e2e:
   script:
     - npm ci
     - npx playwright install --with-deps
-    - npm run test:e2e || true
+    - set +e
+    - npx playwright test --reporter=line,json --output=test-results
+    - TEST_EXIT=$?
+    - export SENTINEL_TEST_EXIT_CODE=$TEST_EXIT
     - npx @sentinelqa/uploader playwright
+    - exit $TEST_EXIT
   artifacts:
     when: always
     paths:
@@ -43,7 +47,7 @@ e2e:
       - test-results/
 ```
 
-### Minimal GitHub Actions
+### Minimal GitHub Actions (preserves test exit code)
 
 ```yaml
 name: E2E
@@ -58,14 +62,20 @@ jobs:
           node-version: "20"
       - run: npm ci
       - run: npx playwright install --with-deps
-      - run: npm run test:e2e || true
-      - run: npx @sentinelqa/uploader playwright
+      - run: |
+          set +e
+          npx playwright test --reporter=line,json --output=test-results
+          TEST_EXIT=$?
+          echo "SENTINEL_TEST_EXIT_CODE=$TEST_EXIT" >> $GITHUB_ENV
+          npx @sentinelqa/uploader playwright
+          exit $TEST_EXIT
 ```
 
 ## Required Environment Variables
 
 - `SENTINEL_TOKEN` (project ingest token)
 - `SENTINEL_URL` (optional; defaults to `https://app.sentinelqa.com`)
+- `SENTINEL_TEST_EXIT_CODE` (optional; used to preserve CI test exit code)
 
 ## Optional: BYO S3 (Advanced)
 
@@ -92,5 +102,8 @@ Set these to upload directly to your own bucket:
 **No CI metadata**
 - The uploader detects GitLab or GitHub. If running locally, set the CI env vars or run in CI.
 
+**No failed tests**
+- Ensure `@playwright/test` is installed and the JSON reporter is enabled.
+
 **BYO uploads failing**
 - Verify `SENTINEL_S3_*` values and permissions.

package/dist/cli.js

@@ -7,6 +7,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const client_s3_1 = require("@aws-sdk/client-s3");
+const httpClient_1 = require("./httpClient");
+const output_1 = require("./output");
 const DEFAULT_APP_URL = "https://app.sentinelqa.com";
 const DEFAULT_JSON_PATH = "playwright-report/report.json";
 const DEFAULT_PLAYWRIGHT_REPORT_DIR = "playwright-report";
@@ -15,9 +17,19 @@ const readEnv = (key) => {
     const value = process.env[key];
     return value && value.trim().length > 0 ? value.trim() : null;
 };
+const getPreservedExitCode = () => {
+    const raw = readEnv("SENTINEL_TEST_EXIT_CODE");
+    if (!raw)
+        return null;
+    const num = Number.parseInt(raw, 10);
+    if (!Number.isFinite(num) || num <= 0)
+        return null;
+    return num;
+};
 const fail = (message) => {
     console.error(`Error: ${message}`);
-    process.exit(1);
+    const preserved = getPreservedExitCode();
+    process.exit(preserved ?? 1);
 };
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const withRetry = async (fn, label) => {
@@ -192,22 +204,24 @@ const computeRunStatus = (tests) => {
 };
 const bestEffortComplete = async (appUrl, ingestToken, runId, status, tests) => {
     try {
-        await fetch(`${appUrl}/api/runs/${runId}/complete`, {
+        const res = await (0, httpClient_1.requestJson)(`${appUrl}/api/runs/${runId}/complete`, {
             method: "POST",
             headers: {
-                "content-type": "application/json",
                 authorization: `Bearer ${ingestToken}`
             },
-            body: JSON.stringify({
+            body: {
                 status,
                 finishedAt: new Date().toISOString(),
                 tests,
                 artifacts: []
-            })
-        });
+            }
+        }, 0);
+        if (res.status >= 400)
+            return null;
+        return res.body;
     }
     catch {
-        // Ignore best-effort failures; original error will be surfaced.
+        return null;
     }
 };
 const detectGitLabEnv = () => {
@@ -375,25 +389,25 @@ const main = async () => {
     if (!ci.workflow.id)
         fail("Workflow ID is required.");
     const appUrl = readEnv("SENTINEL_URL") || readEnv("APP_URL") || DEFAULT_APP_URL;
-    const createRes = await withRetry(() => fetch(`${appUrl}/api/runs`, {
+    const createRes = await (0, httpClient_1.requestJson)(`${appUrl}/api/runs`, {
         method: "POST",
         headers: {
-            "content-type": "application/json",
             authorization: `Bearer ${ingestToken}`
         },
-        body: JSON.stringify({
+        body: {
             provider: ci.provider,
             commit: ci.commit,
             workflow: ci.workflow,
             job: ci.job,
             ci: ci.ci
-        })
-    }), "POST /api/runs");
-    if (!createRes.ok) {
-        const body = await createRes.text();
-        fail(`POST /api/runs failed (${createRes.status}): ${body}`);
+        }
+    }, 2);
+    if (createRes.status >= 400) {
+        fail(`POST /api/runs failed (${createRes.status}): ${createRes.raw}`);
     }
-    const { runId } = await createRes.json();
+    const runId = createRes.body?.runId;
+    const internalRunUrl = createRes.body?.internalRunUrl ||
+        `${appUrl}/runs/${runId}`;
     if (!runId)
         fail("Missing runId from /api/runs response.");
     const uploadStart = Date.now();
@@ -450,26 +464,24 @@ const main = async () => {
             }));
         }
         else {
-            const presignRes = await withRetry(() => fetch(`${appUrl}/api/uploads/presign`, {
+            const presignRes = await (0, httpClient_1.requestJson)(`${appUrl}/api/uploads/presign`, {
                 method: "POST",
                 headers: {
-                    "content-type": "application/json",
                     authorization: `Bearer ${ingestToken}`
                 },
-                body: JSON.stringify({
+                body: {
                     items: finalArtifacts.map((artifact) => ({
                         relPath: artifact.objectKey,
                         contentType: artifact.contentType,
                         sizeBytes: artifact.sizeBytes,
                         kind: artifact.type
                     }))
-                })
-            }), "POST /api/uploads/presign");
-            if (!presignRes.ok) {
-                const body = await presignRes.text();
-                fail(`POST /api/uploads/presign failed (${presignRes.status}): ${body}`);
+                }
+            }, 2);
+            if (presignRes.status >= 400) {
+                fail(`POST /api/uploads/presign failed (${presignRes.status}): ${presignRes.raw}`);
             }
-            const presignData = await presignRes.json();
+            const presignData = presignRes.body;
             const uploadMap = new Map((presignData.items || []).map((item) => [item.relPath, item]));
             await withRetry(async () => {
                 for (const artifact of finalArtifacts) {
@@ -478,16 +490,11 @@ const main = async () => {
                         throw new Error(`Missing upload URL for ${artifact.objectKey}`);
                     }
                     await withRetry(async () => {
-                        const body = fs_1.default.createReadStream(artifact.filePath);
-                        const res = await fetch(item.uploadUrl, {
-                            method: "PUT",
-                            headers: {
-                                "content-type": artifact.contentType
-                            },
-                            body
-                        });
-                        if (!res.ok) {
-                            throw new Error(`Upload failed (${res.status}) for ${artifact.objectKey}`);
+                        const stat = fs_1.default.statSync(artifact.filePath);
+                        const stream = fs_1.default.createReadStream(artifact.filePath);
+                        const result = await (0, httpClient_1.putFile)(item.uploadUrl, stream, artifact.contentType, stat.size);
+                        if (result.status >= 400) {
+                            throw new Error(`Upload failed (${result.status}) for ${artifact.objectKey}: ${result.raw}`);
                         }
                     }, `upload ${artifact.objectKey}`);
                     artifact.objectKey = item.objectKey;
@@ -500,17 +507,39 @@ const main = async () => {
         }
     }
     catch (err) {
-        await bestEffortComplete(appUrl, ingestToken, runId, "failed", tests);
+        const fallback = await bestEffortComplete(appUrl, ingestToken, runId, "failed", tests);
+        if (fallback) {
+            const output = (0, output_1.formatCiOutput)({
+                failedCount: fallback.failedCount ??
+                    tests.filter((t) => t.status === "failed").length,
+                totalCount: fallback.totalCount ?? tests.length,
+                internalRunUrl: fallback.internalRunUrl || internalRunUrl,
+                internalFirstFailureUrl: fallback.internalFirstFailureUrl || null,
+                shareRunUrl: fallback.shareRunUrl || null,
+                shareFirstFailureUrl: fallback.shareFirstFailureUrl || null
+            }, !process.env.NO_COLOR);
+            console.log(output);
+        }
+        else {
+            console.log(internalRunUrl);
+        }
+        console.error("Warning: Sentinel uploader failed to upload artifacts.");
         fail(err?.message || String(err));
     }
     const uploadDurationMs = Date.now() - uploadStart;
-    const completeRes = await withRetry(() => fetch(`${appUrl}/api/runs/${runId}/complete`, {
+    console.log(JSON.stringify({
+        event: "uploader_summary",
+        runId,
+        tests: tests.length,
+        artifacts: artifacts.length,
+        uploadDurationMs
+    }));
+    const completeRes = await (0, httpClient_1.requestJson)(`${appUrl}/api/runs/${runId}/complete`, {
         method: "POST",
         headers: {
-            "content-type": "application/json",
             authorization: `Bearer ${ingestToken}`
         },
-        body: JSON.stringify({
+        body: {
             status,
             finishedAt: new Date().toISOString(),
             tests,
@@ -522,42 +551,21 @@ const main = async () => {
                 contentType: artifact.contentType,
                 testKey: null
             }))
-        })
-    }), "POST /api/runs/:runId/complete");
-    if (!completeRes.ok) {
-        const body = await completeRes.text();
-        fail(`POST /api/runs/:runId/complete failed (${completeRes.status}): ${body}`);
-    }
-    let shareUrl = null;
-    try {
-        const data = await completeRes.json();
-        shareUrl = data.shareUrl || null;
-    }
-    catch {
-        shareUrl = null;
-    }
-    const internalUrl = `${appUrl}/runs/${runId}`;
-    console.log(JSON.stringify({
-        event: "uploader_summary",
-        runId,
-        tests: tests.length,
-        artifacts: artifacts.length,
-        uploadDurationMs
-    }));
-    console.log(`Uploaded ${artifacts.length} artifacts and completed run ${runId}.`);
-    console.log(internalUrl);
-    if (shareUrl)
-        console.log(shareUrl);
-    if (status === "failed") {
-        const total = tests.length;
-        const failed = tests.filter((t) => t.status === "failed").length;
-        const useColor = !process.env.NO_COLOR;
-        const bold = useColor ? "\u001b[1m" : "";
-        const red = useColor ? "\u001b[31m" : "";
-        const reset = useColor ? "\u001b[0m" : "";
-        console.log(`${bold}${red}CI Debug Report${reset}`);
-        console.log(`${bold}${failed} failed / ${total} total${reset}`);
+        }
+    }, 2);
+    if (completeRes.status >= 400) {
+        fail(`POST /api/runs/:runId/complete failed (${completeRes.status}): ${completeRes.raw}`);
     }
+    const response = completeRes.body || {};
+    const output = (0, output_1.formatCiOutput)({
+        failedCount: response.failedCount ?? tests.filter((t) => t.status === "failed").length,
+        totalCount: response.totalCount ?? tests.length,
+        internalRunUrl: response.internalRunUrl || internalRunUrl,
+        internalFirstFailureUrl: response.internalFirstFailureUrl || null,
+        shareRunUrl: response.shareRunUrl || null,
+        shareFirstFailureUrl: response.shareFirstFailureUrl || null
+    }, !process.env.NO_COLOR);
+    console.log(output);
 };
 main().catch((err) => {
     fail(err?.message || String(err));

package/dist/httpClient.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.putFile = exports.requestJson = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const requestText = (url, options) => new Promise((resolve, reject) => {
+    const target = new URL(url);
+    const client = target.protocol === "https:" ? https_1.default : http_1.default;
+    const headers = { ...(options.headers || {}) };
+    let body;
+    if (options.body !== undefined) {
+        body = JSON.stringify(options.body);
+        headers["content-type"] = headers["content-type"] || "application/json";
+        headers["content-length"] = Buffer.byteLength(body).toString();
+    }
+    const req = client.request({
+        method: options.method,
+        hostname: target.hostname,
+        port: target.port,
+        path: `${target.pathname}${target.search}`,
+        headers
+    }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        res.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            resolve({ status: res.statusCode || 0, raw });
+        });
+    });
+    const timeoutMs = options.timeoutMs ?? 15000;
+    req.setTimeout(timeoutMs, () => {
+        req.destroy(new Error(`Request timed out after ${timeoutMs}ms`));
+    });
+    req.on("error", reject);
+    if (body)
+        req.write(body);
+    req.end();
+});
+const requestJson = async (url, options, retries = 2) => {
+    let attempt = 0;
+    while (attempt <= retries) {
+        try {
+            const { status, raw } = await requestText(url, options);
+            const parsed = raw ? JSON.parse(raw) : null;
+            if (status >= 500 && attempt < retries) {
+                attempt += 1;
+                continue;
+            }
+            return { status, body: parsed, raw };
+        }
+        catch (error) {
+            if (attempt >= retries)
+                throw error;
+            attempt += 1;
+        }
+    }
+    throw new Error("Request failed");
+};
+exports.requestJson = requestJson;
+const putFile = (url, fileStream, contentType, contentLength, timeoutMs = 60000) => new Promise((resolve, reject) => {
+    const target = new URL(url);
+    const client = target.protocol === "https:" ? https_1.default : http_1.default;
+    const req = client.request({
+        method: "PUT",
+        hostname: target.hostname,
+        port: target.port,
+        path: `${target.pathname}${target.search}`,
+        headers: {
+            "content-type": contentType,
+            "content-length": contentLength.toString()
+        }
+    }, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        res.on("end", () => {
+            resolve({
+                status: res.statusCode || 0,
+                raw: Buffer.concat(chunks).toString("utf8")
+            });
+        });
+    });
+    req.setTimeout(timeoutMs, () => {
+        req.destroy(new Error(`Upload timed out after ${timeoutMs}ms`));
+    });
+    req.on("error", reject);
+    fileStream.on("error", reject);
+    fileStream.pipe(req);
+});
+exports.putFile = putFile;

package/dist/output.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCiOutput = void 0;
+const colorize = (value, code, useColor) => {
+    if (!useColor)
+        return value;
+    return `\u001b[${code}m${value}\u001b[0m`;
+};
+const formatCiOutput = (links, useColor = true) => {
+    const lines = [];
+    const failedLine = `${links.failedCount} failed / ${links.totalCount} total`;
+    const header = links.failedCount > 0
+        ? colorize("❌ CI Debug Report", "1;31", useColor)
+        : colorize("✅ CI Debug Report", "1;32", useColor);
+    const countLine = colorize(failedLine, "1", useColor);
+    lines.push(header);
+    lines.push(countLine);
+    lines.push("");
+    if (links.internalFirstFailureUrl) {
+        lines.push("First failure (fastest):");
+        lines.push(links.internalFirstFailureUrl);
+        lines.push("");
+    }
+    lines.push("Full run:");
+    lines.push(links.internalRunUrl);
+    if (links.shareRunUrl) {
+        lines.push("");
+        lines.push("Share (expires in 72h):");
+        lines.push(links.shareFirstFailureUrl || links.shareRunUrl);
+    }
+    return lines.join("\n");
+};
+exports.formatCiOutput = formatCiOutput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/uploader",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "private": false,
   "description": "Sentinel uploader CLI for CI/CD debugging artifacts",
   "license": "MIT",
@@ -32,6 +32,7 @@
   "main": "dist/cli.js",
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node test/output.test.js",
     "publish:dry": "npm run build && npm pack --dry-run"
   },
   "dependencies": {