agent-browser-priv 0.28.0-priv.1 → 0.28.0-priv.2

package/README.md

@@ -74,6 +74,12 @@ agent-browser upgrade
 
 Detects your installation method (npm, Homebrew, or Cargo) and runs the appropriate update command automatically.
 
+`agent-browser doctor` reports the installed Patchright backend version, the
+Patchright version pinned by the current `agent-browser` release, and npm latest
+when network checks are enabled. Patchright updates are release-controlled:
+after upgrading `agent-browser`, run `agent-browser install` to refresh the
+backend to the version pinned by that release.
+
 ### Requirements
 
 - **Patchright backend** - Run `agent-browser install` to install pinned Patchright and its browser artifacts for the default local backend. Requires Node.js and npm for install and runtime launch.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-browser-priv",
-  "version": "0.28.0-priv.1",
+  "version": "0.28.0-priv.2",
   "description": "Browser automation CLI for AI agents",
   "type": "module",
   "packageManager": "pnpm@11.1.3",
@@ -29,7 +29,9 @@
     "build:docker": "docker build --platform linux/amd64 -t agent-browser-builder -f docker/Dockerfile.build .",
     "release": "pnpm run version:sync && pnpm run build:all-platforms",
     "postinstall": "node scripts/postinstall.js",
-    "build:dashboard": "cd packages/dashboard && pnpm build"
+    "build:dashboard": "cd packages/dashboard && pnpm build",
+    "runtime:update-check": "node scripts/check-runtime-updates.mjs",
+    "runtime:update-patchright": "node scripts/update-patchright-version.mjs"
   },
   "keywords": [
     "browser",

package/scripts/check-runtime-updates.mjs

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const rootDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+const installRsPath = join(rootDir, 'cli/src/install.rs');
+const trackingPath = join(rootDir, 'priv/version-tracking.json');
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function readPatchrightPin() {
+  const source = readFileSync(installRsPath, 'utf8');
+  const match = source.match(/pub const PATCHRIGHT_VERSION:\s*&str\s*=\s*"([^"]+)"/);
+  if (!match) {
+    throw new Error('Could not find PATCHRIGHT_VERSION in cli/src/install.rs');
+  }
+  return match[1];
+}
+
+function npmLatest(packageName) {
+  return execFileSync('npm', ['view', packageName, 'version'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+    timeout: 20_000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function upstreamTags() {
+  const output = execFileSync(
+    'git',
+    [
+      'ls-remote',
+      '--tags',
+      '--refs',
+      'https://github.com/vercel-labs/agent-browser.git',
+      'refs/tags/v*',
+    ],
+    {
+      cwd: rootDir,
+      encoding: 'utf8',
+      timeout: 20_000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  );
+  return output
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => line.split(/\s+/)[1]?.replace('refs/tags/', ''))
+    .filter(Boolean)
+    .filter((tag) => /^v\d+\.\d+\.\d+/.test(tag));
+}
+
+function parseVersion(version) {
+  const cleaned = version.replace(/^v/, '').split('-')[0];
+  const parts = cleaned.split('.').map((part) => Number.parseInt(part, 10));
+  return [parts[0] || 0, parts[1] || 0, parts[2] || 0];
+}
+
+function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  for (let i = 0; i < 3; i += 1) {
+    if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  }
+  return a.localeCompare(b);
+}
+
+function latestTag(tags) {
+  if (tags.length === 0) return null;
+  return [...tags].sort(compareVersions).at(-1);
+}
+
+function buildReport() {
+  const tracking = readJson(trackingPath);
+  const patchrightPinned = readPatchrightPin();
+  const patchrightLatest = npmLatest('patchright');
+  const latestUpstreamTag = latestTag(upstreamTags());
+
+  return {
+    patchright: {
+      pinned: patchrightPinned,
+      latest: patchrightLatest,
+      outdated: patchrightPinned !== patchrightLatest,
+      tracking_matches_source: tracking.patchright_pin === patchrightPinned,
+    },
+    agent_browser: {
+      tracked_upstream_tag: tracking.agent_browser_upstream_tag,
+      latest_upstream_tag: latestUpstreamTag,
+      outdated: Boolean(
+        latestUpstreamTag &&
+          compareVersions(latestUpstreamTag, tracking.agent_browser_upstream_tag) > 0,
+      ),
+    },
+    tracking: {
+      path: 'priv/version-tracking.json',
+      policy: tracking.policy,
+    },
+  };
+}
+
+function printHuman(report) {
+  console.log('Runtime update check');
+  console.log('');
+  console.log(
+    `Patchright: pinned ${report.patchright.pinned}, npm latest ${report.patchright.latest}`,
+  );
+  console.log(
+    `  status: ${report.patchright.outdated ? 'outdated' : 'current'}`,
+  );
+  console.log(
+    `  tracking: ${report.patchright.tracking_matches_source ? 'matches source' : 'does not match source'}`,
+  );
+  console.log('');
+  console.log(
+    `agent-browser upstream: tracked ${report.agent_browser.tracked_upstream_tag}, latest ${report.agent_browser.latest_upstream_tag ?? 'unknown'}`,
+  );
+  console.log(
+    `  status: ${report.agent_browser.outdated ? 'sync available' : 'current'}`,
+  );
+}
+
+const report = buildReport();
+
+if (process.argv.includes('--json')) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  printHuman(report);
+}
+
+if (!report.patchright.tracking_matches_source) {
+  process.exitCode = 1;
+}

package/scripts/update-patchright-version.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const rootDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+const installRsPath = join(rootDir, 'cli/src/install.rs');
+const trackingPath = join(rootDir, 'priv/version-tracking.json');
+
+function usage() {
+  console.error('Usage: node scripts/update-patchright-version.mjs <version|latest>');
+}
+
+function npmLatest() {
+  return execFileSync('npm', ['view', 'patchright', 'version'], {
+    cwd: rootDir,
+    encoding: 'utf8',
+    timeout: 20_000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+}
+
+function validateVersion(version) {
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
+    throw new Error(`Invalid Patchright version: ${version}`);
+  }
+}
+
+function buildPackageFiles(version) {
+  const packageJson = {
+    name: 'patchright',
+    private: true,
+    type: 'module',
+    dependencies: {
+      patchright: version,
+    },
+  };
+
+  const dir = mkdtempSync(join(tmpdir(), 'agent-browser-patchright-'));
+  try {
+    writeFileSync(join(dir, 'package.json'), `${JSON.stringify(packageJson, null, 2)}\n`);
+    execFileSync(
+      'npm',
+      [
+        'install',
+        '--package-lock-only',
+        '--ignore-scripts',
+        '--omit=dev',
+        '--no-audit',
+        '--fund=false',
+      ],
+      {
+        cwd: dir,
+        stdio: 'inherit',
+        timeout: 60_000,
+      },
+    );
+    const packageLock = JSON.parse(readFileSync(join(dir, 'package-lock.json'), 'utf8'));
+    if (packageLock.packages?.['']) {
+      delete packageLock.packages[''].name;
+    }
+    return {
+      packageJson: `${JSON.stringify(packageJson, null, 2)}\n`,
+      packageLock: `${JSON.stringify(packageLock, null, 2)}\n`,
+    };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function replaceRawString(source, name, value) {
+  const pattern = new RegExp(`let ${name} = r#"(.*?)"#;`, 's');
+  if (!pattern.test(source)) {
+    throw new Error(`Could not find raw string ${name} in cli/src/install.rs`);
+  }
+  return source.replace(pattern, `let ${name} = r#"${value}"#;`);
+}
+
+function updateInstallRs(version, packageJson, packageLock) {
+  let source = readFileSync(installRsPath, 'utf8');
+  source = source.replace(
+    /pub const PATCHRIGHT_VERSION:\s*&str\s*=\s*"[^"]+";/,
+    `pub const PATCHRIGHT_VERSION: &str = "${version}";`,
+  );
+  source = replaceRawString(source, 'package_json', packageJson);
+  source = replaceRawString(source, 'package_lock', packageLock);
+  writeFileSync(installRsPath, source);
+}
+
+function updateTracking(version) {
+  const tracking = JSON.parse(readFileSync(trackingPath, 'utf8'));
+  tracking.patchright_pin = version;
+  writeFileSync(trackingPath, `${JSON.stringify(tracking, null, 2)}\n`);
+}
+
+const requested = process.argv[2];
+if (!requested) {
+  usage();
+  process.exit(1);
+}
+
+const version = requested === 'latest' ? npmLatest() : requested;
+validateVersion(version);
+
+const { packageJson, packageLock } = buildPackageFiles(version);
+updateInstallRs(version, packageJson, packageLock);
+updateTracking(version);
+
+console.log(`Updated Patchright backend pin to ${version}`);

package/skill-data/core/SKILL.md

@@ -402,6 +402,8 @@ agent-browser doctor --json              # structured output for programmatic co
 ```
 
 `doctor` auto-cleans stale socket/pid/version sidecar files on every run.
+For the default Patchright backend, it also reports the installed Patchright
+version, the release pin, and npm latest when network checks are enabled.
 Destructive actions require `--fix`. Exit code is `0` if all checks pass
 (warnings OK), `1` if any fail.