@nyssance/tauri-hasgard 0.6.0-alpha.1 → 0.6.0-alpha.4

package/dist/process-supervisor.js

@@ -1,12 +1,42 @@
-import {
-  stopProcessGroup
-} from "./chunk-N7YDYAKI.js";
+// src/process-supervisor.js
+import { spawn } from "node:child_process";
+import { lstatSync, unlinkSync } from "node:fs";
+import { createConnection } from "node:net";
+import { setTimeout as delay2 } from "node:timers/promises";
+
+// src/process-group.js
+import { setTimeout as delay } from "node:timers/promises";
+function signalGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch (error) {
+    if (error.code === "ESRCH")
+      return false;
+    if (signal === 0 && error.code === "EPERM")
+      return true;
+    throw error;
+  }
+}
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (signalGroup(pid, 0)) {
+    if (Date.now() >= deadline)
+      return false;
+    await delay(25);
+  }
+  return true;
+}
+async function stopProcessGroup(pid) {
+  signalGroup(pid, "SIGTERM");
+  if (!await waitForExit(pid, 5000)) {
+    signalGroup(pid, "SIGKILL");
+    if (!await waitForExit(pid, 5000))
+      throw new Error(`Hasgard process group ${pid} survived SIGKILL`);
+  }
+}
 
 // src/process-supervisor.js
-import { spawn } from "child_process";
-import { lstatSync, unlinkSync } from "fs";
-import { createConnection } from "net";
-import { setTimeout as delay } from "timers/promises";
 var application;
 var starting = false;
 var stopping;
@@ -19,7 +49,8 @@ function identity(path) {
     const stat = lstatSync(path);
     return { dev: stat.dev, ino: stat.ino, socket: stat.isSocket() };
   } catch (error) {
-    if (error.code === "ENOENT") return void 0;
+    if (error.code === "ENOENT")
+      return;
     throw error;
   }
 }
