tauri-test-cli 0.6.2 → 0.7.1

package/dist/cli.js

@@ -102312,7 +102312,7 @@ var init_esm11 = __esm(() => {
 });
 
 // src/cli.ts
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 
 // src/driver.ts
 import { spawn, execSync } from "child_process";
@@ -120707,7 +120707,9 @@ async function connect(options) {
 }
 async function disconnect() {
   if (browser) {
-    await browser.deleteSession();
+    try {
+      await browser.deleteSession();
+    } catch {}
     browser = null;
   }
   stopDriver();
@@ -120905,12 +120907,18 @@ async function waitForInteractive(selector, timeout = 5000) {
   await element.waitForClickable({ timeout });
 }
 
+// src/commands/utils.ts
+var xvfbDisplay = null;
+function getXvfbDisplay() {
+  return xvfbDisplay;
+}
+
 // src/commands/screenshot.ts
 var HTML2CANVAS_CDN = "https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html2canvas.min.js";
 async function screenshot(options = {}) {
   const browser3 = requireBrowser();
   const autoWait = options.autoWait ?? true;
-  const timeout = options.timeout ?? 5000;
+  const timeout = options.timeout ?? 15000;
   if (autoWait) {
     await waitForDomStable();
   }
@@ -120921,12 +120929,21 @@ async function screenshot(options = {}) {
     data2 = await withTimeout(captureWithHtml2Canvas(browser3), timeout, "html2canvas timed out");
     method = "html2canvas";
   } catch (err) {
-    console.error(`html2canvas failed: ${err}, trying native...`);
+    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: ${err}, ${nativeErr}`);
+      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...`);
+      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}`);
+      }
     }
   }
   if (options.output) {
@@ -120993,6 +121010,61 @@ 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(`
+`);
+        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("");
+    }
+  });
+  if (!base64) {
+    throw new Error("Canvas screenshot capture returned empty");
+  }
+  return base64;
+}
 
 // src/commands/snapshot.ts
 import { writeFile as writeFile2 } from "fs/promises";
@@ -121250,21 +121322,17 @@ async function waitFor(selector, options = {}) {
 // src/commands/eval.ts
 async function evaluate(script) {
   const browser3 = requireBrowser();
-  const wrappedScript = `
-    return (function() {
-      ${script}
-    })();
-  `;
   try {
+    const result = await browser3.execute(`return ${script}`);
+    return result;
+  } catch {
+    const wrappedScript = `
+      return (function() {
+        ${script}
+      })();
+    `;
     const result = await browser3.execute(wrappedScript);
     return result;
-  } catch (err) {
-    try {
-      const result = await browser3.execute(`return ${script}`);
-      return result;
-    } catch {
-      throw err;
-    }
   }
 }
 
@@ -121278,7 +121346,7 @@ var HTML2CANVAS_CDN2 = "https://cdn.jsdelivr.net/npm/html2canvas@1.4.1/dist/html
 async function screenshot2(options = {}) {
   const browser3 = requireBrowser();
   const autoWait = options.autoWait ?? true;
-  const timeout = options.timeout ?? 5000;
+  const timeout = options.timeout ?? 15000;
   if (autoWait) {
     await waitForDomStable();
   }
@@ -121289,12 +121357,21 @@ async function screenshot2(options = {}) {
     data2 = await withTimeout2(captureWithHtml2Canvas2(browser3), timeout, "html2canvas timed out");
     method = "html2canvas";
   } catch (err) {
-    console.error(`html2canvas failed: ${err}, trying native...`);
+    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: ${err}, ${nativeErr}`);
+      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...`);
+      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}`);
+      }
     }
   }
   if (options.output) {
@@ -121361,6 +121438,61 @@ 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(`
+`);
+        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("");
+    }
+  });
+  if (!base64) {
+    throw new Error("Canvas screenshot capture returned empty");
+  }
+  return base64;
+}
 
 // src/commands/snapshot.ts
 import { writeFile as writeFile4 } from "fs/promises";
