@evan_zhong/browser-attach 0.16.0 → 0.17.2

package/extension/background.js

@@ -1,98 +1,7 @@
-import { CONNECTION } from './config.generated.js';
-import { createController } from './controller.js';
-
-let socket;
-let connecting = false;
-let keepAlive;
-let reconnect;
-let status = 'disconnected';
-let identity;
-const controller = createController(chrome, event => {
-  if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(event));
-});
-
-async function getIdentity() {
-  const local = await chrome.storage.local.get(['instanceId', 'profileName']);
-  const session = await chrome.storage.session.get('runId');
-  const instanceId = local.instanceId || crypto.randomUUID();
-  const runId = session.runId || crypto.randomUUID();
-  if (!local.instanceId) await chrome.storage.local.set({ instanceId });
-  if (!session.runId) await chrome.storage.session.set({ runId });
-  const family = /Edg\//.test(navigator.userAgent) ? 'edge' : 'chrome';
-  return { instance_id: instanceId, run_id: runId, family,
-    profile_name: local.profileName || (family === 'edge' ? 'Edge' : 'Chrome'),
-    user_agent: navigator.userAgent, extension_id: chrome.runtime.id, extension_version: chrome.runtime.getManifest().version };
-}
-
-async function connect() {
-  if (connecting || socket?.readyState === WebSocket.OPEN) return;
-  connecting = true;
-  try {
-    identity = await getIdentity();
-    const ws = new WebSocket(CONNECTION.url);
-    socket = ws;
-    ws.onopen = () => {
-      ws.send(JSON.stringify({ type: 'hello', token: CONNECTION.token, browser: identity }));
-      keepAlive = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'ping' }));
-      }, 20000);
-    };
-    ws.onmessage = async event => {
-      let request;
-      try {
-        request = JSON.parse(event.data);
-        if (request.type === 'connected') {
-          status = 'connected';
-          await chrome.action.setBadgeText({ text: 'ON' });
-          await chrome.action.setBadgeBackgroundColor({ color: '#13755b' });
-          return;
-        }
-        if (!request.id) return;
-        const result = await controller.execute(request.owner, request.command, request.arguments || {});
-        if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ id: request.id, result }));
-      } catch (error) {
-        if (request?.id && ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ id: request.id, error: error.message || String(error) }));
-        }
-      }
-    };
-    ws.onclose = async () => {
-      clearInterval(keepAlive);
-      status = 'disconnected';
-      connecting = false;
-      await controller.releaseAll();
-      await chrome.action.setBadgeText({ text: 'OFF' });
-      clearTimeout(reconnect);
-      reconnect = setTimeout(connect, 2000);
-    };
-    ws.onerror = () => ws.close();
-  } catch (error) {
-    connecting = false;
-    status = error.message;
-  }
-}
-
-chrome.runtime.onMessage.addListener((message, sender, respond) => {
-  if (sender.id !== chrome.runtime.id) return;
-  if (message.type === 'status') {
-    getIdentity().then(browser => respond({ status, browser, claims: controller.claimedCount() }));
-    return true;
-  }
-  if (message.type === 'reconnect') {
-    if (socket?.readyState === WebSocket.OPEN) socket.close();
-    else connect();
-    respond({ ok: true });
-  }
-  if (message.type === 'release_all') {
-    controller.releaseAll().then(() => respond({ ok: true }));
-    return true;
-  }
-});
-chrome.alarms.onAlarm.addListener(alarm => { if (alarm.name === 'connect') connect(); });
-chrome.runtime.onStartup.addListener(connect);
-chrome.runtime.onInstalled.addListener(async () => {
-  await chrome.alarms.create('connect', { periodInMinutes: 0.5 });
-  connect();
-});
-chrome.alarms.create('connect', { periodInMinutes: 0.5 });
-connect();
+import { CONNECTION } from './config.generated.js';
+import { createController } from './controller.js';
+import { createConnection } from './connection.js';
+
+let connection;
+const controller = createController(chrome, event => connection?.send(event));
+connection = createConnection(chrome, CONNECTION, controller);

package/extension/connection.js

