yoke-mcp 0.1.2 → 0.1.4

package/PRIVACY.md

@@ -1,6 +1,6 @@
 # Privacy policy for Yoke
 
-Last updated: 23 August 2026
+Last updated: 5 September 2026
 
 Yoke handles a lot of what is on your screen, and sends none of it to us.
 
@@ -32,8 +32,8 @@ To one place: the local program you connected. The path is
 
     extension  ->  native messaging host  ->  Unix socket  ->  MCP server  ->  your client
 
-Every hop is on your computer. The socket lives in a directory readable only by
-your user account. Nothing is written to a remote service by Yoke, and the
+Every hop is on your computer. The sockets, one per Chrome profile, live in a
+directory readable only by your user account. Nothing is written to a remote service by Yoke, and the
 extension makes no network requests of its own.
 
 What your client then does with what it receives is outside Yoke's control and
@@ -49,6 +49,11 @@ Almost nothing, and nothing that outlives the browser:
 - Console messages and network requests for tabs being driven, kept in memory
   only, capped at 500 entries per tab, and discarded when the tab closes, when
   the debugger detaches, or when Chrome restarts the extension.
+- A random eight character id for the Chrome profile the extension runs in, and
+  the label you type for it in the popup, kept in the extension's own storage in
+  that profile. The id names the local socket for that profile and appears in
+  tool output so a client can tell two profiles apart. It is not derived from
+  anything about you and is not sent anywhere.
 - No cookies, credentials, passwords, form values or browsing history are
   recorded or persisted anywhere by Yoke.
 
@@ -56,9 +61,18 @@ The values of password fields are deliberately excluded from what Yoke reports
 about a page. The field is described so a client can type into it; its contents
 are not returned.
 
-URLs are reduced to origin and path in tool output by default, because query
-strings routinely carry session tokens. A client must opt in per call to receive
-a raw URL.
+URL fields in tool output are reduced to origin and path, because query strings
+routinely carry session tokens. `list_tabs` accepts `full_urls` to opt out of
+that, and it is the only tool that does: everywhere else the reduction is
+unconditional.
+
+Redaction covers URL fields and not whole payloads, which is worth stating
+plainly rather than leaving to be discovered. A page's own text comes back as it
+is, so a URL printed on the page arrives whole. So do console messages, and the
+value of any expression a caller evaluates, including `location.href` or
+`document.cookie`. Screenshots are pixels and are not filtered at all. The
+redaction stops Yoke from volunteering a URL, and it is not a filter on what a
+page can tell a caller that asks.
 
 ## Permissions and why each exists
 

package/README.md

