testdriverai 7.11.225-test → 7.11.227-test

package/docs/docs.json

@@ -179,7 +179,7 @@
   "redirects": [
     {
       "source": "/",
-      "destination": "/quickstart-github"
+      "destination": "/quickstart"
     },
     {
       "source": "/quickstart-ai-setup",

package/docs/provision.mdx

@@ -142,7 +142,7 @@ await testdriver.provision.installer(options)
     </ParamField>
     
     <ParamField path="launch" type="boolean" default={true}>
-      Whether to focus/launch the app after installation.
+      Whether to launch the app after installation. For a `.deb` on Linux, the app is started from its `.desktop` entry (or, when `appName` is set and there is no `.desktop` entry, from its `/usr/bin` binary) and then `appName` is focused. On Windows and macOS, `appName` is focused.
     </ParamField>
   </Expandable>
 </ParamField>
@@ -151,7 +151,9 @@ await testdriver.provision.installer(options)
 - Downloads the installer from the URL
 - Auto-detects the install method based on file extension
 - Runs the appropriate install command (e.g., `msiexec` for `.msi`, `dpkg` for `.deb`)
-- Optionally focuses the installed application
+- For `.deb` packages, installs any missing dependencies with `apt-get install -f` and fails if the package isn't fully installed
+- For `.deb` packages on Linux with `launch: true`, starts the app in the background
+- Focuses `appName` when it's set and `launch` is `true`
 
 ```javascript
 // Windows MSI installer
@@ -160,11 +162,10 @@ await testdriver.provision.installer({
   appName: 'MyApp',
 });
 
-// Linux DEB package
+// Linux DEB package: installs dependencies, starts the app, focuses it
 await testdriver.provision.installer({
   url: 'https://example.com/app.deb',
   appName: 'MyApp',
-  launch: true,
 });
 ```
 

package/examples/installer.test.mjs

@@ -28,6 +28,32 @@ describe("Provision Installer", () => {
     },
   );
 
+  it.skipIf(!isLinux)(
+    "should install a .deb with missing dependencies and launch its window",
+    async (context) => {
+      const testdriver = TestDriver(context, { ...getDefaults(context) });
+
+      // Yaak is a Tauri app. Its .deb depends on WebKitGTK and libsoup,
+      // which aren't preinstalled, so dpkg alone leaves it unconfigured.
+      await testdriver.provision.installer({
+        url: 'https://github.com/mountain-loop/yaak/releases/download/v2026.9.0/yaak_2026.9.0_amd64.deb',
+        appName: 'Yaak',
+      });
+
+      // The package and its dependencies are fully installed
+      const status = await testdriver.exec(
+        'sh',
+        "dpkg-query -W -f='${Status}' yaak",
+        10000,
+      );
+      expect(status).toBe('install ok installed');
+
+      // launch: true (the default) started the app, so its window is on screen
+      const result = await testdriver.assert('The Yaak app window is open');
+      expect(result).toBeTruthy();
+    },
+  );
+
   it.skipIf(!isLinux)(
     "should download a shell script and verify it exists",
     async (context) => {

package/lib/provision.js

@@ -479,10 +479,14 @@ with zipfile.ZipFile(io.BytesIO(zip_data)) as zf:
      * @param {string} options.url - URL to download the installer from
      * @param {string} [options.filename] - Filename to save as (auto-detected from URL if not provided)
      * @param {string} [options.appName] - Application name to focus after install
-     * @param {boolean} [options.launch=true] - Whether to launch the app after installation
+     * @param {boolean} [options.launch=true] - Whether to launch the app after installation.
+     *   For a .deb on Linux this starts the app from its `.desktop` entry (or, when
+     *   `appName` is set and there is no `.desktop` entry, its first `/usr/bin` binary),
+     *   then focuses `appName`. On other platforms it only focuses `appName`.
      * @returns {Promise<string>} Path to the downloaded file
      * @example
-     * // Install a .deb package on Linux (auto-detected)
+     * // Install a .deb package on Linux (auto-detected). Missing dependencies
+     * // are installed with apt, then the app is started and focused.
      * await testdriver.provision.installer({
      *   url: 'https://example.com/app.deb',
      *   appName: 'MyApp'
@@ -592,7 +596,25 @@ with zipfile.ZipFile(io.BytesIO(zip_data)) as zf:
         }
       } else if (self.os === "linux") {
         if (ext === "deb") {
-          installCommand = `sudo dpkg -i "${actualFilePath}" && sudo apt-get install -f -y`;
+          // dpkg -i exits non-zero when dependencies are missing, so resolve
+          // them with apt-get install -f instead of stopping there. Fail the
+          // step if the package still isn't fully installed afterwards.
+          // Runs in a subshell: the sandbox shell is persistent, so a bare
+          // `exit` would kill it instead of failing the command.
+          installCommand = [
+            `(`,
+            `PKG=$(dpkg-deb -f "${actualFilePath}" Package)`,
+            `if ! sudo DEBIAN_FRONTEND=noninteractive dpkg -i "${actualFilePath}"; then`,
+            `  sudo apt-get update -qq`,
+            `  sudo DEBIAN_FRONTEND=noninteractive apt-get install -f -y`,
+            `fi`,
+            `if ! dpkg -s "$PKG" 2>/dev/null | grep -q '^Status: install ok installed'; then`,
+            `  echo "[provision.installer] package $PKG is not fully installed" >&2`,
+            `  dpkg -l "$PKG" >&2`,
+            `  exit 1`,
+            `fi`,
+            `)`,
+          ].join("\n");
         } else if (ext === "rpm") {
           installCommand = `sudo rpm -i "${actualFilePath}"`;
         } else if (ext === "appimage") {
@@ -614,8 +636,47 @@ with zipfile.ZipFile(io.BytesIO(zip_data)) as zf:
         console.log(`[provision.installer] ✅ Installation complete`);
       }
 
-      // Launch and focus the app if appName is provided and launch is true
+      // On Linux, installing a .deb doesn't start anything. Start the app
+      // from its .desktop entry (or a /usr/bin binary when appName is set)
+      // so a window exists to focus and test.
+      let launched = false;
+      if (launch && self.os === "linux" && ext === "deb") {
+        const launchScript = [
+          `(`,
+          `PKG=$(dpkg-deb -f "${actualFilePath}" Package)`,
+          `FILES=$(dpkg -L "$PKG")`,
+          `DESKTOP=$(echo "$FILES" | grep -E '^/usr/(local/)?share/applications/.*\\.desktop$' | head -n1)`,
+          `CMD=""`,
+          `if [ -n "$DESKTOP" ]; then`,
+          `  CMD=$(grep -m1 '^Exec=' "$DESKTOP" | sed -e 's/^Exec=//' -e 's/ *%[a-zA-Z]//g')`,
+          `fi`,
+          appName
+            ? `if [ -z "$CMD" ]; then CMD=$(echo "$FILES" | grep -E '^/usr/(local/)?bin/[^/]+$' | head -n1); fi`
+            : ``,
+          `if [ -n "$CMD" ]; then`,
+          `  nohup sh -c "$CMD" >/dev/null 2>&1 &`,
+          `  echo "TD_LAUNCHED=$CMD"`,
+          `fi`,
+          `)`,
+        ].join("\n");
+        const output = await self.exec(shell, launchScript, 30000, true);
+        const match = /TD_LAUNCHED=(.+)/.exec(output || "");
+        if (match) {
+          launched = true;
+          console.log(`[provision.installer] ✅ Launched ${match[1].trim()}`);
+        } else {
+          console.log(
+            `[provision.installer] No .desktop entry found, skipping launch`,
+          );
+        }
+      }
+
+      // Focus the app if appName is provided and launch is true
       if (appName && launch) {
+        if (launched) {
+          // Give the app time to open its first window
+          await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
         await new Promise((resolve) => setTimeout(resolve, 2000));
         await self.focusApplication(appName);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testdriverai",
-  "version": "7.11.225-test",
+  "version": "7.11.227-test",
   "description": "Next generation autonomous AI agent for end-to-end testing of web & desktop",
   "main": "sdk.js",
   "types": "sdk.d.ts",

package/sdk.d.ts

@@ -903,7 +903,7 @@ export interface ProvisionInstallerOptions {
   filename?: string;
   /** Application name to focus after install */
   appName?: string;
-  /** Whether to launch the app after installation (default: true) */
+  /** Whether to launch the app after installation (default: true). For a .deb on Linux this starts the app from its .desktop entry, then focuses appName. */
   launch?: boolean;
 }