@@ -121618,21 +121750,17 @@ async function waitFor2(selector, options = {}) {
 // src/commands/eval.ts
 async function evaluate2(script) {
   const browser3 = requireBrowser();
-  const wrappedScript = `
-    return (function() {
-      ${script}
-    })();
-  `;
   try {
+    const result = await browser3.execute(`return ${script}`);
+    return result;
+  } catch {
+    const wrappedScript = `
+      return (function() {
+        ${script}
+      })();
+    `;
     const result = await browser3.execute(wrappedScript);
     return result;
-  } catch (err) {
-    try {
-      const result = await browser3.execute(`return ${script}`);
-      return result;
-    } catch {
-      throw err;
-    }
   }
 }
 
@@ -121657,12 +121785,16 @@ async function executeCommand(cmd, globalAutoWait) {
   console.error(`[${new Date().toISOString()}] activateWindow took ${Date.now() - activateStart}ms`);
   const cmdStart = Date.now();
   let result;
+  if (cmd.cmd === "screenshot" || cmd.cmd === "snapshot") {
+    await injectKeepAlive();
+  }
   switch (cmd.cmd) {
     case "screenshot":
       result = await screenshot2({
         output: cmd.output,
         fullPage: cmd.fullPage,
-        autoWait
+        autoWait,
+        timeout: cmd.timeout
       });
       break;
     case "snapshot":
@@ -122131,7 +122263,7 @@ async function waitForDisplay(display, timeoutMs = 1e4) {
   return false;
 }
 var xvfbProcess = null;
-var xvfbDisplay = null;
+var xvfbDisplay2 = null;
 async function startXvfb() {
   const display = findAvailableDisplay();
   const displayStr = `:${display}`;
@@ -122161,7 +122293,7 @@ async function startXvfb() {
     throw new Error(`Xvfb display ${displayStr} failed to start within timeout`);
   }
   console.error(`Xvfb ready on display ${displayStr}`);
-  xvfbDisplay = display;
+  xvfbDisplay2 = display;
   process.env.DISPLAY = displayStr;
   delete process.env.WAYLAND_DISPLAY;
   process.env.GDK_BACKEND = "x11";
@@ -122172,10 +122304,250 @@ function stopXvfb() {
     console.error("Stopping Xvfb...");
     xvfbProcess.kill("SIGTERM");
     xvfbProcess = null;
-    xvfbDisplay = null;
+    xvfbDisplay2 = null;
   }
 }
 
+// src/commands/install-skill.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { resolve, dirname, join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/generated/skill-content.ts
+var SKILL_MD_CONTENT = `---
+name: tauri-test-cli
+description: Use when needing to visually verify Tauri app behavior, test UI interactions, take screenshots, or inspect DOM state.
+---
+
+# tauri-test-cli
+
+Visual testing CLI for Tauri apps. Start server once, send commands anytime.
+
+## Step 1: Detect Runtime & Set Command Prefix
+
+> **Local dependency?** If \`node_modules/tauri-test-cli\` exists in the project, skip Steps 1-2 and use \`npx tauri-test-cli\` (or \`pnpm exec tauri-test-cli\` / \`bunx tauri-test-cli\`) as your command prefix.
+
+Determine how to invoke tauri-test-cli based on the project:
+
+\`\`\`bash
+# Check what's available
+ls pixi.toml bun.lock package-lock.json pnpm-lock.yaml 2>/dev/null
+\`\`\`
+
+Set your command prefix for ALL subsequent commands:
+- **pixi + bun** (pixi.toml + bun.lock): \`pixi run bunx tauri-test-cli\`
+- **pixi + npm** (pixi.toml, no bun): \`pixi run npx tauri-test-cli\`
+- **bun** (bun.lock, no pixi): \`bunx tauri-test-cli\`
+- **npm** (package-lock.json): \`npx tauri-test-cli\`
+- **pnpm** (pnpm-lock.yaml): \`pnpm dlx tauri-test-cli\`
+
+Use this prefix for EVERY command below. Examples below use \`CMD\` as placeholder.
+
+## Step 2: Ensure Latest Version
+
+**bunx and npx cache aggressively.** Always clear all caches before running:
+
+\`\`\`bash
+# Clear ALL known cache locations
+rm -rf /tmp/bunx-*tauri-test-cli* 2>/dev/null        # bunx temp cache (primary)
+rm -rf ~/.bun/install/cache/tauri-test-cli* 2>/dev/null  # bun install cache
+rm -rf ~/.npm/_npx/*/node_modules/tauri-test-cli 2>/dev/null  # npx cache
+\`\`\`
+
+This ensures you always get the latest published version.
+
+## Step 3: Check Dependencies
+
+\`\`\`bash
+CMD check-deps
+\`\`\`
+
+If tauri-driver is missing:
+\`\`\`bash
+CMD setup
+\`\`\`
+
+## Step 4: Find the App Binary
+
+\`\`\`bash
+# Search for tauri.conf.json to find the app name
+find . -name "tauri.conf.json" -not -path "*/node_modules/*" 2>/dev/null
+
+# Common binary locations:
+# ./target/debug/app-name
+# ./src-tauri/target/debug/app-name
+# ./apps/*/src-tauri/target/debug/app-name
+\`\`\`
+
+Read \`tauri.conf.json\` to get the app identifier/name. Check if the binary exists:
+\`\`\`bash
+ls ./path/to/target/debug/app-name 2>/dev/null
+\`\`\`
+
+If missing, build it:
+\`\`\`bash
+# If pixi project:
+pixi run cargo build --manifest-path ./path/to/src-tauri/Cargo.toml
+# Otherwise:
+cd ./path/to/src-tauri && cargo build
+\`\`\`
+
+## Step 5: Check if Dev Server Needed
+
+Read \`tauri.conf.json\` — if it has a \`devUrl\` (e.g., \`http://localhost:5173\`), the debug binary needs the frontend dev server running.
+
+\`\`\`bash
+# 1. Check if devUrl exists
+grep -o '"devUrl".*' path/to/tauri.conf.json
+
+# 2. If devUrl found, check if the dev server is already reachable
+curl -s -o /dev/null -w "%{http_code}" http://localhost:5173
+
+# 3. If curl fails (connection refused / non-200), start the dev server
+# Look at package.json for the right dev command
+cd frontend-dir && npm run dev &
+sleep 5
+
+# 4. Verify it's reachable now
+curl -s -o /dev/null -w "%{http_code}" http://localhost:5173
+\`\`\`
+
+If \`build/\` or \`dist/\` exists in the frontend directory, the binary may work without a dev server — but verify by checking the app loads correctly after starting the server.
+
+## Step 6: Clean Up & Start Server
+
+**IMPORTANT on Linux:** Always use \`--xvfb\` flag. This avoids window focus and rendering issues.
+
+\`\`\`bash
+# Clean up any stale processes first
+CMD cleanup
+
+# Start server (--xvfb on Linux, omit on macOS)
+CMD server --app ./path/to/binary --xvfb &
+
+# Wait for server — it can take 15-20 seconds
+sleep 15
+CMD status
+\`\`\`
+
+If status says "No server running", wait longer:
+\`\`\`bash
+sleep 10
+CMD status
+\`\`\`
+
+**DO NOT** try to manually start Xvfb, use the existing Wayland display, or work around \`--xvfb\` failures. If \`--xvfb\` fails, check the error message and report it.
+
+## Quick Reference
+
+| Action | Command |
+|--------|---------|
+| Check deps | \`CMD check-deps\` |
+| Status | \`CMD status\` |
+| Start server | \`CMD server --app ./path/to/app --xvfb &\` |
+| Click | \`CMD click "selector"\` |
+| Type | \`CMD type "selector" "text"\` |
+| Screenshot | \`CMD screenshot --output /tmp/screen.png\` |
+| DOM snapshot | \`CMD snapshot --output /tmp/dom.yaml\` |
+| Wait appear | \`CMD wait "selector" --timeout 3000\` |
+| Wait gone | \`CMD wait "selector" --gone --timeout 5000\` |
+| Eval JS | \`CMD eval "document.title"\` |
+| Stop | \`CMD stop\` |
+| Cleanup | \`CMD cleanup\` |
+
+## After Server Starts
+
+\`\`\`bash
+# Always take an initial screenshot to verify the app loaded
+CMD screenshot --output /tmp/initial.png
+# Use Read tool to view the screenshot!
+
+# Run test commands
+CMD click "button"
+CMD screenshot --output /tmp/after-click.png
+
+# When done
+CMD stop
+\`\`\`
+
+## Troubleshooting
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| "Connection refused" in screenshot | Frontend dev server not running | Start frontend: \`npm run dev\` |
+| Blank/white screen | App not loaded yet | Increase \`--wait\` timeout |
+| "tauri-driver not found" | Missing dependency | Run \`CMD setup\` |
+| "Maximum sessions" error | Stale processes | Run \`CMD cleanup\` |
+| "Xvfb display failed to start" | Old CLI version (< 0.6.2) | Clear caches: \`rm -rf /tmp/bunx-*tauri-test-cli* ~/.bun/install/cache/tauri-test-cli*\` and retry |
+| Server not ready after 15s | Slow app startup | Wait longer, check if dev server is needed |
+
+## Screenshot vs Snapshot
+
+- **Screenshot**: Visual appearance, layout, colors
+- **DOM snapshot**: Element existence, text content, attributes
+- **Use snapshot** for canvas elements (screenshots can't capture canvas)
+
+## Cleanup (if stuck)
+
+\`\`\`bash
+CMD stop
+CMD cleanup
+pkill Xvfb 2>/dev/null   # Linux only
+\`\`\`
+`;
+
+// src/commands/install-skill.ts
+function findProjectRoot(cwd) {
+  let dir = resolve(cwd);
+  const root2 = dirname(dir) === dir ? dir : undefined;
+  while (true) {
+    if (existsSync(join3(dir, ".claude"))) {
+      return dir;
+    }
+    const parent2 = dirname(dir);
+    if (parent2 === dir)
+      break;
+    dir = parent2;
+  }
+  return null;
+}
+function installSkill(opts = {}) {
+  let targetDir;
+  let mode;
+  if (opts.global && opts.project) {
+    console.error("Error: cannot specify both --global and --project");
+    return { success: false };
+  }
+  if (opts.global) {
+    targetDir = join3(homedir3(), ".claude", "skills", "tauri-test-cli");
+    mode = "global";
+  } else if (opts.project) {
+    targetDir = join3(process.cwd(), ".claude", "skills", "tauri-test-cli");
+    mode = "project";
+  } else {
+    const projectRoot = findProjectRoot(process.cwd());
+    if (projectRoot) {
+      targetDir = join3(projectRoot, ".claude", "skills", "tauri-test-cli");
+      mode = `project (${projectRoot})`;
+    } else {
+      targetDir = join3(homedir3(), ".claude", "skills", "tauri-test-cli");
+      mode = "global";
+    }
+  }
+  const targetPath = join3(targetDir, "SKILL.md");
+  if (existsSync(targetPath)) {
+    const existing = readFileSync2(targetPath, "utf-8");
+    if (existing === SKILL_MD_CONTENT) {
+      console.log(`Skill already up-to-date (${mode}): ${targetPath}`);
+      return { success: true };
+    }
+  }
+  mkdirSync(targetDir, { recursive: true });
+  writeFileSync(targetPath, SKILL_MD_CONTENT, "utf-8");
+  console.log(`Installed skill (${mode}): ${targetPath}`);
+  return { success: true };
+}
+
 // src/cli.ts
 async function sendToServer(port, cmd) {
   const url2 = `http://127.0.0.1:${port}`;
@@ -122256,6 +122628,9 @@ COMMANDS:
   check-deps
       Check if all required system dependencies are installed
 
+  install-skill [--global | --project]
+      Install Claude Code skill for tauri-test-cli
+
   help
       Show this help message
 
@@ -122375,7 +122750,8 @@ async function executeCommand2(cmd, globalAutoWait) {
       return await screenshot({
         output: cmd.output,
         fullPage: cmd.fullPage,
-        autoWait
+        autoWait,
+        timeout: cmd.timeout
       });
     case "snapshot":
       return await snapshot({
@@ -122412,7 +122788,7 @@ async function executeCommand2(cmd, globalAutoWait) {
       }
       return await evaluate(cmd.script);
     case "sleep":
-      await new Promise((resolve2) => setTimeout(resolve2, cmd.ms ?? 1000));
+      await new Promise((resolve3) => setTimeout(resolve3, cmd.ms ?? 1000));
       return { slept: cmd.ms ?? 1000 };
     default:
       throw new Error(`Unknown command: ${cmd.cmd}`);
@@ -122484,7 +122860,14 @@ async function main() {
       process.exit(1);
     }
   }
-  const appPath = options.app ? resolve(options.app) : undefined;
+  if (command === "install-skill") {
+    const result = installSkill({
+      global: !!options.global,
+      project: !!options.project
+    });
+    process.exit(result.success ? 0 : 1);
+  }
+  const appPath = options.app ? resolve2(options.app) : undefined;
   const jsonOutput = !!options.json;
   const port = options.port ? parseInt(options.port) : 9222;
   const clientModeCommands = ["screenshot", "snapshot", "click", "type", "wait", "eval"];
@@ -122507,7 +122890,8 @@ async function main() {
           cmd = {
             cmd: "screenshot",
             output: options.output,
-            fullPage: !!options["full-page"]
+            fullPage: !!options["full-page"],
+            timeout: options.timeout ? parseInt(options.timeout) : undefined
           };
           break;
         case "snapshot":
@@ -122666,7 +123050,8 @@ async function main() {
         result = await screenshot({
           output: options.output,
           fullPage: !!options["full-page"],
-          autoWait
+          autoWait,
+          timeout: options.timeout ? parseInt(options.timeout) : undefined
         });
         break;
       case "snapshot":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-test-cli",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "CLI for testing Tauri applications with screenshot capture, DOM inspection, and user interaction simulation",
   "type": "module",
   "bin": {
@@ -30,7 +30,8 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "test:watch": "bun test --watch",
-    "prepublishOnly": "bun run build && bun test",
+    "generate-skill-content": "bun scripts/generate-skill-content.ts",
+    "prepublishOnly": "bun run generate-skill-content && bun run build && bun test",
     "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {

package/scripts/generate-skill-content.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+/**
+ * Reads skills/tauri-test-cli/SKILL.md and generates src/generated/skill-content.ts
+ * with the content embedded as a string constant for bundling.
+ */
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+
+const ROOT = resolve(dirname(new URL(import.meta.url).pathname), "..");
+const SKILL_PATH = resolve(ROOT, "skills/tauri-test-cli/SKILL.md");
+const OUT_DIR = resolve(ROOT, "src/generated");
+const OUT_PATH = resolve(OUT_DIR, "skill-content.ts");
+
+const raw = readFileSync(SKILL_PATH, "utf-8");
+
+// Escape for template literal embedding
+const escaped = raw
+  .replace(/\\/g, "\\\\")
+  .replace(/`/g, "\\`")
+  .replace(/\$/g, "\\$");
+
+const output = `// AUTO-GENERATED — do not edit. Run: bun scripts/generate-skill-content.ts
+export const SKILL_MD_CONTENT = \`${escaped}\`;
+`;
+
+mkdirSync(OUT_DIR, { recursive: true });
+writeFileSync(OUT_PATH, output, "utf-8");
+console.log(`Generated ${OUT_PATH}`);