syncme-mcp 0.0.0-stage → 1.0.1

package/LICENSE

@@ -0,0 +1,75 @@
+Required Notice: Copyright Kevin Lin (https://github.com/levinkin)
+
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose.  However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies of the software.  Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

package/PRIVACY.md

@@ -0,0 +1,11 @@
+# syncme privacy policy
+
+syncme doesn't collect, send or sell any data.
+
+when you click copy on a site, the extension reads that site's cookies and passes them to the syncme bridge running on your own computer. the bridge saves them into a separate chrome profile on that same computer. nothing leaves your machine and there's no server.
+
+the extension only reads cookies for sites you added yourself. the list of saved sites and the auto-copy setting are kept in chrome's local extension storage.
+
+no analytics, no tracking, no third parties.
+
+questions: open an issue at https://github.com/levinkin/syncme/issues

package/README.md

@@ -1,3 +1,81 @@
-# Temporary Holding Version
+# syncme
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+copies your logins for a site from your normal chrome into a separate chrome that ai agents and scripts can drive. so jev, browser-use or playwright can use your accounts without touching your real browser.
+
+## how it works
+
+1. when you're on a site you want, click the syncme icon and it asks if you want to copy it over
+2. syncme grabs that site's cookies and puts them in its own chrome profile (the "ai browser"). this runs headless in the background, nothing pops up
+3. when a script needs the browser, run `npx -y syncme-mcp open`. the ai browser opens as normal chrome with your logins already in it and prints a cdp url to connect to
+
+it only copies cookies for sites you said yes to. no passwords, no other sites. syncme never touches your real chrome profile.
+
+there's also a setting to re-copy all your saved sites every time the ai browser starts, so logins stay fresh.
+
+## setup
+
+needs chrome and node 20 or newer. works on mac and windows.
+
+there's nothing to install: the extension talks to the bridge over a websocket on 127.0.0.1, and any command starts the bridge itself.
+
+1. install the extension (chrome web store, or load this folder unpacked from `chrome://extensions` with developer mode on)
+2. click the syncme icon and use one of the connect buttons, or run `npx -y syncme-mcp setup` to wire up claude code, codex, cursor, windsurf and claude desktop
+
+## commands
+
+```
+npx -y syncme-mcp open                       # start the ai browser, prints {"cdp": "http://127.0.0.1:<port>"}
+npx -y syncme-mcp sync https://example.com   # copy one site, asks you in chrome first if it's not saved yet
+npx -y syncme-mcp stop                       # close the ai browser
+npx -y syncme-mcp shutdown                   # close it and stop the bridge
+npx -y syncme-mcp setup                      # add the mcp server to the ai apps you have installed
+npx -y syncme-mcp unpair                     # forget the paired extension, for when you reinstall it
+npx -y syncme-mcp pack                       # build syncme.zip for the web store
+```
+
+connecting from playwright:
+
+```js
+import {chromium} from 'playwright-core';
+import {execFileSync} from 'node:child_process';
+
+const {cdp} = JSON.parse(execFileSync('npx', ['-y', 'syncme-mcp', 'open']));
+const browser = await chromium.connectOverCDP(cdp);
+await (await browser.contexts()[0].newPage()).goto('https://example.com');
+```
+
+## mcp
+
+you can also hook it up as an mcp server so your ai can ask for a site itself. it calls `copy_site` with something like `https://github.com`, you get a popup in chrome asking if it can have that login, and if you say yes it copies it and gets back the cdp url. there's also `open_browser` and `close_browser`.
+
+```
+claude mcp add --scope user syncme -- npx -y syncme-mcp
+codex mcp add syncme -- npx -y syncme-mcp
+npx -y syncme-mcp setup   # does both of the above, plus the json configs
+```
+
+or by hand:
+
+```json
+{
+  "mcpServers": {
+    "syncme": {
+      "command": "npx",
+      "args": ["-y", "syncme-mcp"]
+    }
+  }
+}
+```
+
+keep chrome open with the extension for it to work, since syncme takes the cookies from there.
+
+## notes
+
+- the ai browser profile lives in `~/Library/Application Support/syncme` on mac, `%LOCALAPPDATA%\syncme` on windows and `~/.local/state/syncme` on linux
+- removing a site from the list stops future copies, but the ai browser keeps cookies it already has
+- the extension and syncme pair the first time they connect and check each other after that, so other accounts on your computer can't pose as either one
+- the bridge listens only on `127.0.0.1:47621`, only accepts a websocket whose origin is this extension, and only takes commands from a local token only your user can read
+
+## license
+
+[PolyForm Noncommercial 1.0.0](LICENSE). free to use, change and share for anything that isn't commercial. if you want to use it for a business, ask me.

package/approve.html

@@ -0,0 +1,17 @@
+<!doctype html>
+<html lang="en"><meta charset="utf-8"><title>syncme</title>
+<style>body{font:15px system-ui;width:340px;margin:16px}button{padding:8px 14px}li{margin:6px 0}li button{padding:2px 8px;margin-left:6px}label{display:block;margin:14px 0}#question{font-weight:600}</style>
+<p id="question"></p>
+<button id="copy">Copy</button> <button id="deny" hidden>No</button>
+<p id="status" role="status"></p>
+<div id="settings">
+<label><input type="checkbox" id="auto"> Copy all saved sites when the AI browser starts</label>
+<h2>Saved sites</h2>
+<ul id="approved"></ul>
+<h2>Connect your ai</h2>
+<p id="waiting" hidden>connect an ai app first.</p>
+<p id="pairing" hidden><span></span> <button id="repair">Re-pair</button></p>
+<p><a id="cursor" hidden>Add to Cursor</a> <a id="vscode" hidden>Add to VS Code</a></p>
+<button id="claude">Copy Claude Code command</button> <button id="setup">Copy setup command</button>
+</div>
+<script src="approve.js"></script></html>

package/approve.js

@@ -0,0 +1,76 @@
+const status = document.querySelector('#status');
+const question = document.querySelector('#question');
+const copyButton = document.querySelector('#copy');
+const auto = document.querySelector('#auto');
+let site;
+async function render() {
+  const {approved = []} = await chrome.storage.local.get('approved');
+  const list = document.querySelector('#approved');
+  list.replaceChildren();
+  for (const value of approved) {
+    const li = document.createElement('li');
+    li.append(document.createTextNode(new URL(value).host));
+    const button = document.createElement('button');
+    button.textContent = 'Remove';
+    button.onclick = async () => {
+      const {approved = []} = await chrome.storage.local.get('approved');
+      await chrome.storage.local.set({approved: approved.filter(x => x !== value)});
+      status.textContent = 'Removed. The AI browser keeps cookies it already has.';
+      await render();
+    };
+    li.append(button); list.append(li);
+  }
+}
+const requested = new URLSearchParams(location.search).get('site');
+if (requested) {
+  question.textContent = `Your AI wants your ${new URL(requested).host} login. Copy it?`;
+  document.querySelector('#settings').hidden = true;
+  const deny = document.querySelector('#deny');
+  deny.hidden = false;
+  copyButton.onclick = () => chrome.runtime.sendMessage({op: 'allow', answer: true});
+  deny.onclick = () => chrome.runtime.sendMessage({op: 'allow', answer: false});
+} else chrome.tabs.query({active: true, currentWindow: true}).then(([tab]) => {
+  const u = tab?.url ? new URL(tab.url) : null;
+  if (u && ['http:', 'https:'].includes(u.protocol)) {
+    site = u.origin;
+    question.textContent = `Copy ${u.host} to your AI browser?`;
+  } else {
+    question.textContent = 'Open a website to copy it.';
+    copyButton.hidden = true;
+  }
+});
+if (!requested) copyButton.onclick = async () => {
+  copyButton.disabled = true;
+  status.textContent = 'Copying...';
+  try {
+    const result = await chrome.runtime.sendMessage({op: 'copy', origin: site});
+    status.textContent = result?.ok ? `Copied ${result.count} cookies.` : result?.error === 'Busy' ? 'Busy, try again in a moment.' : result?.error === 'Not connected' ? 'Connect an ai app first.' : 'Copy failed.';
+  } catch (_) {
+    status.textContent = 'Copy failed.';
+  } finally {
+    copyButton.disabled = false;
+  }
+  await render();
+};
+chrome.storage.local.get('autoSync').then(({autoSync}) => { auto.checked = autoSync === true; });
+auto.onchange = () => chrome.storage.local.set({autoSync: auto.checked});
+const server = {name: 'syncme', command: 'npx', args: ['-y', 'syncme-mcp']};
+const links = {
+  cursor: 'cursor://anysphere.cursor-deeplink/mcp/install?name=syncme&config=' + btoa(JSON.stringify({command: server.command, args: server.args})),
+  vscode: 'vscode:mcp/install?' + encodeURIComponent(JSON.stringify(server)),
+};
+for (const [id, href] of Object.entries(links)) {
+  const link = document.querySelector('#' + id);
+  link.href = href;
+  link.hidden = false;
+}
+document.querySelector('#claude').onclick = () => navigator.clipboard.writeText('claude mcp add syncme -- npx -y syncme-mcp');
+document.querySelector('#setup').onclick = () => navigator.clipboard.writeText('npx -y syncme-mcp setup');
+chrome.storage.session.get(['connected', 'pairing']).then(({connected, pairing}) => {
+  document.querySelector('#waiting').hidden = connected === true || Boolean(pairing);
+  const box = document.querySelector('#pairing');
+  box.hidden = !pairing;
+  box.firstChild.textContent = pairing === 'lost' ? 'syncme lost its pairing with this extension.' : 'syncme is paired with a different extension. Run npx -y syncme-mcp unpair, then hit Re-pair.';
+});
+document.querySelector('#repair').onclick = () => { chrome.runtime.sendMessage({op: 'repair'}); document.querySelector('#pairing').hidden = true; };
+render();

package/background.js

@@ -0,0 +1,112 @@
+let socket;
+function origin(value) {
+  const u = new URL(value);
+  if (!['http:', 'https:'].includes(u.protocol) || u.username || u.password || u.pathname !== '/' || u.search || u.hash || u.origin !== value) throw Error('Enter an exact http(s) origin without a trailing slash.');
+  return u;
+}
+const pending = new Map();
+const asking = new Map();
+async function allow(value) {
+  const w = await chrome.windows.create({url: 'approve.html?site=' + encodeURIComponent(value), type: 'popup', width: 380, height: 220, focused: true});
+  return new Promise(resolve => {
+    const timer = setTimeout(() => done(false), 100000);
+    function done(answer) {
+      if (!asking.delete(w.id)) return;
+      clearTimeout(timer);
+      chrome.windows.remove(w.id).catch(() => {});
+      resolve(answer);
+    }
+    asking.set(w.id, done);
+  });
+}
+chrome.windows.onRemoved.addListener(id => asking.get(id)?.(false));
+const hex = bytes => [...new Uint8Array(bytes)].map(b => b.toString(16).padStart(2, '0')).join('');
+const random = () => hex(crypto.getRandomValues(new Uint8Array(32)));
+async function sign(secret, purpose) {
+  const key = await crypto.subtle.importKey('raw', new TextEncoder().encode(secret), {name: 'HMAC', hash: 'SHA-256'}, false, ['sign']);
+  return hex(await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(purpose)));
+}
+function connect() {
+  if (socket) return;
+  const ws = new WebSocket('ws://127.0.0.1:47621/');
+  socket = ws;
+  let secret, nonce, verified = false;
+  const send = value => ws.send(JSON.stringify(value));
+  const keepAlive = setInterval(() => verified && ws.readyState === WebSocket.OPEN && send({op: 'ping'}), 20000);
+  const refuse = async pairing => { await chrome.storage.session.set({pairing}); ws.close(); };
+  let chain = Promise.resolve();
+  ws.onmessage = event => { chain = chain.then(() => handle(event)).catch(() => {}); };
+  const handle = async event => {
+    let message;
+    try { message = JSON.parse(event.data); } catch (_) { return; }
+    if (!verified) {
+      if (message.op === 'hello' && !nonce) {
+        ({secret} = await chrome.storage.local.get('secret'));
+        if (!message.paired) {
+          if (secret) return refuse('lost');
+          secret = random();
+          await chrome.storage.local.set({secret});
+          send({op: 'pair', secret});
+        } else if (!secret) return refuse('other');
+        nonce = random();
+        send({op: 'proof', proof: await sign(secret, 'extension:' + message.nonce), nonce});
+      } else if (message.op === 'refused') return refuse('other');
+      else if (message.op === 'ready' && nonce && message.proof === await sign(secret, 'server:' + nonce)) {
+        if (socket !== ws || ws.readyState !== WebSocket.OPEN) return;
+        verified = true;
+        await chrome.storage.session.set({connected: true, pairing: null});
+      } else ws.close();
+      return;
+    }
+    if (message.op === 'copied') { pending.get(message.id)?.(message); pending.delete(message.id); return; }
+    const {approved = [], autoSync = false} = await chrome.storage.local.get(['approved', 'autoSync']);
+    if (message.op === 'list') { send({id: message.id, origins: autoSync ? approved : []}); return; }
+    let stage = 'request';
+    try {
+      if (message.op !== 'sync' || typeof message.id !== 'string') throw Error('Invalid request');
+      const u = origin(message.origin);
+      if (!approved.includes(u.origin)) {
+        if (!await allow(u.origin)) throw Error('Origin not approved');
+        const {approved: now = []} = await chrome.storage.local.get('approved');
+        await chrome.storage.local.set({approved: [...new Set([...now, u.origin])]});
+      }
+      stage = 'cookies';
+      const cookies = (await chrome.cookies.getAll({domain: u.hostname})).filter(c => c.domain.replace(/^\./, '') === u.hostname && !c.partitionKey && (!c.secure || u.protocol === 'https:'));
+      send({id: message.id, origin: u.origin, cookies});
+    } catch (_) { try { send({id: message.id, error: stage === 'cookies' ? 'Cookie API refused' : 'Origin unavailable or not approved'}); } catch (_) {} }
+  };
+  ws.onclose = ws.onerror = () => {
+    clearInterval(keepAlive);
+    if (socket !== ws) return;
+    socket = undefined;
+    verified = false;
+    chrome.storage.session.set({connected: false});
+    for (const done of pending.values()) done({error: 'Not connected'});
+    pending.clear();
+  };
+  ws.isVerified = () => verified;
+}
+async function copy(value) {
+  const u = origin(value);
+  const {approved = []} = await chrome.storage.local.get('approved');
+  await chrome.storage.local.set({approved: [...new Set([...approved, u.origin])]});
+  connect();
+  if (socket?.readyState !== WebSocket.OPEN || !socket.isVerified()) return {error: 'Not connected'};
+  const id = crypto.randomUUID();
+  const result = new Promise(resolve => pending.set(id, resolve));
+  socket.send(JSON.stringify({op: 'copy', id, origin: u.origin}));
+  return result;
+}
+chrome.runtime.onStartup.addListener(connect);
+chrome.runtime.onInstalled.addListener(connect);
+chrome.alarms.create('connect', {periodInMinutes: 0.5});
+chrome.alarms.onAlarm.addListener(connect);
+chrome.runtime.onMessage.addListener((message, sender, reply) => {
+  if (sender.id !== chrome.runtime.id) return;
+  if (message.op === 'allow') { asking.get(sender.tab?.windowId)?.(message.answer === true); return; }
+  if (message.op === 'repair') { chrome.storage.local.remove('secret').then(() => chrome.storage.session.set({pairing: null})).then(() => { socket?.close(); socket = undefined; connect(); }); return; }
+  if (message.op !== 'copy') return;
+  copy(message.origin).then(reply, () => reply({error: 'Invalid site'}));
+  return true;
+});
+connect();