@@ -27,7 +58,8 @@ function sameIdentity(first, second) {
   return first && second && first.dev === second.dev && first.ino === second.ino;
 }
 function captureEndpoint() {
-  if (ownedEndpoint || !endpoint) return;
+  if (ownedEndpoint || !endpoint)
+    return;
   const current = identity(endpoint);
   if (current?.socket && !sameIdentity(current, initialEndpoint)) {
     ownedEndpoint = current;
@@ -35,7 +67,8 @@ function captureEndpoint() {
   }
 }
 async function removeOwnedEndpoint() {
-  if (!ownedEndpoint || !sameIdentity(identity(endpoint), ownedEndpoint)) return;
+  if (!ownedEndpoint || !sameIdentity(identity(endpoint), ownedEndpoint))
+    return;
   const accepting = await new Promise((resolve, reject) => {
     const socket = createConnection({ path: endpoint });
     socket.once("connect", () => {
@@ -43,10 +76,12 @@ async function removeOwnedEndpoint() {
       resolve(true);
     });
     socket.once("error", (error) => {
-      if (error.code === "ECONNREFUSED" || error.code === "ENOENT") resolve(false);
-      else reject(error);
+      if (error.code === "ECONNREFUSED" || error.code === "ENOENT")
+        resolve(false);
+      else
+        reject(error);
     });
-    socket.setTimeout(1e3, () => {
+    socket.setTimeout(1000, () => {
       socket.destroy();
       reject(new Error("Endpoint cleanup probe timed out"));
     });
@@ -55,35 +90,44 @@ async function removeOwnedEndpoint() {
     try {
       unlinkSync(endpoint);
     } catch (error) {
-      if (error.code !== "ENOENT") throw error;
+      if (error.code !== "ENOENT")
+        throw error;
     }
   }
 }
 process.stderr.on("error", (error) => {
-  if (error.code !== "EPIPE") shutdown(1);
+  if (error.code !== "EPIPE")
+    shutdown(1);
 });
 function send(message, stream) {
-  if (!process.connected) return;
+  if (!process.connected)
+    return;
   const writable = process.send(message, (error) => {
     if (error) {
       if (error.code !== "ERR_IPC_CHANNEL_CLOSED" && error.code !== "EPIPE")
         process.stderr.write(`Hasgard supervisor IPC: ${error.message}
 `);
-      if (process.connected) process.disconnect();
-    } else stream?.resume();
+      if (process.connected)
+        process.disconnect();
+    } else
+      stream?.resume();
   });
-  if (!writable) stream?.pause();
+  if (!writable)
+    stream?.pause();
 }
 process.once("message", (config) => {
-  if (!process.connected || stopping) return;
+  if (!process.connected || stopping)
+    return;
   starting = true;
   try {
     endpoint = config.env.TAURI_HASGARD_SOCKET;
-    if (typeof endpoint !== "string" || !endpoint) throw new Error("Supervisor requires TAURI_HASGARD_SOCKET");
+    if (typeof endpoint !== "string" || !endpoint)
+      throw new Error("Supervisor requires TAURI_HASGARD_SOCKET");
     initialEndpoint = identity(endpoint);
     endpointWatch = setInterval(captureEndpoint, 25);
     process.on("message", (message) => {
-      if (message.type !== "endpoint") return;
+      if (message.type !== "endpoint")
+        return;
       const current = identity(endpoint);
       if (!current?.socket || !sameIdentity(current, message.identity)) {
         send({ type: "error", message: "Application endpoint changed during readiness" });
@@ -109,7 +153,8 @@ process.once("message", (config) => {
   }
 });
 process.once("disconnect", () => shutdown(0));
-for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) process.on(signal, () => shutdown(0));
+for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
+  process.on(signal, () => shutdown(0));
 process.on("uncaughtException", (error) => {
   process.stderr.write(`Hasgard supervisor error: ${error.stack}
 `);
@@ -121,15 +166,17 @@ process.on("unhandledRejection", (error) => {
   shutdown(1);
 });
 function shutdown(exitCode) {
-  if (!stopping) stopping = cleanup(exitCode);
+  if (!stopping)
+    stopping = cleanup(exitCode);
 }
 async function cleanup(exitCode) {
   clearInterval(endpointWatch);
   const pid = application?.pid;
-  if (!starting || pid === void 0) process.exit(exitCode);
+  if (!starting || pid === undefined)
+    process.exit(exitCode);
   let groupStopped = false;
   let endpointFailures = 0;
-  for (; ; ) {
+  for (;; ) {
     try {
       let endpointError;
       try {
@@ -141,14 +188,16 @@ async function cleanup(exitCode) {
         await stopProcessGroup(pid);
         groupStopped = true;
       }
-      if (endpointError) throw endpointError;
+      if (endpointError)
+        throw endpointError;
       await removeOwnedEndpoint();
       process.exit(exitCode);
     } catch (error) {
       process.stderr.write(`Hasgard orphan cleanup: ${error.message}
 `);
-      if (groupStopped && ++endpointFailures >= 3) process.exit(1);
-      await delay(1e3);
+      if (groupStopped && ++endpointFailures >= 3)
+        process.exit(1);
+      await delay2(1000);
     }
   }
 }

package/dist/window.d.ts

@@ -1,4 +1,4 @@
-import { HasgardRpcClient } from "./rpc-client.js";
+import type { HasgardRpcClient } from "./rpc-client.js";
 import type { BoundingBox, ClickOptions, ConsoleLogEntry, ConsoleLogOptions, DialogListing, DialogPolicy, DiffOptions, DragOffset, DropFile, FileInput, FilterOptions, FormsDump, FulfillOptions, HasgardTarget, JsonValue, NativeScreenshot, NativeScreenshotOptions, NetworkRequestEntry, NetworkRequestOptions, PressOptions, QueryDimension, RecorderEntry, RecorderResult, RecorderStatus, RoleQuery, RouteListing, RouteOptions, ScrollOptions, Snapshot, SnapshotDiff, SnapshotOptions, StorageListing, StorageOptions, TextQuery, WaitForFunctionOptions, WaitOptions, WatchChanges, WatchOptions, WindowInfo, WindowState } from "./types.js";
 export declare const byRef: (ref: string) => HasgardTarget;
 export declare const bySelector: (selector: string) => HasgardTarget;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyssance/tauri-hasgard",
-  "version": "0.6.0-alpha.1",
+  "version": "0.6.0-alpha.4",
   "description": "Playwright Test fixtures for native Tauri Hasgard automation",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,24 +18,23 @@
     "NOTICE.md"
   ],
   "scripts": {
-    "build": "bun node_modules/tsup/dist/cli-default.js src/index.ts src/process-supervisor.js --format esm --outDir dist --clean && bun node_modules/typescript/bin/tsc -p tsconfig.json --noEmit false --emitDeclarationOnly --declaration true",
+    "build": "bun run clean && bun build src/index.ts src/process-supervisor.js --target node --format esm --outdir dist --packages external && bun node_modules/typescript/bin/tsc -p tsconfig.json --noEmit false --emitDeclarationOnly --declaration true",
     "dev": "bun run --parallel dev:js dev:types",
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "bun check --no-script",
     "clean": "rm -rf dist",
-    "dev:js": "tsup src/index.ts src/process-supervisor.js --format esm --outDir dist --watch",
+    "dev:js": "bun build src/index.ts src/process-supervisor.js --target node --format esm --outdir dist --packages external --watch",
     "dev:types": "tsc -p tsconfig.json --noEmit false --emitDeclarationOnly --declaration true --watch"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.61.1 <2"
   },
   "devDependencies": {
-    "@playwright/test": "1.62.1",
-    "@types/node": "^26.1.0",
-    "tsup": "^8.5.1",
+    "@playwright/test": "1.64.1",
+    "@types/node": "^26.6.5",
     "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.5"
   },
   "keywords": [
     "tauri",

package/dist/chunk-N7YDYAKI.js

@@ -1,31 +0,0 @@
-// src/process-group.js
-import { setTimeout as delay } from "timers/promises";
-function signalGroup(pid, signal) {
-  try {
-    process.kill(-pid, signal);
-    return true;
-  } catch (error) {
-    if (error.code === "ESRCH") return false;
-    if (signal === 0 && error.code === "EPERM") return true;
-    throw error;
-  }
-}
-async function waitForExit(pid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (signalGroup(pid, 0)) {
-    if (Date.now() >= deadline) return false;
-    await delay(25);
-  }
-  return true;
-}
-async function stopProcessGroup(pid) {
-  signalGroup(pid, "SIGTERM");
-  if (!await waitForExit(pid, 5e3)) {
-    signalGroup(pid, "SIGKILL");
-    if (!await waitForExit(pid, 5e3)) throw new Error(`Hasgard process group ${pid} survived SIGKILL`);
-  }
-}
-
-export {
-  stopProcessGroup
-};