@flowriki/agent 0.1.0-beta.5 → 0.1.0-beta.6

package/dist/{chunk-QJOMJVCO.js → chunk-ZUHML4TR.js}

@@ -4994,12 +4994,19 @@ function redactPanel(state) {
   if (!Array.isArray(panel.steps)) return state;
   return { ...panel, steps: panel.steps.map((s) => redact(s)) };
 }
+var START_GRACE_MS = 3e3;
 var RecordingCoordinator = class {
   constructor(deps) {
     this.deps = deps;
   }
   deps;
   session = null;
+  /** The browser opening, while `start` has already answered.
+   *
+   * Held so that stop and status can wait for it rather than racing it: a
+   * recording asked to stop a second after it was asked to start must not find
+   * a half-built session. */
+  starting = null;
   draft = null;
   stopInFlight = null;
   active() {
@@ -5008,7 +5015,10 @@ var RecordingCoordinator = class {
   }
   status() {
     return {
-      active: Boolean(this.session),
+      // A browser still opening counts as active: `start` has answered, the
+      // draft exists, and telling the dashboard "nothing is recording" in that
+      // window is what makes a Stop pressed early do nothing at all.
+      active: Boolean(this.session) || Boolean(this.draft && this.starting),
       featureId: this.draft?.featureId ?? null,
       name: this.draft?.name ?? null,
       steps: (this.draft?.steps ?? []).map(redact),
@@ -5047,6 +5057,30 @@ var RecordingCoordinator = class {
       startPath: "/",
       recordedBy: recordedBy?.trim() || ""
     };
+    let failure = null;
+    this.starting = this.open(target, opts).catch((error) => {
+      failure = error;
+      this.draft = null;
+      this.session = null;
+      this.deps.lease?.release("recording");
+      this.deps.emit({ type: "recording.interrupted", reason: String(error.message).split("\n")[0] });
+      return null;
+    });
+    await Promise.race([this.starting, new Promise((r) => setTimeout(r, START_GRACE_MS).unref?.())]);
+    if (failure) throw failure;
+    return { url: target };
+  }
+  /** Resolves once the browser is open, or the attempt has failed.
+   *
+   * For callers that need the session itself rather than the answer — the
+   * local server driving a panel, and every test that types into the page. */
+  async ready() {
+    await this.starting?.catch(() => null);
+  }
+  /** Everything that used to happen before `start` answered. */
+  async open(target, opts) {
+    const config = this.deps.store.readConfig();
+    const configuredBase = config.baseUrl;
     try {
       this.session = await startRecordingSession({
         url: target,
@@ -5077,12 +5111,13 @@ var RecordingCoordinator = class {
       throw err;
     }
     this.deps.lease?.activate("recording");
+    if (!this.session || !this.draft) return null;
     const opened = new URL(this.session.startUrl);
     const projectOrigin = configuredBase ? new URL(normalizeStartUrl(configuredBase)).origin : "";
     this.draft.baseUrl = opened.origin === projectOrigin ? "" : opened.origin;
     this.draft.startPath = opened.pathname + opened.search;
     this.deps.emit({ type: "recording.started", name: this.draft.name, url: this.session.startUrl });
-    return { url: this.session.startUrl };
+    return null;
   }
   /** onStep fires more than once per step — again when the outcome window
    *  resolves and attaches assertions — so this is an upsert, not an append. */
@@ -5114,6 +5149,8 @@ var RecordingCoordinator = class {
     return this.stopInFlight;
   }
   async doStop() {
+    await this.starting?.catch(() => null);
+    this.starting = null;
     const draft = this.draft;
     if (!draft) return { ok: false, error: "no recording in progress" };
     const environment = this.session?.environment;
@@ -5536,8 +5573,26 @@ var CommandSchema = z4.object({
   /** Wall-clock expiry. A command that surfaced from a queue an hour late must
    *  not start a browser on somebody's machine. */
   expiresAt: z4.number().int().positive(),
+  /** When the service stamped this, by the service's clock.
+   *
+   * Present so the agent never has to compare a timestamp minted on another
+   * machine against its own clock. `expiresAt` alone made the deadline
+   * meaningless the moment two clocks disagreed: a machine running five
+   * minutes fast rejected every command the instant it arrived, saying it had
+   * expired before it got there — which is true only if you believe both
+   * clocks. Optional, so an older service that does not send it still works;
+   * the agent falls back to the absolute deadline it has always used. */
+  issuedAt: z4.number().int().positive().optional(),
   args: z4.record(z4.unknown()).default({})
-}).strict();
+  // UNKNOWN FIELDS ARE IGNORED, not refused.
+  //
+  // Strictness here looked like caution and was a compatibility trap: the day
+  // the service added `issuedAt`, every agent older than that release began
+  // refusing every command as unrecognised — over a field it had no need to
+  // read. The allowlist on command NAMES is the security boundary and is
+  // unchanged; which extra keys ride along is not, because nothing acts on a
+  // field it does not know about.
+});
 var AckSchema = z4.object({
   type: z4.literal("ack"),
   commandId: z4.string().min(1),
@@ -5718,7 +5773,7 @@ var AgentState = class {
       if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, v]) => [key, canonical(v)]));
       return value;
     };
-    const { expiresAt: _expiry, ...work } = command;
+    const { expiresAt: _expiry, issuedAt: _issued, ...work } = command;
     const text = JSON.stringify(canonical(work));
     if (Buffer.byteLength(text) > 256 * 1024) throw new Error("command exceeds local size limit");
     return crypto22.createHash("sha256").update(text).digest("hex");
@@ -5882,7 +5937,9 @@ var Agent = class {
     }
     const previous = this.previous(command.id, fingerprint2);
     if (previous) return previous;
-    if (command.expiresAt <= this.now()) {
+    const ttl = command.issuedAt === void 0 ? null : command.expiresAt - command.issuedAt;
+    const expired = ttl === null ? command.expiresAt <= this.now() : ttl <= 0;
+    if (expired) {
       return this.refuse(command.id, "expired", "the command expired before it reached this machine");
     }
     const handler = this.opts.handlers[command.name];
@@ -6981,7 +7038,7 @@ function openBrowser(url, env = process.env) {
 }
 
 // src/engine.ts
-var AGENT_VERSION = "0.1.0-beta.5";
+var AGENT_VERSION = "0.1.0-beta.6";
 async function connect(options = {}) {
   let service;
   try {

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   resolveCheckouts,
   start,
   status
-} from "./chunk-QJOMJVCO.js";
+} from "./chunk-ZUHML4TR.js";
 
 // src/cli.ts
 import { parseArgs } from "util";

package/dist/engine.js

@@ -9,7 +9,7 @@ import {
   resolveCheckouts,
   start,
   status
-} from "./chunk-QJOMJVCO.js";
+} from "./chunk-ZUHML4TR.js";
 export {
   AGENT_VERSION,
   browsersReady,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowriki/agent",
-  "version": "0.1.0-beta.5",
+  "version": "0.1.0-beta.6",
   "description": "Run Flowriki UI tests on your own computer. Connects this machine to your Flowriki account.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",