browserzap 0.6.0 → 0.7.0

package/bridge-server/mcp-server.js

@@ -32,6 +32,7 @@ const { BIND_HOST, DEFAULT_PORT, PROTOCOL_VERSION, sanitizeSessionName } = requi
 const { ensureBridge: ensureBridgeListening } = require('./ensure-bridge');
 const { LIMITS, CALL_DEADLINE_MS, STATUS_DEADLINE_MS } = require('./limits');
 const chromeLauncher = require('./chrome-launcher');
+const { MIN_EXTENSION_VERSION, isOlderThan } = require('./extension-version');
 const { MCP_TOOLS, LOCAL_TOOLS, validateArguments } = require('./tools');
 const { currentPlan, hasFeature } = require('./entitlements');
 const { envelope, errorEnvelope, executeStep, createActionClient } = require('./executor');
@@ -482,6 +483,12 @@ async function callToolWith(progress, requestId, toolName, args) {
   const started = Date.now();
   const traceId = `${SESSION_ID}-t${++traceSeq}`;
   const finish = (env, extraContent) => {
+    // The person can message the agent from the side panel at any time; the
+    // agent learns of it on its next call. browser_status says it itself.
+    if (toolName !== 'browser_status' && !toolName.startsWith('feedback_') && typeof env.summary === 'string') {
+      const waiting = feedback.pendingCount();
+      if (waiting) env.summary = `${env.summary} ${unreadFeedbackNote(waiting)}`;
+    }
     log('tool_call', {
       tool: toolName,
       traceId: env.traceId,
@@ -557,6 +564,24 @@ async function callToolWith(progress, requestId, toolName, args) {
   }
 }
 
+/**
+ * An action the connected build does not know (an extension older than the tool
+ * surface, src/actions/browser-actions.ts) comes back as `Unknown action: …`
+ * with INVALID_ARGUMENT. Report that as `needs_user` naming the build, so the
+ * person is told to update instead of the agent retrying a call that cannot
+ * work. Same code, same `ok`, the call itself is not refused here.
+ */
+async function nameUnsupportedAction(env) {
+  if (env.ok !== false || env.error?.code !== 'INVALID_ARGUMENT') return;
+  if (typeof env.error.message !== 'string' || !env.error.message.startsWith('Unknown action:')) return;
+  const version = await connectedExtensionVersion();
+  env.state = 'needs_user';
+  env.summary = version
+    ? `The BrowserZap extension (${version}) does not support this action; update it from chrome://extensions → Update.`
+    : 'The BrowserZap extension does not support this action and did not report its version, which means it is older than 0.7.0; update it from chrome://extensions → Update.';
+  env.nextAction = 'Ask the user to update the BrowserZap extension. Chrome updates store extensions by itself; to update now open chrome://extensions → Update.';
+}
+
 /**
  * Run one browser tool through the extension and build its envelope. Live
  * calls and workflow steps both come through here, so a replayed step gets
@@ -565,6 +590,7 @@ async function callToolWith(progress, requestId, toolName, args) {
  */
 async function executeTool(toolName, args, { allowedOrigins = ALLOWED_ORIGINS, onStart } = {}) {
   const env = await executeStep(startAction, toolName, args, { allowedOrigins, onStart });
+  await nameUnsupportedAction(env);
   const extra = [];
   if (typeof env.screenshot === 'string') {
     const format = env.format || 'jpeg';
@@ -677,6 +703,11 @@ function checkUpload(traceId, args) {
 
 // ─── Comment mode batches (docs/COMMENT_MODE.md) ─────────────────────────────
 
+/** The sentence that tells the agent the person is waiting for it to read something. */
+function unreadFeedbackNote(waiting) {
+  return `The person sent ${waiting} comment batch(es) or message(s) from the BrowserZap side panel: call feedback_get now and act on them.`;
+}
+
 /** Inline images per feedback_get: enough to see every comment, small enough for any client. */
 const FEEDBACK_INLINE_IMAGES = 12;
 const FEEDBACK_INLINE_BYTES = 6 * 1024 * 1024;
@@ -719,10 +750,14 @@ function feedbackTool(traceId, toolName, args) {
       }
     }
   }
-  const pages = [...new Set(batch.comments.map((c) => c.page.url))];
+  const pages = [...new Set(batch.comments.map((c) => c.page?.url).filter(Boolean))];
+  const messages = batch.comments.filter((c) => c.kind === 'message').length;
+  const pinned = batch.comments.length - messages;
+  const what = [messages ? `${messages} message(s)` : '', pinned ? `${pinned} comment(s)` : ''].filter(Boolean).join(' and ');
+  const where = pages.length === 0 ? '' : ` on ${pages.length === 1 ? pages[0] : `${pages.length} pages`}`;
   return {
     env: okEnvelope(traceId,
-      `${batch.comments.length} comment(s) from the person on ${pages.length === 1 ? pages[0] : `${pages.length} pages`}.`,
+      `${what} from the person${where}.`,
       { batch },
       {}),
     extra,
@@ -1014,7 +1049,7 @@ const backgroundRuns = createRunRegistry({
 });
 
 /** Tools that only read, allowed while a background run drives the tab. */
-const READ_WHILE_RUNNING = new Set(['browser_status', 'page_inspect', 'screenshot_capture', 'page_console', 'page_network', 'browser_list_tabs', 'browser_list_profiles']);
+const READ_WHILE_RUNNING = new Set(['browser_status', 'page_inspect', 'screenshot_capture', 'page_console', 'page_network', 'browser_list_tabs', 'browser_list_profiles', 'chat_reply']);
 
 /**
  * "5 of 5 done" / "3 of 5 done, 2 need attention" as a Chrome notification
@@ -1100,6 +1135,38 @@ function planEvidence() {
   return { plan, licenseStatus, features, limits, expiresAt, notice, proPackage: Boolean(pro), recording: recorder ? recorder.name : null };
 }
 
+/** The profile a status/report should speak about: the selected one, else the first. */
+function relevantProfile(profiles) {
+  if (!Array.isArray(profiles) || profiles.length === 0) return null;
+  return profiles.find((p) => p.selected) ?? profiles[0];
+}
+
+/** The version the connected extension reported, or null when it is older than 0.7.0 (WP5). */
+async function connectedExtensionVersion() {
+  try {
+    const reply = await bridgeRequest('profiles_list', {}, 1500);
+    if (reply?.ok !== true) return null;
+    const profile = relevantProfile(reply.data?.profiles);
+    return typeof profile?.extensionVersion === 'string' ? profile.extensionVersion : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * What browser_status says about a store build that lags this bridge (WP5, F4).
+ * A notice only: `ok` never changes and no call is ever refused for it.
+ */
+function extensionVersionNotice(version) {
+  if (version === null) {
+    return 'The BrowserZap extension did not report its version, which means it is older than 0.7.0. Chrome updates store extensions automatically; to update now open chrome://extensions → Update.';
+  }
+  if (isOlderThan(version, MIN_EXTENSION_VERSION)) {
+    return `The BrowserZap extension is older than this bridge (${version} < ${MIN_EXTENSION_VERSION}). Chrome updates store extensions automatically; to update now open chrome://extensions → Update.`;
+  }
+  return null;
+}
+
 async function statusTool(traceId, args) {
   const evidence = {
     bridge: sessionStarted ? 'connected' : lastCloseCode === 4003 ? 'unauthorized' : lastCloseCode === 4005 ? 'version_mismatch' : 'unreachable',
@@ -1117,6 +1184,7 @@ async function statusTool(traceId, args) {
     sessionLog: process.env.BROWSERZAP_LOG === 'off' ? null : sessionLog.file(),
     screenshots: { folder: screenshots.screenshotDir(), keepDays: screenshots.keepDays() },
     profiles: null,
+    extensionVersion: null,
   };
   if (!sessionStarted) {
     try {
@@ -1131,12 +1199,17 @@ async function statusTool(traceId, args) {
     const reply = await bridgeRequest('profiles_list', {}, 1500);
     evidence.profiles = reply.data?.profiles ?? null;
   } catch { /* an older bridge: no profile list */ }
+  evidence.extensionVersion = relevantProfile(evidence.profiles)?.extensionVersion ?? null;
   if (Array.isArray(evidence.profiles) && evidence.profiles.length > 1 && !evidence.profiles.some((p) => p.selected)) {
+    // The extension did answer (with its profile list), so the version notice
+    // belongs here too; the error itself is unchanged.
+    const notice = extensionVersionNotice(evidence.extensionVersion);
     return {
       ...errorEnvelope(traceId, 'PROFILE_REQUIRED',
         `${evidence.profiles.length} Chrome profiles are connected (${evidence.profiles.map((p) => `"${p.label}"`).join(', ')}). Choose one first.`,
         'Call browser_select_profile with the profile the user means.'),
       evidence: { ...evidence, extension: 'connected' },
+      ...(notice ? { notice } : {}),
     };
   }
   const call = startAction('status', { includeTab: args.includeTab === true }, STATUS_DEADLINE_MS);
@@ -1144,9 +1217,11 @@ async function statusTool(traceId, args) {
     const result = await call.promise;
     const env = envelope(call.id, result);
     env.evidence = { ...evidence, extension: 'connected' };
+    const notice = extensionVersionNotice(evidence.extensionVersion);
+    if (notice) env.notice = notice;
     const waiting = feedback.pendingCount();
     if (waiting && typeof env.summary === 'string') {
-      env.summary = `${env.summary} The person sent ${waiting} comment batch(es) from Comment mode: call feedback_get.`;
+      env.summary = `${env.summary} ${unreadFeedbackNote(waiting)}`;
     }
     return env;
   } catch {

package/bridge-server/native-host.js

@@ -22,11 +22,11 @@
  * closes or after a bounded wait with no request.
  */
 
-const { getOrCreateSecret } = require('./secret');
+const { getOrCreateSecret, configDir } = require('./secret');
 const { DEFAULT_PORT, PROTOCOL_VERSION, fileLogger } = require('./server');
 const { ensureBridge } = require('./ensure-bridge');
 const { helloProbe } = require('./probe');
-const { HOST_NAME, allowedOrigins } = require('./extension-id');
+const { HOST_NAME, allowedOrigins, allowedExtensionIds } = require('./extension-id');
 
 /** Inbound frames above this are rejected before parsing. Chrome's own host→Chrome cap is 1 MiB. */
 const MAX_MESSAGE_BYTES = 1024 * 1024;
@@ -139,11 +139,29 @@ async function handleRequest(request, options = {}) {
   return { type: 'hello', port, token, protocolVersion: PROTOCOL_VERSION };
 }
 
+/**
+ * Whether Chrome's reported caller origin may start this helper.
+ *
+ * Defense in depth: allowed_origins in the host manifest is the real control.
+ * Chrome may pass no origin at all, and anything that is not a
+ * chrome-extension:// origin is not ours to judge here. The set of extension
+ * ids comes from `dir` (store id only, plus the unpacked id after
+ * `browserzap setup --dev`), so it is the same answer `setup` wrote.
+ */
+function isAllowedOrigin(origin, { dir } = {}) {
+  if (typeof origin !== 'string' || !origin.startsWith('chrome-extension://')) return true;
+  try {
+    return allowedOrigins(allowedExtensionIds({ dir })).includes(origin);
+  } catch {
+    return false; // a config dir we cannot read allows nothing beyond the manifest
+  }
+}
+
 function main() {
   // Defense in depth: allowed_origins is the real control, but refuse a caller
   // that is not the BrowserZap extension if Chrome tells us who it is.
   const origin = process.argv[2];
-  if (typeof origin === 'string' && origin.startsWith('chrome-extension://') && !allowedOrigins().includes(origin)) {
+  if (!isAllowedOrigin(origin, { dir: configDir() })) {
     logLine('wrong_origin');
     process.exit(1);
   }
@@ -204,4 +222,5 @@ module.exports = {
   decodeMessage,
   handleRequest,
   configuredPort,
+  isAllowedOrigin,
 };

package/bridge-server/probe.js

@@ -82,6 +82,61 @@ function helloProbe({ port, token, session, name, timeoutMs = 3000 }) {
   });
 }
 
+/**
+ * Ask the bridge which Chrome profiles are connected (`browserzap doctor`).
+ *
+ * Connects like helloProbe, then sends the bridge's own `profiles_list`
+ * request (answered by server.js with `{ type: 'bridge_reply', id, ok, data }`)
+ * and ends its session on close as helloProbe does, so no session lingers.
+ * Resolves { ok: true, profiles } or { ok: false, profiles: [] }. Never logs
+ * the token.
+ */
+function listProfiles({ port, token, session, name, timeoutMs = 2000 }) {
+  const requestId = 'doctor-profiles';
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`ws://${BIND_HOST}:${port}`);
+    let settled = false;
+    const finish = (result, { gracefully = false } = {}) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try {
+        if (gracefully) ws.close();
+        else ws.terminate();
+      } catch { /* already closed */ }
+      resolve(result);
+    };
+    const timer = setTimeout(() => finish({ ok: false, profiles: [] }), timeoutMs);
+    ws.on('open', () => {
+      ws.send(JSON.stringify({ type: 'hello', role: 'agent', token: token ?? '', protocolVersion: PROTOCOL_VERSION, session, name }));
+    });
+    ws.on('message', (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(String(data));
+      } catch {
+        return; // the timer covers a stuck handshake
+      }
+      if (msg.type === 'session_started') {
+        // Same rule as helloProbe: a probe's session ends with its socket.
+        const close = ws.close.bind(ws);
+        ws.close = (...closeArgs) => {
+          try { ws.send(JSON.stringify({ type: 'session_end', session: msg.session })); } catch { /* closing anyway */ }
+          close(...closeArgs);
+        };
+        ws.send(JSON.stringify({ type: 'profiles_list', id: requestId }));
+        return;
+      }
+      if (msg.type === 'bridge_reply' && msg.id === requestId) {
+        const profiles = msg.data?.profiles ?? msg.evidence?.profiles;
+        finish(Array.isArray(profiles) ? { ok: true, profiles } : { ok: false, profiles: [] }, { gracefully: true });
+      }
+    });
+    ws.on('close', () => finish({ ok: false, profiles: [] }));
+    ws.on('error', () => finish({ ok: false, profiles: [] }));
+  });
+}
+
 /** The protocol a refusing bridge says it speaks ("Version mismatch: this bridge speaks protocol 2, …"), or null. */
 function bridgeProtocolFrom(reason) {
   const m = /speaks protocol (\d+)/.exec(String(reason || ''));
@@ -121,4 +176,4 @@ async function stopBridgeOnPort(port) {
   return pids;
 }
 
-module.exports = { isListening, helloProbe, bridgeProtocolFrom, nodePidsOnPort, stopBridgeOnPort };
+module.exports = { isListening, helloProbe, listProfiles, bridgeProtocolFrom, nodePidsOnPort, stopBridgeOnPort };

package/bridge-server/server.js

@@ -74,7 +74,7 @@ const VALID_AGENT_ACTIONS = new Set([
   'status', 'inspect', 'navigate', 'click', 'fill', 'select_option', 'wait_for',
   'screenshot', 'press_key', 'scroll', 'pause', 'resume',
   'new_tab', 'list_tabs', 'switch_tab', 'close_tab', 'notify', 'upload',
-  'console', 'network',
+  'console', 'network', 'say',
 ]);
 
 const VALID_MESSAGE_TYPES = new Set([
@@ -157,8 +157,9 @@ function createBridgeServer(options = {}) {
    * Connected browser profiles. Every Chrome profile has its own copy of the
    * extension (its own instance id, tabs and logins), and each may connect
    * once (multi-profile, docs/MULTI_PROFILE.md). The same install reconnecting
-   * replaces its own socket.
-   * @type {Map<string, { ws: WebSocket, browser: string, label: string, connectedAt: number }>}
+   * replaces its own socket. `extensionVersion` is what the extension reported
+   * in its hello (WP5); null when it is older and reports nothing.
+   * @type {Map<string, { ws: WebSocket, browser: string, label: string, connectedAt: number, extensionVersion: string | null }>}
    */
   const profiles = new Map();
   /** @type {Map<WebSocket, string>} */
@@ -183,6 +184,8 @@ function createBridgeServer(options = {}) {
   };
   const profileList = (selected) => [...profiles.entries()].map(([id, p]) => ({
     id, label: p.label, browser: p.browser, connectedAt: new Date(p.connectedAt).toISOString(), selected: id === selected,
+    // What the store build said in its hello; null for a build older than 0.7.0.
+    extensionVersion: p.extensionVersion ?? null,
   }));
 
   // The side panel's workflow runner: a built-in session that drives the
@@ -552,13 +555,17 @@ function createBridgeServer(options = {}) {
     // came from auto-pairing or from a pasted token (ADR-009).
     pairing.recordPairing(id);
     const browser = typeof hello.browser === 'string' ? hello.browser : 'unknown';
+    // Additive hello field (WP5): a build older than 0.7.0 sends nothing, which
+    // is accepted as it always was. A reconnect that omits it keeps the version
+    // this profile reported before.
+    const extensionVersion = typeof hello.extensionVersion === 'string' && hello.extensionVersion ? hello.extensionVersion.slice(0, 32) : null;
     const existing = profiles.get(id);
     if (existing && existing.ws !== ws && existing.ws.readyState === WebSocket.OPEN) {
       log('Browser profile reconnected (replacing old connection)');
       existing.ws.close(CLOSE_REPLACED, 'Replaced by new extension connection');
     }
     const label = sanitizeSessionName(hello.label) ?? existing?.label ?? `Profile ${profiles.size + (existing ? 0 : 1)}`;
-    profiles.set(id, { ws, browser, label, connectedAt: Date.now() });
+    profiles.set(id, { ws, browser, label, connectedAt: Date.now(), extensionVersion: extensionVersion ?? existing?.extensionVersion ?? null });
     socketToProfile.set(ws, id);
     log(`Browser profile "${label}" connected (${browser}, ${id.slice(0, 8)}); ${profiles.size} connected`);
 

package/bridge-server/setup.js

@@ -25,12 +25,20 @@ const { configDir } = require('./secret');
 const { isListening, helloProbe } = require('./probe');
 const { DEFAULT_PORT } = require('./server');
 const { readSecret } = require('./secret');
-const { EXTENSION_ID, STORE_EXTENSION_ID, HOST_NAME, allowedOrigins, extensionIdFromKey } = require('./extension-id');
+const {
+  EXTENSION_ID,
+  STORE_EXTENSION_ID,
+  HOST_NAME,
+  allowedOrigins,
+  allowedExtensionIds,
+  setDevExtensionAllowed,
+  extensionIdFromKey,
+} = require('./extension-id');
 
 const HOST_DIR_NAME = 'native-host';
 const NATIVE_HOST_SCRIPT = path.join(__dirname, 'native-host.js');
 const MCP_ENTRY = path.join(__dirname, 'index.js');
-/** The Chrome Web Store listing (STORE_EXTENSION_ID); it opens once the listing is published. */
+/** The Chrome Web Store listing (STORE_EXTENSION_ID): the only install path for a user (D3). */
 const STORE_URL = `https://chromewebstore.google.com/detail/${STORE_EXTENSION_ID}`;
 
 /** HKCU only: no administrator rights, and the key is per-user by design. */
@@ -97,7 +105,8 @@ function hostManifest({ dir = configDir(), platform = process.platform, nodePath
     description: 'BrowserZap bridge helper: starts the local bridge and hands this extension its pairing token.',
     path: launcherPath(dir, platform),
     type: 'stdio',
-    allowed_origins: allowedOrigins(),
+    // Store id only, unless `setup --dev` saved the developer build (D4).
+    allowed_origins: allowedOrigins(allowedExtensionIds({ dir })),
   };
 }
 
@@ -356,10 +365,17 @@ function write(line = '') {
   process.stdout.write(`${line}\n`);
 }
 
-/** A file the extension may be loaded from, for the doctor's id check. */
+/**
+ * A file the extension may be loaded from, for the doctor's id check, or null.
+ *
+ * An npm install ships no extension at all (D3), so "no manifest" is a normal
+ * answer and never a path to a file that is not there (F1).
+ */
 function extensionManifestPath(root = path.join(__dirname, '..')) {
   const built = path.join(root, 'extension', 'manifest.json');
-  return fs.existsSync(built) ? built : path.join(root, 'src', 'manifest.json');
+  if (fs.existsSync(built)) return built;
+  const source = path.join(root, 'src', 'manifest.json');
+  return fs.existsSync(source) ? source : null;
 }
 
 /**
@@ -395,12 +411,16 @@ async function doctor({
   );
 
   const allowed = Array.isArray(manifest?.allowed_origins) ? manifest.allowed_origins : [];
-  const expected = allowedOrigins();
+  const expectedIds = allowedExtensionIds({ dir });
+  const expected = allowedOrigins(expectedIds);
+  const mode = expectedIds.length > 1
+    ? 'store + developer build (setup --dev)'
+    : `store only (${STORE_EXTENSION_ID})`;
   record(
-    expected.length > 1 ? 'Host allows the unpacked and store extension ids' : 'Host allows this extension id',
+    'Allowed extensions',
     expected.every((origin) => allowed.includes(origin)),
-    allowed.length ? allowed.join(', ') : 'no allowed_origins',
-    `Run: browserzap setup (expected ${expected.join(', ')})`,
+    `${mode}: ${allowed.length ? allowed.join(', ') : 'no allowed_origins'}`,
+    'Run: browserzap setup',
   );
 
   const launcher = manifest?.path;
@@ -460,17 +480,23 @@ async function doctor({
   }
 
   const extManifestFile = extensionManifest;
-  let extKey = null;
-  try {
-    extKey = JSON.parse(fs.readFileSync(extManifestFile, 'utf8')).key ?? null;
-  } catch { /* no manifest yet */ }
-  const derivedId = extensionIdFromKey(extKey);
-  record(
-    'Extension id matches its manifest key',
-    derivedId === EXTENSION_ID,
-    derivedId ? `${derivedId} (${extManifestFile})` : `no key in ${extManifestFile}`,
-    'The key in src/manifest.json changed. The native host manifest must be updated and setup re-run.',
-  );
+  if (!extManifestFile) {
+    // An npm install ships no extension: the store build is the one users have,
+    // and the host manifest already allows it. Nothing to derive.
+    record('Store extension id', true, `${STORE_EXTENSION_ID} (allowed by the native host)`);
+  } else {
+    let extKey = null;
+    try {
+      extKey = JSON.parse(fs.readFileSync(extManifestFile, 'utf8')).key ?? null;
+    } catch { /* no manifest yet */ }
+    const derivedId = extensionIdFromKey(extKey);
+    record(
+      'Extension id matches its manifest key',
+      derivedId === EXTENSION_ID,
+      derivedId ? `${derivedId} (${extManifestFile})` : `no key in ${extManifestFile}`,
+      'The key in src/manifest.json changed. The native host manifest must be updated and setup re-run.',
+    );
+  }
 
   const secret = readSecret();
   const listening = await isListening(port);
@@ -498,6 +524,24 @@ async function doctor({
       : 'Open the BrowserZap side panel; the background service starts the bridge through the native host.',
   );
 
+  // The version the connected extension reports (F4). Informational: an older
+  // store build still works, and Chrome updates it on its own.
+  let extensionVersion = 'not available';
+  if (probe.ok) {
+    try {
+      const listed = await require('./probe').listProfiles({
+        port,
+        token: secret,
+        session: 'doctor-profiles',
+        name: 'doctor',
+        timeoutMs: 2000,
+      });
+      const profile = listed.ok ? (listed.profiles.find((p) => p.selected) ?? listed.profiles[0]) : null;
+      extensionVersion = profile ? (profile.extensionVersion ?? 'not reported (older than 0.7.0)') : 'not available';
+    } catch { /* informational only */ }
+  }
+  record('Extension version', true, extensionVersion);
+
   let width = 0;
   for (const r of results) width = Math.max(width, r.name.length);
   out('BrowserZap doctor');
@@ -560,18 +604,25 @@ function wslCommand({ nodePath = process.execPath, serverPath = MCP_ENTRY, globa
  * `browserzap setup`. `args` is everything after the command word.
  * Returns the process exit code.
  */
-async function setupCommand(args = [], { extensionPath = null } = {}) {
+async function setupCommand(args = [], { extensionPath = null, dir = configDir() } = {}) {
   const yes = args.includes('--yes') || args.includes('-y');
   const skipClients = args.includes('--no-clients');
   const register = !args.includes('--no-registry');
+  const dev = args.includes('--dev');
+
+  // Saved before the host is registered: the manifest's allowed_origins must
+  // name the ids this run enables (D4). A plain `setup` switches a developer
+  // machine back to store only, and says so below.
+  setDevExtensionAllowed(dir, dev);
 
-  const result = registerNativeHost({ register });
+  const result = registerNativeHost({ dir, register });
   write('BrowserZap setup');
   if (fromNpxCache()) {
     write('  Warning: this copy runs from the npx cache, which npm may clear; Chrome and your agent would then');
     write('  lose BrowserZap. Install it once with `npm install -g browserzap`, then run `browserzap setup`.');
   }
   write(`  Extension id: ${EXTENSION_ID}`);
+  write(`  Extension mode: ${dev ? 'store + developer build (setup --dev)' : 'store only'}`);
   write(`  Host manifest: ${result.manifestPaths[0]}`);
   write(`  Launcher:      ${result.launcher}`);
   if (result.registryKey && register) {
@@ -625,11 +676,17 @@ async function setupCommand(args = [], { extensionPath = null } = {}) {
   }
 
   write('Next:');
-  write(`  1. Add the extension: ${STORE_URL}`);
-  write('     (Chrome Web Store; the listing is in review. Until it opens there:');
-  write(`      chrome://extensions → Developer mode → Load unpacked → ${extensionPath ?? 'the extension/ folder of this package'})`);
+  write(`  1. Install the extension: ${STORE_URL}`);
+  write('     (Chrome keeps it updated.)');
+  if (extensionPath) {
+    // A source checkout only: the store is the install path for a user (D3).
+    write(`     Developer build: chrome://extensions → Developer mode → Load unpacked → ${extensionPath}`);
+  }
   write('  2. Open the BrowserZap side panel. It connects automatically; no token to paste.');
   write('  3. Open your MCP client and start work. `browserzap doctor` re-checks this setup.');
+  if (!dev && extensionPath) {
+    write('  (To connect an unpacked build instead, run: browserzap setup --dev)');
+  }
   return result.ok || !result.registryKey ? 0 : 1;
 }
 
@@ -650,6 +707,7 @@ function confirm(question) {
 }
 
 module.exports = {
+  STORE_URL,
   launcherTargets,
   blockingPolicy,
   fromNpxCache,
@@ -674,6 +732,7 @@ module.exports = {
   defaultRegistryRunner,
   planMcpClients,
   applyMcpPlan,
+  extensionManifestPath,
   doctor,
   setupCommand,
 };

package/bridge-server/tools.js

@@ -341,6 +341,19 @@ const MCP_TOOLS = [
       properties: { tabId: { type: 'integer', minimum: 0 } },
     },
   },
+  {
+    name: 'chat_reply',
+    description:
+      'Write to the person in the BrowserZap side panel chat, as your message. Use it to answer a message they sent ' +
+      '(read with feedback_get) or to say what you are about to do. Plain text, shown only on this computer; never put ' +
+      'passwords or other secrets in it.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['message'],
+      properties: { message: { type: 'string', minLength: 1, maxLength: 2000 } },
+    },
+  },
   {
     name: 'browser_set_session_name',
     description: 'Name this session; the name appears on the Chrome tab group so the user knows what it is doing.',
@@ -680,6 +693,7 @@ const ANNOTATIONS = {
   screenshot_capture: ['Screenshot', READ],
   browser_press_key: ['Press key', { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }],
   browser_scroll: ['Scroll', { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }],
+  chat_reply: ['Reply in the side panel', { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }],
   task_pause: ['Hand over to the user', { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }],
   task_resume: ['Wait for the user', LOCAL_READ],
   browser_new_tab: ['New tab', { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }],
@@ -736,6 +750,7 @@ const TOOL_TO_ACTION = {
   browser_scroll: 'scroll',
   task_pause: 'pause',
   task_resume: 'resume',
+  chat_reply: 'say',
   browser_new_tab: 'new_tab',
   browser_list_tabs: 'list_tabs',
   browser_switch_tab: 'switch_tab',
@@ -814,4 +829,16 @@ function validateArguments(tool, args) {
   return check(tool.inputSchema, args ?? {}, 'arguments');
 }
 
-module.exports = { MCP_TOOLS, TOOL_TO_ACTION, INTERNAL_ACTIONS, PAGE_TOOLS, LOCAL_TOOLS, validateArguments, check };
+/**
+ * Tools held back for internal testing (0.8). They are offered only when
+ * BROWSERZAP_EXPERIMENTAL lists their feature, e.g. BROWSERZAP_EXPERIMENTAL=chat.
+ * A hidden tool is also refused if called (mcp-server.js looks tools up here).
+ */
+const EXPERIMENTAL_TOOLS = Object.freeze({ chat_reply: 'chat' });
+const enabledExperiments = new Set(String(process.env.BROWSERZAP_EXPERIMENTAL ?? '').split(',').map((s) => s.trim()).filter(Boolean));
+for (let i = MCP_TOOLS.length - 1; i >= 0; i--) {
+  const feature = EXPERIMENTAL_TOOLS[MCP_TOOLS[i].name];
+  if (feature && !enabledExperiments.has(feature)) MCP_TOOLS.splice(i, 1);
+}
+
+module.exports = { EXPERIMENTAL_TOOLS, MCP_TOOLS, TOOL_TO_ACTION, INTERNAL_ACTIONS, PAGE_TOOLS, LOCAL_TOOLS, validateArguments, check };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browserzap",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Let your AI agent (Claude Code, Codex, Cursor or any MCP client) work in your own Chrome, with your logins, your approval and a Stop button.",
   "homepage": "https://browserzap.com",
   "bugs": {
@@ -31,13 +31,11 @@
   },
   "files": [
     "bridge-server/",
-    "extension/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
     "LICENSE-UPSTREAM",
-    "THIRD_PARTY_NOTICES.md",
-    "!extension/**/*.map"
+    "THIRD_PARTY_NOTICES.md"
   ],
   "engines": {
     "node": ">=22"
@@ -89,7 +87,8 @@
     "ts-loader": "^9.5.1",
     "typescript": "^5.6.3",
     "webpack": "^5.96.1",
-    "webpack-cli": "^5.1.4"
+    "webpack-cli": "^5.1.4",
+    "preact": "^10.29.8"
   },
   "dependencies": {
     "ws": "^8.22.0"