tauri-test-cli 0.7.1 → 0.8.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";
@@ -120910,6 +120911,11 @@ async function waitForInteractive(selector, timeout = 5000) {
 // src/commands/utils.ts
 var xvfbDisplay = null;
 function getXvfbDisplay() {
+  const envVal = process.env.TAURI_TEST_XVFB_DISPLAY;
+  if (envVal !== undefined) {
+    const n = Number(envVal);
+    return Number.isFinite(n) ? n : null;
+  }
   return xvfbDisplay;
 }
 
@@ -120925,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}`);
       }
     }
   }
@@ -120988,22 +121004,28 @@ async function captureWithHtml2Canvas(browser3) {
     throw new Error("Failed to load html2canvas from CDN");
   }
   await new Promise((r) => setTimeout(r, 50));
-  const base64 = await browser3.executeAsync((done) => {
-    const h2c = window.html2canvas;
-    if (!h2c) {
-      done("");
-      return;
-    }
-    h2c(document.body, {
-      useCORS: true,
-      allowTaint: true,
-      logging: false,
-      backgroundColor: "#ffffff"
-    }).then((canvas) => {
-      const dataUrl = canvas.toDataURL("image/png");
-      done(dataUrl.replace(/^data:image\/png;base64,/, ""));
-    }).catch(() => done(""));
-    setTimeout(() => done(""), 4000);
+  const base64 = await browser3.execute(() => {
+    return new Promise((resolve) => {
+      const h2c = window.html2canvas;
+      if (!h2c) {
+        resolve("");
+        return;
+      }
+      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);
+    });
   });
   if (!base64) {
     throw new Error("html2canvas capture returned empty");
@@ -121011,60 +121033,78 @@ async function captureWithHtml2Canvas(browser3) {
   return base64;
 }
 async function captureWithCanvas(browser3) {
-  const base64 = await browser3.executeAsync((done) => {
-    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");
-        done(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");
-        done(dataUrl.replace(/^data:image\/png;base64,/, ""));
-      };
-      img.src = url2;
-      setTimeout(() => {
-        const dataUrl = canvas.toDataURL("image/png");
-        done(dataUrl.replace(/^data:image\/png;base64,/, ""));
-      }, 4000);
-    } catch (e) {
-      done("");
-    }
+          for (let i = 0;i < lines.length && i < 40; i++) {
+            ctx.fillText(lines[i], 10, 20 + i * 20);
+          }
+          const dataUrl = canvas.toDataURL("image/png");
+          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("");
+      }
+    });
   });
   if (!base64) {
     throw new Error("Canvas screenshot capture returned empty");
   }
   return base64;
 }
+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
 import { writeFile as writeFile2 } from "fs/promises";
@@ -121342,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();
@@ -121353,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}`);
       }
     }
   }
@@ -121416,22 +121467,28 @@ async function captureWithHtml2Canvas2(browser3) {
     throw new Error("Failed to load html2canvas from CDN");
   }
   await new Promise((r) => setTimeout(r, 50));
-  const base64 = await browser3.executeAsync((done) => {
-    const h2c = window.html2canvas;
-    if (!h2c) {
-      done("");
-      return;
-    }
-    h2c(document.body, {
-      useCORS: true,
-      allowTaint: true,
-      logging: false,
-      backgroundColor: "#ffffff"
-    }).then((canvas) => {
-      const dataUrl = canvas.toDataURL("image/png");
-      done(dataUrl.replace(/^data:image\/png;base64,/, ""));
-    }).catch(() => done(""));
-    setTimeout(() => done(""), 4000);
+  const base64 = await browser3.execute(() => {
+    return new Promise((resolve) => {
+      const h2c = window.html2canvas;
+      if (!h2c) {
+        resolve("");
+        return;
+      }
+      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);
+    });
   });
   if (!base64) {
     throw new Error("html2canvas capture returned empty");
@@ -121439,60 +121496,78 @@ async function captureWithHtml2Canvas2(browser3) {
   return base64;
 }
 async function captureWithCanvas2(browser3) {
-  const base64 = await browser3.executeAsync((done) => {
-    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");
-        done(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");
-        done(dataUrl.replace(/^data:image\/png;base64,/, ""));
-      };
-      img.src = url2;
-      setTimeout(() => {
-        const dataUrl = canvas.toDataURL("image/png");
-        done(dataUrl.replace(/^data:image\/png;base64,/, ""));
-      }, 4000);
-    } catch (e) {
-      done("");
-    }
+          for (let i = 0;i < lines.length && i < 40; i++) {
+            ctx.fillText(lines[i], 10, 20 + i * 20);
+          }
+          const dataUrl = canvas.toDataURL("image/png");
+          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("");
+      }
+    });
   });
   if (!base64) {
     throw new Error("Canvas screenshot capture returned empty");
   }
   return base64;
 }
+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
 import { writeFile as writeFile4 } from "fs/promises";
@@ -122294,6 +122369,7 @@ async function startXvfb() {
   }
   console.error(`Xvfb ready on display ${displayStr}`);
   xvfbDisplay2 = display;
+  process.env.TAURI_TEST_XVFB_DISPLAY = String(display);
   process.env.DISPLAY = displayStr;
   delete process.env.WAYLAND_DISPLAY;
   process.env.GDK_BACKEND = "x11";
@@ -122305,6 +122381,7 @@ function stopXvfb() {
     xvfbProcess.kill("SIGTERM");
     xvfbProcess = null;
     xvfbDisplay2 = null;
+    delete process.env.TAURI_TEST_XVFB_DISPLAY;
   }
 }
 

package/package.json

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