@@ -0,0 +1,142 @@
+import { compareVersions } from './version.js';
+
+export function createConnection(chrome, CONNECTION, controller) {
+  let socket;
+  let connecting = false;
+  let keepAlive;
+  let reconnect;
+  let status = 'disconnected';
+  let identity;
+  let maintenance = false;
+  let cleanup = Promise.resolve();
+
+  async function release() {
+    const result = await controller.releaseAll();
+    if (result.errors?.length) throw new Error(`Extension cleanup failed: ${result.errors.join('; ')}`);
+  }
+
+  async function prepareReload(version) {
+    const current = chrome.runtime.getManifest().version;
+    if (compareVersions(version, current) <= 0) throw new Error('Reload target must be newer than the running extension');
+    const response = await fetch(chrome.runtime.getURL('manifest.json'), { cache: 'no-store' });
+    if (!response.ok || (await response.json()).version !== version) throw new Error('Extension files do not match the Hub; reload was not attempted');
+    const previous = (await chrome.storage.local.get('reloadAttempt')).reloadAttempt;
+    if (previous?.from === current && previous.target === version) throw new Error('Extension reload did not apply the update; reload manually after checking the extension directory');
+    maintenance = true;
+    await release();
+    await chrome.storage.local.set({ reloadAttempt: { from: current, target: version } });
+  }
+
+  async function getIdentity() {
+    const local = await chrome.storage.local.get(['instanceId', 'profileName']);
+    const session = await chrome.storage.session.get('runId');
+    const instanceId = local.instanceId || crypto.randomUUID();
+    const runId = session.runId || crypto.randomUUID();
+    if (!local.instanceId) await chrome.storage.local.set({ instanceId });
+    if (!session.runId) await chrome.storage.session.set({ runId });
+    const family = /Edg\//.test(navigator.userAgent) ? 'edge' : 'chrome';
+    return { instance_id: instanceId, run_id: runId, family,
+      profile_name: local.profileName || (family === 'edge' ? 'Edge' : 'Chrome'),
+      user_agent: navigator.userAgent, extension_id: chrome.runtime.id, extension_version: chrome.runtime.getManifest().version };
+  }
+
+  async function connect() {
+    if (connecting || socket?.readyState === WebSocket.OPEN) return;
+    connecting = true;
+    try {
+      await cleanup;
+      await release();
+      identity = await getIdentity();
+      const ws = new WebSocket(CONNECTION.url);
+      socket = ws;
+      ws.onopen = () => {
+        ws.send(JSON.stringify({ type: 'hello', token: CONNECTION.token, browser: identity }));
+        keepAlive = setInterval(() => {
+          if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'ping' }));
+        }, 20000);
+      };
+      ws.onmessage = async event => {
+        let request;
+        try {
+          request = JSON.parse(event.data);
+          if (request.type === 'connected') {
+            maintenance = false;
+            status = 'connected';
+            await chrome.storage.local.remove('reloadAttempt');
+            await chrome.action.setBadgeText({ text: 'ON' });
+            await chrome.action.setBadgeBackgroundColor({ color: '#13755b' });
+            return;
+          }
+          if (!request.id) return;
+          let result;
+          if (request.command === 'prepare_upgrade') {
+            maintenance = true;
+            await release();
+            result = { prepared: true };
+          } else if (request.command === 'resume') {
+            maintenance = false;
+            result = { resumed: true };
+          } else if (request.command === 'reload_extension') {
+            await prepareReload(request.arguments?.version);
+            if (ws.readyState !== WebSocket.OPEN) return;
+            ws.send(JSON.stringify({ id: request.id, result: { reloading: true } }));
+            chrome.runtime.reload();
+            return;
+          } else {
+            if (maintenance) throw new Error('Extension is preparing an upgrade');
+            result = await controller.execute(request.owner, request.command, request.arguments || {});
+          }
+          if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ id: request.id, result }));
+        } catch (error) {
+          if (request?.id && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ id: request.id, error: error.message || String(error) }));
+          }
+        }
+      };
+      ws.onclose = () => {
+        clearInterval(keepAlive);
+        status = 'disconnected';
+        connecting = false;
+        cleanup = release().catch(error => { status = error.message; });
+        chrome.action.setBadgeText({ text: 'OFF' }).catch(() => {});
+        scheduleReconnect();
+      };
+      ws.onerror = () => ws.close();
+    } catch (error) {
+      connecting = false;
+      status = error.message;
+      scheduleReconnect();
+    }
+  }
+
+  function scheduleReconnect() {
+    clearTimeout(reconnect);
+    reconnect = setTimeout(connect, 2000);
+  }
+
+  chrome.runtime.onMessage.addListener((message, sender, respond) => {
+    if (sender.id !== chrome.runtime.id) return;
+    if (message.type === 'status') {
+      getIdentity().then(browser => respond({ status, browser, claims: controller.claimedCount() }));
+      return true;
+    }
+    if (message.type === 'reconnect') {
+      if (socket?.readyState === WebSocket.OPEN) socket.close();
+      else connect();
+      respond({ ok: true });
+    }
+    if (message.type === 'release_all') {
+      release().then(() => respond({ ok: true }), error => respond({ ok: false, error: error.message }));
+      return true;
+    }
+  });
+  chrome.alarms.onAlarm.addListener(alarm => { if (alarm.name === 'connect') connect(); });
+  chrome.runtime.onStartup.addListener(connect);
+  chrome.runtime.onInstalled.addListener(async () => {
+    await chrome.alarms.create('connect', { periodInMinutes: 0.5 });
+    connect();
+  });
+  chrome.alarms.create('connect', { periodInMinutes: 0.5 });
+  connect();
+  return { send(event) { if (socket?.readyState === WebSocket.OPEN) socket.send(JSON.stringify(event)); } };
+}

