@sentinelqa/uploader 0.1.0 → 0.1.2

package/dist/cli.js

@@ -73,6 +73,38 @@ const listFilesRecursive = (dirPath) => {
     }
     return results;
 };
+const findLatestMatch = (dirPath, matcher) => {
+    if (!fs_1.default.existsSync(dirPath))
+        return null;
+    if (!fs_1.default.statSync(dirPath).isDirectory())
+        return null;
+    const entries = fs_1.default.readdirSync(dirPath, { withFileTypes: true });
+    const files = entries
+        .filter((e) => e.isFile() && matcher(e.name))
+        .map((e) => path_1.default.join(dirPath, e.name));
+    if (files.length === 0)
+        return null;
+    files.sort((a, b) => fs_1.default.statSync(b).mtimeMs - fs_1.default.statSync(a).mtimeMs);
+    return files[0];
+};
+const detectPlaywrightJson = () => {
+    const envPath = readEnv("PLAYWRIGHT_JSON_PATH");
+    if (envPath && fs_1.default.existsSync(envPath) && fs_1.default.statSync(envPath).isFile()) {
+        return envPath;
+    }
+    const defaultPath = DEFAULT_JSON_PATH;
+    if (fs_1.default.existsSync(defaultPath) && fs_1.default.statSync(defaultPath).isFile()) {
+        return defaultPath;
+    }
+    const reportPattern = (name) => name.startsWith("report-") && name.endsWith(".json");
+    const latestReport = findLatestMatch(DEFAULT_TEST_RESULTS_DIR, reportPattern);
+    if (latestReport)
+        return latestReport;
+    const anyJson = findLatestMatch(DEFAULT_TEST_RESULTS_DIR, (name) => name.endsWith(".json"));
+    if (anyJson)
+        return anyJson;
+    return null;
+};
 const normalizeError = (value) => {
     if (!value)
         return null;
@@ -158,6 +190,26 @@ const extractTestsFromReport = (reportJson) => {
 const computeRunStatus = (tests) => {
     return tests.some((t) => t.status === "failed") ? "failed" : "passed";
 };
+const bestEffortComplete = async (appUrl, ingestToken, runId, status, tests) => {
+    try {
+        await fetch(`${appUrl}/api/runs/${runId}/complete`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${ingestToken}`
+            },
+            body: JSON.stringify({
+                status,
+                finishedAt: new Date().toISOString(),
+                tests,
+                artifacts: []
+            })
+        });
+    }
+    catch {
+        // Ignore best-effort failures; original error will be surfaced.
+    }
+};
 const detectGitLabEnv = () => {
     const isGitLab = readEnv("GITLAB_CI") === "true" || !!readEnv("CI_PROJECT_ID");
     if (!isGitLab)
@@ -261,9 +313,18 @@ const main = async () => {
     const ingestToken = readEnv("SENTINEL_TOKEN") || readEnv("PROJECT_INGEST_TOKEN");
     if (!ingestToken)
         fail("SENTINEL_TOKEN is required.");
-    const playwrightJsonPath = getArgValue(args, "--playwright-json-path") ||
-        readEnv("PLAYWRIGHT_JSON_PATH") ||
-        DEFAULT_JSON_PATH;
+    const cliJsonPath = getArgValue(args, "--playwright-json-path");
+    const playwrightJsonPath = cliJsonPath || detectPlaywrightJson();
+    if (!playwrightJsonPath) {
+        fail([
+            "PLAYWRIGHT_JSON_PATH not found.",
+            "Checked:",
+            `- ${readEnv("PLAYWRIGHT_JSON_PATH") || "(env not set)"}`,
+            `- ${DEFAULT_JSON_PATH}`,
+            `- ${DEFAULT_TEST_RESULTS_DIR}/report-*.json`,
+            `- ${DEFAULT_TEST_RESULTS_DIR}/*.json`
+        ].join("\n"));
+    }
     const playwrightReportDir = getArgValue(args, "--playwright-report-dir") ||
         readEnv("PLAYWRIGHT_REPORT_DIR") ||
         DEFAULT_PLAYWRIGHT_REPORT_DIR;
@@ -333,77 +394,86 @@ const main = async () => {
         return { ...artifact, sizeBytes: stat.size, contentType };
     });
     let finalArtifacts = artifactsWithMeta;
-    if (byoBucket) {
-        const s3Region = readEnv("SENTINEL_S3_REGION") || readEnv("AWS_REGION") || readEnv("S3_REGION");
-        if (!s3Region)
-            fail("SENTINEL_S3_REGION is required for BYO S3.");
-        const s3Endpoint = readEnv("SENTINEL_S3_ENDPOINT") || readEnv("S3_ENDPOINT");
-        const accessKeyId = readEnv("SENTINEL_S3_ACCESS_KEY_ID") || readEnv("AWS_ACCESS_KEY_ID");
-        const secretAccessKey = readEnv("SENTINEL_S3_SECRET_ACCESS_KEY") || readEnv("AWS_SECRET_ACCESS_KEY");
-        if (!accessKeyId || !secretAccessKey) {
-            fail("SENTINEL_S3_ACCESS_KEY_ID and SENTINEL_S3_SECRET_ACCESS_KEY are required.");
-        }
-        const s3Client = new client_s3_1.S3Client({
-            region: s3Region,
-            ...(s3Endpoint ? { endpoint: s3Endpoint } : {}),
-            credentials: { accessKeyId, secretAccessKey }
-        });
-        await withRetry(async () => {
-            await uploadArtifacts(s3Client, byoBucket, finalArtifacts);
-        }, "upload artifacts");
-        finalArtifacts = finalArtifacts.map((artifact) => ({
-            ...artifact,
-            bucket: byoBucket
-        }));
-    }
-    else {
-        const presignRes = await withRetry(() => fetch(`${appUrl}/api/uploads/presign`, {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                authorization: `Bearer ${ingestToken}`
-            },
-            body: JSON.stringify({
-                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}`);
+    try {
+        if (byoBucket) {
+            const s3Region = readEnv("SENTINEL_S3_REGION") ||
+                readEnv("AWS_REGION") ||
+                readEnv("S3_REGION");
+            if (!s3Region)
+                fail("SENTINEL_S3_REGION is required for BYO S3.");
+            const s3Endpoint = readEnv("SENTINEL_S3_ENDPOINT") || readEnv("S3_ENDPOINT");
+            const accessKeyId = readEnv("SENTINEL_S3_ACCESS_KEY_ID") || readEnv("AWS_ACCESS_KEY_ID");
+            const secretAccessKey = readEnv("SENTINEL_S3_SECRET_ACCESS_KEY") ||
+                readEnv("AWS_SECRET_ACCESS_KEY");
+            if (!accessKeyId || !secretAccessKey) {
+                fail("SENTINEL_S3_ACCESS_KEY_ID and SENTINEL_S3_SECRET_ACCESS_KEY are required.");
+            }
+            const s3Client = new client_s3_1.S3Client({
+                region: s3Region,
+                ...(s3Endpoint ? { endpoint: s3Endpoint } : {}),
+                credentials: { accessKeyId, secretAccessKey }
+            });
+            await withRetry(async () => {
+                await uploadArtifacts(s3Client, byoBucket, finalArtifacts);
+            }, "upload artifacts");
+            finalArtifacts = finalArtifacts.map((artifact) => ({
+                ...artifact,
+                bucket: byoBucket
+            }));
         }
-        const presignData = await presignRes.json();
-        const uploadMap = new Map((presignData.items || []).map((item) => [item.relPath, item]));
-        await withRetry(async () => {
-            for (const artifact of finalArtifacts) {
-                const item = uploadMap.get(artifact.objectKey);
-                if (!item?.uploadUrl || !item?.objectKey) {
-                    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}`);
-                    }
-                }, `upload ${artifact.objectKey}`);
-                artifact.objectKey = item.objectKey;
+        else {
+            const presignRes = await withRetry(() => fetch(`${appUrl}/api/uploads/presign`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${ingestToken}`
+                },
+                body: JSON.stringify({
+                    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}`);
             }
-        }, "upload artifacts");
-        finalArtifacts = finalArtifacts.map((artifact) => ({
-            ...artifact,
-            bucket: presignData.bucket
-        }));
+            const presignData = await presignRes.json();
+            const uploadMap = new Map((presignData.items || []).map((item) => [item.relPath, item]));
+            await withRetry(async () => {
+                for (const artifact of finalArtifacts) {
+                    const item = uploadMap.get(artifact.objectKey);
+                    if (!item?.uploadUrl || !item?.objectKey) {
+                        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}`);
+                        }
+                    }, `upload ${artifact.objectKey}`);
+                    artifact.objectKey = item.objectKey;
+                }
+            }, "upload artifacts");
+            finalArtifacts = finalArtifacts.map((artifact) => ({
+                ...artifact,
+                bucket: presignData.bucket
+            }));
+        }
+    }
+    catch (err) {
+        await bestEffortComplete(appUrl, ingestToken, runId, "failed", tests);
+        fail(err?.message || String(err));
     }
     const uploadDurationMs = Date.now() - uploadStart;
     const completeRes = await withRetry(() => fetch(`${appUrl}/api/runs/${runId}/complete`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/uploader",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "description": "Sentinel uploader CLI for CI/CD debugging artifacts",
   "license": "MIT",