stably 4.12.21 → 4.12.22-rc.0

package/dist/node_modules/playwright/lib/cli/client/session.js

@@ -230,8 +230,17 @@ to restart the browser session.`);
           resolve();
       });
       child.on("close", (code) => {
-        if (!signalled)
-          reject(new Error(`Daemon process exited with code ${code}`));
+        if (!signalled) {
+          // Read the .err log — when the daemon crashes before outputting ### Error
+          // (e.g., SyntaxError, missing module), the real error is only in this file.
+          let message = `Daemon process exited with code ${code}`;
+          try {
+            const errLogContent = import_fs.default.readFileSync(errLog, "utf-8").trim();
+            if (errLogContent)
+              message += "\n" + errLogContent;
+          } catch {}
+          reject(new Error(message));
+        }
       });
     });
     process.off("SIGINT", sigintHandler);

package/dist/node_modules/playwright/lib/cli/daemon/daemon.js

@@ -43,27 +43,9 @@ var import_socketConnection = require("../client/socketConnection");
 var import_commands = require("./commands");
 var import_command = require("./command");
 const daemonDebug = (0, import_utilsBundle.debug)("pw:daemon");
-async function socketExists(socketPath) {
-  try {
-    const stat = await import_promises.default.stat(socketPath);
-    if (stat?.isSocket())
-      return true;
-  } catch (e) {
-  }
-  return false;
-}
 async function startMcpDaemonServer(config, contextFactory) {
   const sessionConfig = config.sessionConfig;
   const { socketPath, version } = sessionConfig;
-  if (import_os.default.platform() !== "win32" && await socketExists(socketPath)) {
-    daemonDebug(`Socket already exists, removing: ${socketPath}`);
-    try {
-      await import_promises.default.unlink(socketPath);
-    } catch (error) {
-      daemonDebug(`Failed to remove existing socket: ${error}`);
-      throw error;
-    }
-  }
   const cwd = import_url.default.pathToFileURL(process.cwd()).href;
   const clientInfo = {
     name: "playwright-cli",
@@ -194,6 +176,9 @@ async function startMcpDaemonServer(config, contextFactory) {
   const shutdown = (exitCode) => {
     daemonDebug(`shutting down daemon with exit code ${exitCode}`);
     server.close();
+    if (import_os.default.platform() !== "win32") {
+      try { require("fs").unlinkSync(socketPath); } catch {}
+    }
     (0, import_utils.gracefullyProcessExitDoNotHang)(exitCode);
   };
   const server = import_net.default.createServer((socket) => {
@@ -230,9 +215,42 @@ async function startMcpDaemonServer(config, contextFactory) {
     };
   });
   return new Promise((resolve, reject) => {
+    let retried = false;
     server.on("error", (error) => {
-      daemonDebug(`server error: ${error.message}`);
-      reject(error);
+      if (error.code !== "EADDRINUSE" || retried) {
+        daemonDebug(`server error: ${error.message}`);
+        return reject(error);
+      }
+      daemonDebug("Socket already in use, checking if daemon is alive...");
+      const client = import_net.default.connect(socketPath);
+      client.setTimeout(5000);
+      client.on("timeout", () => {
+        client.destroy();
+        retried = true;
+        reject(new Error(
+          `Daemon at ${socketPath} is not responding (connect timed out). ` +
+          `Remove the socket manually or kill the process.`
+        ));
+      });
+      client.on("connect", () => {
+        client.destroy();
+        reject(new Error(
+          `Another daemon is already running on ${socketPath}. ` +
+          `Close it with 'stably-browser close' first.`
+        ));
+      });
+      client.on("error", () => {
+        if (retried) return;
+        daemonDebug("Stale socket detected, removing and retrying...");
+        if (import_os.default.platform() !== "win32") {
+          try { require("fs").unlinkSync(socketPath); } catch {}
+        }
+        retried = true;
+        server.listen(socketPath, () => {
+          daemonDebug(`daemon server listening on ${socketPath}`);
+          resolve(socketPath);
+        });
+      });
     });
     server.listen(socketPath, () => {
       daemonDebug(`daemon server listening on ${socketPath}`);

package/dist/node_modules/playwright/lib/cli/daemon/program.js

@@ -43,6 +43,20 @@ function decorateCLICommand(command, version) {
     options.chromiumSandbox = options.chromiumSandbox === true ? void 0 : false;
     (0, import_watchdog.setupExitWatchdog)();
     const config = await resolveCLIConfig(options.daemonSession);
+    // Docker's /dev/shm defaults to 64MB. Chrome uses /dev/shm for renderer shared
+    // memory (frame compositing, screenshot buffers). Complex pages can push Chrome
+    // past 64MB, silently crashing the renderer and killing the CDP connection.
+    // --disable-dev-shm-usage tells Chrome to use /tmp instead.
+    //
+    // Injected AFTER resolveCLIConfig() so it operates on the final resolved config,
+    // not the pipeline inputs — doesn't interfere with user-set PLAYWRIGHT_MCP_CONFIG
+    // or any other config source (defaults, env vars, --config= files, CLI flags).
+    // Harmless on non-Docker: both /dev/shm and /tmp are tmpfs.
+    // Harmless for CDP connections: CdpContextFactory ignores launchOptions.args.
+    if (!config.browser.launchOptions.args)
+      config.browser.launchOptions.args = [];
+    if (!config.browser.launchOptions.args.includes("--disable-dev-shm-usage"))
+      config.browser.launchOptions.args.push("--disable-dev-shm-usage");
     const browserContextFactory = (0, import_browserContextFactory.contextFactory)(config);
     const extensionContextFactory = new import_extensionContextFactory.ExtensionContextFactory(config.browser.launchOptions.channel || "chrome", config.browser.userDataDir, config.browser.launchOptions.executablePath);
     const cf = config.extension ? extensionContextFactory : browserContextFactory;

package/dist/node_modules/playwright/lib/mcp/browser/browserContextFactory.js

@@ -147,7 +147,17 @@ class CdpContextFactory extends BaseContextFactory {
     });
   }
   async _doCreateContext(browser) {
-    return this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
+    if (this.config.browser.isolated)
+      return await browser.newContext();
+    // Non-isolated: reuse the default context so pages survive across sessions.
+    // After a browser crash/disconnect, _browserPromise is cleared (see BaseContextFactory)
+    // and _obtainBrowser reconnects via connectOverCDP. The fresh connection should have
+    // a default context, but if contexts()[0] is undefined (e.g., browser was restarted
+    // without a default context), fall back to creating a new one so the daemon doesn't crash.
+    const context = browser.contexts()[0];
+    if (context)
+      return context;
+    return await browser.newContext();
   }
 }
 class RemoteContextFactory extends BaseContextFactory {

package/dist/node_modules/playwright/lib/mcp/browser/config.js

@@ -106,9 +106,12 @@ async function resolveCLIConfig(cliOptions) {
 }
 async function validateConfig(config) {
   if (config.browser.browserName === "chromium" && config.browser.launchOptions.chromiumSandbox === void 0) {
-    if (process.platform === "linux")
-      config.browser.launchOptions.chromiumSandbox = config.browser.launchOptions.channel !== "chromium";
-    else
+    if (process.platform === "linux") {
+      // On Linux, enable sandbox for non-bundled channels (chrome, msedge, etc.) UNLESS
+      // running as root. Chrome refuses to sandbox when running as root (common in CI/Docker).
+      const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
+      config.browser.launchOptions.chromiumSandbox = isRoot ? false : config.browser.launchOptions.channel !== "chromium";
+    } else
       config.browser.launchOptions.chromiumSandbox = true;
   }
   if (config.saveVideo && !checkFfmpeg()) {

package/dist/node_modules/playwright/lib/mcp/browser/config.js.rej

@@ -0,0 +1,11 @@
+--- lib/mcp/browser/config.js
++++ lib/mcp/browser/config.js
+@@ -305,7 +305,7 @@
+ function outputDir(config, clientInfo) {
+   if (config.outputDir)
+     return import_path.default.resolve(config.outputDir);
+   const rootPath = (0, import_server2.firstRootPath)(clientInfo);
+   if (rootPath)
+-    return import_path.default.resolve(rootPath, config.skillMode ? ".playwright-cli" : ".playwright-mcp");
++    return import_path.default.resolve(rootPath, config.skillMode ? ".stably-browser" : ".playwright-mcp");
+   const tmpDir = process.env.PW_TMPDIR_FOR_TEST ?? import_os.default.tmpdir();

package/dist/node_modules/playwright/lib/mcp/browser/sessionLog.js

@@ -118,6 +118,40 @@ class SessionLog {
     lines.push("");
     this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
   }
+  logUserAction(action, tab, code, isUpdate) {
+    code = code.trim();
+    // Send recorder event for user action tracking
+    const actionForLog = { ...action };
+    delete actionForLog.ariaSnapshot;
+    delete actionForLog.selector;
+    actionForLog.isUpdate = !!isUpdate;
+    sendRecorderEvent({
+      type: "user-action",
+      action: actionForLog,
+      code,
+      url: tab.page.url(),
+      timestamp: Date.now()
+    });
+    // Also log to session file
+    const lines = [""];
+    lines.push(
+      `### User action: ${action.name}`,
+      "- Args",
+      "```json",
+      JSON.stringify(actionForLog, null, 2),
+      "```"
+    );
+    if (code) {
+      lines.push(
+        "- Code",
+        "```js",
+        code,
+        "```"
+      );
+    }
+    lines.push("");
+    this._sessionFileQueue = this._sessionFileQueue.then(() => import_fs.default.promises.appendFile(this._file, lines.join("\n")));
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/stably-plugin-cli/skills/bulk-test-handling/SKILL.md