package/manifest.json

@@ -0,0 +1,33 @@
+{
+  "manifest_version": 3,
+  "name": "syncme",
+  "version": "1.0.0",
+  "description": "copy your logins for a site into a separate chrome that your ai agents and scripts can use",
+  "icons": {
+    "16": "icons/16.png",
+    "32": "icons/32.png",
+    "48": "icons/48.png",
+    "128": "icons/128.png"
+  },
+  "key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyDi/Cstz6nR487vgWA2QTykf48Svj3DFUeSMva5uZdxoYIJSxKW1S9d+YGFFM0osrctIUWL6YbeGQYxWcnakI4oItc9x0oKO9w5lLYm1Azzn3zy/Pj/8dN647SyBjeyjW5EDAs2eNwWj15qjOy+y1u3Oqep/8kx0eVHwoHWwojH2trvOIBUwa1zd9eJ8fV4lcrEUr9okjlaZEB3s+qYR/D/ezvOlP3VMHztCL1dptv/Y8DtVVFqC+AkfaOqLEGYfaXufF+cdG/V6DBu6YZ1mww1VET/rjcGKCl+OsEFIwIOU0usOWbLB1JnspVupeq8CDe+baHBU24qQZc3U7UpaUQIDAQAB",
+  "permissions": [
+    "alarms",
+    "cookies",
+    "storage"
+  ],
+  "host_permissions": [
+    "http://*/*",
+    "https://*/*"
+  ],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_popup": "approve.html",
+    "default_icon": {
+      "16": "icons/16.png",
+      "32": "icons/32.png"
+    }
+  },
+  "options_page": "approve.html"
+}

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "syncme-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "copy your logins for a site into a separate chrome that your ai agents and scripts can use",
+  "type": "module",
+  "bin": {
+    "syncme-mcp": "syncme.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "playwright-core": "^1.49.0",
+    "ws": "^8.18.0"
+  },
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/levinkin/syncme.git"
+  }
+}

