@leera.io/qa-runner 1.0.1 → 1.0.2

package/dist/src/client.js

@@ -49,8 +49,11 @@ export class RunnerClient {
             return { result: 'unexpected', status: error.status, message: error.message };
         }
     }
-    async heartbeat(jobId) {
-        const response = await this.json('/api/v1/qa/runner/heartbeat', { job_id: jobId });
+    async heartbeat(jobId, progress) {
+        const response = await this.json('/api/v1/qa/runner/heartbeat', {
+            job_id: jobId,
+            ...(progress ? { progress } : {}),
+        });
         return response?.continue ?? false;
     }
     async uploadEvidence(jobId, name, bytes, contentType = 'image/png') {

package/dist/src/executor.js

@@ -76,9 +76,9 @@ export async function createDriver(registry, ctx, shared) {
     return factory.create(ctx, shared);
 }
 /** Runs a claimed job's script on the driver its platform maps to (web, android, …). */
-export async function executeClaimedJob(registry, ctx, shared, shouldStop) {
+export async function executeClaimedJob(registry, ctx, shared, shouldStop, onProgress) {
     const driver = await createDriver(registry, ctx, shared);
-    return executeSteps(driver, ctx.job.automation, { jobTimeoutMs: ctx.timeouts.jobMs }, shouldStop, ctx.redact);
+    return executeSteps(driver, ctx.job.automation, { jobTimeoutMs: ctx.timeouts.jobMs, ...(onProgress ? { onProgress } : {}) }, shouldStop, ctx.redact);
 }
 /**
  * Runs a script's steps in index order on a driver: stops at the first failed or
@@ -93,6 +93,23 @@ export async function executeSteps(driver, script, options, shouldStop, redact)
     let videoPath;
     try {
         const ordered = [...script.steps].sort((a, b) => a.index - b.index);
+        const report = (progress) => {
+            if (!options.onProgress)
+                return;
+            const passed = steps.filter((outcome) => outcome.result === 'passed').length;
+            try {
+                options.onProgress({
+                    ...progress,
+                    step_count: ordered.length,
+                    steps_passed: passed,
+                    steps_failed: steps.length - passed,
+                });
+            }
+            catch {
+                // Progress is a courtesy to whoever is watching; it never fails the job.
+            }
+        };
+        report({ phase: 'launching' });
         try {
             await driver.launch();
         }
@@ -104,8 +121,9 @@ export async function executeSteps(driver, script, options, shouldStop, redact)
             const outcome = { index: first.index, result: 'blocked', note: redact(errorMessage(error)), screenshots: [] };
             return { steps: [outcome], elapsedSecs: Math.max(1, Math.round((Date.now() - started) / 1000)), stopped: false };
         }
-        for (const step of ordered) {
+        for (const [position, step] of ordered.entries()) {
             const outcome = { index: step.index, result: 'passed', screenshots: [] };
+            report({ phase: 'running', step_index: step.index, step_number: position + 1 });
             driver.beginStep(step.index);
             try {
                 for (const action of step.actions) {

package/dist/src/progress.js

@@ -0,0 +1,32 @@
+/**
+ * Sends progress one request at a time, keeping only the newest update while one
+ * is in flight: a script with fast steps must not queue a request per step, and
+ * the run page only needs where the job is now, not every place it has been.
+ */
+export function progressReporter(send) {
+    let pending;
+    let inFlight = false;
+    let stopped = false;
+    const pump = async () => {
+        inFlight = true;
+        while (pending && !stopped) {
+            const next = pending;
+            pending = undefined;
+            await send(next).catch(() => undefined);
+        }
+        inFlight = false;
+    };
+    return {
+        report(progress) {
+            if (stopped)
+                return;
+            pending = progress;
+            if (!inFlight)
+                void pump();
+        },
+        stop() {
+            stopped = true;
+            pending = undefined;
+        },
+    };
+}

package/dist/src/runner.js

@@ -11,6 +11,7 @@ import { ExitCode, ExitError, messageOf } from './errors.js';
 import { createDriver, executeClaimedJob, jobContext, sessionContext } from './executor.js';
 import { HealthMonitor, healthReport } from './health.js';
 import { homePaths, readJsonFile, writePrivateFile } from './home.js';
+import { progressReporter } from './progress.js';
 import { redactor } from './template.js';
 import { runSession } from './session/loop.js';
 import { isSessionClaim } from './types.js';
@@ -326,6 +327,16 @@ export class Runner {
             })
                 .catch((error) => log.warn('heartbeat failed', { job_id: jobId, error: redact(messageOf(error)) }));
         }, job.job.heartbeat_seconds * 1_000);
+        const progress = progressReporter(async (update) => {
+            try {
+                if (!(await client.heartbeat(jobId, update)))
+                    cancelled = true;
+            }
+            catch (error) {
+                // An older server refuses the extra field or the network blipped; the timed heartbeat keeps the lease.
+                log.debug('progress report failed', { job_id: jobId, error: redact(messageOf(error)) });
+            }
+        });
         let videoPath;
         try {
             const ctx = jobContext(job, {
@@ -339,7 +350,7 @@ export class Runner {
                 redact,
                 log,
             });
-            const report = await executeClaimedJob(registry, ctx, shared, () => cancelled || this.stopping);
+            const report = await executeClaimedJob(registry, ctx, shared, () => cancelled || this.stopping, progress.report);
             videoPath = report.videoPath;
             if (cancelled) {
                 log.info('job cancelled', { job_id: jobId });
@@ -351,6 +362,13 @@ export class Runner {
                 this.jobFinished(job, 'error', 'the runner shut down before the job finished', [], report.elapsedSecs);
                 return;
             }
+            const passedSteps = report.steps.filter((step) => step.result === 'passed').length;
+            progress.report({
+                phase: 'uploading',
+                step_count: Math.max(job.item.steps.length, report.steps.length),
+                steps_passed: passedSteps,
+                steps_failed: report.steps.length - passedSteps,
+            });
             const stepResults = [];
             for (const step of report.steps) {
                 const attachments = [];
@@ -416,6 +434,7 @@ export class Runner {
         }
         finally {
             clearInterval(heartbeat);
+            progress.stop();
             this.running.delete(jobId);
             // Each job records into its own temporary directory.
             if (videoPath)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leera.io/qa-runner",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Runs recorded QA test scripts on your own machines and reports results back to your workspace.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",