@@ -101,6 +101,12 @@ After all batches complete, provide:
 - List of any failed/skipped tests with reasons
 - Suggestions for resolving issues
 
+## Orchestrator Available
+
+If `create-planner` and `create-worker` subagents are available (check your available subagent types), defer to the orchestrator for parallel execution instead of using this batch approach. The orchestrator groups tests by page and runs workers in parallel, which is faster than sequential batching. This skill applies only when the orchestrator subagents are not available.
+
+Note: the batching guidance in this skill (browser-close between tests, batch sizes of ~6) still applies *within* each orchestrator worker — workers process their page group's tests sequentially with the same browser-reset pattern.
+
 ## Do NOT
 
 - Start creating tests without informing user of scope

package/dist/stably-plugin-cli/skills/stably-browser/SKILL.md

@@ -231,6 +231,40 @@ stably-browser run-test --help
 - Overrides `browser`/`context`/`page` fixtures to connect via CDP (no new browser launched)
 - Preserves browser state after the run (pages remain open for inspection)
 
+## Test Creation Workflow
+
+Use `stably-browser` as a live exploration tool during test creation, not just as a final verifier.
+
+Preferred pattern when feasible:
+
+1. Open the page and explore it live.
+```bash
+stably-browser open https://example.com/target
+stably-browser click e15
+stably-browser fill e22 "query"
+```
+
+2. Read the snapshot returned by each action.
+- Treat the browser snapshot as ground truth for visible DOM structure, roles, labels, text, and control behavior.
+- Use code/source reads for routes, feature flags, auth/setup, and hidden preconditions.
+
+3. Reuse emitted Playwright code.
+- `stably-browser` actions emit concrete Playwright code/locator suggestions.
+- Prefer copying that evidence into the test instead of inventing selectors from scratch.
+
+4. Run `stably-browser run-test` to verify.
+- Use `run-test` after you understand the page, or earlier when it is needed to bootstrap project-aware auth/setup.
+- After `run-test`, prefer inspecting the persisted browser/session before blindly rerunning from the error text alone.
+
+5. If auth/setup requires a project-aware bootstrap:
+- Direct `open` may not reproduce Playwright project auth/setup on its own.
+- In those repos, use `stably-browser run-test --project=<project>` or a seed test to establish the correct state, then inspect the persisted browser/session.
+
+Anti-patterns:
+- Guessing selectors from source code when the live browser already shows the actual DOM
+- Treating `run-test` as the only discovery tool
+- Blindly looping `run-test` → read error → edit without inspecting the browser state in between
+
 ### Running Multiple Tests — Sequential vs Parallel
 
 When verifying that multiple independent tests pass, each test needs its own clean browser state. Two approaches:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stably",
-  "version": "4.12.21",
+  "version": "4.12.22-rc.0",
   "packageManager": "pnpm@10.24.0",
   "description": "AI-powered E2E Playwright testing CLI. Stably can understand your codebase, edit/run tests, and handle complex test scenarios for you.",
   "main": "dist/index.mjs",