browser-commander 0.3.0 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Changelog
 
+## 0.5.2
+
+### Patch Changes
+
+- 87224ee: Fix package.json path in version-and-commit.mjs for monorepo structure
+
+  The git show command uses repository root paths, not the workflow's working directory. Since this is a monorepo with js/ and rust/ folders, the path must be js/package.json instead of just package.json.
+
+  This was causing "Unexpected end of JSON input" errors when the script tried to read package.json from the repository root (which doesn't exist) instead of js/package.json.
+
+## 0.5.1
+
+### Patch Changes
+
+- 2b22f43: Fix PlaywrightAdapter.evaluateOnPage() to spread multiple arguments correctly
+
+  When using `evaluateOnPage()` with multiple arguments, the arguments are now properly spread to the function in the browser context, matching Puppeteer's behavior.
+
+  Previously, the function would receive the entire array as its first parameter instead of spread arguments, causing issues like invalid selectors when passing selector + array combinations.
+
+## 0.5.0
+
+### Minor Changes
+
+- adfccde: Add Rust implementation with parallel JavaScript codebase reorganization
+
+  This introduces a complete Rust translation of the browser-commander library alongside the existing JavaScript implementation. The codebase is now organized into two parallel structures:
+  - `js/` - JavaScript implementation (all existing functionality preserved)
+  - `rust/` - New Rust implementation with the same modular architecture
+
+  Key features of the Rust implementation:
+  - Unified API across multiple browser engines (chromiumoxide, fantoccini)
+  - Core types and traits (constants, engine adapter, logger)
+  - Element operations (selectors, visibility, content)
+  - User interactions (click, scroll, fill)
+  - Browser management (launcher, navigation)
+  - General utilities (URL handling, wait operations)
+  - High-level DRY utilities
+  - Comprehensive test coverage with 106 tests
+
+## 0.4.0
+
+### Minor Changes
+
+- 5af2479: Add support for custom Chrome args in launchBrowser
+
+  Adds a new `args` option to the `launchBrowser` function that allows passing custom Chrome arguments to append to the default `CHROME_ARGS`. This is useful for headless server environments (Docker, CI/CD) that require additional flags like `--no-sandbox`, `--disable-setuid-sandbox`, or `--disable-dev-shm-usage`.
+
+  Usage example:
+
+  ```javascript
+  import { launchBrowser } from 'browser-commander';
+
+  const { browser, page } = await launchBrowser({
+    engine: 'puppeteer',
+    headless: true,
+    args: ['--no-sandbox', '--disable-setuid-sandbox'],
+  });
+  ```
+
+  Fixes #11
+
 ## 0.3.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-commander",
-  "version": "0.3.0",
+  "version": "0.5.2",
   "description": "Universal browser automation library that supports both Playwright and Puppeteer with a unified API",
   "main": "src/index.js",
   "type": "module",

package/scripts/validate-changeset.mjs

@@ -15,7 +15,10 @@ import { readFileSync, readdirSync, existsSync } from 'fs';
 import { join } from 'path';
 
 const PACKAGE_NAME = 'browser-commander';
+// When running from js/ directory, the changeset dir is local
 const CHANGESET_DIR = '.changeset';
+// But git diff output uses repository-root relative paths
+const GIT_CHANGESET_PATH = 'js/.changeset';
 
 /**
  * Ensure a git commit is available locally, fetching if necessary
@@ -46,13 +49,19 @@ function parseAddedChangesets(diffOutput) {
       continue;
     }
     const [status, filePath] = line.split('\t');
+    // Check both local (.changeset/) and repo-root (js/.changeset/) paths
+    const isChangeset =
+      filePath.startsWith(`${CHANGESET_DIR}/`) ||
+      filePath.startsWith(`${GIT_CHANGESET_PATH}/`);
     if (
       status === 'A' &&
-      filePath.startsWith(`${CHANGESET_DIR}/`) &&
+      isChangeset &&
       filePath.endsWith('.md') &&
       !filePath.endsWith('README.md')
     ) {
-      addedChangesets.push(filePath.replace(`${CHANGESET_DIR}/`, ''));
+      // Extract just the filename
+      const fileName = filePath.split('/').pop();
+      addedChangesets.push(fileName);
     }
   }
   return addedChangesets;

package/scripts/version-and-commit.mjs

@@ -126,7 +126,9 @@ function countChangesets() {
  */
 async function getVersion(source = 'local') {
   if (source === 'remote') {
-    const result = await $`git show origin/main:package.json`.run({
+    // Use js/package.json for monorepo structure
+    // The workflow runs with working-directory: js, but git show uses repo root paths
+    const result = await $`git show origin/main:js/package.json`.run({
       capture: true,
     });
     return JSON.parse(result.stdout).version;

package/src/browser/launcher.js

@@ -11,6 +11,7 @@ import { disableTranslateInPreferences } from '../core/preferences.js';
  * @param {boolean} options.headless - Run in headless mode (default: false)
  * @param {number} options.slowMo - Slow down operations by ms (default: 150 for Playwright, 0 for Puppeteer)
  * @param {boolean} options.verbose - Enable verbose logging (default: false)
+ * @param {string[]} options.args - Custom Chrome arguments to append to the default CHROME_ARGS
  * @returns {Promise<Object>} - Object with browser and page
  */
 export async function launchBrowser(options = {}) {
@@ -20,8 +21,12 @@ export async function launchBrowser(options = {}) {
     headless = false,
     slowMo = engine === 'playwright' ? 150 : 0,
     verbose = false,
+    args = [],
   } = options;
 
+  // Combine default CHROME_ARGS with custom args
+  const chromeArgs = [...CHROME_ARGS, ...args];
+
   if (!['playwright', 'puppeteer'].includes(engine)) {
     throw new Error(
       `Invalid engine: ${engine}. Expected 'playwright' or 'puppeteer'`
@@ -50,7 +55,7 @@ export async function launchBrowser(options = {}) {
       slowMo,
       chromiumSandbox: true,
       viewport: null,
-      args: CHROME_ARGS,
+      args: chromeArgs,
       ignoreDefaultArgs: ['--enable-automation'],
     });
     page = browser.pages()[0];
@@ -59,7 +64,7 @@ export async function launchBrowser(options = {}) {
     browser = await puppeteer.default.launch({
       headless,
       defaultViewport: null,
-      args: ['--start-maximized', ...CHROME_ARGS],
+      args: ['--start-maximized', ...chromeArgs],
       userDataDir,
     });
     const pages = await browser.pages();

package/src/core/engine-adapter.js

@@ -304,13 +304,25 @@ export class PlaywrightAdapter extends EngineAdapter {
 
   async evaluateOnPage(fn, args = []) {
     // Playwright only accepts a single argument (can be array/object)
+    // To match Puppeteer's behavior where args are spread, we wrap the function
+    // and pass all args as a single array, then apply them in the browser context
     if (args.length === 0) {
       return await this.page.evaluate(fn);
     } else if (args.length === 1) {
       return await this.page.evaluate(fn, args[0]);
     } else {
-      // Multiple args - pass as array
-      return await this.page.evaluate(fn, args);
+      // Multiple args - wrap function to accept array and spread them
+      // This makes Playwright behave like Puppeteer's spread behavior
+      // We pass the function string and args array, then reconstruct and call in browser
+      const fnString = fn.toString();
+      return await this.page.evaluate(
+        ({ fnStr, argsArray }) => {
+          // Reconstruct the function in browser context and call with spread args
+          const reconstructedFn = new Function(`return (${fnStr})`)();
+          return reconstructedFn(...argsArray);
+        },
+        { fnStr: fnString, argsArray: args }
+      );
     }
   }
 

package/tests/helpers/mocks.js

@@ -105,28 +105,15 @@ export function createMockPlaywrightPage(options = {}) {
       return locs.map((l) => l.evaluate(fn, ...args));
     },
     locator: locatorMock,
-    evaluate: async (fn, ...args) => {
+    // Playwright's page.evaluate() only accepts a single argument (not spread)
+    // This is the key difference from Puppeteer
+    evaluate: async (fn, arg) => {
       if (evaluateResult !== null) {
         return evaluateResult;
       }
-      // Create mock window/document context
-      const mockContext = {
-        innerHeight: 800,
-        innerWidth: 1200,
-        sessionStorage: {
-          _data: {},
-          getItem: (key) => mockContext.sessionStorage._data[key] || null,
-          setItem: (key, val) => {
-            mockContext.sessionStorage._data[key] = val;
-          },
-          removeItem: (key) => {
-            delete mockContext.sessionStorage._data[key];
-          },
-        },
-        querySelectorAll: () => [],
-      };
       try {
-        return fn(...args);
+        // Playwright passes exactly one argument (can be object/array)
+        return fn(arg);
       } catch {
         return fn;
       }

package/tests/unit/browser/launcher.test.js

@@ -0,0 +1,126 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+
+describe('launcher', () => {
+  describe('launchBrowser args option', () => {
+    let originalEnv;
+    let mockChromium;
+    let mockPuppeteer;
+    let launchBrowser;
+    let capturedPlaywrightArgs;
+    let capturedPuppeteerArgs;
+
+    beforeEach(async () => {
+      // Save original environment
+      originalEnv = { ...process.env };
+
+      // Reset captured args
+      capturedPlaywrightArgs = null;
+      capturedPuppeteerArgs = null;
+
+      // Create mock browser context for Playwright
+      const mockBrowserContext = {
+        pages: () => [
+          {
+            bringToFront: async () => {},
+          },
+        ],
+        close: async () => {},
+      };
+
+      // Create mock browser for Puppeteer
+      const mockBrowser = {
+        pages: async () => [
+          {
+            bringToFront: async () => {},
+          },
+        ],
+        close: async () => {},
+      };
+
+      // Mock Playwright's chromium
+      mockChromium = {
+        launchPersistentContext: async (userDataDir, options) => {
+          capturedPlaywrightArgs = options.args;
+          return mockBrowserContext;
+        },
+      };
+
+      // Mock Puppeteer
+      mockPuppeteer = {
+        default: {
+          launch: async (options) => {
+            capturedPuppeteerArgs = options.args;
+            return mockBrowser;
+          },
+        },
+      };
+
+      // Use mock.module to mock the dynamic imports
+      // Since we can't easily mock dynamic imports in Node.js test runner,
+      // we'll test the CHROME_ARGS constant usage directly
+    });
+
+    afterEach(() => {
+      // Restore original environment
+      process.env = originalEnv;
+    });
+
+    it('should export CHROME_ARGS constant', async () => {
+      const { CHROME_ARGS } = await import('../../../src/core/constants.js');
+      assert.ok(Array.isArray(CHROME_ARGS));
+      assert.ok(CHROME_ARGS.length > 0);
+    });
+
+    it('should include expected default Chrome args', async () => {
+      const { CHROME_ARGS } = await import('../../../src/core/constants.js');
+      assert.ok(CHROME_ARGS.includes('--disable-session-crashed-bubble'));
+      assert.ok(CHROME_ARGS.includes('--no-first-run'));
+      assert.ok(CHROME_ARGS.includes('--no-default-browser-check'));
+    });
+
+    it('launchBrowser function should accept args option', async () => {
+      // We can verify the function signature by checking that it
+      // destructures args from options without throwing
+      const { launchBrowser } =
+        await import('../../../src/browser/launcher.js');
+      assert.ok(typeof launchBrowser === 'function');
+
+      // The function should accept options object with args array
+      // We can't fully test the launch without actual browsers,
+      // but we can verify the function exists and is callable
+    });
+
+    it('launchBrowser should throw for invalid engine', async () => {
+      const { launchBrowser } =
+        await import('../../../src/browser/launcher.js');
+
+      await assert.rejects(
+        () => launchBrowser({ engine: 'invalid-engine' }),
+        (error) => {
+          assert.ok(error.message.includes('Invalid engine'));
+          assert.ok(error.message.includes('invalid-engine'));
+          return true;
+        }
+      );
+    });
+
+    it('launchBrowser should accept args in options', async () => {
+      const { launchBrowser } =
+        await import('../../../src/browser/launcher.js');
+
+      // Verify the function signature accepts args
+      // This test validates that the args parameter is correctly destructured
+      // by attempting to call with an invalid engine (which fails before browser launch)
+      // but proves args is accepted without error during options parsing
+      const customArgs = ['--no-sandbox', '--disable-setuid-sandbox'];
+
+      await assert.rejects(
+        () => launchBrowser({ engine: 'invalid', args: customArgs }),
+        /Invalid engine/
+      );
+
+      // If we got here, the args option was accepted without error
+    });
+  });
+});

package/tests/unit/core/engine-adapter.test.js

@@ -78,6 +78,53 @@ describe('engine-adapter', () => {
       const count = await adapter.count('button');
       assert.strictEqual(count, 5);
     });
+
+    describe('evaluateOnPage', () => {
+      it('should handle zero arguments', async () => {
+        page = createMockPlaywrightPage();
+        adapter = new PlaywrightAdapter(page);
+        const result = await adapter.evaluateOnPage(() => 42);
+        assert.strictEqual(result, 42);
+      });
+
+      it('should handle single argument', async () => {
+        page = createMockPlaywrightPage();
+        adapter = new PlaywrightAdapter(page);
+        const result = await adapter.evaluateOnPage((x) => x * 2, [5]);
+        assert.strictEqual(result, 10);
+      });
+
+      it('should handle multiple arguments by spreading them', async () => {
+        page = createMockPlaywrightPage();
+        adapter = new PlaywrightAdapter(page);
+        // This is the bug case - multiple args should be spread, not passed as array
+        const result = await adapter.evaluateOnPage((a, b) => a + b, [3, 7]);
+        assert.strictEqual(result, 10);
+      });
+
+      it('should handle selector + array arguments (real-world bug case)', async () => {
+        page = createMockPlaywrightPage();
+        adapter = new PlaywrightAdapter(page);
+        // This reproduces the original bug: selector and processedIds
+        const result = await adapter.evaluateOnPage(
+          (selector, processedIds) =>
+            `Selector: ${selector}, Count: ${processedIds.length}`,
+          ['[data-qa="test"]', ['id1', 'id2']]
+        );
+        assert.ok(result.includes('Selector: [data-qa="test"]'));
+        assert.ok(result.includes('Count: 2'));
+      });
+
+      it('should handle multiple arguments of different types', async () => {
+        page = createMockPlaywrightPage();
+        adapter = new PlaywrightAdapter(page);
+        const result = await adapter.evaluateOnPage(
+          (str, num, obj) => `${str}-${num}-${obj.key}`,
+          ['hello', 42, { key: 'world' }]
+        );
+        assert.strictEqual(result, 'hello-42-world');
+      });
+    });
   });
 
   describe('PuppeteerAdapter', () => {
@@ -130,6 +177,42 @@ describe('engine-adapter', () => {
       const count = await adapter.count('button');
       assert.strictEqual(count, 5);
     });
+
+    describe('evaluateOnPage', () => {
+      it('should handle zero arguments', async () => {
+        page = createMockPuppeteerPage();
+        adapter = new PuppeteerAdapter(page);
+        const result = await adapter.evaluateOnPage(() => 42);
+        assert.strictEqual(result, 42);
+      });
+
+      it('should handle single argument', async () => {
+        page = createMockPuppeteerPage();
+        adapter = new PuppeteerAdapter(page);
+        const result = await adapter.evaluateOnPage((x) => x * 2, [5]);
+        assert.strictEqual(result, 10);
+      });
+
+      it('should handle multiple arguments by spreading them', async () => {
+        page = createMockPuppeteerPage();
+        adapter = new PuppeteerAdapter(page);
+        // Puppeteer natively spreads args - ensure same behavior as Playwright fix
+        const result = await adapter.evaluateOnPage((a, b) => a + b, [3, 7]);
+        assert.strictEqual(result, 10);
+      });
+
+      it('should handle selector + array arguments (parity with PlaywrightAdapter)', async () => {
+        page = createMockPuppeteerPage();
+        adapter = new PuppeteerAdapter(page);
+        const result = await adapter.evaluateOnPage(
+          (selector, processedIds) =>
+            `Selector: ${selector}, Count: ${processedIds.length}`,
+          ['[data-qa="test"]', ['id1', 'id2']]
+        );
+        assert.ok(result.includes('Selector: [data-qa="test"]'));
+        assert.ok(result.includes('Count: 2'));
+      });
+    });
   });
 
   describe('createEngineAdapter', () => {

package/.github/workflows/release.yml

@@ -1,296 +0,0 @@
-name: Checks and release
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    types: [opened, synchronize, reopened]
-  # Manual release support - consolidated here to work with npm trusted publishing
-  # npm only allows ONE workflow file as trusted publisher, so all publishing
-  # must go through this workflow (release.yml)
-  workflow_dispatch:
-    inputs:
-      release_mode:
-        description: 'Manual release mode'
-        required: true
-        type: choice
-        default: 'instant'
-        options:
-          - instant
-          - changeset-pr
-      bump_type:
-        description: 'Manual release type'
-        required: true
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-      description:
-        description: 'Manual release description (optional)'
-        required: false
-        type: string
-
-concurrency: ${{ github.workflow }}-${{ github.ref }}
-
-jobs:
-  # Changeset check - only runs on PRs
-  changeset-check:
-    name: Check for Changesets
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Check for changesets
-        env:
-          # Pass PR context to the validation script
-          GITHUB_BASE_REF: ${{ github.base_ref }}
-          GITHUB_BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          GITHUB_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-        run: |
-          # Skip changeset check for automated version PRs
-          if [[ "${{ github.head_ref }}" == "changeset-release/"* ]]; then
-            echo "Skipping changeset check for automated release PR"
-            exit 0
-          fi
-
-          # Run changeset validation script
-          # This validates that exactly ONE changeset was ADDED by this PR
-          # Pre-existing changesets from other merged PRs are ignored
-          node scripts/validate-changeset.mjs
-
-  # Linting and formatting - runs after changeset check on PRs, immediately on main
-  lint:
-    name: Lint and Format Check
-    runs-on: ubuntu-latest
-    needs: [changeset-check]
-    if: always() && (github.event_name == 'push' || needs.changeset-check.result == 'success')
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Run ESLint
-        run: npm run lint
-
-      - name: Check formatting
-        run: npm run format:check
-
-      - name: Check code duplication
-        run: npm run check:duplication
-
-  # Test job - runs on Node.js only (browser automation requires specific setup)
-  test:
-    name: Test (Node.js on ${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    needs: [changeset-check]
-    if: always() && (github.event_name == 'push' || needs.changeset-check.result == 'success')
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Run unit tests
-        run: npm test
-
-  # Release - only runs on main after tests pass (for push events)
-  release:
-    name: Release
-    needs: [lint, test]
-    # Use always() to ensure this job runs even if changeset-check was skipped
-    # This is needed because lint/test jobs have a transitive dependency on changeset-check
-    if: always() && github.ref == 'refs/heads/main' && github.event_name == 'push' && needs.lint.result == 'success' && needs.test.result == 'success'
-    runs-on: ubuntu-latest
-    # Permissions required for npm OIDC trusted publishing
-    permissions:
-      contents: write
-      pull-requests: write
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Update npm for OIDC trusted publishing
-        run: node scripts/setup-npm.mjs
-
-      - name: Check for changesets
-        id: check_changesets
-        run: |
-          # Count changeset files (excluding README.md and config.json)
-          CHANGESET_COUNT=$(find .changeset -name "*.md" ! -name "README.md" | wc -l)
-          echo "Found $CHANGESET_COUNT changeset file(s)"
-          echo "has_changesets=$([[ $CHANGESET_COUNT -gt 0 ]] && echo 'true' || echo 'false')" >> $GITHUB_OUTPUT
-          echo "changeset_count=$CHANGESET_COUNT" >> $GITHUB_OUTPUT
-
-      - name: Merge multiple changesets
-        if: steps.check_changesets.outputs.has_changesets == 'true' && steps.check_changesets.outputs.changeset_count > 1
-        run: |
-          echo "Multiple changesets detected, merging..."
-          node scripts/merge-changesets.mjs
-
-      - name: Version packages and commit to main
-        if: steps.check_changesets.outputs.has_changesets == 'true'
-        id: version
-        run: node scripts/version-and-commit.mjs --mode changeset
-
-      - name: Publish to npm
-        # Run if version was committed OR if a previous attempt already committed (for re-runs)
-        if: steps.version.outputs.version_committed == 'true' || steps.version.outputs.already_released == 'true'
-        id: publish
-        run: node scripts/publish-to-npm.mjs --should-pull
-
-      - name: Create GitHub Release
-        if: steps.publish.outputs.published == 'true'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: node scripts/create-github-release.mjs --release-version "${{ steps.publish.outputs.published_version }}" --repository "${{ github.repository }}"
-
-      - name: Format GitHub release notes
-        if: steps.publish.outputs.published == 'true'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: node scripts/format-github-release.mjs --release-version "${{ steps.publish.outputs.published_version }}" --repository "${{ github.repository }}" --commit-sha "${{ github.sha }}"
-
-  # Manual Instant Release - triggered via workflow_dispatch with instant mode
-  # This job is in release.yml because npm trusted publishing
-  # only allows one workflow file to be registered as a trusted publisher
-  instant-release:
-    name: Instant Release
-    if: github.event_name == 'workflow_dispatch' && github.event.inputs.release_mode == 'instant'
-    runs-on: ubuntu-latest
-    # Permissions required for npm OIDC trusted publishing
-    permissions:
-      contents: write
-      pull-requests: write
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Update npm for OIDC trusted publishing
-        run: node scripts/setup-npm.mjs
-
-      - name: Version packages and commit to main
-        id: version
-        run: node scripts/version-and-commit.mjs --mode instant --bump-type "${{ github.event.inputs.bump_type }}" --description "${{ github.event.inputs.description }}"
-
-      - name: Publish to npm
-        # Run if version was committed OR if a previous attempt already committed (for re-runs)
-        if: steps.version.outputs.version_committed == 'true' || steps.version.outputs.already_released == 'true'
-        id: publish
-        run: node scripts/publish-to-npm.mjs
-
-      - name: Create GitHub Release
-        if: steps.publish.outputs.published == 'true'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: node scripts/create-github-release.mjs --release-version "${{ steps.publish.outputs.published_version }}" --repository "${{ github.repository }}"
-
-      - name: Format GitHub release notes
-        if: steps.publish.outputs.published == 'true'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: node scripts/format-github-release.mjs --release-version "${{ steps.publish.outputs.published_version }}" --repository "${{ github.repository }}" --commit-sha "${{ github.sha }}"
-
-  # Manual Changeset PR - creates a pull request with the changeset for review
-  changeset-pr:
-    name: Create Changeset PR
-    if: github.event_name == 'workflow_dispatch' && github.event.inputs.release_mode == 'changeset-pr'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '20.x'
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Create changeset file
-        run: node scripts/create-manual-changeset.mjs --bump-type "${{ github.event.inputs.bump_type }}" --description "${{ github.event.inputs.description }}"
-
-      - name: Format changeset with Prettier
-        run: |
-          # Run Prettier on the changeset file to ensure it matches project style
-          npx prettier --write ".changeset/*.md" || true
-
-          echo "Formatted changeset files"
-
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v7
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          commit-message: 'chore: add changeset for manual ${{ github.event.inputs.bump_type }} release'
-          branch: changeset-manual-release-${{ github.run_id }}
-          delete-branch: true
-          title: 'chore: manual ${{ github.event.inputs.bump_type }} release'
-          body: |
-            ## Manual Release Request
-
-            This PR was created by a manual workflow trigger to prepare a **${{ github.event.inputs.bump_type }}** release.
-
-            ### Release Details
-            - **Type:** ${{ github.event.inputs.bump_type }}
-            - **Description:** ${{ github.event.inputs.description || 'Manual release' }}
-            - **Triggered by:** @${{ github.actor }}
-
-            ### Next Steps
-            1. Review the changeset in this PR
-            2. Merge this PR to main
-            3. The automated release workflow will create a version PR
-            4. Merge the version PR to publish to npm and create a GitHub release

package/LICENSE

@@ -1,24 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
-
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <https://unlicense.org>

package/README.md

@@ -1,320 +0,0 @@
-# Browser Commander
-
-A universal browser automation library that supports both Playwright and Puppeteer with a unified API. The key focus is on **stoppable page triggers** - ensuring automation logic is properly mounted/unmounted during page navigation.
-
-## Installation
-
-```bash
-npm install browser-commander
-```
-
-You'll also need either Playwright or Puppeteer:
-
-```bash
-# With Playwright
-npm install playwright
-
-# Or with Puppeteer
-npm install puppeteer
-```
-
-## Core Concept: Page State Machine
-
-Browser Commander manages the browser as a state machine with two states:
-
-```
-+------------------+                      +------------------+
-|                  |   navigation start   |                  |
-|  WORKING STATE   | -------------------> |  LOADING STATE   |
-|  (action runs)   |                      |  (wait only)     |
-|                  |   <-----------------  |                  |
-+------------------+     page ready       +------------------+
-```
-
-**LOADING STATE**: Page is loading. Only waiting/tracking operations are allowed. No automation logic runs.
-
-**WORKING STATE**: Page is fully loaded (30 seconds of network idle). Page triggers can safely interact with DOM.
-
-## Quick Start
-
-```javascript
-import {
-  launchBrowser,
-  makeBrowserCommander,
-  makeUrlCondition,
-} from 'browser-commander';
-
-// 1. Launch browser
-const { browser, page } = await launchBrowser({ engine: 'playwright' });
-
-// 2. Create commander
-const commander = makeBrowserCommander({ page, verbose: true });
-
-// 3. Register page trigger with condition and action
-commander.pageTrigger({
-  name: 'example-trigger',
-  condition: makeUrlCondition('*example.com*'), // matches URLs containing 'example.com'
-  action: async (ctx) => {
-    // ctx.commander has all methods, but they throw ActionStoppedError if navigation happens
-    // ctx.checkStopped() - call in loops to check if should stop
-    // ctx.abortSignal - use with fetch() for cancellation
-    // ctx.onCleanup(fn) - register cleanup when action stops
-
-    console.log(`Processing: ${ctx.url}`);
-
-    // Safe iteration - stops if navigation detected
-    await ctx.forEach(['item1', 'item2'], async (item) => {
-      await ctx.commander.clickButton({ selector: `[data-id="${item}"]` });
-    });
-  },
-});
-
-// 4. Navigate - action auto-starts when page is ready
-await commander.goto({ url: 'https://example.com' });
-
-// 5. Cleanup
-await commander.destroy();
-await browser.close();
-```
-
-## URL Condition Helpers
-
-The `makeUrlCondition` helper makes it easy to create URL matching conditions:
-
-```javascript
-import {
-  makeUrlCondition,
-  allConditions,
-  anyCondition,
-  notCondition,
-} from 'browser-commander';
-
-// Exact URL match
-makeUrlCondition('https://example.com/page');
-
-// Contains substring (use * wildcards)
-makeUrlCondition('*checkout*'); // URL contains 'checkout'
-makeUrlCondition('*example.com*'); // URL contains 'example.com'
-
-// Starts with / ends with
-makeUrlCondition('/api/*'); // starts with '/api/'
-makeUrlCondition('*.json'); // ends with '.json'
-
-// Express-style route patterns
-makeUrlCondition('/vacancy/:id'); // matches /vacancy/123
-makeUrlCondition('https://hh.ru/vacancy/:vacancyId'); // matches specific domain + path
-makeUrlCondition('/user/:userId/profile'); // multiple segments
-
-// RegExp
-makeUrlCondition(/\/product\/\d+/);
-
-// Custom function (receives full context)
-makeUrlCondition((url, ctx) => {
-  const parsed = new URL(url);
-  return (
-    parsed.pathname.startsWith('/admin') && parsed.searchParams.has('edit')
-  );
-});
-
-// Combine conditions
-allConditions(
-  makeUrlCondition('*example.com*'),
-  makeUrlCondition('*/checkout*')
-); // Both must match
-
-anyCondition(makeUrlCondition('*/cart*'), makeUrlCondition('*/checkout*')); // Either matches
-
-notCondition(makeUrlCondition('*/admin*')); // Negation
-```
-
-## Page Trigger Lifecycle
-
-### The Guarantee
-
-When navigation is detected:
-
-1. **Action is signaled to stop** (AbortController.abort())
-2. **Wait for action to finish** (up to 10 seconds for graceful cleanup)
-3. **Only then start waiting for page load**
-
-This ensures:
-
-- No DOM operations on stale/loading pages
-- Actions can do proper cleanup (clear intervals, save state)
-- No race conditions between action and navigation
-
-## Action Context API
-
-When your action is called, it receives a context object with these properties:
-
-```javascript
-commander.pageTrigger({
-  name: 'my-trigger',
-  condition: makeUrlCondition('*/checkout*'),
-  action: async (ctx) => {
-    // Current URL
-    ctx.url; // 'https://example.com/checkout'
-
-    // Trigger name (for debugging)
-    ctx.triggerName; // 'my-trigger'
-
-    // Check if action should stop
-    ctx.isStopped(); // Returns true if navigation detected
-
-    // Throw ActionStoppedError if stopped (use in manual loops)
-    ctx.checkStopped();
-
-    // AbortSignal - use with fetch() or other cancellable APIs
-    ctx.abortSignal;
-
-    // Safe wait (throws if stopped during wait)
-    await ctx.wait(1000);
-
-    // Safe iteration (checks stopped between items)
-    await ctx.forEach(items, async (item) => {
-      await ctx.commander.clickButton({ selector: item.selector });
-    });
-
-    // Register cleanup (runs when action stops)
-    ctx.onCleanup(() => {
-      console.log('Cleaning up...');
-    });
-
-    // Commander with all methods wrapped to throw on stop
-    await ctx.commander.fillTextArea({ selector: 'input', text: 'hello' });
-
-    // Raw commander (use carefully - does not auto-throw)
-    ctx.rawCommander;
-  },
-});
-```
-
-## API Reference
-
-### makeBrowserCommander(options)
-
-```javascript
-const commander = makeBrowserCommander({
-  page, // Required: Playwright/Puppeteer page
-  verbose: false, // Enable debug logging
-  enableNetworkTracking: true, // Track HTTP requests
-  enableNavigationManager: true, // Enable navigation events
-});
-```
-
-### commander.pageTrigger(config)
-
-```javascript
-const unregister = commander.pageTrigger({
-  name: 'trigger-name',                    // For debugging
-  condition: (ctx) => boolean,             // When to run (receives {url, commander})
-  action: async (ctx) => void,             // What to do
-  priority: 0,                             // Higher runs first
-});
-```
-
-### commander.goto(options)
-
-```javascript
-await commander.goto({
-  url: 'https://example.com',
-  waitUntil: 'domcontentloaded', // Playwright/Puppeteer option
-  timeout: 60000,
-});
-```
-
-### commander.clickButton(options)
-
-```javascript
-await commander.clickButton({
-  selector: 'button.submit',
-  scrollIntoView: true,
-  waitForNavigation: true,
-});
-```
-
-### commander.fillTextArea(options)
-
-```javascript
-await commander.fillTextArea({
-  selector: 'textarea.message',
-  text: 'Hello world',
-  checkEmpty: true,
-});
-```
-
-### commander.destroy()
-
-```javascript
-await commander.destroy(); // Stop actions, cleanup
-```
-
-## Best Practices
-
-### 1. Use ctx.forEach for Loops
-
-```javascript
-// BAD: Won't stop on navigation
-for (const item of items) {
-  await ctx.commander.click({ selector: item });
-}
-
-// GOOD: Stops immediately on navigation
-await ctx.forEach(items, async (item) => {
-  await ctx.commander.click({ selector: item });
-});
-```
-
-### 2. Use ctx.checkStopped for Complex Logic
-
-```javascript
-action: async (ctx) => {
-  while (hasMorePages) {
-    ctx.checkStopped(); // Throws if navigation detected
-
-    await processPage(ctx);
-    hasMorePages = await ctx.commander.isVisible({ selector: '.next' });
-  }
-};
-```
-
-### 3. Register Cleanup for Resources
-
-```javascript
-action: async (ctx) => {
-  const intervalId = setInterval(updateStatus, 1000);
-
-  ctx.onCleanup(() => {
-    clearInterval(intervalId);
-    console.log('Interval cleared');
-  });
-
-  // ... rest of action
-};
-```
-
-### 4. Use ctx.abortSignal with Fetch
-
-```javascript
-action: async (ctx) => {
-  const response = await fetch(url, {
-    signal: ctx.abortSignal, // Cancels on navigation
-  });
-};
-```
-
-## Debugging
-
-Enable verbose mode for detailed logs:
-
-```javascript
-const commander = makeBrowserCommander({ page, verbose: true });
-```
-
-## Architecture
-
-See [src/ARCHITECTURE.md](src/ARCHITECTURE.md) for detailed architecture documentation.
-
-## License
-
-[UNLICENSE](LICENSE)