@qawolf/cli 1.9.2 → 1.10.0

package/dist/cli.js

@@ -156412,12 +156412,14 @@ var interactiveRunnerMessages = {
   launched: (id) => `Launched runner ${id}.`,
   launchedForCommand: (id) => `No runner was given, so launched ${id} for this command. Its browser is fresh: nothing has been run on it and nothing is signed in. It bills until it is stopped or idles out, so stop it with qawolf runner stop --runner ${id} when you are done.`,
   followEventsTimedOut: (stream, seconds) => `Stopped following ${stream} after ${formatSeconds(seconds * 1000)}: reading keeps the runner alive and billing, so a follow does not run unbounded. Pass --timeout to wait longer, or follow again to continue.`,
+  followEndCutShort: "The run settled, but the last window of its followed streams could not be read, so the output above may be missing its final lines.",
   followTimedOut: (runId, runnerId, seconds) => `Stopped following run ${runId} after ${formatSeconds(seconds * 1000)}. The run may still be going: read it with qawolf runner events run-status --run ${runId}, and stop the runner with qawolf runner stop --runner ${runnerId} when you are done. Pass --timeout to wait longer.`,
   missingPackageJson: "No package.json in the current directory. A run reads its npm dependencies from one, so it has to travel with the flow.",
   noRunnerIdForScreenshot: `${noRunnerId} A screenshot also needs a screen, which a runner gets from its first run: run a flow on it with qawolf runner run.`,
   noRunnerId,
   notRunning: (id) => `Runner ${id} was not running.`,
   runFailed: (errorMessage2) => errorMessage2 === undefined ? "The run failed and reported no reason." : `The run failed: ${errorMessage2}`,
+  runInProgress: "The run is in progress.",
   runPassed: "The run passed.",
   runSettledUnknown: (status) => `The run settled as "${status}", which this version of the CLI does not recognize. Upgrade to read it.`,
   runSubmitAnsweredUnknown: (outcome) => `The runner answered the submission with "${outcome}", which this version of the CLI does not recognize. Upgrade to read it.`,
@@ -175909,7 +175911,7 @@ function startUpdateCheck(deps) {
 // package.json
 var package_default = {
   name: "@qawolf/cli",
-  version: "1.9.2",
+  version: "1.10.0",
   description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   keywords: [
     "automation",
@@ -186853,6 +186855,20 @@ function readRunSettlement(payload) {
     type: "settled"
   };
 }
+function findSettlement(entries) {
+  for (const entry of entries) {
+    const settlement = readRunSettlement(entry.payload);
+    if (settlement.type !== "settled")
+      continue;
+    if (settlement.status === "passed")
+      return { type: "passed" };
+    if (settlement.status === "failed") {
+      return { errorMessage: settlement.errorMessage, type: "failed" };
+    }
+    return { status: settlement.status, type: "unrecognized" };
+  }
+  return;
+}
 var runLogPayloadSchema = exports_external.object({ message: exports_external.string() });
 function formatRunLogLine(payload) {
   const parsed = runLogPayloadSchema.safeParse(payload);
@@ -186915,6 +186931,18 @@ function createJournalCursor(ctx, runnerId, request) {
     return { entries: window2.value.entries, type: "entries" };
   };
 }
+function createPrintingCursor(ctx, runnerId, request, format) {
+  const read = createJournalCursor(ctx, runnerId, request);
+  return async () => {
+    const window2 = await read();
+    if (window2.type !== "entries")
+      return window2;
+    for (const entry of window2.entries) {
+      ctx.ui.stream(entry, format(entry.payload));
+    }
+    return window2;
+  };
+}
 var unreachableGraceMs = 60000;
 function createUnreachableBudget(pollIntervalMs2) {
   const limit = Math.ceil(unreachableGraceMs / pollIntervalMs2);
@@ -186996,22 +187024,49 @@ function readErrorPath(error51) {
   return typeof path9 === "string" ? path9 : undefined;
 }
 
-// src/domains/interactiveRunner/followRun.ts
-var pollIntervalMs3 = 1000;
-function findSettlement(entries) {
-  for (const entry of entries) {
-    const settlement = readRunSettlement(entry.payload);
-    if (settlement.type !== "settled")
-      continue;
-    if (settlement.status === "passed")
-      return { type: "passed" };
-    if (settlement.status === "failed") {
-      return { errorMessage: settlement.errorMessage, type: "failed" };
+// src/domains/interactiveRunner/followPrinters.ts
+var anchorPollIntervalMs = 1000;
+async function resolveRecorderAnchor(ctx, resolved, deps) {
+  if (resolved.type === "launched")
+    return { ok: true, sinceSequence: 0 };
+  return anchorRecorderCursor(ctx, resolved.runnerId, deps);
+}
+async function anchorRecorderCursor(ctx, runnerId, deps) {
+  const unreachable = createUnreachableBudget(anchorPollIntervalMs);
+  for (;; ) {
+    const anchor = await readJournal(ctx, runnerId, {
+      stream: "recorder",
+      tail: 1
+    });
+    if (anchor.type === "read") {
+      return { ok: true, sinceSequence: anchor.value.nextSequence };
     }
-    return { status: settlement.status, type: "unrecognized" };
+    if (anchor.type === "failed") {
+      return { failure: journalReadFailure(anchor), ok: false };
+    }
+    if (unreachable.exhausted()) {
+      return { failure: { ...unreachableFailure }, ok: false };
+    }
+    await deps.sleep(anchorPollIntervalMs);
   }
-  return;
 }
+function createFollowPrinters(ctx, options) {
+  const jsonLine = (payload) => JSON.stringify(payload);
+  const printers = [];
+  if (options.logs) {
+    printers.push(createPrintingCursor(ctx, options.runnerId, { runId: options.runId, stream: "run-logs" }, formatRunLogLine));
+  }
+  if (options.runEvents) {
+    printers.push(createPrintingCursor(ctx, options.runnerId, { runId: options.runId, stream: "run-events" }, jsonLine));
+  }
+  if (options.recorderSinceSequence !== undefined) {
+    printers.push(createPrintingCursor(ctx, options.runnerId, { sinceSequence: options.recorderSinceSequence, stream: "recorder" }, jsonLine));
+  }
+  return printers;
+}
+
+// src/domains/interactiveRunner/followRun.ts
+var pollIntervalMs3 = 1000;
 function reportSettlement(ctx, settlement) {
   if (settlement.type === "passed") {
     ctx.ui.success(interactiveRunnerMessages.runPassed);
@@ -187023,40 +187078,49 @@ function reportSettlement(ctx, settlement) {
   };
 }
 async function followRun(ctx, options, deps) {
-  const readLogs = createJournalCursor(ctx, options.runnerId, {
-    runId: options.runId,
-    stream: "run-logs"
-  });
+  const printers = createFollowPrinters(ctx, options);
   const readStatus = createJournalCursor(ctx, options.runnerId, {
     runId: options.runId,
     stream: "run-status"
   });
   const unreachable = createUnreachableBudget(pollIntervalMs3);
-  const printLogs = async () => {
-    const logs = await readLogs();
-    if (logs.type !== "entries")
-      return logs;
-    for (const entry of logs.entries) {
-      ctx.ui.stream(entry, formatRunLogLine(entry.payload));
+  const printAll = async () => {
+    for (const print of printers) {
+      const window2 = await print();
+      if (window2.type !== "entries")
+        return window2;
     }
-    return logs;
+    return;
+  };
+  let progressReported = false;
+  const printProgress = (entries) => {
+    if (printers.length > 0 || progressReported)
+      return;
+    const entry = entries.find((e) => readRunSettlement(e.payload).type === "in-progress");
+    if (entry === undefined)
+      return;
+    progressReported = true;
+    ctx.ui.stream(entry, interactiveRunnerMessages.runInProgress);
   };
   const maxPolls = Math.max(1, Math.ceil(options.timeoutSeconds * 1000 / pollIntervalMs3));
   for (let poll = 1;; poll++) {
-    const logs = await printLogs();
-    if (logs.type === "failed")
-      return journalReadFailure(logs);
-    const status = logs.type === "unreachable" ? logs : await readStatus();
+    const interrupted = await printAll();
+    if (interrupted?.type === "failed")
+      return journalReadFailure(interrupted);
+    const status = interrupted?.type === "unreachable" ? interrupted : await readStatus();
     if (status.type === "failed")
       return journalReadFailure(status);
-    if (logs.type === "unreachable" || status.type === "unreachable") {
+    if (status.type === "unreachable") {
       if (unreachable.exhausted())
         return { ...unreachableFailure };
     } else {
       unreachable.reset();
+      printProgress(status.entries);
       const settlement = findSettlement(status.entries);
       if (settlement !== undefined) {
-        await printLogs();
+        if (await printAll() !== undefined) {
+          ctx.ui.warn(interactiveRunnerMessages.followEndCutShort);
+        }
         return reportSettlement(ctx, settlement);
       }
     }
@@ -187094,6 +187158,13 @@ async function handleRunnerRun(ctx, options, deps) {
     return { ...failureFields(resolved), exitCode: resolved.exitCode };
   }
   announceRunner(ctx, resolved);
+  let recorderSinceSequence;
+  if (options.recorderEvents) {
+    const anchor = await resolveRecorderAnchor(ctx, resolved, deps);
+    if (!anchor.ok)
+      return { ...anchor.failure };
+    recorderSinceSequence = anchor.sinceSequence;
+  }
   const result = await ctx.platformClient.callPublicApi(publicContractsV1.runner.runFlow, { entryPointPath, files, id: resolved.runnerId }, runnerCallOptions);
   if (!result.ok) {
     return { ...failureFields(result), exitCode: exitCodes.network };
@@ -187111,12 +187182,16 @@ async function handleRunnerRun(ctx, options, deps) {
       };
     case "submitted": {
       const runId = result.value.runId;
-      if (!options.follow) {
+      const follow = options.follow || options.logs || options.runEvents || options.recorderEvents;
+      if (!follow) {
         ctx.ui.output({ runId, runnerId: resolved.runnerId }, interactiveRunnerMessages.runSubmitted(runId));
         return;
       }
       ctx.ui.info(interactiveRunnerMessages.runSubmitted(runId));
       return followRun(ctx, {
+        logs: options.logs,
+        recorderSinceSequence,
+        runEvents: options.runEvents,
         runId,
         runnerId: resolved.runnerId,
         timeoutSeconds: timeout.seconds
@@ -187136,16 +187211,20 @@ async function handleRunnerRun(ctx, options, deps) {
 var runExamples2 = `
 Examples:
   $ qawolf runner run flows/checkout.flow.ts
-  $ qawolf runner run flows/checkout.flow.ts --follow`;
+  $ qawolf runner run flows/checkout.flow.ts --follow
+  $ qawolf runner run flows/checkout.flow.ts --follow --logs`;
 var eventsExamples = `
 Examples:
   $ qawolf runner events recorder --tail 5
   $ qawolf runner events run-logs --run <runId> --follow
   $ qawolf runner events console --since 120 --json`;
 function registerRunnerRunCommands(runner, signals) {
-  declareCommandKind(runner.command("run <file>"), "write").description("Run a flow on an interactive runner, shipping the current directory's files with it").option("--follow", "Stream the run's logs until it settles", false).option("--runner <id>", runnerFlagDescription).option("--timeout <seconds>", "Give up following after this long. Following keeps the runner alive, so a run that never settles would otherwise bill until the terminal closed", String(defaultFollowTimeoutSeconds)).addHelpText("after", runExamples2).action((file2, opts, command) => withAuthContext(signals, (ctx) => handleRunnerRun(ctx, {
+  declareCommandKind(runner.command("run <file>"), "write").description("Run a flow on an interactive runner, shipping the current directory's files with it").option("--follow", "Report the run's status until it settles: in progress, then passed or failed", false).option("--logs", "Stream every log line the run produces while following. Implies --follow", false).option("--run-events", "Stream the run's progress events as JSON lines while following. Implies --follow", false).option("--recorder-events", "Stream the browser actions the runner records as JSON lines while following, from an anchor taken just before submission: the recorder is runner-wide, not run-scoped. Implies --follow", false).option("--runner <id>", runnerFlagDescription).option("--timeout <seconds>", "Give up following after this long. Following keeps the runner alive, so a run that never settles would otherwise bill until the terminal closed", String(defaultFollowTimeoutSeconds)).addHelpText("after", runExamples2).action((file2, opts, command) => withAuthContext(signals, (ctx) => handleRunnerRun(ctx, {
     entryPoint: file2,
     follow: opts.follow,
+    logs: opts.logs,
+    recorderEvents: opts.recorderEvents,
+    runEvents: opts.runEvents,
     runner: opts.runner,
     timeout: opts.timeout
   }, runnerDeps(ctx)))(opts, command));
@@ -187205,4 +187284,4 @@ createProgram({ signals }).parseAsync().catch(() => {
     process.exitCode = 1;
 }).finally(() => flushAndExit(typeof process.exitCode === "number" ? process.exitCode : 0));
 
-//# debugId=80A0CD4106C384B664756E2164756E21
+//# debugId=8CB687F9691544E564756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qawolf/cli",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "description": "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   "keywords": [
     "automation",

package/skills/qawolf-cli/references/runner.md

@@ -166,13 +166,23 @@ The call answers with a run id as soon as the run is accepted. **The outcome is
 not in that answer**, it is in the `run-status` stream, whose entries carry
 `runId`, `status` and an `errorMessage` when there is one.
 
-**Pass `--follow` to `run` and let it wait for you.** It streams the run's logs
-and ends on the settled status, never on the logs, so a run that prints nothing
+**Pass `--follow` to `run` and let it wait for you.** It reports the run's
+status — in progress, then passed or failed — and ends on the settled status.
+Exit code `1` means the run did not pass. Three flags mirror more streams into
+the follow, and each implies `--follow` on its own: `--logs` streams every log
+line the run produces, `--run-events` streams the run's progress events as JSON
+lines, and `--recorder-events` streams the browser actions the runner records
+as JSON lines — the recorder is runner-wide rather than run-scoped, so that one
+carries whatever is recorded after an anchor taken just before submission. Whatever mirrors are on, the
+follow still ends on the status, never on them, so a run that prints nothing
 still terminates the follow and a run that dies mid-sentence still reports how.
-Exit code `1` means the run did not pass.
+Combining mirror flags interleaves their lines with nothing saying which stream
+a line came from — fine for eyeballs; when parsing, follow one stream at a time.
 
 ```sh
 qawolf runner run flows/checkout.flow.ts --follow
+qawolf runner run flows/checkout.flow.ts --follow --logs
+qawolf runner run flows/checkout.flow.ts --follow --recorder-events
 ```
 
 If you would rather submit and come back later, note that `--follow` on `events`