tauri-test-cli 0.5.2 → 0.6.1

package/dist/cli.js

@@ -102311,8 +102311,11 @@ var init_esm11 = __esm(() => {
   };
 });
 
+// src/cli.ts
+import { resolve } from "path";
+
 // src/driver.ts
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 
 // node_modules/webdriverio/build/node.js
 var import_jszip = __toESM(require_lib3(), 1);
@@ -120571,17 +120574,78 @@ import { homedir } from "os";
 import { join } from "path";
 var driverProcess = null;
 var browser = null;
+var exitHandlerRegistered = false;
 var DRIVER_PORT = 4444;
 var DRIVER_HOST = "127.0.0.1";
+function getDescendantPids(pid) {
+  try {
+    const children2 = execSync(`pgrep -P ${pid} 2>/dev/null`, { encoding: "utf8" }).trim().split(`
+`).filter(Boolean).map(Number);
+    const descendants = [];
+    for (const child of children2) {
+      descendants.push(child, ...getDescendantPids(child));
+    }
+    return descendants;
+  } catch {
+    return [];
+  }
+}
+function killProcessTree(pid, signal = "SIGKILL") {
+  const descendants = getDescendantPids(pid);
+  for (const child of descendants.reverse()) {
+    try {
+      process.kill(child, signal);
+    } catch {}
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {}
+}
+function forceKillDriver() {
+  if (driverProcess?.pid) {
+    killProcessTree(driverProcess.pid);
+    driverProcess = null;
+  }
+}
+function killStaleDriver() {
+  let killed = false;
+  for (const port of [DRIVER_PORT, DRIVER_PORT + 1]) {
+    try {
+      const pids = execSync(`lsof -ti:${port} 2>/dev/null`, { encoding: "utf8" }).trim();
+      if (pids) {
+        for (const pidStr of pids.split(`
+`)) {
+          const pid = parseInt(pidStr);
+          if (pid) {
+            killProcessTree(pid);
+            killed = true;
+          }
+        }
+      }
+    } catch {}
+  }
+  if (killed) {
+    execSync("sleep 0.5");
+  }
+}
 async function startDriver() {
   if (driverProcess) {
     return;
   }
+  killStaleDriver();
   const tauriDriverPath = join(homedir(), ".cargo", "bin", "tauri-driver");
   return new Promise((resolve, reject) => {
-    driverProcess = spawn(tauriDriverPath, [], {
-      stdio: ["ignore", "pipe", "pipe"]
+    driverProcess = spawn("setsid", [
+      "sh",
+      "-c",
+      `"${tauriDriverPath}" & PID=$!; trap "kill 0 2>/dev/null" EXIT; read; exit`
+    ], {
+      stdio: ["pipe", "pipe", "pipe"]
     });
+    if (!exitHandlerRegistered) {
+      exitHandlerRegistered = true;
+      process.on("exit", forceKillDriver);
+    }
     driverProcess.on("error", (err) => {
       reject(new Error(`Failed to start tauri-driver: ${err.message}`));
     });
@@ -120602,8 +120666,8 @@ async function startDriver() {
   });
 }
 function stopDriver() {
-  if (driverProcess) {
-    driverProcess.kill();
+  if (driverProcess?.pid) {
+    killProcessTree(driverProcess.pid);
     driverProcess = null;
   }
 }
@@ -120653,22 +120717,83 @@ async function disconnect() {
 import { writeFile } from "fs/promises";
 
 // src/driver.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn2, execSync as execSync2 } from "child_process";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 var driverProcess2 = null;
 var browser2 = null;
+var exitHandlerRegistered2 = false;
 var DRIVER_PORT2 = 4444;
 var DRIVER_HOST2 = "127.0.0.1";
+function getDescendantPids2(pid) {
+  try {
+    const children2 = execSync2(`pgrep -P ${pid} 2>/dev/null`, { encoding: "utf8" }).trim().split(`
+`).filter(Boolean).map(Number);
+    const descendants = [];
+    for (const child of children2) {
+      descendants.push(child, ...getDescendantPids2(child));
+    }
+    return descendants;
+  } catch {
+    return [];
+  }
+}
+function killProcessTree2(pid, signal = "SIGKILL") {
+  const descendants = getDescendantPids2(pid);
+  for (const child of descendants.reverse()) {
+    try {
+      process.kill(child, signal);
+    } catch {}
+  }
+  try {
+    process.kill(pid, signal);
+  } catch {}
+}
+function forceKillDriver2() {
+  if (driverProcess2?.pid) {
+    killProcessTree2(driverProcess2.pid);
+    driverProcess2 = null;
+  }
+}
+function killStaleDriver2() {
+  let killed = false;
+  for (const port of [DRIVER_PORT2, DRIVER_PORT2 + 1]) {
+    try {
+      const pids = execSync2(`lsof -ti:${port} 2>/dev/null`, { encoding: "utf8" }).trim();
+      if (pids) {
+        for (const pidStr of pids.split(`
+`)) {
+          const pid = parseInt(pidStr);
+          if (pid) {
+            killProcessTree2(pid);
+            killed = true;
+          }
+        }
+      }
+    } catch {}
+  }
+  if (killed) {
+    execSync2("sleep 0.5");
+  }
+}
 async function startDriver2() {
   if (driverProcess2) {
     return;
   }
+  killStaleDriver2();
   const tauriDriverPath = join2(homedir2(), ".cargo", "bin", "tauri-driver");
   return new Promise((resolve, reject) => {
-    driverProcess2 = spawn2(tauriDriverPath, [], {
-      stdio: ["ignore", "pipe", "pipe"]
+    driverProcess2 = spawn2("setsid", [
+      "sh",
+      "-c",
+      `"${tauriDriverPath}" & PID=$!; trap "kill 0 2>/dev/null" EXIT; read; exit`
+    ], {
+      stdio: ["pipe", "pipe", "pipe"]
     });
+    if (!exitHandlerRegistered2) {
+      exitHandlerRegistered2 = true;
+      process.on("exit", forceKillDriver2);
+    }
     driverProcess2.on("error", (err) => {
       reject(new Error(`Failed to start tauri-driver: ${err.message}`));
     });
@@ -120688,12 +120813,6 @@ async function startDriver2() {
     setTimeout(() => resolve(), 1000);
   });
 }
-function stopDriver2() {
-  if (driverProcess2) {
-    driverProcess2.kill();
-    driverProcess2 = null;
-  }
-}
 async function waitForPageLoad2(browser3, timeout = 1e4) {
   const start = Date.now();
   while (Date.now() - start < timeout) {
@@ -120731,13 +120850,6 @@ async function connect2(options) {
 function getBrowser() {
   return browser2;
 }
-async function disconnect2() {
-  if (browser2) {
-    await browser2.deleteSession();
-    browser2 = null;
-  }
-  stopDriver2();
-}
 function requireBrowser() {
   if (!browser2) {
     throw new Error("Not connected. Run 'tauri-test-cli connect' first.");
@@ -121158,6 +121270,7 @@ async function evaluate(script) {
 
 // src/server.ts
 import { createServer } from "http";
+import { readFileSync } from "fs";
 
 // src/commands/screenshot.ts
 import { writeFile as writeFile3 } from "fs/promises";
@@ -121675,12 +121788,10 @@ async function shutdown() {
     return;
   isShuttingDown = true;
   console.error("Shutting down...");
+  forceKillDriver2();
   if (serverInstance) {
     serverInstance.close();
   }
-  try {
-    await disconnect2();
-  } catch {}
   process.exit(0);
 }
 async function injectKeepAlive() {
@@ -121714,6 +121825,36 @@ async function startServer(options) {
   const { port, appPath, waitTimeout, autoWait } = options;
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
+  const getAncestorPids = () => {
+    const pids = [];
+    let pid = process.pid;
+    while (pid > 1) {
+      try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        const ppid = parseInt(stat.split(") ")[1].split(" ")[1]);
+        if (ppid <= 1)
+          break;
+        pids.push(ppid);
+        pid = ppid;
+      } catch {
+        break;
+      }
+    }
+    return pids;
+  };
+  const ancestorPids = getAncestorPids();
+  if (ancestorPids.length > 0) {
+    setInterval(() => {
+      for (const pid of ancestorPids) {
+        try {
+          process.kill(pid, 0);
+        } catch {
+          shutdown();
+          return;
+        }
+      }
+    }, 500);
+  }
   console.error(`Launching app and waiting for load (timeout: ${waitTimeout}ms)...`);
   await connect2({ appPath, waitTimeout });
   console.error("App loaded successfully.");
@@ -121740,7 +121881,7 @@ async function startServer(options) {
 }
 
 // src/checks.ts
-import { execSync } from "child_process";
+import { execSync as execSync3 } from "child_process";
 import os4 from "os";
 var reset = "\x1B[0m";
 var bold = "\x1B[1m";
@@ -121751,7 +121892,7 @@ var dim = "\x1B[2m";
 function commandExists(cmd) {
   try {
     const checkCmd = os4.platform() === "win32" ? `where ${cmd} 2>nul` : `which ${cmd} 2>/dev/null`;
-    execSync(checkCmd, { stdio: "ignore" });
+    execSync3(checkCmd, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -121759,7 +121900,7 @@ function commandExists(cmd) {
 }
 function pkgConfigExists(pkg) {
   try {
-    execSync(`pkg-config --modversion ${pkg}`, { stdio: "ignore" });
+    execSync3(`pkg-config --modversion ${pkg}`, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -121848,7 +121989,7 @@ function printDependencyStatus() {
 }
 
 // src/commands/utils.ts
-import { execSync as execSync2, spawn as spawn3 } from "child_process";
+import { execSync as execSync4, spawn as spawn3 } from "child_process";
 import os5 from "os";
 var reset2 = "\x1B[0m";
 var bold2 = "\x1B[1m";
@@ -121862,7 +122003,7 @@ async function setup() {
   console.log();
   try {
     try {
-      execSync2("cargo --version", { stdio: "ignore" });
+      execSync4("cargo --version", { stdio: "ignore" });
     } catch {
       return {
         success: false,
@@ -121925,7 +122066,7 @@ async function cleanup() {
   if (platform === "win32") {
     for (const pattern of processPatterns) {
       try {
-        execSync2(`taskkill /F /IM ${pattern}.exe 2>nul`, { stdio: "ignore" });
+        execSync4(`taskkill /F /IM ${pattern}.exe 2>nul`, { stdio: "ignore" });
         killed.push(pattern);
         console.log(`  ${green2}✓${reset2} Killed ${pattern}`);
       } catch {
@@ -121935,7 +122076,7 @@ async function cleanup() {
   } else {
     for (const pattern of processPatterns) {
       try {
-        execSync2(`pkill -f "${pattern}"`, { stdio: "ignore" });
+        execSync4(`pkill -f "${pattern}"`, { stdio: "ignore" });
         killed.push(pattern);
         console.log(`  ${green2}✓${reset2} Killed ${pattern}`);
       } catch {
@@ -121956,7 +122097,7 @@ function checkXvfb() {
     return false;
   }
   try {
-    execSync2("which Xvfb", { stdio: "ignore" });
+    execSync4("which Xvfb", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -121967,7 +122108,7 @@ function findAvailableDisplay() {
     const lockFile = `/tmp/.X${display}-lock`;
     const socketFile = `/tmp/.X11-unix/X${display}`;
     try {
-      execSync2(`test -e ${lockFile} || test -e ${socketFile}`, { stdio: "ignore" });
+      execSync4(`test -e ${lockFile} || test -e ${socketFile}`, { stdio: "ignore" });
     } catch {
       return display;
     }
@@ -121980,7 +122121,7 @@ async function waitForDisplay(display, timeoutMs = 1e4) {
   const pollInterval = 100;
   while (Date.now() - startTime < timeoutMs) {
     try {
-      execSync2(`DISPLAY=${displayStr} xdpyinfo`, { stdio: "ignore", timeout: 1000 });
+      execSync4(`DISPLAY=${displayStr} xdpyinfo`, { stdio: "ignore", timeout: 1000 });
       return true;
     } catch {
       await new Promise((resolve) => setTimeout(resolve, pollInterval));
@@ -122270,7 +122411,7 @@ async function executeCommand2(cmd, globalAutoWait) {
       }
       return await evaluate(cmd.script);
     case "sleep":
-      await new Promise((resolve) => setTimeout(resolve, cmd.ms ?? 1000));
+      await new Promise((resolve2) => setTimeout(resolve2, cmd.ms ?? 1000));
       return { slept: cmd.ms ?? 1000 };
     default:
       throw new Error(`Unknown command: ${cmd.cmd}`);
@@ -122342,7 +122483,7 @@ async function main() {
       process.exit(1);
     }
   }
-  const appPath = options.app;
+  const appPath = options.app ? resolve(options.app) : undefined;
   const jsonOutput = !!options.json;
   const port = options.port ? parseInt(options.port) : 9222;
   const clientModeCommands = ["screenshot", "snapshot", "click", "type", "wait", "eval"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-test-cli",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "CLI for testing Tauri applications with screenshot capture, DOM inspection, and user interaction simulation",
   "type": "module",
   "bin": {

package/scripts/publish.sh

@@ -81,29 +81,34 @@ MINOR_VERSION="${major}.$((minor + 1)).0"
 MAJOR_VERSION="$((major + 1)).0.0"
 
 echo -e "${CYAN}Select version bump type:${NC}"
-echo "  1) patch  (${CURRENT_VERSION} -> ${PATCH_VERSION})"
-echo "  2) minor  (${CURRENT_VERSION} -> ${MINOR_VERSION})"
-echo "  3) major  (${CURRENT_VERSION} -> ${MAJOR_VERSION})"
-echo "  4) cancel"
+echo "  1) none   (keep ${CURRENT_VERSION})"
+echo "  2) patch  (${CURRENT_VERSION} -> ${PATCH_VERSION})"
+echo "  3) minor  (${CURRENT_VERSION} -> ${MINOR_VERSION})"
+echo "  4) major  (${CURRENT_VERSION} -> ${MAJOR_VERSION})"
+echo "  5) cancel"
 echo ""
 
-read -p "Enter choice [1-4]: " -n 1 -r CHOICE
+read -p "Enter choice [1-5]: " -n 1 -r CHOICE
 echo ""
 
 case $CHOICE in
     1)
+        BUMP_TYPE=""
+        NEW_VERSION="$CURRENT_VERSION"
+        ;;
+    2)
         BUMP_TYPE="patch"
         NEW_VERSION="$PATCH_VERSION"
         ;;
-    2)
+    3)
         BUMP_TYPE="minor"
         NEW_VERSION="$MINOR_VERSION"
         ;;
-    3)
+    4)
         BUMP_TYPE="major"
         NEW_VERSION="$MAJOR_VERSION"
         ;;
-    4|*)
+    5|*)
         echo -e "${YELLOW}Publish cancelled.${NC}"
         exit 0
         ;;
@@ -115,33 +120,39 @@ echo ""
 # STEP 3: Bump version
 # ============================================================================
 
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${GREEN}▶ Step 3: Bumping version to ${NEW_VERSION}...${NC}"
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo ""
+if [[ -n "$BUMP_TYPE" ]]; then
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${GREEN}▶ Step 3: Bumping version to ${NEW_VERSION}...${NC}"
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo ""
 
-./scripts/bump-version.sh "$BUMP_TYPE"
+    ./scripts/bump-version.sh "$BUMP_TYPE"
 
-# ============================================================================
-# STEP 4: Commit, tag, and push to GitHub
-# ============================================================================
+    # ============================================================================
+    # STEP 4: Commit, tag, and push to GitHub
+    # ============================================================================
 
-echo ""
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${GREEN}▶ Step 4: Pushing to GitHub...${NC}"
-echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo ""
+    echo ""
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${GREEN}▶ Step 4: Pushing to GitHub...${NC}"
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo ""
 
-echo -e "${BLUE}Committing changes...${NC}"
-git add pixi.toml package.json .claude-plugin/plugin.json
-git commit -m "Bump version to $NEW_VERSION"
+    echo -e "${BLUE}Committing changes...${NC}"
+    git add pixi.toml package.json .claude-plugin/plugin.json
+    git commit -m "Bump version to $NEW_VERSION"
 
-echo -e "${BLUE}Creating git tag v${NEW_VERSION}...${NC}"
-git tag "v${NEW_VERSION}"
+    echo -e "${BLUE}Creating git tag v${NEW_VERSION}...${NC}"
+    git tag "v${NEW_VERSION}"
 
-echo -e "${BLUE}Pushing to remote...${NC}"
-git push
-git push --tags
+    echo -e "${BLUE}Pushing to remote...${NC}"
+    git push
+    git push --tags
+else
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${GREEN}▶ Skipping version bump, keeping ${CURRENT_VERSION}${NC}"
+    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+fi
 
 echo -e "${GREEN}✓ Pushed to GitHub${NC}"