lynkeus 0.3.0 → 0.5.0

package/src/runtime.ts

@@ -11,18 +11,38 @@ import { type Expected, expectedOf } from './targets.js';
 export type Outcome = { text?: string; json?: unknown; code: number; error?: string; why?: string };
 
 /** The screen, requests and trace after a failure, read as rules; empty when there is nothing to read. */
-export const whyFor = async (base: Base, expected?: Expected): Promise<string> => {
+export const whyFor = async (base: Base, expected?: Expected, startedAt?: number): Promise<string> => {
   try {
     const device = await base.device();
     const [screen, requests, trace] = await Promise.all([device.screen(), device.requests(), device.trace()]);
+    const during = duringCommand(requests.requests, startedAt);
     return describeWhy(
-      explain({ screen, requests: requests.requests.slice(-40), inFlight: requests.inFlight, trace: trace.events.slice(-40), target: expected }),
+      explain({
+        screen,
+        requests: during.slice(-40),
+        inFlight: requests.inFlight,
+        trace: trace.events.slice(-40),
+        target: expected,
+        fetchedBefore: during.length < requests.requests.length,
+      }),
     );
   } catch {
     return '';
   }
 };
 
+/**
+ * The requests made while the failed command ran, and a little before: a 403 from minutes ago is not why a wait
+ * failed now. Only when the app's clock reads like this machine's (a simulator, an emulator); a host on a clock of
+ * its own keeps them all.
+ */
+export const duringCommand = <R extends { startedAt: number }>(requests: R[], startedAt: number | undefined, now = Date.now()): R[] => {
+  if (startedAt === undefined || requests.length === 0) return requests;
+  const latest = Math.max(...requests.map((r) => r.startedAt));
+  if (Math.abs(latest - now) > 10 * 60_000) return requests;
+  return requests.filter((r) => r.startedAt >= startedAt - 3000);
+};
+
 const TARGET_ARG: Record<string, number> = { press: 0, see: 0, wait: 0, swipe: 1, nav: 0, type: 1 };
 
 export const execute = async (argv: string[], base: Base): Promise<Outcome> => {
@@ -37,6 +57,7 @@ export const execute = async (argv: string[], base: Base): Promise<Outcome> => {
     throw error;
   }
   if (parsed.flags.help) return { code: 0, text: helpFor(command) };
+  const startedAt = Date.now();
   try {
     const result = await command.run({ ...base, ...parsed });
     if (result === undefined) return { code: 0 };
@@ -46,7 +67,7 @@ export const execute = async (argv: string[], base: Base): Promise<Outcome> => {
     const out: Outcome = { code: 1, error: error instanceof Error ? error.message : String(error) };
     const at = TARGET_ARG[command.name];
     if (at !== undefined) {
-      const why = await whyFor(base, expectedOf(parsed.args[at]));
+      const why = await whyFor(base, expectedOf(parsed.args[at]), startedAt);
       if (why) out.why = why;
     }
     return out;