qiksy-mcp 1.46.0 → 1.47.0

package/connect.mjs

@@ -122,6 +122,68 @@ export function portInPlace(targets) {
   return 0;
 }
 
+/**
+ * THE PAIRING, FOR A COMMAND THAT HAS NO ENVIRONMENT — i.e. the finish hook.
+ *
+ * The server proper is started BY the agent, which hands it the token in the entry's `env` block.
+ * A Stop hook is not started that way: it is a bare command in a bare shell, so QIKSY_MCP_TOKEN is
+ * empty, the hub closes the unauthenticated join — correctly — and the hook then fails in the one
+ * way nobody notices: silently, once per run, into a log no one reads. Measured on a real setup
+ * (21.09.2026): `npx qiksy-mcp done` answered «the bridge closed the connection» and the browser
+ * never heard a thing, while the same command with the token in front of it rang through.
+ *
+ * So the hook reads the same pairing the agent itself uses. `~/.claude.json` is in the search
+ * because that is where `claude mcp add` puts an entry — top level, or under projects/<cwd> — and
+ * it is READ ONLY here: connect writes `.mcp.json` instead, and a command that fires on every stop
+ * must never rewrite the file that holds every project's servers.
+ */
+export function pairingInPlace({ dir = process.cwd(), home = homedir(), platform = osPlatform() } = {}) {
+  const targets = agentTargets({ dir, home, platform });
+  const found = { token: tokenInPlace(targets), port: portInPlace(targets) };
+  if (found.token && found.port) return found;
+
+  for (const entry of claudeJsonEntries(join(home, '.claude.json'), dir)) {
+    const tok = entry?.env?.QIKSY_MCP_TOKEN;
+    if (!found.token && typeof tok === 'string' && tok.length >= 16) found.token = tok;
+    if (!found.port) {
+      const args = Array.isArray(entry?.args) ? entry.args : [];
+      const i = args.indexOf('--port');
+      const p = i !== -1 ? Number(args[i + 1]) : NaN;
+      if (Number.isInteger(p) && p > 0) found.port = p;
+    }
+    if (found.token && found.port) break;
+  }
+  return found;
+}
+
+/**
+ * Every qiksy entry in `~/.claude.json`, THE ONE FOR THIS FOLDER FIRST.
+ *
+ * Order is the whole point: the token is the same everywhere (the popup has one field), but the
+ * PORT is per project, and a hook that picks a neighbouring project's port rings a bridge that
+ * belongs to somebody else's run. Deepest matching project path wins, then the global entry, then
+ * whatever else is there — the last one so a folder that was never connected still finds the
+ * pairing instead of going silent.
+ */
+function claudeJsonEntries(file, dir) {
+  let json;
+  try {
+    json = JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return []; // missing or hand-broken: not our file to fix, and not a reason to fail
+  }
+  const projects = json?.projects && typeof json.projects === 'object' ? json.projects : {};
+  const mine = Object.keys(projects)
+    .filter((p) => dir === p || dir.startsWith(`${p}/`))
+    .sort((a, b) => b.length - a.length);
+  const rest = Object.keys(projects).filter((p) => !mine.includes(p));
+  const out = [];
+  for (const p of mine) if (projects[p]?.mcpServers?.qiksy) out.push(projects[p].mcpServers.qiksy);
+  if (json?.mcpServers?.qiksy) out.push(json.mcpServers.qiksy);
+  for (const p of rest) if (projects[p]?.mcpServers?.qiksy) out.push(projects[p].mcpServers.qiksy);
+  return out;
+}
+
 /** Write our one entry, keep everything else in the file exactly as it was. */
 export function writeEntry(target, entry) {
   const { json, existed } = readConfig(target.file);
@@ -213,8 +275,15 @@ export const mintToken = () => randomBytes(18).toString('base64url');
 export async function connectAgents({ dir = process.cwd(), home = homedir(), platform = osPlatform(), port, token, hook = true } = {}) {
   const targets = agentTargets({ home, platform, dir });
   const installed = targets.filter((t) => existsSync(t.needs));
-  const keptToken = token || tokenInPlace(targets);
-  const keptPort = port || portInPlace(targets);
+  /* THE SEARCH FOR AN EXISTING PAIRING IS WIDER THAN THE LIST WE WRITE INTO, and that is the whole
+     point of it. `claude mcp add` puts the entry in ~/.claude.json, which is not a file connect
+     writes; looking only at its own targets, a re-run found nothing, minted a FRESH token and wrote
+     it everywhere — leaving the browser paired with a secret nobody holds any more. It costs the
+     person a «Token rejected» on the next restart and a trip to the popup, for a command they ran
+     to fix something else. Seen live on the owner's own machine, 21.09.2026. */
+  const inPlace = pairingInPlace({ dir, home, platform });
+  const keptToken = token || inPlace.token;
+  const keptPort = port || inPlace.port;
   const usePort = keptPort || (await freePort());
   const useToken = keptToken || mintToken();
   const entry = serverEntry({ port: usePort, token: useToken, platform });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiksy-mcp",
-  "version": "1.46.0",
+  "version": "1.47.0",
   "description": "Browser MCP server for the Chrome tab you already have open — your session, your logins. Gives Claude Code, Cursor, Codex and VS Code the live page: findings, forms, failed requests with server bodies.",
   "keywords": [
     "mcp",

package/server.mjs

@@ -35,7 +35,7 @@ import { project } from './project.mjs';
 import { recordGap, listGaps, gapInvite, GAPS_FILE } from './gaps.mjs';
 import { STATES, STATE_KEYS, renderGallery } from './gallery.mjs';
 import { renderSearchableSvg } from './svg-shot.mjs';
-import { connectAgents, toClipboard } from './connect.mjs';
+import { connectAgents, toClipboard, pairingInPlace } from './connect.mjs';
 
 const log = (...a) => console.error('[qiksy-mcp]', ...a);
 
@@ -855,17 +855,26 @@ if (process.argv[2] === 'done') {
    * loudly because the browser is closed would be a hook people remove.
    */
   const bad = process.argv.includes('--problem');
-  const said = await new Promise((res) => {
+
+  /* ONE ATTEMPT WITH ONE PAIRING. Resolves to the sentence to print, plus `refused` when the hub
+     shut the door on us — which is the only failure worth trying a second key on. */
+  const ring = (token, port) => new Promise((res) => {
     let ws;
-    const give = (msg) => { try { ws?.close(); } catch { /* already gone */ } res(msg); };
+    let answered = false;
+    const give = (said, refused = false) => {
+      if (answered) return;
+      answered = true;
+      try { ws?.close(); } catch { /* already gone */ }
+      res({ said, refused });
+    };
     const timer = setTimeout(() => give('no answer from the bridge'), 6000);
     try {
-      ws = new WebSocket(`ws://${HOST}:${PORT}`);
+      ws = new WebSocket(`ws://${HOST}:${port}`);
     } catch {
       clearTimeout(timer);
-      return res('could not reach the bridge');
+      return give('could not reach the bridge');
     }
-    ws.on('open', () => ws.send(JSON.stringify({ t: 'join', v: PROTOCOL_VERSION, token: TOKEN, pid: process.pid })));
+    ws.on('open', () => ws.send(JSON.stringify({ t: 'join', v: PROTOCOL_VERSION, token, pid: process.pid })));
     ws.on('message', (raw) => {
       let m;
       try { m = JSON.parse(raw.toString()); } catch { return; }
@@ -873,9 +882,45 @@ if (process.argv[2] === 'done') {
       if (m.t === 'res') { clearTimeout(timer); give(m.result?.soundNote || m.error || 'done'); }
     });
     ws.on('error', () => { clearTimeout(timer); give('no bridge on this port'); });
-    ws.on('close', () => { clearTimeout(timer); give('the bridge closed the connection'); });
+    /* Closed before an answer = the token was refused. The hub says nothing more, by design: it
+       is an authentication gate, and a gate that explains itself is a gate that helps a stranger. */
+    ws.on('close', () => { clearTimeout(timer); give('the bridge closed the connection — the token it holds is a different one', true); });
   });
-  log(said);
+
+  /* TWO PLACES A TOKEN CAN COME FROM, AND THE ENVIRONMENT IS NOT THE TRUSTWORTHY ONE.
+   *
+   * A hook runs in a bare shell: no `env` block from the agent, so usually nothing — and sometimes
+   * WORSE than nothing, because an old QIKSY_MCP_TOKEN left in a .zshenv from a previous setup is
+   * exported into every shell on the machine and looks exactly like configuration. Found on the
+   * owner's own machine 21.09.2026: the shell carried a token three generations old, the hub
+   * refused it, and the command reported «the bridge closed the connection» — which reads as a
+   * browser problem, so the search starts in the popup, which was never wrong.
+   *
+   * So the environment is tried FIRST (an explicit export must still win when it is right), and a
+   * refusal falls through to the pairing the agent itself is using. Two attempts, never more. */
+  const tries = [];
+  if (TOKEN) tries.push({ token: TOKEN, port: PORT, from: 'the environment' });
+  const p = pairingInPlace({ dir: process.cwd() });
+  if (p.token && p.token !== TOKEN) {
+    const own = portArg === -1 && !process.env.QIKSY_MCP_PORT && p.port ? p.port : PORT;
+    tries.push({ token: p.token, port: own, from: 'your agent config' });
+  }
+  if (!tries.length) {
+    /* Naming the missing half, because «the bridge closed the connection» sent the last person
+       looking at the browser — the one part that was working. */
+    log('no token: set QIKSY_MCP_TOKEN, or run `npx qiksy-mcp connect` in this project first');
+    process.exit(0);
+  }
+
+  let last = '';
+  for (const t of tries) {
+    const r = await ring(t.token, t.port);
+    last = r.said;
+    if (!r.refused) break;
+    /* Said out loud only when there IS a second key to try — otherwise it is noise on every stop. */
+    if (t !== tries[tries.length - 1]) log(`the token in ${t.from} was refused — trying the one in your agent config`);
+  }
+  log(last);
   process.exit(0);
 }