browser4-cli 0.1.6 → 0.1.8

package/README.md

@@ -1,4 +1,4 @@
-# Browser4 CLI
+# Browser4
 
 Make websites accessible for AI agents. Automate tasks online with ease.
 
@@ -53,16 +53,6 @@ pnpm link --global  # Makes browser4-cli available globally
 - **Java 17+** - Required to run the Browser4 backend (`Browser4.jar`).
 - **Rust** - Only needed when building from source (see From Source above).
 
-
-
-
-
-
-
-
-
-
-
 ## Usage
 
 ```
@@ -143,7 +133,6 @@ The tables below mirror the commands surfaced by the global `browser4-cli help`
 | Command | Description |
 |---|---|
 | `screenshot [ref]` | Take a screenshot |
-| `pdf` | Save page as PDF |
 
 #### Tabs
 
@@ -156,6 +145,28 @@ The tables below mirror the commands surfaced by the global `browser4-cli help`
 
 Use `tab-list` first to find the zero-based tab index you want to select or close.
 
+#### Browser storage
+
+| Command | Description |
+|---|---|
+| `state-save <path>` | Save cookies and localStorage to a JSON file |
+| `state-load <path>` | Restore cookies and localStorage from a saved state file |
+| `cookie-list` | List all cookies (optionally filtered by `--domain` / `--path`) |
+| `cookie-get <name>` | Get a cookie by name |
+| `cookie-set <name> <value>` | Set a cookie (optional `--path`, `--domain`) |
+| `cookie-delete <name>` | Delete a cookie by name |
+| `cookie-clear` | Clear all cookies for the current page |
+| `localstorage-list` | List all localStorage entries |
+| `localstorage-get <key>` | Get a localStorage value by key |
+| `localstorage-set <key> <value>` | Set a localStorage key-value pair |
+| `localstorage-delete <key>` | Delete a localStorage key |
+| `localstorage-clear` | Clear all localStorage entries |
+| `sessionstorage-list` | List all sessionStorage entries |
+| `sessionstorage-get <key>` | Get a sessionStorage value by key |
+| `sessionstorage-set <key> <value>` | Set a sessionStorage key-value pair |
+| `sessionstorage-delete <key>` | Delete a sessionStorage key |
+| `sessionstorage-clear` | Clear all sessionStorage entries |
+
 #### Browser sessions
 
 | Command | Description |
@@ -166,6 +177,17 @@ Use `tab-list` first to find the zero-based tab index you want to select or clos
 
 Use `close-all` for session cleanup when you want to keep the current Browser4 service running. Use `kill-all` only when you explicitly want to stop the backend and clean up tracked Browser4 processes.
 
+#### Server management
+
+| Command | Description |
+|---|---|
+| `install` | Download the self-contained Browser4 runtime bundle (JAR + bundled JRE) from GitHub Releases |
+| `upgrade` | Upgrade `browser4-cli` itself to the latest release (requires `cargo`) |
+| `stop` | Kill the Browser4 backend after closing all sessions |
+| `status` | Check whether the Browser4 backend is reachable and healthy |
+
+When a local Browser4 checkout is detected with the `browser4-bundle` module present,
+`install` auto-builds the runtime bundle from source instead of downloading.
 
 ### Advanced commands
 
@@ -174,18 +196,186 @@ Query `browser4-cli help <command>` for the exact syntax when you need them.
 
 | Command | Description |
 |---|---|
-| `batch [command...]` | Execute multiple commands in one invocation. Only DOM operations are supported (Core, Navigation, Keyboard, Mouse, Export, Tabs categories). Commands like `open`, `close`, `list`, `agent-run`, etc. are not allowed in batch mode. |
+| `batch [command...]` | Execute multiple commands in one invocation. Only DOM operations are supported (Core, Navigation, Keyboard, Mouse, Export, Tabs categories). Commands like `open`, `close`, `list`, `agent run`, etc. are not allowed in batch mode. |
 | `console [min-level]` | List console messages |
 | `extract <instruction>` | Extract structured data from the current page |
 | `summarize [instruction]` | Summarize page content using AI |
-| `agent-run <task>` | Run an autonomous agent task |
-| `agent-status <id>` | Check the status of a running agent task |
-| `agent-result <id>` | Get the result of a completed agent task |
-| `co-create` | Create a collective session with parallel browser contexts |
-| `co-submit [url]` | Submit URL(s) or tasks to the active collective session |
-| `co-scrape <url>` | Scrape data from a URL using CSS selectors |
-| `co-status <id>` | Check the status of a collective task |
-| `co-result <id>` | Get the result of a completed collective task |
+| `agent run <task>` | Run an autonomous agent task |
+| `agent status <id>` | Check the status of a running agent task |
+| `agent result <id>` | Get the result of a completed agent task |
+| `swarm create` | Create a swarm scrape session with parallel browser contexts |
+| `swarm submit [url]` | Submit URL(s) or X-SQL payloads as scrape jobs |
+| `swarm status <id>` | Check the status of a scrape job |
+| `swarm result <id>` | Get the result of a completed scrape job |
+
+## Agent task workflow (`agent <subcommand>`)
+
+The `agent-*` commands wrap the backend command agent's asynchronous task API.
+They are useful when you want Browser4 to plan and execute a natural-language
+task in the background instead of issuing one low-level browser action at a
+time.
+
+Like other advanced commands, they are intentionally omitted from the global
+`browser4-cli help` overview. Query `browser4-cli help agent run` (or
+`agent status` / `agent result`) when you need the exact syntax.
+
+Use the spaced `agent <subcommand>` form:
+
+```shell
+browser4-cli agent run "Open example.com and summarize the hero section"
+browser4-cli agent status agent-task-1
+browser4-cli agent result agent-task-1
+```
+
+### Command lifecycle
+
+| Step | Command | What it does |
+|---|---|---|
+| 1 | `agent run <task>` | Submits an asynchronous natural-language task through `command_run` and prints the returned task ID |
+| 2 | `agent status <id>` | Fetches the latest task status payload through `command_status` |
+| 3 | `agent result <id>` | Fetches the completed task result payload through `command_result` |
+
+### Notes
+
+- `agent run` is asynchronous: it returns immediately after the backend accepts
+  the task and prints a follow-up `agent status` command with the generated task
+  ID.
+- `agent status` prints the backend status payload as-is. In practice this is a
+  JSON object that commonly includes fields such as `id`, `status`,
+  `statusCode`, `processState`, `message`, `agentState`, `agentHistory`, and
+  `commandResult`.
+- `agent result` prints the backend result payload as-is. Depending on the task,
+  it may be plain text or structured JSON.
+- These commands are task-ID based and do not require an active CLI browser
+  session slot. The global `-s=<name>` option is therefore usually not relevant
+  for `agent-*` follow-up calls.
+- `agent` subcommands are not supported inside `batch` mode.
+- `agent run` performs a short post-submit status probe so obvious missing-LLM
+  configuration failures can be surfaced immediately instead of leaving you with
+  a task ID that will never succeed.
+
+### Use cases
+
+#### 1. Submit an autonomous agent task
+
+```shell
+browser4-cli agent run "Open example.com and summarize the hero section"
+```
+
+Typical output:
+
+```text
+Task submitted: agent-task-1
+Use 'browser4-cli agent status agent-task-1' to check progress.
+```
+
+#### 2. Poll task progress
+
+```shell
+browser4-cli agent status agent-task-1
+```
+
+Example status payload:
+
+```json
+{"id":"agent-task-1","status":"RUNNING"}
+```
+
+On a real Browser4 backend the payload can be richer and may include lifecycle
+details such as `processState`, agent history snapshots, or an embedded partial
+`commandResult`.
+
+#### 3. Read the final result
+
+```shell
+browser4-cli agent result agent-task-1
+```
+
+If the backend returns a structured `CommandResult`, expect fields such as
+`summary`, `pageSummary`, `fields`, `links`, or `xsqlResultSet`.
+
+## Swarm scrape workflow (`swarm <subcommand>`)
+
+The `swarm` subcommands support a swarm scrape workflow where one CLI session
+coordinates multiple browser contexts in the Browser4 backend.
+
+Use the spaced `swarm <subcommand>` form:
+
+```shell
+browser4-cli swarm create
+browser4-cli swarm submit https://example.com
+```
+
+### Command lifecycle
+
+| Step | Command | What it does |
+|---|---|---|
+| 1 | `swarm create` | Opens a swarm scrape session and persists the returned session ID in the current CLI slot |
+| 2 | `swarm submit [url]` | Submits one direct URL plus any URLs from `--seed-file` as scrape jobs through `ScrapeController.submit(payload)` |
+| 3 | `swarm status <id>` | Calls `ScrapeController.getStatus(id)` and prints the returned scrape job status JSON |
+| 4 | `swarm result <id>` | Calls `ScrapeController.getResult(id)` and prints the returned scrape job result JSON |
+
+### Notes
+
+- `swarm create` accepts backend capability hints such as `--profile-mode`,
+  `--max-open-tabs`, `--max-browser-contexts`, and `--display-mode`.
+- `swarm submit` accepts either a direct positional URL, `--seed-file`, or both.
+  Seed files are plain text files with one URL per line; blank lines and lines
+  starting with `#` are ignored.
+- `swarm submit` maps CLI flags like `--deadline`, `--expires`, `--refresh`,
+  `--parse`, and `--store-content` into the raw submission payload sent to the
+  scrape REST API.
+- `swarm status` and `swarm result` are read-only follow-up commands; keep the job ID
+  printed by `swarm submit`.
+
+### Use cases
+
+#### 1. Create a supervised swarm scrape session for manual monitoring
+
+```shell
+browser4-cli swarm create \
+  --profile-mode=TEMPORARY \
+  --max-open-tabs=12 \
+  --max-browser-contexts=3 \
+  --display-mode=HEADLESS
+```
+
+Use this when you want multiple isolated browser contexts and you still want to
+watch the run visually.
+
+#### 2. Submit a seed crawl as scrape jobs
+
+```shell
+browser4-cli swarm submit https://example.com/direct \
+  --seed-file=./swarm-seeds.txt \
+  --deadline=2026-03-30T00:00:00Z \
+  --expires=1d \
+  --refresh \
+  --parse \
+  --store-content
+```
+
+Example `swarm-seeds.txt`:
+
+```text
+# campaign landing pages
+https://example.com/seed-1
+https://example.com/seed-2
+```
+
+This pattern is useful for warming caches, refreshing a URL list, or launching
+parallel collection across a curated seed set.
+
+#### 3. Poll and fetch the result
+
+```shell
+browser4-cli swarm status scrape-task-4
+browser4-cli swarm result scrape-task-4
+```
+
+The status and result commands print the scrape job response payload as-is. In
+the current backend, `getResult(id)` returns the same response envelope type as
+`getStatus(id)`.
 
 ## Element References
 
