specrails-hub 1.61.1 → 1.61.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-hub",
-  "version": "1.61.1",
+  "version": "1.61.3",
   "license": "MIT",
   "repository": {
     "type": "git",

package/server/dist/browser-playwright.js

@@ -7,39 +7,6 @@
 //
 // Screencast uses CDP (`Page.startScreencast`) since Playwright exposes no
 // screencast API; input + screenshot + DOM use Playwright's high-level page API.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPlaywrightLauncher = createPlaywrightLauncher;
 const chromium_resolver_1 = require("./chromium-resolver");
@@ -577,9 +544,14 @@ class PlaywrightContextHandle {
  */
 function createPlaywrightLauncher() {
     return async (opts) => {
+        // Use CommonJS require (NOT dynamic import()): in the packaged pkg sidecar the
+        // native-addon banner redirects require('playwright') to the externally-copied
+        // package via _Module._load. A dynamic import() goes through Node's ESM resolver
+        // instead, which can't find 'playwright' inside the /snapshot pkg vfs
+        // ("Cannot find package 'playwright'"). require keeps it on the patched path.
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { chromium } = (await Promise.resolve().then(() => __importStar(require('playwright'))));
-        const executablePath = opts.executablePath ?? (0, chromium_resolver_1.resolveBundledChromiumPath)() ?? undefined;
+        const { chromium } = require('playwright');
+        const executablePath = opts.executablePath ?? (await (0, chromium_resolver_1.resolveBundledChromiumExecutable)()) ?? undefined;
         const context = await chromium.launchPersistentContext(opts.userDataDir, {
             headless: true,
             executablePath,

package/server/dist/chromium-resolver.js

@@ -3,31 +3,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundledChromiumCandidates = bundledChromiumCandidates;
+exports.discoverChromiumExecutable = discoverChromiumExecutable;
 exports.resolveBundledChromiumPath = resolveBundledChromiumPath;
+exports.resolveBundledChromiumExecutable = resolveBundledChromiumExecutable;
 const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
 /**
  * Resolve the Chromium executable the browser-capture feature should launch.
  *
- * Mirrors the bundled-runtime resolution used by `path-resolver.ts` for node/git:
- * in desktop mode (`SPECRAILS_IS_DESKTOP=1`) we existence-gate a bundled Chromium
- * shipped under `<runtimes>/chromium/` (declared in tauri.conf.json via the
- * `runtimes/**` glob, codesigned in CI before `tauri build`). When the bundled
- * binary is absent (dev, a runtimes-less build, or a partial extraction) we return
- * `null` so Playwright falls back to its own managed Chromium download — never
- * dead-ending the feature.
+ * In desktop mode (`SPECRAILS_IS_DESKTOP=1`) we ship Chromium INSIDE the app, but
+ * NOT as an unpacked directory: Tauri's resource bundler dereferences symlinks when
+ * it copies `bundle.resources` into the .app (tauri-apps/tauri#13219), which mangles
+ * Chromium's versioned `*.framework` (the `Versions/Current` + top-level symlinks
+ * become flat duplicate copies) and invalidates its code signature — macOS
+ * notarization then rejects the app ("The signature of the binary is invalid").
  *
- * Layout (matches the CI assembly + smoke test):
- *   macOS/Linux: runtimes/chromium/chrome-<plat>/Chromium.app/Contents/MacOS/Chromium
- *                or runtimes/chromium/bin/chromium
- *   Windows:     runtimes/chromium/chrome-win/chrome.exe
- *                or runtimes/chromium/bin/chromium.exe
+ * So we ship Chromium as a single OPAQUE archive (`<runtimes>/chromium/chromium.tar.gz`):
+ *   - Tauri copies one regular file — nothing to dereference, and notarization treats
+ *     archive bytes as opaque data (it never inspects Mach-O inside a .tar.gz), so the
+ *     app notarizes cleanly with NO Developer-ID signing of Chromium required.
+ *   - At first use we extract it to a writable cache (`~/.specrails/runtimes/chromium`),
+ *     which restores the framework symlinks intact. The extracted Chromium keeps
+ *     Google's original ad-hoc ("linker-signed") signature, which is sufficient to
+ *     execute on Apple Silicon, and — being self-extracted rather than downloaded —
+ *     carries no `com.apple.quarantine` xattr, so Gatekeeper does not block it.
  *
- * Multiple candidate paths are probed so the exact Playwright tarball layout
- * (which nests under chrome-<platform>/) and a flattened bin/ layout both work.
+ * When no archive is present (dev, a runtimes-less build, a partial extraction) we
+ * fall back to discovering an UNPACKED `<runtimes>/chromium` tree, and finally to
+ * `null` so Playwright uses its own managed browser — never dead-ending the feature.
+ *
+ * We DISCOVER rather than hard-code the executable path because Playwright's layout
+ * changes across versions (`chrome-mac/Chromium.app` → `chrome-mac-arm64/Google Chrome
+ * for Testing.app`, `chrome-win/chrome.exe`, `chrome-linux/chrome`).
  */
-function fileExists(p) {
+const MAX_DEPTH = 6;
+function isFile(p) {
     try {
         return fs_1.default.statSync(p).isFile();
     }
@@ -35,32 +47,90 @@ function fileExists(p) {
         return false;
     }
 }
-function bundledChromiumCandidates(runtimesPath) {
-    const root = path_1.default.join(runtimesPath, 'chromium');
+/** Depth-bounded search for the first file whose basename satisfies `match`. */
+function findFirstFile(root, match, depth = 0) {
+    if (depth > MAX_DEPTH)
+        return null;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    // Files first (cheap), then recurse into dirs.
+    for (const e of entries) {
+        if (e.isFile() && match(e.name))
+            return path_1.default.join(root, e.name);
+    }
+    for (const e of entries) {
+        if (e.isDirectory()) {
+            const hit = findFirstFile(path_1.default.join(root, e.name), match, depth + 1);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+/** On macOS: locate the main executable inside the first `*.app` under `root`. */
+function findMacAppExecutable(root, depth = 0) {
+    if (depth > MAX_DEPTH)
+        return null;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && e.name.endsWith('.app')) {
+            const macosDir = path_1.default.join(root, e.name, 'Contents', 'MacOS');
+            // The main binary is conventionally named like the app (sans ".app");
+            // fall back to the first regular file in MacOS/.
+            const preferred = path_1.default.join(macosDir, e.name.slice(0, -'.app'.length));
+            if (isFile(preferred))
+                return preferred;
+            try {
+                for (const inner of fs_1.default.readdirSync(macosDir, { withFileTypes: true })) {
+                    if (inner.isFile())
+                        return path_1.default.join(macosDir, inner.name);
+                }
+            }
+            catch { /* keep searching */ }
+        }
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && !e.name.endsWith('.app')) {
+            const hit = findMacAppExecutable(path_1.default.join(root, e.name), depth + 1);
+            if (hit)
+                return hit;
+        }
+    }
+    return null;
+}
+/** Find the bundled Chromium executable under `<chromiumRoot>`, or null. */
+function discoverChromiumExecutable(chromiumRoot) {
+    if (!fs_1.default.existsSync(chromiumRoot))
+        return null;
     if (process.platform === 'win32') {
-        return [
-            path_1.default.join(root, 'bin', 'chromium.exe'),
-            path_1.default.join(root, 'chrome-win', 'chrome.exe'),
-            path_1.default.join(root, 'chrome.exe'),
-        ];
+        return findFirstFile(chromiumRoot, (n) => n === 'chrome.exe' || n === 'chromium.exe');
     }
     if (process.platform === 'darwin') {
-        return [
-            path_1.default.join(root, 'bin', 'chromium'),
-            path_1.default.join(root, 'chrome-mac', 'Chromium.app', 'Contents', 'MacOS', 'Chromium'),
-            path_1.default.join(root, 'Chromium.app', 'Contents', 'MacOS', 'Chromium'),
-        ];
+        return (findMacAppExecutable(chromiumRoot) ??
+            findFirstFile(chromiumRoot, (n) => n === 'Chromium' || n === 'chromium' || n === 'chrome'));
     }
     // linux
-    return [
-        path_1.default.join(root, 'bin', 'chromium'),
-        path_1.default.join(root, 'chrome-linux', 'chrome'),
-        path_1.default.join(root, 'chrome'),
-    ];
+    return findFirstFile(chromiumRoot, (n) => n === 'chrome' || n === 'chromium' || n === 'chrome-wrapper');
 }
 /**
- * Returns the absolute path to the bundled Chromium binary, or `null` when no
- * bundle is present (so Playwright uses its managed browser). Never throws.
+ * Returns the absolute path to an UNPACKED bundled Chromium binary, or `null`.
+ *
+ * This is the synchronous, no-extraction path: it only inspects a chromium tree that
+ * already exists on disk under `<runtimes>/chromium`. Prefer the async
+ * `resolveBundledChromiumExecutable()` for the launch path — it additionally extracts
+ * the shipped `chromium.tar.gz` archive. Kept for the unpacked fallback (local builds)
+ * and never throws.
  */
 function resolveBundledChromiumPath() {
     if (process.env.SPECRAILS_IS_DESKTOP !== '1')
@@ -68,9 +138,130 @@ function resolveBundledChromiumPath() {
     const runtimesPath = process.env.SPECRAILS_BUNDLED_RUNTIMES_PATH;
     if (!runtimesPath)
         return null;
-    for (const candidate of bundledChromiumCandidates(runtimesPath)) {
-        if (fileExists(candidate))
-            return candidate;
+    try {
+        return discoverChromiumExecutable(path_1.default.join(runtimesPath, 'chromium'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Candidate archive names under `<runtimes>/chromium`, in preference order. */
+const ARCHIVE_NAMES = ['chromium.tar.gz', 'chromium.tar'];
+/** Writable extraction destination (overridable for tests via env). */
+function chromiumCacheDir() {
+    return (process.env.SPECRAILS_CHROMIUM_CACHE_DIR ||
+        path_1.default.join(os_1.default.homedir(), '.specrails', 'runtimes', 'chromium'));
+}
+/** Identity string for an archive (size:mtime) used to skip re-extraction. */
+function archiveIdentity(archivePath) {
+    const st = fs_1.default.statSync(archivePath);
+    return `${st.size}:${Math.round(st.mtimeMs)}`;
+}
+/** Resolve the platform `tar` binary. macOS/Linux ship `/usr/bin/tar`; Windows 10+ ships `tar` (bsdtar) on PATH. */
+function tarBinary() {
+    if (process.platform !== 'win32' && isFile('/usr/bin/tar'))
+        return '/usr/bin/tar';
+    return 'tar';
+}
+/** Extract `archivePath` into `destDir` using the system tar (auto-detects gzip). */
+function runTarExtract(archivePath, destDir) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(tarBinary(), ['-xf', archivePath, '-C', destDir], { stdio: ['ignore', 'ignore', 'pipe'] });
+        let stderr = '';
+        child.stderr?.on('data', (d) => { stderr += d.toString(); });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`tar exited ${code}: ${stderr.trim().slice(0, 500)}`));
+        });
+    });
+}
+// In-process single-slot cache so concurrent / StrictMode double-invokes share one
+// extraction instead of racing. Keyed by archive identity; invalidated if it changes.
+let _extractInflight = null;
+/** First archive that exists under `<runtimes>/chromium`, or null. */
+function findBundledArchive(runtimesPath) {
+    for (const name of ARCHIVE_NAMES) {
+        const p = path_1.default.join(runtimesPath, 'chromium', name);
+        if (isFile(p))
+            return p;
     }
     return null;
 }
+async function extractAndDiscover(archivePath, identity) {
+    const destRoot = chromiumCacheDir();
+    const marker = path_1.default.join(destRoot, '.source');
+    // Fast path: already extracted from this exact archive.
+    try {
+        if (fs_1.default.readFileSync(marker, 'utf8') === identity) {
+            const exe = discoverChromiumExecutable(destRoot);
+            if (exe)
+                return exe;
+        }
+    }
+    catch { /* not yet extracted / stale → fall through */ }
+    // Extract to a temp sibling, then atomically swap in.
+    const tmpDir = `${destRoot}.tmp-${process.pid}`;
+    fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    fs_1.default.mkdirSync(tmpDir, { recursive: true });
+    try {
+        await runTarExtract(archivePath, tmpDir);
+        const exeInTmp = discoverChromiumExecutable(tmpDir);
+        if (!exeInTmp)
+            throw new Error('no chromium executable found after extraction');
+        try {
+            fs_1.default.chmodSync(exeInTmp, 0o755);
+        }
+        catch { /* perms best-effort */ }
+        fs_1.default.rmSync(destRoot, { recursive: true, force: true });
+        fs_1.default.mkdirSync(path_1.default.dirname(destRoot), { recursive: true });
+        fs_1.default.renameSync(tmpDir, destRoot);
+        fs_1.default.writeFileSync(marker, identity);
+        return discoverChromiumExecutable(destRoot);
+    }
+    finally {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Resolve the bundled Chromium executable for the launch path, extracting the
+ * shipped archive on first use. Returns `null` (never throws) when not in desktop
+ * mode, when no bundle is present, or when extraction fails — so Playwright falls
+ * back to its managed browser rather than dead-ending.
+ */
+async function resolveBundledChromiumExecutable() {
+    if (process.env.SPECRAILS_IS_DESKTOP !== '1')
+        return null;
+    const runtimesPath = process.env.SPECRAILS_BUNDLED_RUNTIMES_PATH;
+    if (!runtimesPath)
+        return null;
+    let archivePath = null;
+    try {
+        archivePath = findBundledArchive(runtimesPath);
+    }
+    catch {
+        archivePath = null;
+    }
+    // No archive shipped → fall back to an unpacked tree (local/dev builds).
+    if (!archivePath)
+        return resolveBundledChromiumPath();
+    let identity;
+    try {
+        identity = archiveIdentity(archivePath);
+    }
+    catch {
+        return resolveBundledChromiumPath();
+    }
+    if (_extractInflight && _extractInflight.identity === identity) {
+        return _extractInflight.promise;
+    }
+    const promise = extractAndDiscover(archivePath, identity).catch((err) => {
+        console.error('[chromium-resolver] extraction failed:', err instanceof Error ? err.message : err);
+        _extractInflight = null; // allow a later retry
+        return resolveBundledChromiumPath();
+    });
+    _extractInflight = { identity, promise };
+    return promise;
+}