package/syncme.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import {spawn, spawnSync} from 'node:child_process';
+import {createHash, createHmac, randomBytes, timingSafeEqual} from 'node:crypto';
+import {chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync} from 'node:fs';
+import {homedir, tmpdir} from 'node:os';
+import {dirname, join} from 'node:path';
+import {createInterface} from 'node:readline';
+import {fileURLToPath} from 'node:url';
+import {chromium} from 'playwright-core';
+import {WebSocket, WebSocketServer} from 'ws';
+
+const ROOT = dirname(fileURLToPath(import.meta.url));
+const MANIFEST = JSON.parse(readFileSync(join(ROOT, 'manifest.json'), 'utf8'));
+const EXTENSION = createHash('sha256').update(Buffer.from(MANIFEST.key, 'base64')).digest('hex').slice(0, 32).replace(/[0-9a-f]/g, c => String.fromCharCode(97 + parseInt(c, 16)));
+const ORIGIN = 'chrome-extension://' + EXTENSION;
+const STATE = process.platform === 'win32' ? join(process.env.LOCALAPPDATA || homedir(), 'syncme') : process.platform === 'darwin' ? join(homedir(), 'Library', 'Application Support', 'syncme') : join(homedir(), '.local', 'state', 'syncme');
+const PORT = 47621;
+const LIMIT = 1024 * 1024;
+const CLIENT_URL = 'ws://127.0.0.1:' + PORT + '/client';
+const BRIDGE_URL = 'ws://127.0.0.1:' + PORT + '/';
+const SERVER = {command: 'npx', args: ['-y', 'syncme-mcp']};
+const SAME_SITE = {no_restriction: 'None', lax: 'Lax', strict: 'Strict', unspecified: 'Lax'};
+
+const rejected = phase => Object.assign(Error('Rejected'), {phase});
+const hex64 = value => typeof value === 'string' && /^[0-9a-f]{64}$/.test(value);
+const proof = (token, purpose) => createHmac('sha256', token).update(purpose).digest('hex');
+const same = (left, right) => typeof left === 'string' && typeof right === 'string' && left.length === right.length && timingSafeEqual(Buffer.from(left), Buffer.from(right));
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+function privateState() {
+  mkdirSync(STATE, {recursive: true, mode: 0o700});
+  if (lstatSync(STATE).isSymbolicLink()) throw Error('Unsafe runtime directory');
+  if (process.platform === 'win32') {
+    const sid = spawnSync('whoami', ['/user', '/fo', 'csv', '/nh'], {encoding: 'utf8'}).stdout.trim().split(',').pop().trim().replaceAll('"', '');
+    const result = spawnSync('icacls', [STATE, '/inheritance:r', '/grant:r', '*' + sid + ':(OI)(CI)F'], {stdio: 'ignore'});
+    if (result.status !== 0) throw Error('Unsafe runtime permissions');
+  } else chmodSync(STATE, 0o700);
+  const token = join(STATE, 'token');
+  try {
+    writeFileSync(token, randomBytes(32).toString('hex'), {flag: 'wx', mode: 0o600});
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+  }
+  return readFileSync(token, 'utf8');
+}
+
+function send(socket, value) {
+  const data = JSON.stringify(value);
+  if (!data.length || Buffer.byteLength(data) > LIMIT) throw Error('Message too large');
+  if (socket.readyState !== WebSocket.OPEN) throw Error('Disconnected');
+  socket.send(data);
+}
+
+function messages(socket) {
+  const queue = [];
+  const waiting = [];
+  let failure;
+  const fail = () => {
+    failure = failure || Error('Connection closed');
+    for (const waiter of waiting.splice(0)) waiter.reject(failure);
+  };
+  socket.on('message', data => {
+    let value;
+    try {
+      value = JSON.parse(data.toString());
+    } catch {
+      return fail();
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return fail();
+    if (waiting.length) waiting.shift().resolve(value);
+    else queue.push(value);
+  });
+  socket.on('close', fail);
+  socket.on('error', fail);
+  return () => {
+    if (queue.length) return Promise.resolve(queue.shift());
+    if (failure) return Promise.reject(failure);
+    return new Promise((resolve, reject) => waiting.push({resolve, reject}));
+  };
+}
+
+async function authorize(socket, next, token) {
+  const challenge = randomBytes(32).toString('hex');
+  send(socket, {challenge});
+  const auth = await next();
+  if (!hex64(auth.nonce) || !same(auth.proof, proof(token, 'client:' + challenge))) {
+    send(socket, {error: 'Unauthorized'});
+    return false;
+  }
+  send(socket, {proof: proof(token, 'server:' + auth.nonce)});
+  return true;
+}
+
+async function authenticate(socket, next, token) {
+  const {challenge} = await next();
+  if (!hex64(challenge)) throw Error('Invalid broker challenge');
+  const nonce = randomBytes(32).toString('hex');
+  send(socket, {proof: proof(token, 'client:' + challenge), nonce});
+  const {proof: answer} = await next();
+  if (!same(answer, proof(token, 'server:' + nonce))) throw Error('Untrusted local endpoint');
+}
+
+function origin(value) {
+  if (typeof value !== 'string' || value.length > 2048 || !/^[\x21-\x7e]+$/.test(value) || value.includes('\\')) throw rejected('origin');
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw rejected('origin');
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.pathname !== '/' || url.search || url.hash || url.origin !== value) throw rejected('origin');
+  if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/.test(url.hostname) || url.hostname.includes('..')) throw rejected('origin');
+  return url;
+}
+
+function cookiesFor(site, cookies) {
+  if (!Array.isArray(cookies) || cookies.length > 3000) throw rejected('cookies');
+  const result = [];
+  for (const c of cookies) {
+    if (!c || typeof c !== 'object' || typeof c.domain !== 'string' || c.domain.replace(/^\./, '') !== site.hostname || c.partitionKey) throw rejected('cookies');
+    for (const field of ['name', 'value', 'domain', 'path']) {
+      if (typeof c[field] !== 'string' || c[field].length > 16384) throw rejected('cookies');
+    }
+    if (!c.path.startsWith('/') || ['secure', 'httpOnly', 'hostOnly', 'session'].some(field => typeof c[field] !== 'boolean')) throw rejected('cookies');
+    if (c.secure && site.protocol !== 'https:') throw rejected('cookies');
+    const item = {name: c.name, value: c.value, path: c.path, secure: c.secure, httpOnly: c.httpOnly};
+    item.domain = c.hostOnly ? site.hostname : c.domain;
+    if (!Object.hasOwn(SAME_SITE, c.sameSite)) throw rejected('cookies');
+    item.sameSite = SAME_SITE[c.sameSite];
+    if (!c.session) {
+      const expiry = c.expirationDate;
+      if (typeof expiry !== 'number' || !Number.isFinite(expiry) || expiry <= 0) throw rejected('cookies');
+      item.expires = expiry;
+    }
+    result.push(item);
+  }
+  return result;
+}
+
+function connectSocket(url) {
+  return new Promise((resolve, reject) => {
+    const socket = new WebSocket(url, {handshakeTimeout: 5000});
+    socket.on('error', () => reject(Error('offline')));
+    socket.once('open', () => resolve(socket));
+  });
+}
+
+async function startServer(launch) {
+  const token = privateState();
+  for (let attempt = 0; attempt < 61; attempt++) {
+    let socket;
+    try {
+      socket = await connectSocket(CLIENT_URL);
+      await authenticate(socket, messages(socket), token);
+      return socket;
+    } catch {
+      socket?.close();
+      if (!launch) return null;
+      if (attempt === 0) spawn(process.execPath, [process.argv[1], 'serve'], {detached: true, stdio: 'ignore', windowsHide: true}).unref();
+    }
+    await sleep(100);
+  }
+  throw Error('Could not start syncme bridge');
+}
+
+async function request(message) {
+  const socket = await startServer(message.op === 'sync' || message.op === 'open');
+  if (!socket) return {ok: true};
+  const next = messages(socket);
+  try {
+    send(socket, message);
+    return await Promise.race([next(), new Promise(resolve => setTimeout(resolve, 150000, {error: 'Timed out'}).unref())]);
+  } finally {
+    socket.close();
+  }
+}
+
+function verify(info, done) {
+  const path = new URL(info.req.url, 'http://127.0.0.1').pathname;
+  if (path === '/client') return done(!info.req.headers.origin);
+  if (path !== '/') return done(false);
+  done(info.origin === ORIGIN);
+}
+
+async function serve() {
+  const token = privateState();
+  const server = new WebSocketServer({host: '127.0.0.1', port: PORT, maxPayload: LIMIT, verifyClient: verify});
+  server.on('error', () => process.exit(0));
+  await new Promise(resolve => server.once('listening', resolve));
+  let bridge, context, endpoint;
+  let headless = false;
+  const pending = new Map();
+  let queue = Promise.resolve();
+  const enqueue = task => (queue = queue.then(task, task).catch(() => {}));
+
+  async function closeBrowser() {
+    const current = context;
+    context = endpoint = undefined;
+    if (current) {
+      try {
+        await current.close();
+      } catch {}
+    }
+  }
+
+  function ask(message) {
+    if (!bridge) throw rejected('bridge');
+    const id = randomBytes(16).toString('hex');
+    const response = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => pending.delete(id) && reject(rejected('bridge')), 120000);
+      pending.set(id, {resolve: value => (clearTimeout(timer), resolve(value)), reject: error => (clearTimeout(timer), reject(error))});
+    });
+    send(bridge, {...message, id});
+    return response;
+  }
+
+  function bridgeGone(socket) {
+    if (bridge !== socket) return;
+    bridge = undefined;
+    for (const waiter of pending.values()) waiter.reject(Error('Bridge disconnected'));
+    pending.clear();
+  }
+
+  async function copyIntoBrowser(values, fromExtension) {
+    for (const value of values) origin(value);
+    if (values.length && !bridge) throw rejected('bridge');
+    if (context) {
+      try {
+        await context.cookies('https://syncme.invalid');
+      } catch {
+        context = endpoint = undefined;
+      }
+    }
+    let carried = [];
+    if (context && headless && !fromExtension) {
+      carried = await context.cookies();
+      await context.close();
+      context = endpoint = undefined;
+    }
+    if (!context) {
+      headless = fromExtension;
+      const profile = join(STATE, 'browser');
+      mkdirSync(profile, {recursive: true, mode: 0o700});
+      rmSync(join(profile, 'DevToolsActivePort'), {force: true});
+      context = await chromium.launchPersistentContext(profile, {channel: 'chrome', headless, args: ['--remote-debugging-address=127.0.0.1', '--remote-debugging-port=0']});
+      await context.addCookies(carried);
+      const port = Number(readFileSync(join(profile, 'DevToolsActivePort'), 'utf8').split('\n')[0]);
+      if (!(port > 0 && port < 65536)) throw Error('Invalid owned browser endpoint');
+      endpoint = 'http://127.0.0.1:' + port;
+      if (bridge) {
+        const listed = await ask({op: 'list'});
+        if (!Array.isArray(listed.origins) || listed.origins.length > 1000) throw rejected('bridge');
+        for (const value of listed.origins) if (!values.includes(value)) values.push(value);
+      }
+    }
+    let count = 0;
+    for (const value of values) {
+      const site = origin(value);
+      const response = await ask({op: 'sync', origin: value});
+      if (response.origin !== value || response.error) throw rejected('bridge');
+      const cookies = cookiesFor(site, response.cookies);
+      for (const cookie of await context.cookies()) {
+        if (cookie.domain.replace(/^\./, '') === site.hostname && (site.protocol === 'https:' || !cookie.secure)) await context.clearCookies({name: cookie.name, domain: cookie.domain, path: cookie.path});
+      }
+      await context.addCookies(cookies);
+      count += cookies.length;
+    }
+    return count;
+  }
+
+  function bridgeMessage(socket, message) {
+    const waiter = typeof message.id === 'string' ? pending.get(message.id) : undefined;
+    if (waiter) {
+      pending.delete(message.id);
+      waiter.resolve(message);
+      return;
+    }
+    if (message.op === 'copied' || message.op === 'ping') return;
+    if (message.op !== 'copy' || typeof message.id !== 'string' || message.id.length > 64) return socket.close();
+    if (pending.size) return send(socket, {op: 'copied', id: message.id, error: 'Busy'});
+    enqueue(async () => {
+      const reply = {op: 'copied', id: message.id};
+      try {
+        send(socket, {...reply, ok: true, cdp: endpoint, count: await copyIntoBrowser([message.origin], true)});
+      } catch (error) {
+        try {
+          send(socket, {...reply, error: error.phase ? 'Request rejected' : 'Owned browser operation failed', phase: error.phase});
+        } catch {}
+      }
+    });
+  }
+
+  function shutdown(socket) {
+    for (const waiter of pending.values()) waiter.reject(Error('Shutting down'));
+    pending.clear();
+    const current = bridge;
+    bridge = undefined;
+    if (current) current.close();
+    server.close();
+    setTimeout(() => process.exit(0), 100);
+  }
+
+  async function client(socket, next) {
+    const guard = setTimeout(() => socket.close(), 30000);
+    let message;
+    try {
+      if (!(await authorize(socket, next, token))) return socket.close();
+      message = await next();
+    } catch {
+      return socket.close();
+    } finally {
+      clearTimeout(guard);
+    }
+    enqueue(() => operate(socket, message));
+  }
+
+  async function operate(socket, message) {
+    try {
+      const op = message.op;
+      if (op === 'sync' || op === 'open') {
+        const count = await copyIntoBrowser(op === 'sync' ? [message.origin] : [], false);
+        send(socket, {ok: true, cdp: endpoint, count});
+      } else if (op === 'stop' || op === 'shutdown') {
+        await closeBrowser();
+        send(socket, {ok: true});
+      } else return send(socket, {error: 'Unknown operation'});
+    } catch (error) {
+      try {
+        send(socket, {error: error.phase ? 'Request rejected' : 'Owned browser operation failed', phase: error.phase});
+      } catch {}
+    }
+    socket.close();
+    if (message.op === 'shutdown') shutdown(socket);
+  }
+
+  server.on('connection', (socket, incoming) => {
+    if (new URL(incoming.url, 'http://127.0.0.1').pathname === '/client') {
+      client(socket, messages(socket));
+      return;
+    }
+    const next = messages(socket);
+    (async () => {
+      const guard = setTimeout(() => socket.close(), 10000);
+      try {
+        const pairFile = join(STATE, 'pair');
+        let secret = existsSync(pairFile) ? readFileSync(pairFile, 'utf8') : '';
+        const nonce = randomBytes(32).toString('hex');
+        send(socket, {op: 'hello', nonce, paired: Boolean(secret)});
+        let message = await next();
+        if (!secret) {
+          if (message.op !== 'pair' || !hex64(message.secret)) return socket.close();
+          writeFileSync(pairFile, message.secret, {flag: 'wx', mode: 0o600});
+          secret = message.secret;
+          message = await next();
+        }
+        if (message.op !== 'proof' || !hex64(message.nonce) || !same(message.proof, proof(secret, 'extension:' + nonce))) {
+          send(socket, {op: 'refused'});
+          return socket.close();
+        }
+        clearTimeout(guard);
+        send(socket, {op: 'ready', proof: proof(secret, 'server:' + message.nonce)});
+        if (bridge) {
+          const previous = bridge;
+          bridgeGone(previous);
+          previous.close();
+        }
+        bridge = socket;
+        for (;;) {
+          message = await next();
+          if (bridge !== socket) break;
+          bridgeMessage(socket, message);
+        }
+      } catch {
+        socket.close();
+        bridgeGone(socket);
+      } finally {
+        clearTimeout(guard);
+      }
+    })();
+  });
+}
+
+function pack() {
+  const stage = mkdtempSync(join(tmpdir(), 'syncme-pack-'));
+  const zip = join(ROOT, 'syncme.zip');
+  try {
+    const {key, ...store} = MANIFEST;
+    writeFileSync(join(stage, 'manifest.json'), JSON.stringify(store, null, 2));
+    for (const name of ['background.js', 'approve.html', 'approve.js']) copyFileSync(join(ROOT, name), join(stage, name));
+    cpSync(join(ROOT, 'icons'), join(stage, 'icons'), {recursive: true});
+    rmSync(zip, {force: true});
+    const result = process.platform === 'win32'
+      ? spawnSync('powershell', ['-NoProfile', '-Command', `Compress-Archive -Path '${join(stage, '*')}' -DestinationPath '${zip}' -Force`], {stdio: 'ignore'})
+      : spawnSync('zip', ['-r', '-X', '-q', zip, 'manifest.json', 'background.js', 'approve.html', 'approve.js', 'icons'], {cwd: stage, stdio: 'ignore'});
+    if (result.status !== 0) throw Error('Pack failed');
+  } finally {
+    rmSync(stage, {recursive: true, force: true});
+  }
+  console.log(JSON.stringify({packed: zip}));
+}
+
+function setup() {
+  const claude = process.platform === 'win32' ? join(process.env.APPDATA || homedir(), 'Claude', 'claude_desktop_config.json') : join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  const configured = [];
+  const failed = [];
+  for (const [name, file] of [['claude desktop', claude], ['cursor', join(homedir(), '.cursor', 'mcp.json')], ['windsurf', join(homedir(), '.codeium', 'windsurf', 'mcp_config.json')]]) {
+    if (!existsSync(dirname(file))) continue;
+    try {
+      const existing = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {};
+      if (!existing || typeof existing !== 'object' || Array.isArray(existing)) throw Error('Unreadable config');
+      const servers = existing.mcpServers && typeof existing.mcpServers === 'object' && !Array.isArray(existing.mcpServers) ? existing.mcpServers : {};
+      writeFileSync(file, JSON.stringify({...existing, mcpServers: {...servers, syncme: SERVER}}, null, 2) + '\n');
+      configured.push(name);
+    } catch {
+      failed.push(file);
+    }
+  }
+  for (const [name, args] of [['claude', ['mcp', 'add', '--scope', 'user', 'syncme', '--', 'npx', '-y', 'syncme-mcp']], ['codex', ['mcp', 'add', 'syncme', '--', 'npx', '-y', 'syncme-mcp']]]) {
+    const result = spawnSync(name, args, {stdio: 'ignore'});
+    if (result.status === 0) configured.push(name + ' cli');
+    else if (!result.error || result.error.code !== 'ENOENT') failed.push(name + ' cli');
+  }
+  console.log(JSON.stringify({configured, failed}));
+}
+
+function mcp() {
+  const tools = [
+    {name: 'copy_site', description: "Copy the user's login cookies for one site (like https://github.com) from their Chrome into the AI browser, then return the AI browser's CDP url. If the site isn't saved yet, the user gets asked in Chrome first.", inputSchema: {type: 'object', properties: {site: {type: 'string', description: 'exact origin, like https://github.com'}}, required: ['site']}},
+    {name: 'open_browser', description: "Start the AI browser with the user's saved logins and return its CDP url. Connect with Playwright connect_over_cdp or any CDP client.", inputSchema: {type: 'object', properties: {}}},
+    {name: 'close_browser', description: 'Close the AI browser.', inputSchema: {type: 'object', properties: {}}},
+  ];
+  const versions = ['2025-06-18', '2025-03-26', '2024-11-05'];
+  const names = tools.map(tool => tool.name);
+  const write = value => process.stdout.write(JSON.stringify(value) + '\n');
+  let queue = Promise.resolve();
+  async function handle(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return write({jsonrpc: '2.0', id: null, error: {code: -32700, message: 'Parse error'}});
+    }
+    if (!message || typeof message !== 'object' || Array.isArray(message) || !('id' in message)) return;
+    const params = message.params && typeof message.params === 'object' ? message.params : {};
+    const args = params.arguments && typeof params.arguments === 'object' ? params.arguments : {};
+    const method = message.method;
+    if (method === 'tools/call' && !names.includes(params.name)) return write({jsonrpc: '2.0', id: message.id, error: {code: -32602, message: 'Unknown tool'}});
+    if (method === 'tools/call' && params.name === 'copy_site' && typeof args.site !== 'string') return write({jsonrpc: '2.0', id: message.id, error: {code: -32602, message: 'copy_site needs a site string'}});
+    let result;
+    if (method === 'initialize') {
+      const requested = params.protocolVersion;
+      result = {protocolVersion: versions.includes(requested) ? requested : versions[0], capabilities: {tools: {}}, serverInfo: {name: 'syncme', version: MANIFEST.version}};
+    } else if (method === 'tools/list') {
+      result = {tools};
+    } else if (method === 'tools/call') {
+      let response;
+      try {
+        if (params.name === 'copy_site') {
+          origin(args.site);
+          response = await request({op: 'sync', origin: args.site});
+        } else response = await request({op: params.name === 'open_browser' ? 'open' : 'stop'});
+      } catch {
+        response = {error: 'syncme bridge unavailable or site invalid'};
+      }
+      let text;
+      if (response.error) text = 'Failed: ' + response.error + '. The site must be an exact origin like https://github.com, Chrome must be open with the syncme extension, and the user must allow the site.';
+      else if (params.name === 'close_browser') text = 'AI browser closed.';
+      else text = JSON.stringify({cdp: response.cdp, copied_cookies: response.count});
+      result = {content: [{type: 'text', text}], isError: Boolean(response.error)};
+    } else if (method === 'ping') {
+      result = {};
+    } else return write({jsonrpc: '2.0', id: message.id, error: {code: -32601, message: 'Method not found'}});
+    write({jsonrpc: '2.0', id: message.id, result});
+  }
+  createInterface({input: process.stdin}).on('line', line => (queue = queue.then(() => handle(line)).catch(() => {})));
+}
+
+async function main() {
+  const command = process.argv[2] || '';
+  if (!command) return mcp();
+  if (command === 'serve') return serve();
+  if (command === 'pack') return pack();
+  if (command === 'setup') return setup();
+  if (command === 'unpair') return rmSync(join(STATE, 'pair'), {force: true});
+  if (!['sync', 'open', 'stop', 'shutdown'].includes(command) || process.argv.length !== (command === 'sync' ? 4 : 3)) throw Error('Usage: syncme-mcp open | sync https://example.com | stop | shutdown | setup | unpair | pack');
+  const message = {op: command};
+  if (command === 'sync') {
+    origin(process.argv[3]);
+    message.origin = process.argv[3];
+  }
+  const response = await request(message);
+  console.log(JSON.stringify(response));
+  if (response.error) process.exitCode = 1;
+}
+
+try {
+  await main();
+} catch {
+  console.error(JSON.stringify({error: 'syncme failed; check the origin and that chrome has the syncme extension'}));
+  process.exit(1);
+}