@@ -228,16 +418,16 @@ gate for commands that require an active Browser4 session.
 | `open -s=<name>` | Reads/writes the named session state file | Opens, reuses, or refreshes the named session for that slot; subsequent `-s=<name>` commands use the same slot |
 | Command succeeds through `with_session()` | `sessionId` stays unchanged | The command uses the persisted session normally |
 | Command fails because the server reports a stale / expired session and `recover_stale = false` | `invalidate_session()` clears `sessionId`, `activeSelector`, and `lastMousePosition`, while keeping `baseUrl` | The command fails with `Saved session expired. Run "browser4-cli open" first.` |
-| `goto` is invoked but the saved session is missing or no longer `active` in the backend | `invalidate_session()` clears the saved `sessionId`, `activeSelector`, and `lastMousePosition` | The command fails with `No active session for "goto". Run "browser4-cli open" to create or refresh the session first.` |
+| `goto` is invoked but the saved session is missing or no longer `active` in the backend | `invalidate_session()` clears any stale saved `sessionId`, then `create_session()` writes a fresh session before navigation continues | `goto` automatically refreshes the session and proceeds to the requested URL |
 | `close` with an active session | `clear_state()` removes only the current session state file after best-effort remote close | The selected default or named session is fully cleared |
 | `close` with no persisted `sessionId` | `clear_state()` best-effort removes the current session slot | Prints `No active session. Run "browser4-cli open" first.` and exits successfully as a no-op |
 | `close-all` / `kill-all` | `clear_all_state()` removes the default state file and all named session files | All persisted CLI session files are cleared |
 
 Notes:
 