package/extension/controller.js

@@ -343,7 +343,7 @@ export function createController(api, notify = () => {}) {
       }
       const rendered = renderAX(nodes, token, refs, frame.id, target.sessionId, options);
       if (rendered.length || options.query == null) entries.push({ node: false, frameId: frame.id, line: `Frame ${frame.id} ${frame.url}` });
-      entries.push(...rendered);
+      for (const entry of rendered) entries.push(entry);
     }
     const metadata = value(await send(tabId, 'Runtime.evaluate', {
       expression: '({title: document.title, url: location.href})', returnByValue: true,

package/extension/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "BrowserAttach",
-  "version": "0.16.0",
+  "version": "0.17.2",
   "description": "Connect existing Chrome and Edge tabs to a locally paired MCP client.",
   "minimum_chrome_version": "125",
   "permissions": [

package/extension/popup.js

@@ -4,7 +4,13 @@ async function refresh() {
   document.querySelector('#profile').textContent = `${result.browser.family} · ${result.browser.profile_name}`;
   document.querySelector('#claims').textContent = `正在控制 ${result.claims} 个标签页`;
 }
-document.querySelector('#release').onclick = async () => { await chrome.runtime.sendMessage({ type: 'release_all' }); await refresh(); };
+document.querySelector('#release').onclick = async () => {
+  try {
+    const result = await chrome.runtime.sendMessage({ type: 'release_all' });
+    await refresh();
+    if (!result.ok) document.querySelector('#status').textContent = `释放失败：${result.error}`;
+  } catch (error) { document.querySelector('#status').textContent = `释放失败：${error.message}`; }
+};
 document.querySelector('#reconnect').onclick = async () => { await chrome.runtime.sendMessage({ type: 'reconnect' }); await refresh(); };
 document.querySelector('#settings').onclick = () => chrome.runtime.openOptionsPage();
 refresh().catch(error => { document.querySelector('#status').textContent = error.message; });

package/extension/snapshot.js

@@ -21,11 +21,15 @@ export function renderAX(nodes, token, refs, frameId, sessionId, options = snaps
     const parents = new Map();
     for (const node of nodes) for (const child of node.childIds || []) parents.set(child, node.nodeId);
     function keepText(node) {
-      if (!node || kept.has(node.nodeId)) return;
-      const role = node.role?.value;
-      if (!textRoles.has(role) && !node.ignored && !['none', 'generic'].includes(role)) return;
-      kept.add(node.nodeId);
-      for (const child of node.childIds || []) keepText(byId.get(child));
+      const pending = [node];
+      while (pending.length) {
+        const current = pending.pop();
+        if (!current || kept.has(current.nodeId)) continue;
+        const role = current.role?.value;
+        if (!textRoles.has(role) && !current.ignored && !['none', 'generic'].includes(role)) continue;
+        kept.add(current.nodeId);
+        for (const child of current.childIds || []) pending.push(byId.get(child));
+      }
     }
     for (const node of nodes) {
       if (node.ignored || !node.backendDOMNodeId || !(controls.has(node.role?.value) ||
@@ -37,19 +41,33 @@ export function renderAX(nodes, token, refs, frameId, sessionId, options = snaps
     }
   }
   function plainText(node) {
-    if (!node) return null;
-    const role = node.role?.value;
-    if (textRoles.has(role)) return String(node.name?.value || '');
-    if (!node.ignored && !['none', 'generic'].includes(role)) return null;
-    const parts = (node.childIds || []).map(id => plainText(byId.get(id)));
-    return parts.includes(null) ? null : parts.join(' ');
+    const pending = [node], parts = [];
+    while (pending.length) {
+      const current = pending.pop();
+      if (current === ' ') { parts.push(' '); continue; }
+      if (!current) return null;
+      const role = current.role?.value;
+      if (textRoles.has(role)) { parts.push(String(current.name?.value || '')); continue; }
+      if (!current.ignored && !['none', 'generic'].includes(role)) return null;
+      const children = current.childIds || [];
+      for (let index = children.length - 1; index >= 0; index--) {
+        pending.push(byId.get(children[index]));
+        if (index > 0) pending.push(' ');
+      }
+    }
+    return parts.join('');
   }
-  function render(node, depth, parentName = '') {
-    if (!node || visited.has(node.nodeId)) return;
+  // Preserve preorder and ref numbering without using the JavaScript call stack.
+  const children = new Set();
+  for (const node of nodes) for (const child of node.childIds || []) children.add(child);
+  const pending = nodes.filter(node => !children.has(node.nodeId)).reverse().map(node => ({ node, depth: 0, parentName: '' }));
+  while (pending.length) {
+    const { node, depth, parentName } = pending.pop();
+    if (!node || visited.has(node.nodeId)) continue;
     visited.add(node.nodeId);
-    if (kept && !kept.has(node.nodeId)) return;
+    if (kept && !kept.has(node.nodeId)) continue;
     const role = node.role?.value || 'node';
-    if (role === 'InlineTextBox') return;
+    if (role === 'InlineTextBox') continue;
     let name = String(node.name?.value || '');
     let merged = false;
     if (['listitem', 'paragraph'].includes(role) && !name) {
@@ -77,11 +95,13 @@ export function renderAX(nodes, token, refs, frameId, sessionId, options = snaps
       }
       nextDepth++;
     }
-    if (!merged) for (const child of node.childIds || []) render(byId.get(child), nextDepth, skip ? parentName : identityName);
+    if (!merged) {
+      const childIds = node.childIds || [];
+      for (let index = childIds.length - 1; index >= 0; index--) {
+        pending.push({ node: byId.get(childIds[index]), depth: nextDepth, parentName: skip ? parentName : identityName });
+      }
+    }
   }
-  // AX trees normally have a single root, but ignored roots can be disconnected.
-  const children = new Set(nodes.flatMap(node => node.childIds || []));
-  for (const node of nodes) if (!children.has(node.nodeId)) render(node, 0);
   return entries;
 }
 

package/extension/version.js

@@ -0,0 +1,11 @@
+export function compareVersions(a, b) {
+  const parse = value => {
+    if (typeof value !== 'string' || !/^\d+\.\d+\.\d+$/.test(value)) throw new Error('Invalid BrowserAttach version');
+    const parts = value.split('.').map(Number);
+    if (!parts.every(Number.isSafeInteger)) throw new Error('Invalid BrowserAttach version');
+    return parts;
+  };
+  const left = parse(a), right = parse(b);
+  for (let i = 0; i < left.length; i++) if (left[i] !== right[i]) return Math.sign(left[i] - right[i]);
+  return 0;
+}

package/extension/wait.js

@@ -70,7 +70,7 @@ export function inspectWait(query, inspect, args) {
   if (!element) return { satisfied: false, state: 'absent' };
   if (args.condition === 'attached') return { satisfied: true, state: 'attached' };
   if (args.condition === 'text') {
-    const text = element.textContent || '';
+    const text = element.innerText ?? '';
     return { satisfied: args.previous != null ? text !== args.previous : text.includes(args.expected), text: text.slice(0, 500) };
   }
   const bounds = inspect.call(element);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evan_zhong/browser-attach",
-  "version": "0.16.0",
+  "version": "0.17.2",
   "description": "MCP for existing signed-in Chrome and Edge tabs through a locally paired extension",
   "type": "module",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "test": "node --test tests/*.test.mjs",
     "test:live": "node scripts/live-smoke.mjs",
     "test:interaction": "node scripts/interaction-smoke.mjs",
+    "test:upgrade": "node scripts/upgrade-smoke.mjs",
     "test:package": "node scripts/package-smoke.mjs",
     "prepack": "node scripts/check-package.mjs"
   },

package/scripts/check-package.mjs

@@ -14,6 +14,7 @@ const names = result.files.map(file => file.path);
 for (const path of names) {
   if (/config\.generated\.js|(^|\/)(\.local|\.venv|test-results|node_modules)\//.test(path)) throw new Error(`Private file included in package: ${path}`);
 }
+for (const path of ['extension/connection.js', 'extension/version.js']) if (!names.includes(path)) throw new Error(`Package is missing ${path}`);
 for (const path of ['bin/browser-attach.mjs', 'src/mcp.mjs', 'src/hub.mjs', 'extension/manifest.json', 'extension/evaluate.js', 'extension/fetch.js', 'extension/locator.js', 'extension/batch.js', 'extension/wait.js', 'extension/outcomes.js', 'extension/scroll.js', 'extension/drag.js', 'extension/text.js', 'extension/diagnostics.js', 'extension/sessions.js', 'extension/actionability.js', 'extension/limits.js', 'extension/icons/BrowserAttach.png']) {
   if (!names.includes(path)) throw new Error(`Package is missing ${path}`);
 }

package/src/client.mjs

@@ -5,43 +5,86 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import WebSocket from 'ws';
 import { loadConfig, VERSION } from './config.mjs';
+import { compareVersions } from '../extension/version.js';
 
-export async function hubIsRunning(config) {
+async function hubHealth(config) {
   let response;
   try {
     response = await fetch(`http://127.0.0.1:${config.port}/health`, {
       headers: { Authorization: `Bearer ${config.token}` }, signal: AbortSignal.timeout(1000),
     });
   } catch (error) {
-    if (error.cause?.code === 'ECONNREFUSED' || error.name === 'TimeoutError') return false;
+    if (['ECONNREFUSED', 'ECONNRESET', 'ECONNABORTED', 'UND_ERR_SOCKET'].includes(error.cause?.code) || error.name === 'TimeoutError') return null;
     throw error;
   }
   if (!response.ok) throw new Error('BrowserAttach port is occupied by an unpaired service');
   const health = await response.json();
-  if (health.service !== 'browser-attach' || health.version !== VERSION)
-    throw new Error('Hub version differs from this package; stop the hub and start again.');
-  return true;
+  if (health.service !== 'browser-attach') throw new Error('BrowserAttach port is occupied by another service');
+  compareVersions(health.version, VERSION);
+  return health;
+}
+
+export async function hubIsRunning(config) {
+  const health = await hubHealth(config);
+  if (!health) return false;
+  if (health.version !== VERSION) throw new Error(`Hub ${health.version} differs from this package ${VERSION}; reconnect MCP to coordinate an upgrade`);
+  return health.state === 'ready';
 }
 
 export async function ensureHub(configPath) {
   configPath = resolve(configPath);
   const config = await loadConfig(configPath);
-  if (await hubIsRunning(config)) return config;
+  const deadline = Date.now() + 18000;
+  const expected = new Set();
+  let spawned = false, requested = false, readyAfter = 0, spawnError;
+  while (Date.now() < deadline) {
+    if (spawnError) throw spawnError;
+    const health = await hubHealth(config);
+    if (!health) {
+      if (!spawned) {
+        spawned = true;
+        await spawnHub(configPath, error => { spawnError = error; });
+        readyAfter = Date.now() + 2500;
+      }
+    } else {
+      const comparison = compareVersions(health.version, VERSION);
+      if (comparison > 0) throw new Error(`Hub ${health.version} is newer than this package ${VERSION}; refusing to downgrade`);
+      if (comparison < 0 && health.state == null) {
+        throw new Error(`Hub ${health.version} predates coordinated upgrades; run browser-attach stop, restart MCP, and reload the extension manually if it was already loaded`);
+      }
+      if (comparison < 0 && health.state === 'ready' && !requested) {
+        requested = true;
+        for (const item of health.extensions) expected.add(item.instance_id);
+        const response = await fetch(`http://127.0.0.1:${config.port}/upgrade`, { method: 'POST',
+          headers: { Authorization: `Bearer ${config.token}`, 'X-Browser-Attach-Version': VERSION }, signal: AbortSignal.timeout(10000) });
+        const result = await response.json();
+        if (!response.ok) {
+          const current = await hubHealth(config);
+          if (current && compareVersions(current.version, VERSION) < 0 && !['upgrading', 'stopping'].includes(current.state)) throw new Error(result.error);
+        } else for (const id of result.extensions) expected.add(id);
+      } else if (comparison < 0 && health.state === 'ready' && requested) {
+        throw new Error(health.upgrade_error || 'Hub upgrade did not complete; reconnect MCP to retry');
+      } else if (comparison === 0 && health.state === 'ready') {
+        const failure = health.extensions.find(item => item.error);
+        if (failure) throw new Error(`Extension upgrade failed (${failure.instance_id}): ${failure.error}`);
+        for (const item of health.extensions) if (item.ready) expected.delete(item.instance_id);
+        if (!expected.size && health.extensions.every(item => item.ready) && Date.now() >= readyAfter) return config;
+      }
+    }
+    await new Promise(resolve => setTimeout(resolve, 150));
+  }
+  throw new Error(`Hub/extension upgrade did not become ready${expected.size ? `; waiting for ${[...expected].join(', ')}` : ''}. See ${join(dirname(configPath), 'hub.log')}`);
+}
+
+async function spawnHub(configPath, onError) {
   await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
   const log = await open(join(dirname(configPath), 'hub.log'), 'a', 0o600);
   const child = spawn(process.execPath, [fileURLToPath(new URL('../bin/browser-attach.mjs', import.meta.url)), 'hub', '--config', configPath], {
     detached: true, windowsHide: true, stdio: ['ignore', log.fd, log.fd],
     env: { ...process.env, BROWSER_ATTACH_HOME: dirname(configPath) },
   });
-  let spawnError;
-  child.on('error', error => { spawnError = error; });
+  child.on('error', onError);
   child.unref(); await log.close();
-  for (let i = 0; i < 40; i++) {
-    if (spawnError) throw spawnError;
-    await new Promise(resolve => setTimeout(resolve, 150));
-    if (await hubIsRunning(config)) return config;
-  }
-  throw new Error(`Hub did not start. See ${join(dirname(configPath), 'hub.log')}`);
 }
 
 export class AttachClient {
@@ -51,7 +94,7 @@ export class AttachClient {
     if (this.connecting) return this.connecting;
     this.connecting = new Promise((resolve, reject) => {
       const ws = new WebSocket(`ws://127.0.0.1:${this.config.port}/client`, {
-        headers: { Authorization: `Bearer ${this.config.token}` }, maxPayload: 24 * 1024 * 1024,
+        headers: { Authorization: `Bearer ${this.config.token}`, 'X-Browser-Attach-Version': VERSION }, maxPayload: 24 * 1024 * 1024,
       });
       this.socket = ws;
       ws.once('open', resolve); ws.once('error', reject);

package/src/config.mjs

@@ -15,13 +15,17 @@ export const DATA_DIR = configuredHome
   : process.platform === 'win32' ? join(homedir(), '.browser-attach')
     : join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'browser-attach');
 export const DEFAULT_CONFIG = join(DATA_DIR, 'config.json');
-export const VERSION = '0.16.0';
+export const VERSION = '0.17.2';
 
 export async function loadConfig(path = DEFAULT_CONFIG) {
   let config;
   try { config = JSON.parse(await readFile(path, 'utf8')); }
   catch (error) { throw new Error(`Cannot read pairing config ${path}${error.code ? ` (${error.code})` : ''}. Run browser-attach setup.`, { cause: error }); }
+  // Pre-0.17 pairings did not record the extension directory; their setup default
+  // was a sibling `extension` directory next to the pairing file.
+  if (config.extension_dir === undefined) config.extension_dir = join(dirname(resolve(path)), 'extension');
   if (typeof config.token !== 'string' || config.token.length < 32 ||
+      typeof config.extension_dir !== 'string' || !isAbsolute(config.extension_dir) ||
       !Number.isInteger(config.port) || config.port < 1024 || config.port > 65535 ||
       !/^[a-p]{32}$/.test(config.extension_id)) throw new Error('Invalid pairing config. Run browser-attach setup.');
   return config;