browse 0.9.1 → 0.9.2-alpha-ad9825f

package/README.md

@@ -84,7 +84,7 @@ browse back           # Navigate backward
 browse forward        # Navigate forward
 ```
 
-### Snapshot & refs
+### Snapshot
 
 The accessibility snapshot is the recommended way for agents to discover elements. It prints a tree of refs like `@0-12` that the element commands accept directly.
 
@@ -93,7 +93,6 @@ browse snapshot                 # Accessibility snapshot + cached refs
 browse snapshot --compact       # Tree only, no ref maps
 browse snapshot --filter submit # Filter lines by text or /regex/, keeping ancestors
 browse snapshot --max-depth 4   # Trim output deeper than this depth
-browse refs                     # Show refs cached from the last snapshot
 ```
 
 ### Element actions

package/dist/commands/cloud/contexts/add.js

@@ -0,0 +1,45 @@
+import { Args, Flags } from "@oclif/core";
+import { contextNameRequirement, getContextAlias, isValidContextName, saveContextAlias, } from "../../../lib/cloud/contexts-store.js";
+import { fail } from "../../../lib/errors.js";
+import { outputJson } from "../../../lib/output.js";
+import { BrowseCommand } from "../../../base.js";
+export default class ContextsAdd extends BrowseCommand {
+    static description = "Save a local name for an existing Browserbase context ID so you can reuse it by name (e.g. an ID a teammate shared or one created on another device).";
+    static examples = [
+        "browse cloud contexts add github 45ed525f-63a5-490d-b4c4-853f50643b90",
+        "browse cloud contexts add github <new-id> --force",
+    ];
+    static args = {
+        name: Args.string({ required: true, description: "Local name to save." }),
+        id: Args.string({
+            required: true,
+            description: "Existing Browserbase context ID.",
+        }),
+    };
+    static flags = {
+        force: Flags.boolean({
+            description: "Overwrite the name if it is already saved locally.",
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ContextsAdd);
+        if (!isValidContextName(args.name)) {
+            fail(`Invalid context name "${args.name}". ${contextNameRequirement()}`);
+        }
+        // Normalize before storing so whitespace-padded input isn't saved and later
+        // resolved as a bogus context id.
+        const id = args.id.trim();
+        if (id.length === 0) {
+            fail("Context ID cannot be empty.");
+        }
+        if (!flags.force && (await getContextAlias(args.name))) {
+            fail(`A context named "${args.name}" already exists locally. Pass --force to overwrite, ` +
+                `or remove it with "browse cloud contexts delete ${args.name}".`);
+        }
+        await saveContextAlias(args.name, {
+            id,
+            createdAt: new Date().toISOString(),
+        });
+        outputJson({ name: args.name, id });
+    }
+}

package/dist/commands/cloud/contexts/create.js

@@ -1,16 +1,23 @@
 import { Flags } from "@oclif/core";
 import { createBrowserbaseClient, outputJson, resolveBody, withBrowserbaseApi, } from "../../../lib/cloud/api.js";
+import { contextNameRequirement, getContextAlias, isValidContextName, saveContextAlias, } from "../../../lib/cloud/contexts-store.js";
 import { apiCommonFlags, toApiOptions } from "../../../lib/cloud/flags.js";
+import { fail } from "../../../lib/errors.js";
 import { BrowseCommand } from "../../../base.js";
 export default class ContextsCreate extends BrowseCommand {
-    static description = "Create a Browserbase context.";
+    static description = "Create a Browserbase context. Pass --name to save a local alias you can reuse instead of the context ID.";
     static examples = [
         "browse cloud contexts create",
+        "browse cloud contexts create --name github",
         `browse cloud contexts create --body '{"region":"us-west-2"}'`,
         `echo '{"region":"us-west-2"}' | browse cloud contexts create --stdin`,
     ];
     static flags = {
         ...apiCommonFlags,
+        name: Flags.string({
+            description: "Save a local alias for the new context so you can reuse it by name.",
+            helpValue: "<name>",
+        }),
         body: Flags.string({
             description: "Optional JSON request body.",
             helpValue: "<body>",
@@ -21,10 +28,28 @@ export default class ContextsCreate extends BrowseCommand {
     };
     async run() {
         const { flags } = await this.parse(ContextsCreate);
+        const name = flags.name;
+        if (name !== undefined) {
+            if (!isValidContextName(name)) {
+                fail(`Invalid context name "${name}". ${contextNameRequirement()}`);
+            }
+            if (await getContextAlias(name)) {
+                fail(`A context named "${name}" already exists locally. Choose another name or remove it with "browse cloud contexts delete ${name}".`);
+            }
+        }
         await withBrowserbaseApi("contexts", async () => {
             const client = createBrowserbaseClient(toApiOptions(flags));
             const body = await resolveBody({ body: flags.body, stdin: flags.stdin });
-            outputJson(await client.contexts.create(body));
+            const context = await client.contexts.create(body);
+            if (name !== undefined && context.id) {
+                await saveContextAlias(name, {
+                    id: context.id,
+                    createdAt: new Date().toISOString(),
+                });
+                outputJson({ ...context, name });
+                return;
+            }
+            outputJson(context);
         });
     }
 }

package/dist/commands/cloud/contexts/delete.js

@@ -1,22 +1,46 @@
 import { Args } from "@oclif/core";
 import { outputJson, requestBrowserbase } from "../../../lib/cloud/api.js";
+import { resolveContextRefOrFail } from "../../../lib/cloud/contexts-resolve.js";
+import { removeContextAliasesById } from "../../../lib/cloud/contexts-store.js";
 import { apiCommonFlags, toApiOptions } from "../../../lib/cloud/flags.js";
 import { BrowseCommand } from "../../../base.js";
 export default class ContextsDelete extends BrowseCommand {
-    static description = "Delete a Browserbase context.";
-    static examples = ["browse cloud contexts delete <context-id>"];
+    static description = "Delete a Browserbase context by ID or saved name.";
+    static examples = [
+        "browse cloud contexts delete <context-id>",
+        "browse cloud contexts delete github",
+    ];
     static args = {
-        id: Args.string({ required: true, description: "Context ID." }),
+        id: Args.string({
+            required: true,
+            description: "Context ID or saved name.",
+        }),
     };
     static flags = { ...apiCommonFlags };
     async run() {
         const { args, flags } = await this.parse(ContextsDelete);
-        await requestBrowserbase(toApiOptions(flags), `/v1/contexts/${args.id}`, {
+        const id = await resolveContextRefOrFail(args.id);
+        await requestBrowserbase(toApiOptions(flags), `/v1/contexts/${id}`, {
             method: "DELETE",
             headers: {
                 Accept: "*/*",
             },
         });
-        outputJson({ ok: true, id: args.id });
+        // Keep the local name map consistent: drop any aliases pointing at the
+        // now-deleted context (whether the user passed a name or a raw id). The
+        // remote delete already succeeded, so a local cleanup failure must not turn
+        // the command into a false negative — best-effort, never throws.
+        let removed;
+        try {
+            removed = await removeContextAliasesById(id);
+        }
+        catch {
+            removed = [];
+        }
+        outputJson({
+            ok: true,
+            id,
+            ...(removed.length ? { removedAliases: removed } : {}),
+        });
     }
 }

package/dist/commands/cloud/contexts/get.js

@@ -1,19 +1,27 @@
 import { Args } from "@oclif/core";
 import { createBrowserbaseClient, outputJson, withBrowserbaseApi, } from "../../../lib/cloud/api.js";
+import { resolveContextRefOrFail } from "../../../lib/cloud/contexts-resolve.js";
 import { apiCommonFlags, toApiOptions } from "../../../lib/cloud/flags.js";
 import { BrowseCommand } from "../../../base.js";
 export default class ContextsGet extends BrowseCommand {
-    static description = "Get a Browserbase context by ID.";
-    static examples = ["browse cloud contexts get <context-id>"];
+    static description = "Get a Browserbase context by ID or saved name.";
+    static examples = [
+        "browse cloud contexts get <context-id>",
+        "browse cloud contexts get github",
+    ];
     static args = {
-        id: Args.string({ required: true, description: "Context ID." }),
+        id: Args.string({
+            required: true,
+            description: "Context ID or saved name.",
+        }),
     };
     static flags = { ...apiCommonFlags };
     async run() {
         const { args, flags } = await this.parse(ContextsGet);
+        const id = await resolveContextRefOrFail(args.id);
         await withBrowserbaseApi("contexts", async () => {
             const client = createBrowserbaseClient(toApiOptions(flags));
-            outputJson(await client.contexts.retrieve(args.id));
+            outputJson(await client.contexts.retrieve(id));
         });
     }
 }

package/dist/commands/cloud/contexts/list.js

@@ -0,0 +1,48 @@
+import { outputJson } from "../../../lib/cloud/api.js";
+import { listContextAliases, } from "../../../lib/cloud/contexts-store.js";
+import { BrowseCommand } from "../../../base.js";
+import { formatId, formatUtcDateTime, outputFormatFlags, outputTable, resolveOutputFormat, } from "../../../lib/output.js";
+export default class ContextsList extends BrowseCommand {
+    static description = "List Browserbase contexts you have saved locally with a name.";
+    static examples = [
+        "browse cloud contexts list",
+        "browse cloud contexts list --json",
+    ];
+    static flags = {
+        ...outputFormatFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(ContextsList);
+        const contexts = await listContextAliases();
+        if (resolveOutputFormat(flags) === "json") {
+            // Wrap in a named key to match `templates list` / `skills list` so the
+            // JSON shape is consistent and machine-readable across list commands.
+            outputJson({ contexts });
+            return;
+        }
+        if (contexts.length === 0) {
+            console.log("No saved contexts. Create one with: browse cloud contexts create --name <name>");
+            return;
+        }
+        outputContextsTable(contexts, { wide: flags.wide });
+    }
+}
+function outputContextsTable(contexts, options) {
+    outputTable(contexts, [
+        {
+            header: "Name",
+            maxWidth: 24,
+            value: (context) => context.name,
+        },
+        {
+            header: "ID",
+            maxWidth: 12,
+            value: (context) => formatId(context.id, options.wide),
+        },
+        {
+            header: "Created",
+            maxWidth: 17,
+            value: (context) => formatUtcDateTime(context.createdAt),
+        },
+    ], { wide: options.wide });
+}

package/dist/commands/cloud/contexts/update.js

@@ -1,17 +1,25 @@
 import { Args } from "@oclif/core";
 import { outputJson, requestBrowserbaseJson } from "../../../lib/cloud/api.js";
+import { resolveContextRefOrFail } from "../../../lib/cloud/contexts-resolve.js";
 import { apiCommonFlags, toApiOptions } from "../../../lib/cloud/flags.js";
 import { BrowseCommand } from "../../../base.js";
 export default class ContextsUpdate extends BrowseCommand {
     static description = "Refresh the upload URL for a Browserbase context.";
-    static examples = ["browse cloud contexts update <context-id>"];
+    static examples = [
+        "browse cloud contexts update <context-id>",
+        "browse cloud contexts update github",
+    ];
     static args = {
-        id: Args.string({ required: true, description: "Context ID." }),
+        id: Args.string({
+            required: true,
+            description: "Context ID or saved name.",
+        }),
     };
     static flags = { ...apiCommonFlags };
     async run() {
         const { args, flags } = await this.parse(ContextsUpdate);
-        outputJson(await requestBrowserbaseJson(toApiOptions(flags), `/v1/contexts/${args.id}`, {
+        const id = await resolveContextRefOrFail(args.id);
+        outputJson(await requestBrowserbaseJson(toApiOptions(flags), `/v1/contexts/${id}`, {
             method: "PUT",
         }));
     }

package/dist/commands/cloud/sessions/create.js

@@ -1,5 +1,6 @@
 import { Flags } from "@oclif/core";
 import { createBrowserbaseClient, deepMerge, outputJson, resolveBody, withBrowserbaseApi, } from "../../../lib/cloud/api.js";
+import { resolveContextRefOrFail } from "../../../lib/cloud/contexts-resolve.js";
 import { apiCommonFlags, toApiOptions } from "../../../lib/cloud/flags.js";
 import { fail } from "../../../lib/errors.js";
 import { getCliVersion, resolveInstallId, toMetadataValue, } from "../../../lib/identity.js";
@@ -137,8 +138,8 @@ export default class SessionsCreate extends BrowseCommand {
             helpValue: "<seconds>",
         }),
         "context-id": Flags.string({
-            description: "Browserbase context ID for persistent state.",
-            helpValue: "<id>",
+            description: "Browserbase context ID, or a name saved with 'contexts create --name', for persistent state.",
+            helpValue: "<id|name>",
         }),
         persist: Flags.boolean({
             description: "Persist context changes after session ends.",
@@ -162,6 +163,11 @@ export default class SessionsCreate extends BrowseCommand {
     };
     async run() {
         const { flags } = await this.parse(SessionsCreate);
+        // Allow --context-id to be a locally-saved name; resolve it to a real id.
+        // A context id passes through; an unknown name fails with a helpful message.
+        if (flags["context-id"]) {
+            flags["context-id"] = await resolveContextRefOrFail(flags["context-id"]);
+        }
         await withBrowserbaseApi("sessions", async () => {
             const client = createBrowserbaseClient(toApiOptions(flags));
             const jsonBody = await resolveBody({

package/dist/commands/open.js

@@ -7,6 +7,7 @@ export default class Open extends BrowseCommand {
         "browse open https://example.com",
         "browse open https://example.com --local --headed",
         "browse open https://example.com --remote",
+        "browse open https://example.com --remote --verified --proxies",
         "browse open https://example.com --auto-connect",
         "browse open https://example.com --cdp 9222",
         "browse open https://example.com --cdp ws://127.0.0.1:9222/devtools/browser/<id> --target-id <target-id>",

package/dist/lib/cloud/contexts-resolve.js

@@ -0,0 +1,23 @@
+import { fail } from "../errors.js";
+import { resolveContextRefDetailed } from "./contexts-store.js";
+/**
+ * Resolve a context name-or-id for a command. A saved name or a context id
+ * resolves to its id. When a ref is neither but is close to a saved name, we
+ * treat it as a typo and fail with a "did you mean?" hint instead of sending a
+ * bogus id. Otherwise we pass the ref through unchanged so raw ids of any shape
+ * still reach the API — preserving raw-id compatibility.
+ */
+export async function resolveContextRefOrFail(ref) {
+    const { id, suggestions } = await resolveContextRefDetailed(ref);
+    if (id !== null) {
+        return id;
+    }
+    if (suggestions.length === 0) {
+        // Not a known name and not close to one — could be a raw id we don't
+        // recognize the shape of. Let the API be the judge rather than blocking it.
+        return ref;
+    }
+    return fail(`No saved context named "${ref}". Did you mean: ${suggestions.join(", ")}? ` +
+        `Pass a Browserbase context ID, save one with "browse cloud contexts create --name <name>", ` +
+        `or list saved names with "browse cloud contexts list".`);
+}

package/dist/lib/cloud/contexts-store.js

@@ -0,0 +1,209 @@
+import { distance } from "fastest-levenshtein";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { resolveConfigDir } from "../identity.js";
+/**
+ * Local name -> Browserbase context-id map.
+ *
+ * Browserbase contexts are identified only by an opaque id and the platform has
+ * no server-side list endpoint, so to give contexts memorable names (e.g.
+ * `github`, `gmail`) we keep a small map on the local device. It lives next to
+ * the CLI's other state at `(XDG_CONFIG_HOME||~/.config)/browserbase/contexts.json`
+ * (honoring `BROWSERBASE_CONFIG_DIR`). This is purely a client-side convenience:
+ * the ids it stores are the same ids the API already returns, and a missing or
+ * corrupt file degrades to "no saved contexts" rather than an error.
+ */
+const STORE_VERSION = 1;
+const MAX_NAME_LENGTH = 64;
+// A name must start with an alphanumeric and may then contain letters, digits,
+// dots, dashes, and underscores. Keeps names shell- and filename-friendly and
+// unambiguous against opaque context ids.
+const NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+// Browserbase context ids are UUIDs. A name must not be UUID-shaped, otherwise a
+// saved alias could shadow a real id and break raw-id passthrough in resolution.
+const CONTEXT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function looksLikeContextId(value) {
+    return CONTEXT_ID_PATTERN.test(value);
+}
+export function isValidContextName(name) {
+    return (name.length > 0 &&
+        name.length <= MAX_NAME_LENGTH &&
+        NAME_PATTERN.test(name) &&
+        // Disallow id-shaped names so a name can never shadow a raw context id.
+        !looksLikeContextId(name));
+}
+export function contextNameRequirement() {
+    return `Context names must be 1-${MAX_NAME_LENGTH} characters, start with a letter or number, contain only letters, numbers, dots, dashes, or underscores, and not look like a context ID.`;
+}
+export function contextsStorePath(env = process.env) {
+    return join(resolveConfigDir(env), "contexts.json");
+}
+function emptyStore() {
+    // Null-prototype map so a ref like "toString" or "constructor" can never read
+    // an inherited Object.prototype member as if it were a saved alias.
+    return {
+        version: STORE_VERSION,
+        contexts: Object.create(null),
+    };
+}
+async function readStore(env = process.env) {
+    let raw;
+    try {
+        raw = await readFile(contextsStorePath(env), "utf8");
+    }
+    catch {
+        return emptyStore();
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed ||
+            typeof parsed !== "object" ||
+            typeof parsed.contexts !== "object" ||
+            parsed.contexts === null) {
+            return emptyStore();
+        }
+        return {
+            version: STORE_VERSION,
+            contexts: sanitizeContexts(parsed.contexts),
+        };
+    }
+    catch {
+        // Corrupt file: treat as empty rather than crashing the command.
+        return emptyStore();
+    }
+}
+/**
+ * Keep only well-formed entries so a hand-edited or partially-written
+ * `contexts.json` degrades gracefully (a malformed entry is dropped rather than
+ * trusted as a `ContextAlias` and breaking resolution or cleanup).
+ */
+function sanitizeContexts(raw) {
+    // Null-prototype so prototype keys can't be read back as aliases (see emptyStore).
+    const result = Object.create(null);
+    if (!raw || typeof raw !== "object") {
+        return result;
+    }
+    for (const [name, value] of Object.entries(raw)) {
+        // Validate the key too: a hand-edited file could carry an id-shaped or
+        // otherwise invalid name that would shadow a raw id, so hold disk entries to
+        // the same rule as `create --name`.
+        if (!isValidContextName(name)) {
+            continue;
+        }
+        if (!value || typeof value !== "object") {
+            continue;
+        }
+        const entry = value;
+        if (typeof entry.id !== "string" || entry.id.length === 0) {
+            continue;
+        }
+        result[name] = {
+            id: entry.id,
+            createdAt: typeof entry.createdAt === "string" ? entry.createdAt : "",
+        };
+    }
+    return result;
+}
+async function writeStore(store, env = process.env) {
+    const path = contextsStorePath(env);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    // Write to a temp file at 0600 then atomically rename over the target. The
+    // rename means a reader never sees a half-written file, and the final file
+    // always inherits the temp file's 0600 perms even if an older, more permissive
+    // contexts.json already existed (writeFile's `mode` only applies on create).
+    // For this single-user local config, simultaneous writers remain
+    // last-writer-wins; cross-process locking isn't warranted here.
+    const tempPath = `${path}.${process.pid}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(store, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    await rename(tempPath, path);
+}
+export async function listContextAliases(env = process.env) {
+    const store = await readStore(env);
+    return Object.entries(store.contexts)
+        .map(([name, alias]) => ({ name, ...alias }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export async function getContextAlias(name, env = process.env) {
+    const store = await readStore(env);
+    return store.contexts[name];
+}
+export async function saveContextAlias(name, alias, env = process.env) {
+    const store = await readStore(env);
+    store.contexts[name] = alias;
+    await writeStore(store, env);
+}
+export async function removeContextAlias(name, env = process.env) {
+    const store = await readStore(env);
+    if (!(name in store.contexts)) {
+        return false;
+    }
+    delete store.contexts[name];
+    await writeStore(store, env);
+    return true;
+}
+/**
+ * Drop any saved aliases that point at a given context id. Used after a delete
+ * so the local map never references a context that no longer exists, regardless
+ * of whether the user deleted it by name or by raw id. Returns the names pruned.
+ */
+export async function removeContextAliasesById(id, env = process.env) {
+    const store = await readStore(env);
+    const removed = Object.entries(store.contexts)
+        .filter(([, alias]) => alias.id === id)
+        .map(([name]) => name);
+    if (removed.length === 0) {
+        return [];
+    }
+    for (const name of removed) {
+        delete store.contexts[name];
+    }
+    await writeStore(store, env);
+    return removed;
+}
+/**
+ * Resolve a context reference that may be a locally-saved name or a raw
+ * Browserbase context id. If `ref` matches a saved name, returns its id;
+ * otherwise returns `ref` unchanged (assumed to already be a context id). Never
+ * throws — an unknown ref simply passes through to the API.
+ */
+export async function resolveContextRef(ref, env = process.env) {
+    const alias = await getContextAlias(ref, env);
+    return alias ? alias.id : ref;
+}
+/**
+ * Like `resolveContextRef`, but distinguishes "this is an unknown name" from a
+ * real id so callers can show a friendly error instead of letting a typo'd name
+ * hit the API as a bogus id. A ref resolves when it matches a saved name or is
+ * shaped like a context id (UUID); anything else returns `id: null` plus the
+ * closest saved names.
+ */
+export async function resolveContextRefDetailed(ref, env = process.env) {
+    const store = await readStore(env);
+    const alias = store.contexts[ref];
+    if (alias) {
+        return { id: alias.id, suggestions: [] };
+    }
+    if (looksLikeContextId(ref)) {
+        return { id: ref, suggestions: [] };
+    }
+    return {
+        id: null,
+        suggestions: closeContextNameMatches(ref, Object.keys(store.contexts)),
+    };
+}
+/**
+ * Saved names within a small edit distance of `ref`, nearest first, for typo
+ * hints. The threshold scales with name length so short names aren't matched too
+ * loosely.
+ */
+export function closeContextNameMatches(ref, names, limit = 3) {
+    return names
+        .map((name) => ({ name, d: distance(ref, name) }))
+        .filter(({ name, d }) => d <= Math.max(2, Math.floor(name.length / 3)))
+        .sort((a, b) => a.d - b.d || a.name.localeCompare(b.name))
+        .slice(0, limit)
+        .map((match) => match.name);
+}

package/dist/lib/driver/command-cli.js

@@ -1,5 +1,5 @@
 import { Flags } from "@oclif/core";
-import { autoConnectFlag, cdpFlag, chromeArgFlag, headedFlag, headlessFlag, ignoreDefaultChromeArgFlag, localFlag, noDefaultChromeArgsFlag, remoteFlag, sessionFlag, sessionName, targetIdFlag, } from "./flags.js";
+import { autoConnectFlag, cdpFlag, chromeArgFlag, headedFlag, headlessFlag, ignoreDefaultChromeArgFlag, localFlag, noDefaultChromeArgsFlag, proxiesFlag, remoteFlag, sessionFlag, sessionName, targetIdFlag, verifiedFlag, } from "./flags.js";
 import { getDriverStatus } from "./daemon/client.js";
 import { hasChromeArgFlags, resolveConnectionTarget, } from "./mode.js";
 import { outputJson } from "../output.js";
@@ -13,9 +13,11 @@ export const driverCommandFlags = {
     "ignore-default-chrome-arg": ignoreDefaultChromeArgFlag,
     local: localFlag,
     "no-default-chrome-args": noDefaultChromeArgsFlag,
+    proxies: proxiesFlag,
     remote: remoteFlag,
     session: sessionFlag,
     "target-id": targetIdFlag,
+    verified: verifiedFlag,
 };
 export const waitUntilFlag = Flags.string({
     default: "load",
@@ -58,7 +60,9 @@ export function hasExplicitDriverTarget(flags) {
         hasChromeArgFlags(flags) ||
         flags["target-id"] ||
         flags.headed ||
-        flags.headless);
+        flags.headless ||
+        flags.verified ||
+        flags.proxies);
 }
 function hasModeOnlyFlag(flags) {
     return Boolean((flags.local || flags.remote) &&
@@ -68,6 +72,8 @@ function hasModeOnlyFlag(flags) {
         !flags["target-id"] &&
         !flags.headed &&
         !flags.headless &&
+        !flags.verified &&
+        !flags.proxies &&
         flags.local !== flags.remote);
 }
 function targetMatchesRequestedMode(target, flags) {

package/dist/lib/driver/commands/snapshot.js

@@ -29,12 +29,4 @@ export const snapshotHandlers = {
             xpathMap: snapshot.xpathMap,
         };
     },
-    async refs(manager) {
-        const refMaps = manager.getRefMaps();
-        return {
-            count: Object.keys(refMaps.xpathMap).length,
-            urlMap: refMaps.urlMap,
-            xpathMap: refMaps.xpathMap,
-        };
-    },
 };

package/dist/lib/driver/commands/types.js

@@ -19,7 +19,6 @@ export const DRIVER_COMMAND_NAMES = [
     "network.on",
     "network.path",
     "open",
-    "refs",
     "reload",
     "screenshot",
     "select",

package/dist/lib/driver/daemon/client.js

@@ -4,6 +4,7 @@ import net from "node:net";
 import { CommandFailure, fail } from "../../errors.js";
 import { targetsCompatible } from "../mode.js";
 import { cleanupDaemonFiles, ensureRuntimeDir, getLockPath, getPidPath, getSocketPath, PRIVATE_FILE_MODE, } from "./paths.js";
+import { collectForwardedEnv } from "./forwarded-env.js";
 import { isProcessAlive } from "./process.js";
 import { ResponseSchema } from "./protocol.js";
 export async function ensureDriverDaemon({ session, target, }) {
@@ -36,6 +37,7 @@ export async function ensureDriverDaemon({ session, target, }) {
 export async function openViaDaemon(session, url, options = {}) {
     return sendDriverRequest(session, {
         ...options,
+        forwardedEnv: await collectForwardedEnv(),
         id: requestId(),
         type: "open",
         url,
@@ -44,6 +46,7 @@ export async function openViaDaemon(session, url, options = {}) {
 export async function runDriverCommandViaDaemon(session, command, params) {
     return sendDriverRequest(session, {
         command,
+        forwardedEnv: await collectForwardedEnv(),
         id: requestId(),
         params,
         type: "command",