@@ -7,9 +7,9 @@
 [![dependencies](https://img.shields.io/badge/runtime%20deps-0-0e8fa3)](package.json)
 [![license](https://img.shields.io/npm/l/yoke-mcp)](LICENSE)
 
-yoke lets an MCP client drive the Chrome profile you already use. It can work with every tab in every window, read pages, click and type, take screenshots, and inspect console and network activity. Your signed in sessions, cookies, extensions, and open tabs stay available.
+Yoke drives the Chrome you are already using: an extension plus a native messaging host, so there is no browser to launch, no second profile, and no browser-wide debugging port. Chrome spawns the host itself when the extension connects, and the endpoint in between (a Unix socket at mode 0600 inside a directory whose 0700 mode is verified, or a named pipe on Windows) exists only while that connection is live. There is one per Chrome profile, so two profiles with the extension loaded are both reachable and told apart. It does use the Chrome DevTools Protocol, one tab at a time, through the extension's own `debugger` permission, which is why a tab with DevTools open cannot be driven.
 
-That is the reason to use yoke instead of starting a fresh browser through Playwright or Puppeteer. It works where you already work.
+`list_tabs` returns every tab in every window of every connected Chrome profile, and every operation on an existing tab names a `tab_id`, because there is no acting on the active tab when none was named. Any tab yoke drives or reads joins a visible tab group called `yoke`, and `read_page` and `find` describe a password field without returning its value. URL fields in tool output are cut to origin and path by default, with `full_urls: true` on `list_tabs` as the way to opt out, and the package has zero runtime dependencies on Node 22 or later.
 
 Chrome requires a three part bridge:
 
@@ -21,6 +21,83 @@ The MCP client starts `yoke mcp`. Chrome starts the native messaging host when t
 
 The project and repository are named `yoke`. The npm package is `yoke-mcp` because the bare package name belongs to an unrelated project. The command is `yoke`, and the extension is displayed as Yoke.
 
+## How this differs
+
+### Explicit tab targeting
+
+Every operation on an existing tab requires a `tab_id`, with no active tab fallback. `open_tab` creates a tab and therefore has no existing id to name.
+
+### Your own Chrome profile
+
+Yoke runs through an extension in the Chrome profile you are already using. It can reach every tab in every window of that profile, with its existing cookies, logged in sessions, and other extensions. Load it in a second profile and both are reachable at once: `list_browsers` names each, `list_tabs` covers both, and a tab id is enough to route a call to the profile that owns it, because Chrome numbers tabs once for the whole browser.
+
+### No browser-wide debugging endpoint
+
+Yoke uses `chrome.debugger`, which is Chrome's extension API for the Chrome DevTools Protocol. It attaches to one tab at a time and does not require a Chrome launch flag or a browser-wide remote debugging port. The local bridge is a per-profile Unix socket or Windows named pipe that exists only while Chrome has the extension connected.
+
+### Built for a human and an agent in the same browser
+
+Any tab yoke drives or reads joins a visible tab group named `yoke`. Grouping is a visual marker and is not used to find a tab. Chrome permits one debugger client per tab, so yoke cannot drive a tab while DevTools is open on it.
+
+### Privacy-conscious defaults
+
+URL fields are reduced to origin and path by default, and `list_tabs` can opt out with `full_urls: true`. This redaction does not filter page text, console messages, evaluated JavaScript results, or screenshot pixels. `read_page` and `find` describe password fields without returning their values.
+
+### Small and auditable
+
+The package declares zero runtime dependencies and uses Node builtins only. The
+published 0.1.3 tarball is 43 files, all first-party.
+
+TypeScript throughout with `strict` and `noUncheckedIndexedAccess` on. The wire
+shapes are declared once in `src/protocol.ts` and imported by both halves, so a
+request the server can send is one the extension is compiled to answer, and the
+compiler is what enforces that rather than a comment asking nicely.
+
+The permissions and what each one buys are in a table further down, along with
+the native messaging setup and the reasons `debugger` and host access are
+required. None of that makes yoke safe: it drives a browser you are signed into,
+which is privileged by construction. It is documented so the trade is yours to
+judge rather than yours to discover.
+
+### Compared with other browser MCP servers
+
+The cells describe the verified versions and their defaults. Flags that change an answer are named in the cell or the numbered notes.
+
+| Capability | Yoke (npm 0.1.3) | @playwright/mcp 0.0.79 (2026-08) | chrome-devtools-mcp 1.7.0 (pub. 2026-08-10) | BrowserMCP: server 0.1.3 (2025-04-11), extension 1.3.4 (2025-05-07), unmaintained |
+| --- | --- | --- | --- | --- |
+| Runs in the Chrome profile you are already signed in to | Yes. Chrome spawns the host via `connectNative`; there is no browser-launch code | No by default: its own persistent profile keyed to the client's cwd [1]. Yes with `--extension` | No by default: its own profile at `~/.cache/chrome-devtools-mcp/chrome-profile`. Yes with `--autoConnect` [2] | Yes. A Web Store extension in the running browser |
+| Reaches tabs that were already open | Yes, every tab in every window of the Chrome profile that owns the endpoint [3] | No by default (fresh browser, so those tabs do not exist in it). Yes with `--extension` [4] | No by default. With `--autoConnect`, all windows of one profile [2] | One tab at a time, picked by the human in the popup. No tab listing and no tab creation tool [5] |
+| Explicit target on every operation | Yes, `tab_id`, with no active-tab fallback anywhere [6] | No. Implicit current page, switched by `browser_tabs` with a positional index [7] | No. Server-side selected page via `select_page` [8] | No. The single connected tab; no tab id in any of the 12 exposed tool schemas |
+| Needs a Chrome launch flag or a browser-wide debugging port | No | No for the default launch and for `--extension`; yes for `--cdp-endpoint` [9] | Yes on all three attach paths; no when it launches its own browser over a pipe [10] | No |
+| How it reaches the browser, and what listens locally | Native messaging. A per-user endpoint (Unix socket mode 0600 in a directory whose 0700 mode is verified; a named pipe on Windows) that exists only while Chrome has the extension connected. CDP one tab at a time via `chrome.debugger` 1.3 | Playwright drives a browser it launched. `--extension` starts an in-process CDP relay the extension dials over WebSocket | Puppeteer over a pipe for its own browser; a CDP HTTP endpoint or `ws://` URL for the three attach paths | WebSocket server on fixed port 9009, bound to all interfaces, no auth and no origin check, and it kills whatever already holds that port [11] |
+| Runs with your existing cookies and logged-in session | Yes | No by default. Yes with `--extension` [12] | Only with `--autoConnect` [13] | Yes |
+| Marks the tabs it touches | Yes. Any tab it drives or reads joins a visible tab group named "yoke" [14] | No in-tab marker. A separate headed window on its own profile, with automation signals actively suppressed [15] | Nothing added by the server. Chrome's own affordances only, and on `--autoConnect` that is a one-time consent dialog rather than an ongoing marker [16] | Chrome's own debugger infobar, incidental rather than designed, and suppressible [17] |
+| URL redaction on by default | Yes. URL fields are cut to origin plus path; opt out with `full_urls` on `list_tabs` [18] | No. The only mechanism is opt-in substitution of known secret values (`--secrets`) | No, at no setting. Header redaction exists, covers headers only, and is off by default | No. The full page URL is in every snapshot header |
+| Declared runtime dependencies, and install footprint | 0 declared, Node builtins only. The published 0.1.3 tarball is 43 files, all first-party | 2 declared, both pinned to a 1.63.0 alpha. 19 MB installed. No browser download on the default `chrome` channel | 0 declared, and roughly 14 MB of vendored bundle (puppeteer 25.5.0, lighthouse 13.4.0) [19] | 5 declared, 97 transitive as resolved on 2026-08-24, and rising with no new release [20] |
+
+#### Notes, including every place a flag or a version changes the answer
+
+1. `@playwright/mcp` defaults to `browserName: chromium` with `channel: 'chrome'`, so it drives system-installed Google Chrome, but in `~/Library/Caches/ms-playwright-mcp/mcp-{channel}-{sha256(cwd)[0:7]}`. That profile persists between runs and accumulates its own logins, so it is not your profile and not a throwaway either. Its own `--help` text and README call it a temporary directory, which is wrong. Different project directories silently get different profiles.
+2. `--autoConnect` needs Chrome 144 or later plus a manual toggle at `chrome://inspect/#remote-debugging`, and it attaches to one profile (the default, as Chrome determines it), not to every window on the machine. The documented `--browser-url` path steers users away from their real profile: the README tells them to pass `--user-data-dir` so their browsing data is not exposed.
+3. Scoped to one Chrome profile, because the endpoint path is per user and not per profile. On published 0.1.2 a second profile with the extension loaded could take the endpoint silently. Published 0.1.3 fixes that failure mode. The next release gives each profile its own endpoint, described under Several Chrome profiles below.
+4. `--extension` genuinely attaches to every tab the extension already knows about (`chrome.debugger.attach` per tab), so the honest answer is not by default, and supported with `--extension`.
+5. Only from extension v1.3.3 (2025-04-14) could BrowserMCP automate tabs that existed before the extension was installed. The selected tab id is persisted in extension storage and survives a server restart.
+6. `open_tab` creates the tab, so there is no id to name, and it lands in Chrome's current window. `scroll` without a `ref` uses a fixed viewport point, still inside the named tab.
+7. `browser_click`'s `target` is an element reference from a prior snapshot rather than a tab handle. Element targeting is explicit there; page targeting is not.
+8. `--experimentalPageIdRouting` (default false, inert under `--slim`) injects `pageId` into page-scoped tools, so the stateful selection is a default rather than an architectural limit: a selected page by default, with opt-in `pageId` routing.
+9. `--browser-url` on chrome-devtools-mcp also requires closing every running Chrome first. `@playwright/mcp`'s `--extension` route is gated differently rather than ungated: it throws unless the Playwright Extension is present in the profile.
+10. The three attach paths are `--autoConnect` (reads `DevToolsActivePort` from the user data dir after the manual toggle), `--browserUrl` (needs `--remote-debugging-port=9222` and a non-default user data dir), and `--wsEndpoint`. There is no fourth. The self-launched browser passes `pipe: true` and opens no port.
+11. Verified empirically: `address()` returns `{"address":"::"}`. Startup runs `lsof -ti:9009 | xargs kill -9`. A second connection silently closes the first.
+12. `@playwright/mcp` does not disable extensions: its default chromium switch list contains `--disable-extensions` and the MCP launch path cancels it through `ignoreDefaultArgs`. It carries none of your extensions because the profile is fresh, not because extensions are off. That is why the extensions half was cut from this row's title.
+13. On chrome-devtools-mcp 1.7.0 the two halves land on mutually exclusive paths: session state needs `--autoConnect`, while the extension tooling is documented as unsupported on `autoConnect`, `browserUrl` and `wsEndpoint` until Chrome 149 and works only over the pipe connection, that is the dedicated profile that holds no user extensions. Yoke and BrowserMCP carry the user's other extensions by construction; BrowserMCP has had to fix breakage from 1Password and LastPass injecting elements into snapshots.
+14. Every operation that drives or reads a tab marks it: `navigate`, `get_page_text`, `read_page`, `find`, `run_javascript`, `screenshot`, `click`, `type_text`, `press_key`, `scroll`, `read_console`, `read_network`, and `open_tab` groups the tab it creates. Deliberately unmarked: `list_tabs`, `list_tab_groups`, `close_tab`, `ping`, `release_tab`, `ungroup_tabs`. The tab group is present in published 0.1.3. Chrome's own "started debugging this browser" banner also appears when the debugger attaches, and yoke does not suppress it. That is Chrome's behaviour rather than a guarantee from either project: it is not stated on Chrome's `chrome.debugger` reference page. The same caveat applies to the BrowserMCP cell.
+15. Headed is the default (headless is auto-selected only on Linux with no `DISPLAY`). The server pushes `--disable-blink-features=AutomationControlled`, `--disable-infobars` is in the default switch list, and `--enable-automation` is absent. The indication is structural (a separate window on a separate profile) rather than a badge. What `--extension` does here could not be established from the package, so this row says nothing about it.
+16. chrome-devtools-mcp adds no title change, overlay or badge of its own, and it inherits puppeteer's default args, which contain `--enable-automation` and `--disable-infobars` in the same array. Whether Chrome still draws the infobar with both flags present was not tested, so this row claims nothing either way.
+17. Chrome's `--silent-debugger-extension-api` and force-install via `ExtensionInstallForcelist` both remove the infobar, so in those configurations the answer becomes No. BrowserMCP ships no indicator of its own.
+18. Redaction covers URL fields, not the whole payload. Unredacted by design: `read_console` message text, `run_javascript` return values (so `location.href` or `document.cookie` comes back whole, with no flag needed), the page body from `get_page_text`, and screenshot pixels. `full_urls` exists on `list_tabs` only; everywhere else redaction is unconditional.
+19. This is the devDependencies trap in reverse. `npm view chrome-devtools-mcp@1.7.0 dependencies` is empty and the tarball's `package.json` has no `dependencies` key, so a reader who runs `npm ls` against a "substantial" claim finds nothing. The substance is real but vendored by rollup, not installed. Neither chrome-devtools-mcp nor `@playwright/mcp` downloads a browser on its default path: both use system Chrome.
+20. Five direct deps, none of them the five `workspace:*` entries (those are unpublished devDependencies bundled into `dist` at build time). The transitive count grows with no release because `@modelcontextprotocol/sdk ^1.8.0` floats and now resolves to 1.30.0, pulling in express 5.2.1.
+
 ## Why yoke exists
 
 yoke grew out of measurements of Anthropic's Claude in Chrome MCP bridge. That bridge could only see and act on tabs in its own managed group, and each reply included its full tab list with raw URLs. Those limits could not be fixed by an outside client. yoke addresses every tab by id and redacts URLs by default. [MOTIVATION.md](MOTIVATION.md) records the observations behind those choices.
@@ -76,7 +153,7 @@ When setup is complete, the last line is:
 Working. Every link in the chain answered.
 ```
 
-If something is wrong, `doctor` stops after the first broken link, names it, and prints a suggested fix. It checks the compiled host, browser registration, local socket, extension reply, and whether tabs are visible.
+If something is wrong, `doctor` stops after the first broken link, names it, and prints a suggested fix. It checks the compiled host, browser registration, the local sockets, which profiles answered, and for each profile whether the extension replies and tabs are visible.
 
 For a shorter connection check, run:
 
@@ -111,11 +188,11 @@ Clients use different names and locations for their MCP configuration. If you do
 
 ## What it can do
 
-yoke exposes 19 MCP tools. They are grouped here by the job they help with.
+yoke exposes 20 MCP tools. They are grouped here by the job they help with.
 
 | Job | Tools | What they do |
 | --- | --- | --- |
-| Work with tabs | `list_tabs`, `list_tab_groups`, `open_tab`, `navigate`, `close_tab`, `group_tabs`, `ungroup_tabs` | See every window, open background tabs, visit HTTP or HTTPS URLs, close tabs, and manage Chrome tab groups. |
+| Work with tabs | `list_browsers`, `list_tabs`, `list_tab_groups`, `open_tab`, `navigate`, `close_tab`, `group_tabs`, `ungroup_tabs` | See which profiles are connected and every window in each, open background tabs, visit HTTP or HTTPS URLs, close tabs, and manage Chrome tab groups. |
 | Read a page | `get_page_text`, `read_page`, `find`, `screenshot` | Read visible text, describe interactive elements, find a matching element, or capture a foreground or background tab. |
 | Act on a page | `click`, `type_text`, `press_key`, `scroll`, `run_javascript` | Use trusted input by element reference, scroll the page, or evaluate JavaScript in the page's own world. |
 | Debug a page | `read_console`, `read_network`, `release_tab` | Read recorded console and network activity, then detach yoke and clear that tab's buffers. |
@@ -126,6 +203,16 @@ Any tool that acts on an existing tab requires an explicit `tab_id` obtained fro
 
 `navigate` and `open_tab` accept HTTP and HTTPS URLs. New tabs open in the background unless the caller asks to focus one.
 
+### Several Chrome profiles
+
+Chrome starts one native host per profile, and each host listens on its own endpoint named after an id the extension mints the first time it runs in that profile. `list_browsers` lists every profile that answers, with its id, the label you gave it in the popup, its tab and window counts, and the sites it mostly has open, so a profile is recognisable before it has a name.
+
+With one profile connected nothing changes. With more, `list_tabs` and `list_tab_groups` include every profile and add a `browser` column, and every tool that names a `tab_id` reaches the profile holding that tab without being told which: Chrome allocates tab ids from one counter for the whole browser, so two profiles never share one. `open_tab` names no existing tab, so with more than one profile connected it needs `browser`, an id or label from `list_browsers`, and refuses rather than picking.
+
+Two different browsers, such as Chrome and Brave, do number tabs independently. A tab id both report is marked in `list_tabs` and refused by the tab tools, naming both browsers.
+
+The id and label are stored in the extension's own storage in that profile. They never leave your machine.
+
 ### Tab groups
 
 Every tab opened by yoke goes into a cyan group titled `yoke`, so the tab strip names what is driving those tabs. Pass `group_title` to `open_tab` for a different label, which is worth doing when more than one agent works in the same browser. The extension creates that group when needed and reuses a group with the same title in the same window. Reuse comes from Chrome's current group state, so it still works after Chrome has stopped and restarted the extension service worker. You do not collect a row of identical group pills.
@@ -159,13 +246,13 @@ Chrome's own pages and the Chrome Web Store still block page script injection. y
 
 An extension cannot create trusted input through page JavaScript. A click made by a content script reaches the page with `isTrusted: false`, and many sites ignore it. `chrome.debugger` is the extension route to `Input.dispatchMouseEvent`, which creates input the page cannot distinguish from a person's input.
 
-Chrome shows its "started debugging this browser" bar when yoke drives a tab. This is expected. Chrome also permits one debugger client per tab. A tab with DevTools open cannot be driven by yoke, and DevTools cannot open on a tab while yoke is attached. Call `release_tab` to detach yoke, remove the bar, and make the tab available to DevTools.
+Chrome shows its "started debugging this browser" bar when yoke drives a tab. This is expected. Chrome also permits one debugger client per tab. A tab with DevTools open cannot be driven by yoke, and DevTools cannot open on a tab while yoke is attached. Call `release_tab` to detach yoke and clear that tab's console and network buffers. The tab stays in its group.
 
 The same permission lets `screenshot` capture a background tab. `chrome.tabs.captureVisibleTab` can only capture the active tab in a window.
 
 ## Local connection and process lifetime
 
-The bridge does not open a TCP port. On macOS and Linux, the native host listens on a Unix socket inside a directory readable only by your user account. The socket itself is also restricted to that account. Windows uses a named pipe.
+The bridge does not open a TCP port. On macOS and Linux, each native host listens on a Unix socket inside a directory readable only by your user account, one socket per Chrome profile. The socket itself is also restricted to that account. Windows uses a named pipe.
 
 Chrome owns the native host process. It starts the host when the extension calls `connectNative` and stops it when that connection closes. This is why the Unix socket between the MCP server and host is required.
 
@@ -179,7 +266,7 @@ After `npm link`, the command surface is:
 | --- | --- |
 | `yoke install` | Register the native messaging host with each detected Chrome family browser. |
 | `yoke doctor` | Check each link from the build through tab visibility and suggest the first fix. |
-| `yoke status` | Report whether the extension answers and print the local socket path. |
+| `yoke status` | Report which Chrome profiles answer, one line each with id, label, tab count and socket path. |
 | `yoke uninstall` | Remove the native host registration. |
 | `yoke mcp` | Run the MCP server over standard input and standard output. This is what an MCP client starts. |
 
@@ -193,7 +280,8 @@ From a checkout that has not been linked, replace `yoke` with `node dist/cli.js`
 4. A driven tab shows Chrome's debugging bar and cannot share its debugger slot with DevTools.
 5. Element references expire after navigation or a page render. Console and network history starts when yoke first attaches to that tab, not before.
 6. Screenshots capture the page viewport, not browser chrome such as the address bar or tab strip.
-7. Chrome's internal pages cannot be read or driven. Neither can the Chrome Web Store or the extensions gallery: Chrome refuses both `chrome.scripting` and `chrome.debugger` there, so no extension can automate them, including this one. Publishing an extension is therefore a manual job by design.
+7. Two different browsers that both run the extension, such as Chrome and Brave, number their tabs independently. A tab id both report is refused rather than routed, because it cannot be sent to both. Two profiles of the same Chrome never collide.
+8. Chrome's internal pages cannot be read or driven. Neither can the Chrome Web Store or the extensions gallery: Chrome refuses both `chrome.scripting` and `chrome.debugger` there, so no extension can automate them, including this one. Publishing an extension is therefore a manual job by design.
 
 ## Uninstall
 

package/ROADMAP.md

@@ -1,6 +1,6 @@
 # Roadmap
 
-yoke is a Chrome extension and local MCP server for driving the browser you are already signed in to. It gives any MCP client one explicit interface to tabs, page content, trusted input, screenshots, console output and network activity, without a tab-group boundary or a second browser.
+yoke is a Chrome extension and local MCP server for driving the browser you are already signed in to. Every operation names an explicit tab id, every tab in every window is reachable, and it needs no second profile and no browser-wide debugging port. It gives any MCP client one interface to tabs, page content, trusted input, screenshots, console output and network activity.
 
 This roadmap records what has been built and what comes next. Each release is small, shippable on its own, and the non-goals are part of the plan.
 
@@ -39,6 +39,7 @@ Theme: prove the thesis. Built, working end to end, not yet tagged or published.
 - The extension id is pinned by a key in its manifest, because native messaging allowlists by id and an unpacked load would otherwise get a fresh one each time. The private key never enters the repository, and CI asserts the key still derives the allowlisted id.
 - An icon, at 16, 32, 48 and 128, drawn on an 8 unit grid so every line lands on a pixel boundary at 16.
 - Offline tests for the MCP surface and the redaction, driven without a browser. CI green on Node 22 and 24 across Linux, macOS and Windows.
+- Since 0.1.3, unreleased: one endpoint per Chrome profile, named after an id the extension mints and keeps. `list_browsers` names each connected profile, `list_tabs` covers all of them, tab tools route by tab id, and `open_tab` takes `browser` when there is a choice. Closes the wrong-profile case in #6 and #8, where a single per-user endpoint was won by whichever profile connected first.
 
 The acceptance test is one number, and it holds: `list_tabs` returns every tab in the browser rather than the handful inside a managed group. On the machine this was built against that is 41 tabs, all of them addressable.
 

package/dist/browsers.d.ts

@@ -0,0 +1,80 @@
+import type { ArgsOf, OperationName, ResultOf, TabInfo } from './protocol.js';
+export interface Browser {
+    endpoint: string;
+    /** Random, minted by the extension, stable for the life of the profile. */
+    id: string;
+    /** Typed into the popup by the person. Empty until they do. */
+    label: string;
+    windows: number;
+    tabs: number;
+    /** The extension predates `identify`, so id and label are the host's fallback. */
+    unidentified: boolean;
+}
+/** A tab with the browser it lives in. */
+export interface PlacedTab extends TabInfo {
+    browser: Browser;
+}
+/** The name a person or a model would use for a browser in output. */
+export declare const displayName: (browser: Browser) => string;
+/** Refused because the tab is not, or is ambiguously, anywhere. */
+export declare class NoSuchTab extends Error {
+    readonly name = "NoSuchTab";
+}
+/** Refused because the caller named no browser when it had to, or named one that is not there. */
+export declare class NoSuchBrowser extends Error {
+    readonly name = "NoSuchBrowser";
+}
+/** Drops every cached fact. For tests, which change the endpoint directory. */
+export declare function forget(): void;
+/** Every browser that answers, in a stable order. */
+export declare function connectedBrowsers(): Promise<Browser[]>;
+/**
+ * Every tab in every connected browser, each knowing where it lives.
+ *
+ * Also refreshes the routing table, so a list is what teaches the router about
+ * new tabs, and a tool called on a tab nobody has listed yet triggers one.
+ */
+export declare function allTabs(): Promise<{
+    browsers: Browser[];
+    tabs: PlacedTab[];
+}>;
+/**
+ * The one browser a tabless call should go to.
+ *
+ * With one connected there is nothing to choose. With more, the caller has to
+ * say, by id or by label, because picking for them is how a tab ends up opened
+ * in a profile nobody is looking at.
+ */
+export declare function chooseBrowser(selector: unknown, tool: string): Promise<Browser>;
+/**
+ * Forgets where a tab id was placed.
+ *
+ * For a tab that appeared without a listing, which only open_tab does. Two
+ * browsers number tabs independently, so the id it hands out can be one another
+ * browser already holds, and a cached placement for it would send the next
+ * call there. Forgetting forces a listing, which is where collisions are seen.
+ */
+export declare function unplace(tabId: number): void;
+/**
+ * The endpoint holding a tab.
+ *
+ * The routing table is filled by listing, so a tab the caller learnt about from
+ * list_tabs is already placed. One that is not gets a fresh listing before it is
+ * declared missing, because a tab the person opened a moment ago is a perfectly
+ * good thing to be asked about.
+ */
+export declare function endpointForTab(tabId: number): Promise<string>;
+/**
+ * The one endpoint holding every one of these tabs.
+ *
+ * Refused when they are spread across browsers, with each tab's browser named,
+ * because an operation on several tabs goes to one browser and the others
+ * would fail there with a message about a tab that does exist, elsewhere.
+ */
+export declare function endpointForTabs(tabIds: number[]): Promise<string>;
+/** Sends an operation to whichever browser holds the tab it names. */
+export declare function askTab<K extends OperationName>(op: K, args: ArgsOf<K> & {
+    tabId: number;
+}, options?: {
+    timeoutMs?: number;
+}): Promise<ResultOf<K>>;

package/dist/browsers.js

@@ -0,0 +1,232 @@
+// Which Chrome profile a call goes to.
+//
+// Chrome starts one native host per profile, so with the extension loaded in
+// two profiles there are two endpoints, and a caller has to end up at the right
+// one. The rule is the one the rest of the project already lives by: a tab is
+// named by id, and the id decides. Chrome hands out tab ids from one counter for
+// the whole browser process, so two profiles of the same Chrome never share one,
+// and the server can route on it without a selected browser or a `browser`
+// argument on every tool. Only a call that names no tab, open_tab, has to be
+// told where.
+//
+// Two different browsers (Chrome and Brave, say) do each have their own counter,
+// so a collision is possible there. It is detected and refused rather than
+// guessed at.
+import { LEGACY_ID, endpointIdOf, listEndpoints } from './socket-path.js';
+import { ask, ExtensionUnavailable } from './socket-client.js';
+/** The name a person or a model would use for a browser in output. */
+export const displayName = (browser) => browser.label === '' ? browser.id : browser.label;
+/** Refused because the tab is not, or is ambiguously, anywhere. */
+export class NoSuchTab extends Error {
+    name = 'NoSuchTab';
+}
+/** Refused because the caller named no browser when it had to, or named one that is not there. */
+export class NoSuchBrowser extends Error {
+    name = 'NoSuchBrowser';
+}
+/** Stands in for an endpoint when two browsers both claim the tab id. */
+const AMBIGUOUS = '\0ambiguous';
+/**
+ * Which endpoint holds each tab id, as of the last time anyone looked.
+ *
+ * The only thing remembered between calls. Identity is asked for afresh each
+ * time a browser is listed, because the label is typed into the popup while the
+ * server is running, and a cached one would keep answering with the old name.
+ */
+let placement = new Map();
+/** The endpoints the placement was built from, so a change in them invalidates it. */
+let placedFrom = '';
+/** The browsers as of the last listing, for naming an endpoint in a refusal. */
+let lastBrowsers = new Map();
+const endpointSignature = () => listEndpoints().join('\n');
+/** Drops every cached fact. For tests, which change the endpoint directory. */
+export function forget() {
+    placement = new Map();
+    placedFrom = '';
+    lastBrowsers = new Map();
+}
+async function identify(endpoint) {
+    try {
+        const who = await ask(endpoint, 'identify', {}, { timeoutMs: 3_000 });
+        return { endpoint, ...who, unidentified: false };
+    }
+    catch (failure) {
+        // A dead socket is a corpse and is skipped. A live host whose extension
+        // does not know the op is a browser we can still drive, so it is kept under
+        // the id the host itself fell back to.
+        if (failure instanceof ExtensionUnavailable) {
+            return undefined;
+        }
+        return {
+            endpoint,
+            id: endpointIdOf(endpoint) ?? LEGACY_ID,
+            label: '',
+            windows: 0,
+            tabs: 0,
+            unidentified: true,
+        };
+    }
+}
+/** Every browser that answers, in a stable order. */
+export async function connectedBrowsers() {
+    const answered = await Promise.all(listEndpoints().map((endpoint) => identify(endpoint)));
+    return answered.filter((browser) => browser !== undefined);
+}
+/**
+ * Every tab in every connected browser, each knowing where it lives.
+ *
+ * Also refreshes the routing table, so a list is what teaches the router about
+ * new tabs, and a tool called on a tab nobody has listed yet triggers one.
+ */
+export async function allTabs() {
+    const browsers = await connectedBrowsers();
+    const listed = await Promise.all(browsers.map(async (browser) => {
+        try {
+            const { tabs } = await ask(browser.endpoint, 'listTabs', {}, { timeoutMs: 5_000 });
+            return tabs.map((tab) => ({ ...tab, browser }));
+        }
+        catch (failure) {
+            // Gone between identify and now. Not an error in the listing.
+            if (failure instanceof ExtensionUnavailable) {
+                return [];
+            }
+            throw failure;
+        }
+    }));
+    const tabs = listed.flat();
+    placement = new Map();
+    placedFrom = endpointSignature();
+    lastBrowsers = new Map(browsers.map((browser) => [browser.endpoint, browser]));
+    for (const tab of tabs) {
+        const already = placement.get(tab.id);
+        if (already === undefined) {
+            placement.set(tab.id, tab.browser.endpoint);
+        }
+        else if (already !== tab.browser.endpoint) {
+            // Two browsers with the same id: marked so nothing routes to either.
+            placement.set(tab.id, AMBIGUOUS);
+        }
+    }
+    return { browsers, tabs };
+}
+/**
+ * The one browser a tabless call should go to.
+ *
+ * With one connected there is nothing to choose. With more, the caller has to
+ * say, by id or by label, because picking for them is how a tab ends up opened
+ * in a profile nobody is looking at.
+ */
+export async function chooseBrowser(selector, tool) {
+    const browsers = await connectedBrowsers();
+    if (browsers.length === 0) {
+        throw new ExtensionUnavailable('the extension is not connected. Run `yoke install`, then load it in Chrome.');
+    }
+    if (selector === undefined || selector === '') {
+        const only = browsers[0];
+        if (browsers.length === 1 && only !== undefined) {
+            return only;
+        }
+        const names = browsers.map((browser) => `${displayName(browser)} (${browser.tabs} tab(s))`).join(', ');
+        throw new NoSuchBrowser(`${browsers.length} browsers are connected: ${names}. ${tool} opens a tab in one of them, so pass `
+            + 'browser with an id or label from list_browsers.');
+    }
+    const wanted = String(selector);
+    const byId = browsers.find((browser) => browser.id === wanted);
+    if (byId !== undefined) {
+        return byId;
+    }
+    // Labels are typed by a person and nothing stops two profiles getting the
+    // same one, so a label that fits more than one is refused with the ids,
+    // which cannot collide.
+    const byLabel = browsers.filter((browser) => browser.label.toLowerCase() === wanted.toLowerCase());
+    if (byLabel.length > 1) {
+        const ids = byLabel.map((browser) => `${browser.id} (${browser.tabs} tab(s))`).join(', ');
+        throw new NoSuchBrowser(`${byLabel.length} connected browsers are labelled ${JSON.stringify(wanted)}: ${ids}. Pass the id of the one you mean.`);
+    }
+    const match = byLabel[0];
+    if (match === undefined) {
+        const names = browsers.map((browser) => displayName(browser)).join(', ');
+        throw new NoSuchBrowser(`no connected browser is ${JSON.stringify(wanted)}. Connected: ${names}.`);
+    }
+    return match;
+}
+/**
+ * Forgets where a tab id was placed.
+ *
+ * For a tab that appeared without a listing, which only open_tab does. Two
+ * browsers number tabs independently, so the id it hands out can be one another
+ * browser already holds, and a cached placement for it would send the next
+ * call there. Forgetting forces a listing, which is where collisions are seen.
+ */
+export function unplace(tabId) {
+    placement.delete(tabId);
+}
+/**
+ * The endpoint holding a tab.
+ *
+ * The routing table is filled by listing, so a tab the caller learnt about from
+ * list_tabs is already placed. One that is not gets a fresh listing before it is
+ * declared missing, because a tab the person opened a moment ago is a perfectly
+ * good thing to be asked about.
+ */
+export async function endpointForTab(tabId) {
+    // A browser that connected or left since the placement was built can have
+    // introduced a collision the cache knows nothing about, so the cache is
+    // trusted only while the endpoints it was built from are the ones on disk.
+    if (placement.get(tabId) === undefined || endpointSignature() !== placedFrom) {
+        await allTabs();
+    }
+    const endpoint = placement.get(tabId);
+    if (endpoint === AMBIGUOUS) {
+        const { tabs } = await allTabs();
+        const owners = tabs.filter((tab) => tab.id === tabId).map((tab) => displayName(tab.browser));
+        throw new NoSuchTab(`tab ${tabId} exists in ${owners.length} connected browsers at once (${owners.join(', ')}), which `
+            + 'happens when two different browsers both run the extension. Nothing is sent, because it '
+            + 'cannot be sent to both. Disable the extension in one of them, or close that tab in one.');
+    }
+    if (endpoint !== undefined) {
+        return endpoint;
+    }
+    if ((await connectedBrowsers()).length === 0) {
+        throw new ExtensionUnavailable('the extension is not connected. Run `yoke install`, then load it in Chrome.');
+    }
+    throw new NoSuchTab(`tab ${tabId} is not open in any connected browser. Call list_tabs for ids that are.`);
+}
+/**
+ * The one endpoint holding every one of these tabs.
+ *
+ * Refused when they are spread across browsers, with each tab's browser named,
+ * because an operation on several tabs goes to one browser and the others
+ * would fail there with a message about a tab that does exist, elsewhere.
+ */
+export async function endpointForTabs(tabIds) {
+    const endpoints = await Promise.all(tabIds.map((tabId) => endpointForTab(tabId)));
+    const distinct = new Set(endpoints);
+    const only = endpoints[0];
+    if (distinct.size === 1 && only !== undefined) {
+        return only;
+    }
+    const where = tabIds.map((tabId, index) => {
+        const browser = lastBrowsers.get(endpoints[index] ?? '');
+        return `tab ${tabId} is in ${browser === undefined ? 'an unknown browser' : displayName(browser)}`;
+    });
+    throw new NoSuchTab(`those ${tabIds.length} tabs are in ${distinct.size} different browsers: ${where.join(', ')}. `
+        + 'An operation on several tabs goes to one browser, so name tabs from one at a time.');
+}
+/** Sends an operation to whichever browser holds the tab it names. */
+export async function askTab(op, args, options = {}) {
+    const endpoint = await endpointForTab(args.tabId);
+    try {
+        return await ask(endpoint, op, args, options);
+    }
+    catch (failure) {
+        // The host may have gone since the tab was placed. Once more from a fresh
+        // listing, and after that the failure is the answer.
+        if (!(failure instanceof ExtensionUnavailable)) {
+            throw failure;
+        }
+        placement.delete(args.tabId);
+        return ask(await endpointForTab(args.tabId), op, args, options);
+    }
+}
+//# sourceMappingURL=browsers.js.map

package/dist/browsers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browsers.js","sourceRoot":"","sources":["../src/browsers.ts"],"names":[],"mappings":"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"}

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { install, uninstall } from './install.js';
-import { endpointPath } from './socket-path.js';
+import { endpointDir } from './socket-path.js';
 const USAGE = `yoke - browser automation in the Chrome you are already signed in to.
 
 Usage:
@@ -87,15 +87,26 @@ async function main() {
         return checks.every((check) => check.ok) ? EXIT.OK : EXIT.UNAVAILABLE;
     }
     if (action === 'status') {
-        const { available } = await import('./socket-client.js');
-        const reachable = await available();
-        process.stdout.write(`extension: ${reachable ? 'connected' : 'not reachable'}\n`);
-        process.stdout.write(`socket: ${endpointPath()}\n`);
-        if (!reachable) {
+        const { connectedBrowsers } = await import('./browsers.js');
+        const browsers = await connectedBrowsers();
+        if (browsers.length === 0) {
+            process.stdout.write('extension: not reachable\n');
+            process.stdout.write(`endpoints: ${endpointDir()}\n`);
             process.stdout.write('\nIf install has run and the extension is loaded, open chrome://extensions and '
                 + 'check its service worker is running. Chrome starts the host on demand.\n');
+            return EXIT.UNAVAILABLE;
+        }
+        // One line per profile, because with two connected "connected" alone is
+        // exactly the answer that hid the wrong-profile case.
+        process.stdout.write(`extension: connected, ${browsers.length} browser(s)\n`);
+        for (const browser of browsers) {
+            const label = browser.unidentified
+                ? '(legacy endpoint; reload the extension so this profile gets its own)'
+                : browser.label === '' ? '(unnamed)' : browser.label;
+            const tabs = browser.unidentified ? 'tabs unknown' : `${browser.tabs} tab(s)`;
+            process.stdout.write(`  ${browser.id}\t${label}\t${tabs}\t${browser.endpoint}\n`);
         }
-        return reachable ? EXIT.OK : EXIT.UNAVAILABLE;
+        return EXIT.OK;
     }
     process.stdout.write(USAGE);
     return action === undefined || action === '-h' || action === '--help' ? EXIT.OK : EXIT.USAGE;