@nativedesktop/test 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nativedesktop/test",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "type": "module",
   "license": "MIT",
   "homepage": "https://github.com/FormalSnake/NativeDesktop#readme",
@@ -22,7 +22,7 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@nativedesktop/host": "0.2.0",
-    "@nativedesktop/react": "0.2.0"
+    "@nativedesktop/host": "0.3.1",
+    "@nativedesktop/react": "0.3.1"
   }
 }

package/src/launch.ts

@@ -8,23 +8,24 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Backend } from "@nativedesktop/host";
 import { resolveBackend, resolveHostBinary } from "@nativedesktop/host";
-import { AutomationClient } from "./socket.ts";
-import type {
-  DragParams,
-  DragResult,
-  ClickResult,
-  GetTreeResult,
-  JsonNode,
-  KeysResult,
-  ScreenshotResult,
-  ScrollResult,
-  SetValueResult,
-  TypeResult,
-  WaitCondition,
-  WaitForResult,
-  WebViewEvalResult,
-  WebViewInfo,
-  WindowsResult,
+import { AutomationClient, AutomationRpcError } from "./socket.ts";
+import {
+  type DragParams,
+  type DragResult,
+  type ClickResult,
+  type GetTreeResult,
+  type JsonNode,
+  type KeysResult,
+  RPC_ERRORS,
+  type ScreenshotResult,
+  type ScrollResult,
+  type SetValueResult,
+  type TypeResult,
+  type WaitCondition,
+  type WaitForResult,
+  type WebViewEvalResult,
+  type WebViewInfo,
+  type WindowsResult,
 } from "@nativedesktop/react/rpc";
 import { TimedClient } from "./client.ts";
 import { type DialogScript, dialogScriptEnv } from "./dialogs.ts";
@@ -351,14 +352,32 @@ export class AppHandle {
     return this.rpc.call("getTree", { window });
   }
 
+  // A window closing between windows() (or an earlier query) and this call
+  // races the window ref out from under `opts.window`; getTree answers the
+  // distinguishable windowGone error rather than invalidParams (see
+  // schema/rpc.json), and every find* helper below treats that exactly like
+  // an unmatched testId: null, an empty list, or a "not found" throw. tree()
+  // itself does NOT swallow it: a raw tree() caller needs to know the window
+  // is gone rather than get a fake empty snapshot that reads the same as
+  // "this window really has no children".
+  private isWindowGone(e: unknown): boolean {
+    return e instanceof AutomationRpcError && e.code === RPC_ERRORS.windowGone.code;
+  }
+
   async find(testId: string, opts: { window?: number } = {}): Promise<JsonNode | null> {
-    const t = await this.tree(opts.window);
-    return findNode(t.root, testId);
+    const t = await this.tree(opts.window).catch((e) => {
+      if (this.isWindowGone(e)) return null;
+      throw e;
+    });
+    return t ? findNode(t.root, testId) : null;
   }
 
   async findAll(testId: string, opts: { window?: number } = {}): Promise<JsonNode[]> {
-    const t = await this.tree(opts.window);
-    return findAllNodes(t.root, testId);
+    const t = await this.tree(opts.window).catch((e) => {
+      if (this.isWindowGone(e)) return null;
+      throw e;
+    });
+    return t ? findAllNodes(t.root, testId) : [];
   }
 
   async mustFind(testId: string, opts: { window?: number } = {}): Promise<JsonNode> {
@@ -368,8 +387,11 @@ export class AppHandle {
   }
 
   async findMatching(pred: (n: JsonNode) => boolean, opts: { window?: number } = {}): Promise<JsonNode | null> {
-    const t = await this.tree(opts.window);
-    return findMatchingNode(t.root, pred);
+    const t = await this.tree(opts.window).catch((e) => {
+      if (this.isWindowGone(e)) return null;
+      throw e;
+    });
+    return t ? findMatchingNode(t.root, pred) : null;
   }
 
   // --- actions (single RPC, host-side resolution, no retry loops) ------------

package/src/screenshot.ts

@@ -8,8 +8,9 @@
 import { existsSync } from "node:fs";
 import { resolve as resolvePath } from "node:path";
 import type { Backend } from "@nativedesktop/host";
-import type { ScreenshotResult } from "@nativedesktop/react/rpc";
+import { RPC_ERRORS, type ScreenshotResult } from "@nativedesktop/react/rpc";
 import { pngSize } from "./png.ts";
+import { AutomationRpcError } from "./socket.ts";
 
 export interface ScreenshotOptions {
   window?: number;
@@ -50,6 +51,11 @@ export async function takeScreenshot(
       }
       return shot;
     } catch (e) {
+      // A closed window is never coming back mid-run, so retrying just
+      // burns the retry budget on a guaranteed repeat failure; fail fast
+      // with the distinguishable error instead of the generic "N attempts"
+      // wrapper the frame-invalidation races below are meant for.
+      if (e instanceof AutomationRpcError && e.code === RPC_ERRORS.windowGone.code) throw e;
       lastErr = e as Error;
       if (attempt < retries - 1) await new Promise((r) => setTimeout(r, 150));
     }

package/src/socket.ts

@@ -21,6 +21,25 @@ interface JsonRpcResponse {
   error?: JsonRpcError;
 }
 
+/**
+ * A rejected call's `code`/`data` survive on the error object (matching
+ * schema/rpc.json's `errors` table, e.g. RPC_ERRORS.windowGone.code), so a
+ * caller can branch on the error kind without parsing `.message` text.
+ * `.message` keeps the existing "<msg> (<code>)" shape so callers that
+ * already substring-match a code keep working.
+ */
+export class AutomationRpcError extends Error {
+  readonly code: number;
+  readonly data: unknown;
+
+  constructor(code: number, message: string, data?: unknown) {
+    super(`${message} (${code})`);
+    this.name = "AutomationRpcError";
+    this.code = code;
+    this.data = data;
+  }
+}
+
 export class AutomationClient {
   private socket!: import("bun").Socket;
   private inbox = new Uint8Array(0);
@@ -75,7 +94,7 @@ export class AutomationClient {
     const pending = this.pending.get(msg.id);
     if (!pending) return; // unknown/stale id — drop
     this.pending.delete(msg.id);
-    if (msg.error) pending.reject(new Error(`${msg.error.message} (${msg.error.code})`));
+    if (msg.error) pending.reject(new AutomationRpcError(msg.error.code, msg.error.message, msg.error.data));
     else pending.resolve(msg.result);
   }