tauri-test-cli 0.7.2 → 0.9.0

package/dist/cli.js

@@ -120717,6 +120717,7 @@ async function disconnect() {
 
 // src/commands/screenshot.ts
 import { writeFile } from "fs/promises";
+import { execFileSync } from "child_process";
 
 // src/driver.ts
 import { spawn as spawn2, execSync as execSync2 } from "child_process";
@@ -120930,24 +120931,34 @@ async function screenshot(options = {}) {
   const { width, height } = await browser3.getWindowSize();
   let data2;
   let method;
-  try {
-    data2 = await withTimeout(captureWithHtml2Canvas(browser3), timeout, "html2canvas timed out");
-    method = "html2canvas";
-  } catch (err) {
-    console.error(`html2canvas failed: ${err}, trying canvas fallback...`);
+  const xvfbDisplay2 = getXvfbDisplay();
+  if (xvfbDisplay2 !== null) {
     try {
-      data2 = await withTimeout(captureWithCanvas(browser3), timeout, "Canvas screenshot timed out");
-      method = "canvas";
-    } catch (canvasErr) {
-      if (getXvfbDisplay() !== null) {
-        throw new Error(`All screenshot methods failed in Xvfb: html2canvas: ${err}, canvas: ${canvasErr}`);
-      }
-      console.error(`Canvas failed: ${canvasErr}, trying native...`);
+      data2 = captureWithX11(xvfbDisplay2);
+      method = "x11";
+    } catch (err) {
+      console.error(`X11 capture failed: ${err}, falling back to JS-based methods...`);
+    }
+  }
+  if (!data2 && xvfbDisplay2 === null) {
+    try {
+      data2 = await withTimeout(browser3.takeScreenshot(), timeout, `Native screenshot timed out after ${timeout}ms`);
+      method = "native";
+    } catch (err) {
+      console.error(`Native screenshot failed: ${err}, trying html2canvas...`);
+    }
+  }
+  if (!data2) {
+    try {
+      data2 = await withTimeout(captureWithHtml2Canvas(browser3), timeout, "html2canvas timed out");
+      method = "html2canvas";
+    } catch (err) {
+      console.error(`html2canvas failed: ${err}, trying canvas fallback...`);
       try {
-        data2 = await withTimeout(browser3.takeScreenshot(), timeout, `Native screenshot timed out after ${timeout}ms`);
-        method = "native";
-      } catch (nativeErr) {
-        throw new Error(`All screenshot methods failed: html2canvas: ${err}, canvas: ${canvasErr}, native: ${nativeErr}`);
+        data2 = await withTimeout(captureWithCanvas(browser3), timeout, "Canvas screenshot timed out");
+        method = "canvas";
+      } catch (canvasErr) {
+        throw new Error(`All screenshot methods failed: ${xvfbDisplay2 !== null ? "x11 failed, " : ""}html2canvas: ${err}, canvas: ${canvasErr}`);
       }
     }
   }
@@ -120993,105 +121004,106 @@ async function captureWithHtml2Canvas(browser3) {
     throw new Error("Failed to load html2canvas from CDN");
   }
   await new Promise((r) => setTimeout(r, 50));
-  await browser3.execute(() => {
-    window.__h2cResult = undefined;
-    const h2c = window.html2canvas;
-    if (!h2c) {
-      window.__h2cResult = "";
-      return;
-    }
-    h2c(document.body, {
-      useCORS: true,
-      allowTaint: true,
-      logging: false,
-      backgroundColor: "#ffffff"
-    }).then((canvas) => {
-      const dataUrl = canvas.toDataURL("image/png");
-      window.__h2cResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-    }).catch(() => {
-      window.__h2cResult = "";
-    });
-    setTimeout(() => {
-      if (window.__h2cResult === undefined) {
-        window.__h2cResult = "";
+  const base64 = await browser3.execute(() => {
+    return new Promise((resolve) => {
+      const h2c = window.html2canvas;
+      if (!h2c) {
+        resolve("");
+        return;
       }
-    }, 4000);
+      h2c(document.body, {
+        useCORS: true,
+        allowTaint: false,
+        logging: false,
+        backgroundColor: "#ffffff"
+      }).then((canvas) => {
+        try {
+          const dataUrl = canvas.toDataURL("image/png");
+          resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+        } catch {
+          resolve("");
+        }
+      }).catch(() => resolve(""));
+      setTimeout(() => resolve(""), 4000);
+    });
   });
-  const base64 = await pollForResult(browser3, "__h2cResult");
   if (!base64) {
     throw new Error("html2canvas capture returned empty");
   }
   return base64;
 }
 async function captureWithCanvas(browser3) {
-  await browser3.execute(() => {
-    window.__canvasResult = undefined;
-    try {
-      const w2 = window.innerWidth || 800;
-      const h = window.innerHeight || 600;
-      const canvas = document.createElement("canvas");
-      canvas.width = w2;
-      canvas.height = h;
-      const ctx = canvas.getContext("2d");
-      ctx.fillStyle = "#ffffff";
-      ctx.fillRect(0, 0, w2, h);
-      const serializer = new XMLSerializer;
-      const cloned = document.documentElement.cloneNode(true);
-      const html3 = serializer.serializeToString(cloned);
-      const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w2}" height="${h}">
-        <foreignObject width="100%" height="100%">
-          ${html3}
-        </foreignObject>
-      </svg>`;
-      const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
-      const url2 = URL.createObjectURL(blob);
-      const img = new Image;
-      img.onload = () => {
-        ctx.drawImage(img, 0, 0);
-        URL.revokeObjectURL(url2);
-        const dataUrl = canvas.toDataURL("image/png");
-        window.__canvasResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-      };
-      img.onerror = () => {
-        URL.revokeObjectURL(url2);
-        ctx.fillStyle = "#000000";
-        ctx.font = "16px monospace";
-        const text3 = document.body.innerText || "";
-        const lines = text3.split(`
+  const base64 = await browser3.execute(() => {
+    return new Promise((resolve) => {
+      try {
+        const w2 = window.innerWidth || 800;
+        const h = window.innerHeight || 600;
+        const canvas = document.createElement("canvas");
+        canvas.width = w2;
+        canvas.height = h;
+        const ctx = canvas.getContext("2d");
+        ctx.fillStyle = "#ffffff";
+        ctx.fillRect(0, 0, w2, h);
+        const serializer = new XMLSerializer;
+        const cloned = document.documentElement.cloneNode(true);
+        const html3 = serializer.serializeToString(cloned);
+        const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w2}" height="${h}">
+          <foreignObject width="100%" height="100%">
+            ${html3}
+          </foreignObject>
+        </svg>`;
+        const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
+        const url2 = URL.createObjectURL(blob);
+        const img = new Image;
+        const renderText2 = () => {
+          ctx.fillStyle = "#000000";
+          ctx.font = "16px monospace";
+          const text3 = document.body.innerText || "";
+          const lines = text3.split(`
 `);
-        for (let i = 0;i < lines.length && i < 40; i++) {
-          ctx.fillText(lines[i], 10, 20 + i * 20);
-        }
-        const dataUrl = canvas.toDataURL("image/png");
-        window.__canvasResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-      };
-      img.src = url2;
-      setTimeout(() => {
-        if (window.__canvasResult === undefined) {
+          for (let i = 0;i < lines.length && i < 40; i++) {
+            ctx.fillText(lines[i], 10, 20 + i * 20);
+          }
           const dataUrl = canvas.toDataURL("image/png");
-          window.__canvasResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-        }
-      }, 4000);
-    } catch (e) {
-      window.__canvasResult = "";
-    }
+          resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+        };
+        img.onload = () => {
+          try {
+            ctx.drawImage(img, 0, 0);
+            URL.revokeObjectURL(url2);
+            const dataUrl = canvas.toDataURL("image/png");
+            resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+          } catch {
+            URL.revokeObjectURL(url2);
+            renderText2();
+          }
+        };
+        img.onerror = () => {
+          URL.revokeObjectURL(url2);
+          renderText2();
+        };
+        img.src = url2;
+        setTimeout(() => {
+          try {
+            const dataUrl = canvas.toDataURL("image/png");
+            resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+          } catch {
+            renderText2();
+          }
+        }, 4000);
+      } catch (e) {
+        resolve("");
+      }
+    });
   });
-  const base64 = await pollForResult(browser3, "__canvasResult");
   if (!base64) {
     throw new Error("Canvas screenshot capture returned empty");
   }
   return base64;
 }
-async function pollForResult(browser3, key, intervalMs = 100, maxMs = 5000) {
-  const start = Date.now();
-  while (Date.now() - start < maxMs) {
-    const val3 = await browser3.execute((k) => window[k], key);
-    if (val3 !== undefined)
-      return val3;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-  const val2 = await browser3.execute((k) => window[k], key);
-  return val2 ?? "";
+function captureWithX11(display) {
+  const result = execFileSync("import", ["-display", `:${display}`, "-window", "root", "png:-"], { maxBuffer: 50 * 1024 * 1024, timeout: 1e4 });
+  return result.toString("base64");
 }
 
 // src/commands/snapshot.ts
@@ -121370,6 +121382,7 @@ import { readFileSync } from "fs";
 
 // src/commands/screenshot.ts
 import { writeFile as writeFile3 } from "fs/promises";
+import { execFileSync as execFileSync2 } from "child_process";
 var HTML2CANVAS_CDN2 = "https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html2canvas.min.js";
 async function screenshot2(options = {}) {
   const browser3 = requireBrowser();
@@ -121381,24 +121394,34 @@ async function screenshot2(options = {}) {
   const { width, height } = await browser3.getWindowSize();
   let data2;
   let method;
-  try {
-    data2 = await withTimeout2(captureWithHtml2Canvas2(browser3), timeout, "html2canvas timed out");
-    method = "html2canvas";
-  } catch (err) {
-    console.error(`html2canvas failed: ${err}, trying canvas fallback...`);
+  const xvfbDisplay2 = getXvfbDisplay();
+  if (xvfbDisplay2 !== null) {
     try {
-      data2 = await withTimeout2(captureWithCanvas2(browser3), timeout, "Canvas screenshot timed out");
-      method = "canvas";
-    } catch (canvasErr) {
-      if (getXvfbDisplay() !== null) {
-        throw new Error(`All screenshot methods failed in Xvfb: html2canvas: ${err}, canvas: ${canvasErr}`);
-      }
-      console.error(`Canvas failed: ${canvasErr}, trying native...`);
+      data2 = captureWithX112(xvfbDisplay2);
+      method = "x11";
+    } catch (err) {
+      console.error(`X11 capture failed: ${err}, falling back to JS-based methods...`);
+    }
+  }
+  if (!data2 && xvfbDisplay2 === null) {
+    try {
+      data2 = await withTimeout2(browser3.takeScreenshot(), timeout, `Native screenshot timed out after ${timeout}ms`);
+      method = "native";
+    } catch (err) {
+      console.error(`Native screenshot failed: ${err}, trying html2canvas...`);
+    }
+  }
+  if (!data2) {
+    try {
+      data2 = await withTimeout2(captureWithHtml2Canvas2(browser3), timeout, "html2canvas timed out");
+      method = "html2canvas";
+    } catch (err) {
+      console.error(`html2canvas failed: ${err}, trying canvas fallback...`);
       try {
-        data2 = await withTimeout2(browser3.takeScreenshot(), timeout, `Native screenshot timed out after ${timeout}ms`);
-        method = "native";
-      } catch (nativeErr) {
-        throw new Error(`All screenshot methods failed: html2canvas: ${err}, canvas: ${canvasErr}, native: ${nativeErr}`);
+        data2 = await withTimeout2(captureWithCanvas2(browser3), timeout, "Canvas screenshot timed out");
+        method = "canvas";
+      } catch (canvasErr) {
+        throw new Error(`All screenshot methods failed: ${xvfbDisplay2 !== null ? "x11 failed, " : ""}html2canvas: ${err}, canvas: ${canvasErr}`);
       }
     }
   }
@@ -121444,105 +121467,106 @@ async function captureWithHtml2Canvas2(browser3) {
     throw new Error("Failed to load html2canvas from CDN");
   }
   await new Promise((r) => setTimeout(r, 50));
-  await browser3.execute(() => {
-    window.__h2cResult = undefined;
-    const h2c = window.html2canvas;
-    if (!h2c) {
-      window.__h2cResult = "";
-      return;
-    }
-    h2c(document.body, {
-      useCORS: true,
-      allowTaint: true,
-      logging: false,
-      backgroundColor: "#ffffff"
-    }).then((canvas) => {
-      const dataUrl = canvas.toDataURL("image/png");
-      window.__h2cResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-    }).catch(() => {
-      window.__h2cResult = "";
-    });
-    setTimeout(() => {
-      if (window.__h2cResult === undefined) {
-        window.__h2cResult = "";
+  const base64 = await browser3.execute(() => {
+    return new Promise((resolve) => {
+      const h2c = window.html2canvas;
+      if (!h2c) {
+        resolve("");
+        return;
       }
-    }, 4000);
+      h2c(document.body, {
+        useCORS: true,
+        allowTaint: false,
+        logging: false,
+        backgroundColor: "#ffffff"
+      }).then((canvas) => {
+        try {
+          const dataUrl = canvas.toDataURL("image/png");
+          resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+        } catch {
+          resolve("");
+        }
+      }).catch(() => resolve(""));
+      setTimeout(() => resolve(""), 4000);
+    });
   });
-  const base64 = await pollForResult2(browser3, "__h2cResult");
   if (!base64) {
     throw new Error("html2canvas capture returned empty");
   }
   return base64;
 }
 async function captureWithCanvas2(browser3) {
-  await browser3.execute(() => {
-    window.__canvasResult = undefined;
-    try {
-      const w2 = window.innerWidth || 800;
-      const h = window.innerHeight || 600;
-      const canvas = document.createElement("canvas");
-      canvas.width = w2;
-      canvas.height = h;
-      const ctx = canvas.getContext("2d");
-      ctx.fillStyle = "#ffffff";
-      ctx.fillRect(0, 0, w2, h);
-      const serializer = new XMLSerializer;
-      const cloned = document.documentElement.cloneNode(true);
-      const html3 = serializer.serializeToString(cloned);
-      const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w2}" height="${h}">
-        <foreignObject width="100%" height="100%">
-          ${html3}
-        </foreignObject>
-      </svg>`;
-      const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
-      const url2 = URL.createObjectURL(blob);
-      const img = new Image;
-      img.onload = () => {
-        ctx.drawImage(img, 0, 0);
-        URL.revokeObjectURL(url2);
-        const dataUrl = canvas.toDataURL("image/png");
-        window.__canvasResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-      };
-      img.onerror = () => {
-        URL.revokeObjectURL(url2);
-        ctx.fillStyle = "#000000";
-        ctx.font = "16px monospace";
-        const text3 = document.body.innerText || "";
-        const lines = text3.split(`
+  const base64 = await browser3.execute(() => {
+    return new Promise((resolve) => {
+      try {
+        const w2 = window.innerWidth || 800;
+        const h = window.innerHeight || 600;
+        const canvas = document.createElement("canvas");
+        canvas.width = w2;
+        canvas.height = h;
+        const ctx = canvas.getContext("2d");
+        ctx.fillStyle = "#ffffff";
+        ctx.fillRect(0, 0, w2, h);
+        const serializer = new XMLSerializer;
+        const cloned = document.documentElement.cloneNode(true);
+        const html3 = serializer.serializeToString(cloned);
+        const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${w2}" height="${h}">
+          <foreignObject width="100%" height="100%">
+            ${html3}
+          </foreignObject>
+        </svg>`;
+        const blob = new Blob([svg], { type: "image/svg+xml;charset=utf-8" });
+        const url2 = URL.createObjectURL(blob);
+        const img = new Image;
+        const renderText2 = () => {
+          ctx.fillStyle = "#000000";
+          ctx.font = "16px monospace";
+          const text3 = document.body.innerText || "";
+          const lines = text3.split(`
 `);
-        for (let i = 0;i < lines.length && i < 40; i++) {
-          ctx.fillText(lines[i], 10, 20 + i * 20);
-        }
-        const dataUrl = canvas.toDataURL("image/png");
-        window.__canvasResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-      };
-      img.src = url2;
-      setTimeout(() => {
-        if (window.__canvasResult === undefined) {
+          for (let i = 0;i < lines.length && i < 40; i++) {
+            ctx.fillText(lines[i], 10, 20 + i * 20);
+          }
           const dataUrl = canvas.toDataURL("image/png");
-          window.__canvasResult = dataUrl.replace(/^data:image\/png;base64,/, "");
-        }
-      }, 4000);
-    } catch (e) {
-      window.__canvasResult = "";
-    }
+          resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+        };
+        img.onload = () => {
+          try {
+            ctx.drawImage(img, 0, 0);
+            URL.revokeObjectURL(url2);
+            const dataUrl = canvas.toDataURL("image/png");
+            resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+          } catch {
+            URL.revokeObjectURL(url2);
+            renderText2();
+          }
+        };
+        img.onerror = () => {
+          URL.revokeObjectURL(url2);
+          renderText2();
+        };
+        img.src = url2;
+        setTimeout(() => {
+          try {
+            const dataUrl = canvas.toDataURL("image/png");
+            resolve(dataUrl.replace(/^data:image\/png;base64,/, ""));
+          } catch {
+            renderText2();
+          }
+        }, 4000);
+      } catch (e) {
+        resolve("");
+      }
+    });
   });
-  const base64 = await pollForResult2(browser3, "__canvasResult");
   if (!base64) {
     throw new Error("Canvas screenshot capture returned empty");
   }
   return base64;
 }
-async function pollForResult2(browser3, key, intervalMs = 100, maxMs = 5000) {
-  const start = Date.now();
-  while (Date.now() - start < maxMs) {
-    const val3 = await browser3.execute((k) => window[k], key);
-    if (val3 !== undefined)
-      return val3;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-  const val2 = await browser3.execute((k) => window[k], key);
-  return val2 ?? "";
+function captureWithX112(display) {
+  const result = execFileSync2("import", ["-display", `:${display}`, "-window", "root", "png:-"], { maxBuffer: 50 * 1024 * 1024, timeout: 1e4 });
+  return result.toString("base64");
 }
 
 // src/commands/snapshot.ts
@@ -122008,35 +122032,24 @@ 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;
-      }
+  const getDirectParentPid = () => {
+    try {
+      const stat = readFileSync(`/proc/${process.pid}/stat`, "utf8");
+      return parseInt(stat.split(") ")[1].split(" ")[1]);
+    } catch {
+      return process.ppid;
     }
-    return pids;
   };
-  const ancestorPids = getAncestorPids();
-  if (ancestorPids.length > 0) {
+  const parentPid = getDirectParentPid();
+  if (parentPid > 1) {
     setInterval(() => {
-      for (const pid of ancestorPids) {
-        try {
-          process.kill(pid, 0);
-        } catch {
-          shutdown();
-          return;
-        }
+      try {
+        process.kill(parentPid, 0);
+      } catch {
+        shutdown();
+        return;
       }
-    }, 500);
+    }, 2000);
   }
   console.error(`Launching app and waiting for load (timeout: ${waitTimeout}ms)...`);
   await connect2({ appPath, waitTimeout });

package/package.json

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