-- `goto` reuses only the current backend-`active` session. It does not create a
-  new session automatically; run `browser4-cli open` first if the saved session
-  is missing or stale.
+- `goto` first tries to reuse the current backend-`active` session. If the saved
+  session is missing, stale, or the backend had been stopped, it automatically
+  opens a fresh session for the current slot before navigating.
 - `open` first checks whether the saved session for the current slot is still
   backend-`active`. It reuses active sessions and refreshes stale ones by
   creating a new session for the same slot.
@@ -365,6 +555,41 @@ cargo test --test e2e -- --nocapture
 cargo test --test e2e -- --nocapture --scenario=test_e2e_batch_form_submission
 ```
 
+## Publishing the CLI package
+
+For maintainers, the CLI package now uses an npm version guard before publish.
+
+The GitHub release workflow publishes the npm package via npm trusted publishing
+(GitHub Actions OIDC) instead of `NODE_AUTH_TOKEN`. This avoids CI failures caused
+by npm one-time-password challenges (`EOTP`).
+
+- Local release entrypoint: `npm run release`
+- Direct guarded publish entrypoint: `npm run publish:if-needed`
+- GitHub release workflow: re-checks npm immediately before the publish step
+
+If the local version in `cli/package.json` already matches the version currently
+published on npm, the publish step is skipped automatically.
+
+Examples:
+
+```bash
+# Check whether npm publish is needed
+node scripts/check-npm-publish-needed.js --json
+
+# Publish only when the local version differs from npm
+npm run publish:if-needed
+
+# Standard maintainer release command (also guarded)
+npm run release
+```
+
+For local testing, you can override the detected remote version:
+
+```bash
+BROWSER4_CLI_NPM_REMOTE_VERSION=0.1.7 node scripts/check-npm-publish-needed.js --json
+BROWSER4_CLI_NPM_REMOTE_VERSION=0.1.7 node scripts/publish-if-needed.js --dry-run
+```
+
 ## License
 
 Apache-2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser4-cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Browser automation CLI for AI agents",
   "type": "module",
   "files": [
@@ -15,14 +15,15 @@
   },
   "scripts": {
     "version:sync": "node scripts/sync-version.js",
-    "version": "npm run version:sync && git add browser4-cli/Cargo.toml",
+    "version": "npm run version:sync && git add browser4-cli/Cargo.toml browser4-cli/Cargo.lock",
     "build:native": "npm run version:sync && cargo build --release --manifest-path browser4-cli/Cargo.toml && node scripts/copy-native.js",
     "build:linux": "npm run version:sync && docker compose -f docker/docker-compose.yml run --rm build-linux",
     "build:macos": "npm run version:sync && (cargo build --release --manifest-path browser4-cli/Cargo.toml --target aarch64-apple-darwin & cargo build --release --manifest-path browser4-cli/Cargo.toml --target x86_64-apple-darwin & wait) && cp cli/target/aarch64-apple-darwin/release/browser4 bin/browser4-darwin-arm64 && cp cli/target/x86_64-apple-darwin/release/browser4 bin/browser4-darwin-x64",
     "build:windows": "npm run version:sync && docker compose -f docker/docker-compose.yml run --rm build-windows",
     "build:all-platforms": "npm run version:sync && (npm run build:linux & npm run build:windows & wait)",
     "build:docker": "docker build -t browser4-builder -f docker/Dockerfile.build .",
-    "release": "npm run version:sync && npm run build:all-platforms && npm publish",
+    "publish:if-needed": "node scripts/publish-if-needed.js",
+    "release": "npm run publish:if-needed",
     "postinstall": "node scripts/postinstall.js"
   },
   "keywords": [
@@ -45,8 +46,5 @@
     "url": "https://github.com/platonai/Browser4/issues"
   },
   "homepage": "https://browser4.io",
-  "packageManager": "pnpm@10.32.1+sha512.a706938f0e89ac1456b6563eab4edf1d1faf3368d1191fc5c59790e96dc918e4456ab2e67d613de1043d2e8c81f87303e6b40d4ffeca9df15ef1ad567348f2be",
-  "dependencies": {
-    "browser4-cli": "^0.1.5"
-  }
+  "packageManager": "pnpm@10.32.1+sha512.a706938f0e89ac1456b6563eab4edf1d1faf3368d1191fc5c59790e96dc918e4456ab2e67d613de1043d2e8c81f87303e6b40d4ffeca9df15ef1ad567348f2be"
 }

package/scripts/check-npm-publish-needed.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+
+import { appendFileSync } from 'fs';
+import { getPublishDecision, logPublishDecision } from './npm-publish-check.js';
+
+const args = new Set(process.argv.slice(2));
+const shouldWriteGithubOutput = args.has('--github-output');
+const shouldPrintJson = args.has('--json');
+const shouldPrintJsonOnly = args.has('--json-only');
+const shouldPrintShell = args.has('--shell');
+const decision = getPublishDecision();
+
+if (!shouldPrintJsonOnly && !shouldPrintShell) {
+  logPublishDecision('check', decision);
+}
+
+if (shouldPrintJson) {
+  console.log(JSON.stringify(decision));
+}
+
+if (shouldPrintJsonOnly) {
+  console.log(JSON.stringify(decision));
+}
+
+if (shouldPrintShell) {
+  console.log(`PACKAGE_NAME='${decision.packageName}'`);
+  console.log(`CLI_VERSION='${decision.cliVersion}'`);
+  console.log(`REMOTE_VERSION='${decision.remoteVersion}'`);
+  console.log(`LOOKUP_STATUS='${decision.lookupStatus}'`);
+  console.log(`SHOULD_PUBLISH='${decision.shouldPublish ? 'true' : 'false'}'`);
+}
+
+if (shouldWriteGithubOutput) {
+  const githubOutputPath = process.env.GITHUB_OUTPUT;
+  if (!githubOutputPath) {
+    console.error('GITHUB_OUTPUT is required when using --github-output');
+    process.exit(1);
+  }
+
+  appendFileSync(
+    githubOutputPath,
+    [
+      `package_name=${decision.packageName}`,
+      `cli_version=${decision.cliVersion}`,
+      `remote_version=${decision.remoteVersion}`,
+      `lookup_status=${decision.lookupStatus}`,
+      `should_publish=${decision.shouldPublish ? 'true' : 'false'}`,
+      '',
+    ].join('\n')
+  );
+}
+
+if (!decision.shouldPublish && !shouldPrintJsonOnly && !shouldPrintShell) {
+  console.log(`Skipping publish because ${decision.packageName}@${decision.cliVersion} already exists on npm.`);
+}
+

package/scripts/npm-publish-check.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const cliRootDir = join(__dirname, '..');
+const packageJsonPath = join(cliRootDir, 'package.json');
+
+/**
+ * Reads browser4-cli package metadata.
+ *
+ * @returns {{name: string, version: string}}
+ */
+export function readPackageMetadata() {
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+  return {
+    name: packageJson.name,
+    version: packageJson.version,
+  };
+}
+
+/**
+ * Queries npm for the published version of the package.
+ *
+ * @param {string} packageName Package name to inspect.
+ * @returns {{status: string, version: string}}
+ */
+export function getRemoteVersion(packageName) {
+  const overriddenVersion = process.env.BROWSER4_CLI_NPM_REMOTE_VERSION;
+  if (overriddenVersion) {
+    console.log(`Using overridden npm version from BROWSER4_CLI_NPM_REMOTE_VERSION=${overriddenVersion}`);
+    return {
+      status: 'overridden',
+      version: overriddenVersion,
+    };
+  }
+
+  try {
+    const version = execSync(`npm view "${packageName}" version`, {
+      cwd: cliRootDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+    }).trim();
+
+    return {
+      status: 'success',
+      version,
+    };
+  } catch (error) {
+    const stderr = error.stderr?.toString().trim();
+    const stdout = error.stdout?.toString().trim();
+    const message = stderr || stdout || error.message;
+
+    console.warn(`Warning: unable to query npm version for ${packageName}: ${message}`);
+    return {
+      status: 'failed',
+      version: 'unknown',
+    };
+  }
+}
+
+/**
+ * Computes whether npm publish should proceed.
+ *
+ * @returns {{packageName: string, cliVersion: string, remoteVersion: string, lookupStatus: string, shouldPublish: boolean}}
+ */
+export function getPublishDecision() {
+  const metadata = readPackageMetadata();
+  const remoteInfo = getRemoteVersion(metadata.name);
+
+  return {
+    packageName: metadata.name,
+    cliVersion: metadata.version,
+    remoteVersion: remoteInfo.version,
+    lookupStatus: remoteInfo.status,
+    shouldPublish: remoteInfo.version === 'unknown' || metadata.version !== remoteInfo.version,
+  };
+}
+
+/**
+ * Logs a human-readable publish decision.
+ *
+ * @param {string} phase Current phase label.
+ * @param {{packageName: string, cliVersion: string, remoteVersion: string, lookupStatus: string, shouldPublish: boolean}} decision Publish decision.
+ */
+export function logPublishDecision(phase, decision) {
+  console.log(
+    `[${phase}] package=${decision.packageName} local=${decision.cliVersion} remote=${decision.remoteVersion} status=${decision.lookupStatus} shouldPublish=${decision.shouldPublish}`
+  );
+}
+

package/scripts/publish-if-needed.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+ * Publishes browser4-cli only when the local package version differs from npm.
+ *
+ * Usage:
+ *   node scripts/publish-if-needed.js
+ *   node scripts/publish-if-needed.js --dry-run
+ *
+ * Optional env for testing:
+ *   BROWSER4_CLI_NPM_REMOTE_VERSION=<version>
+ */
+
+import { execSync } from 'child_process';
+import { cliRootDir, getPublishDecision, logPublishDecision } from './npm-publish-check.js';
+
+const args = new Set(process.argv.slice(2));
+const isDryRun = args.has('--dry-run');
+
+function runCommand(command) {
+  console.log(`> ${command}`);
+  execSync(command, {
+    cwd: cliRootDir,
+    stdio: 'inherit',
+  });
+}
+
+function main() {
+  const initialDecision = getPublishDecision();
+  logPublishDecision('pre-check', initialDecision);
+
+  if (!initialDecision.shouldPublish) {
+    console.log(`Skipping publish because ${initialDecision.packageName}@${initialDecision.cliVersion} already exists on npm.`);
+    return;
+  }
+
+  if (isDryRun) {
+    console.log('Dry run enabled; version differs, so publish would proceed.');
+    return;
+  }
+
+  runCommand('npm run version:sync');
+
+  const postSyncDecision = getPublishDecision();
+  logPublishDecision('post-sync-check', postSyncDecision);
+
+  if (!postSyncDecision.shouldPublish) {
+    console.log(`Skipping publish after sync because ${postSyncDecision.packageName}@${postSyncDecision.cliVersion} already exists on npm.`);
+    return;
+  }
+
+  runCommand('npm run build:all-platforms');
+
+  const prePublishDecision = getPublishDecision();
+  logPublishDecision('pre-publish-check', prePublishDecision);
+
+  if (!prePublishDecision.shouldPublish) {
+    console.log(`Skipping publish before npm publish because ${prePublishDecision.packageName}@${prePublishDecision.cliVersion} already exists on npm.`);
+    return;
+  }
+
+  runCommand('npm publish');
+}
+
+main();
+

package/scripts/sync-version.js

@@ -5,10 +5,10 @@
  * Run this script before building or releasing.
  */
 
-import { execSync } from "child_process";
-import { readFileSync, writeFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
+import {execSync} from "child_process";
+import {readFileSync, writeFileSync} from "fs";
+import {dirname, join} from "path";
+import {fileURLToPath} from "url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const rootDir = join(__dirname, "..");
@@ -47,7 +47,7 @@ if (cargoVersionRegex.test(cargoToml)) {
 // Update Cargo.lock to match Cargo.toml
 if (cargoTomlUpdated) {
   try {
-    execSync("cargo update -p browser4 --offline", {
+    execSync("cargo update -p browser4-cli --offline", {
       cwd: cliDir,
       stdio: "pipe",
     });
@@ -55,7 +55,7 @@ if (cargoTomlUpdated) {
   } catch {
     // --offline may fail if package not in cache, try without it
     try {
-      execSync("cargo update -p browser4", {
+      execSync("cargo update -p browser4-cli", {
         cwd: cliDir,
         stdio: "pipe",
       });