pendingyou 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.8.0
+
+- The hooks say when a session is on another Pending You. A Claude Code session stayed connected to staging after its
+  person moved to production, so its cards went where they no longer looked. Now both hooks (`pickup` at session
+  start, `handoff` with every message) compare the `pendingyou` MCP server Claude Code uses in the session's folder
+  with the origin they run against (`--origin`), and when they're different sites add one line (about 45 tokens):
+  `Pending You: your MCP server is https://staging.pendingyou.com but your hooks and sign-in are
+  https://www.pendingyou.com, so your cards and their answers may not meet. Ask your person which one they use, and
+  restart the session after fixing it (npx pendingyou init --origin <that one>).` The server is the one Claude Code
+  would use there: local scope (`~/.claude.json`'s `projects`), then the folder's `.mcp.json`, then user scope, then
+  the Pending You plugin when `~/.claude/settings.json` enables it (production's server). All read only, and only the
+  `pendingyou` server's address is looked at; nothing is sent. `pendingyou.com` and `www.pendingyou.com` are the same
+  site; a file that can't be read is never a mismatch. The line is said even when the hooks' origin isn't signed in,
+  and it's kept when a hook reaches its 3-second deadline.
+- `status` says the same: a `Mismatch:` line naming both sites and what to do, a line for a folder's own
+  (local- or project-scope) server that points elsewhere, and "Not ready" (exit 1) until they agree.
+
 ## 0.7.0
 
 - Faster hooks. They ran `npx -y --prefer-offline pendingyou@<version> …`, and npx alone took about half a second

package/README.md

@@ -26,13 +26,18 @@ that. If Claude Code already has a `pendingyou` server pointing somewhere else (
 asks before replacing it; `--yes` replaces it without asking, and with nobody to ask it prints the two commands to
 run. Afterwards restart Claude Code, run `/mcp`, choose pendingyou and Authenticate.
 
+If the `pendingyou` MCP server Claude Code uses in a session's folder is another Pending You than the hooks' (staging
+and production, say), both hooks add one line telling Claude Code so, and to ask you which one you use: its cards
+would otherwise go where you don't look. `npx pendingyou status` flags it too. Fix it with `npx pendingyou init
+--origin <the one you use>`, then restart the session.
+
 The hooks never get in your way: if anything goes wrong (no network, not signed in, a bad option), they print nothing
 and let your message through. Each one stops within 3 seconds whatever happens, with at most its one-line reminder, and
 never refreshes the sign-in itself: when that's due, it starts the refresh in the background, which finishes on its
 own. Running `init` again updates them in place, and adds any a newer version brings.
 
 The hooks run that copy with Node directly, like
-`"/opt/homebrew/bin/node" "~/.config/pendingyou/cli/0.7.0/node_modules/pendingyou/dist/cli.js" handoff || true` (the
+`"/opt/homebrew/bin/node" "~/.config/pendingyou/cli/0.8.0/node_modules/pendingyou/dist/cli.js" handoff || true` (the
 paths in full). If the copy can't be made (no npm, no network), they run through `npx -y --prefer-offline
 pendingyou@<version>` instead. `npx pendingyou status` says which. If you remove the Node they run with, run `init`
 again.
@@ -125,8 +130,9 @@ The sign-in only hears answers to your own Claude Code assistants' questions, or
 answer or change anything, and it doesn't show up as one. It's stored in `~/.config/pendingyou/credentials.json`
 (readable only by you), refreshes itself, and ends after 30 days or on `logout`. `state.json` beside it remembers
 which answers were already handed over (ids only), `claude-code.json` what `init` added, and `cli/` the hooks' copy
-of the command line. `init` reads `~/.claude.json` only to see whether Claude Code has a `pendingyou` MCP server and
-where it points. Nothing is sent anywhere but Pending You.
+of the command line. `init`, `status` and the hooks read `~/.claude.json` (and a folder's `.mcp.json`, and
+`~/.claude/settings.json`'s enabled plugins) only to see whether Claude Code has a `pendingyou` MCP server and where
+it points. Nothing is sent anywhere but Pending You.
 
 ## Development
 

package/dist/environment.js

@@ -0,0 +1,98 @@
+// Is this session on the Pending You its hooks are on? A Claude Code session stayed connected to staging after its
+// person moved to production (2026-10-01): its cards went where they no longer looked, and the hooks, signed in to
+// production, never heard them. So the hooks compare the `pendingyou` MCP server Claude Code has for the session's
+// folder (read from ~/.claude.json and the folder's .mcp.json, read only) with the origin they run against (`--origin`),
+// and when they differ, add one line telling the agent to ask its person which one they use. `status` says the same.
+//
+// Only the pendingyou server's url is read, never anything else from those files; nothing is written, nothing is sent.
+// A server Claude Code can't be read for (no file, another shape, a plugin's server) is never called a mismatch.
+import { join } from 'node:path';
+import { claudeJsonPath, MCP_NAME } from "./claude.js";
+import { claudeDir, readText } from "./files.js";
+/**
+ * The published Pending You plugin for Claude (recordplane/pendingyou-plugin) and where its server is. A hand-added
+ * pendingyou server at any scope overrides it in Claude Code, so it counts only when there's none.
+ */
+export const PLUGIN_ID = 'pending-you@pendingyou';
+export const PLUGIN_MCP_URL = 'https://www.pendingyou.com/mcp';
+const objectAt = (value, key) => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const found = value[key];
+    return typeof found === 'object' && found !== null && !Array.isArray(found)
+        ? found
+        : null;
+};
+const urlOf = (servers) => {
+    const url = objectAt(servers, MCP_NAME)?.url;
+    return typeof url === 'string' && url.length > 0 ? url : null;
+};
+async function readJsonQuietly(path) {
+    try {
+        const text = await readText(path);
+        return text === null ? null : JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The `pendingyou` MCP server Claude Code uses in `folder`: local scope (~/.claude.json's projects[folder]), then the
+ * folder's own .mcp.json, then user scope (~/.claude.json's mcpServers), then the Pending You plugin when
+ * ~/.claude/settings.json enables it. Null when none of them has one with a url.
+ */
+export async function serverForFolder(io, folder) {
+    const [state, project, settings] = await Promise.all([
+        readJsonQuietly(claudeJsonPath(io)),
+        readJsonQuietly(join(folder, '.mcp.json')),
+        readJsonQuietly(join(claudeDir(io), 'settings.json')),
+    ]);
+    const local = urlOf(objectAt(objectAt(objectAt(state, 'projects'), folder), 'mcpServers'));
+    if (local)
+        return { url: local, scope: 'local' };
+    const shared = urlOf(objectAt(project, 'mcpServers'));
+    if (shared)
+        return { url: shared, scope: 'project' };
+    const user = urlOf(objectAt(state, 'mcpServers'));
+    if (user)
+        return { url: user, scope: 'user' };
+    return objectAt(settings, 'enabledPlugins')?.[PLUGIN_ID] === true
+        ? { url: PLUGIN_MCP_URL, scope: 'plugin' }
+        : null;
+}
+/**
+ * The site an address is on, as one name: www.pendingyou.com and pendingyou.com are the same Pending You (the bare
+ * name redirects), so both read https://www.pendingyou.com. Null when it isn't an address.
+ */
+export function siteOf(address) {
+    try {
+        const url = new URL(address);
+        if (url.protocol !== 'https:' && url.protocol !== 'http:')
+            return null;
+        const host = url.host === 'pendingyou.com' ? 'www.pendingyou.com' : url.host;
+        return `${url.protocol}//${host}`;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether the server and the hooks' origin are different Pending Yous. Unknown addresses never differ. */
+export function differs(server, origin) {
+    if (!server)
+        return false;
+    const a = siteOf(server.url);
+    const b = siteOf(origin);
+    return a !== null && b !== null && a !== b;
+}
+/** The line a hook adds when they differ (about 45 tokens). */
+export const mismatchLine = (server, origin) => `Pending You: your MCP server is ${siteOf(server.url)} but your hooks and sign-in are ${siteOf(origin)}, so your cards and their answers may not meet. Ask your person which one they use, and restart the session after fixing it (npx pendingyou init --origin <that one>).`;
+/** The hook's warning for this folder, or null when the two agree or can't be told. Never throws. */
+export async function environmentWarning(io, folder, origin) {
+    try {
+        const server = await serverForFolder(io, folder);
+        return differs(server, origin) ? mismatchLine(server, origin) : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/main.js

@@ -4,6 +4,7 @@ import { getJson, refreshInBackground, SignInNeeded, Unavailable } from "./api.j
 import { commandOf, DEFAULT_ORIGIN, HOOK_COMMANDS, parseArgs, USAGE, UsageError, } from "./args.js";
 import { claudeState, installClaude, uninstallClaude } from "./claude.js";
 import { readCredential, signedInOrigins, updateCredential } from "./credentials.js";
+import { differs, serverForFolder, siteOf } from "./environment.js";
 import { PlainError } from "./errors.js";
 import { hold } from "./hold.js";
 import { OAuthError, revoke, signIn, signInWithDevice } from "./oauth.js";
@@ -71,7 +72,11 @@ async function logout(io, options) {
     return 0;
 }
 async function status(io, origin) {
-    const [signIn, claude] = await Promise.all([checkSignIn(io, origin), claudeState(io)]);
+    const [signIn, claude, here] = await Promise.all([
+        checkSignIn(io, origin),
+        claudeState(io),
+        serverForFolder(io, io.cwd),
+    ]);
     const lines = [`Pending You for Claude Code · ${origin}`];
     const mark = (ok) => (ok ? 'ok     ' : 'missing');
     const url = `${origin}/mcp`;
@@ -83,7 +88,7 @@ async function status(io, origin) {
             ? 'not added; run npx pendingyou init'
             : mcpOk
                 ? `pendingyou${mcp.url ? ` (${mcp.url})` : ''}`
-                : `points at ${mcp.url}, not ${url}; run npx pendingyou init${origin === DEFAULT_ORIGIN ? '' : ` --origin ${origin}`} to replace it`;
+                : `points at ${mcp.url}, not ${url}, so sessions post cards where these hooks don’t hear them; run npx pendingyou init${origin === DEFAULT_ORIGIN ? '' : ` --origin ${origin}`} to replace it`;
     const form = claude.form;
     const hooksRun = form?.runs ?? true;
     const formText = !form
@@ -104,7 +109,15 @@ async function status(io, origin) {
             : signIn.state === 'none'
                 ? 'not signed in; run npx pendingyou login'
                 : 'Pending You couldn’t be reached'}`, `  ${mark(claude.claude !== null)} Claude Code: ${claude.claude ?? 'not found on PATH'}`, `  ${mark(mcpOk)} MCP server: ${mcpText}`, `  ${mark(claude.skill)} Skill: ${claude.skill ? 'saved' : 'not saved; run npx pendingyou init'}`, `  ${mark(claude.hooks && hooksRun)} Hooks: ${claude.hooks ? `session-start pickup and next-message hand-off; ${formText}` : 'not installed; run npx pendingyou init'}`, `  ${mark(claude.stopcheck)} Stop check: ${claude.stopcheck ? 'asks Claude Code to post what it leaves you in chat' : 'not installed; run npx pendingyou init'}`);
-    const ready = signIn.state === 'ok' && claude.hooks && hooksRun;
+    // A folder's own server (local or project scope) wins over the user one in Claude Code: say when it's elsewhere. (The
+    // plugin's server counts only when no server was added by hand, and is production's.)
+    if (here && (here.scope === 'local' || here.scope === 'project') && differs(here, origin))
+        lines.push(`  ${mark(false)} This folder: its ${here.scope}-scope pendingyou MCP server (${here.url}) is another Pending You than ${origin}; Claude Code uses it here instead`);
+    const user = mcp !== false && mcp !== 'unknown' && mcp.url ? { url: mcp.url, scope: 'user' } : null;
+    const other = differs(here, origin) ? here : differs(user, origin) ? user : null;
+    const ready = signIn.state === 'ok' && claude.hooks && hooksRun && !other;
+    if (other)
+        lines.push(`Mismatch: Claude Code’s MCP server is ${siteOf(other.url)} but the hooks and sign-in are ${siteOf(origin) ?? origin}. Use the one you look at (npx pendingyou init --origin <it>), then restart your Claude Code sessions.`);
     lines.push(ready
         ? 'Ready: Claude Code hears answers right away (report_setup hears "instant").'
         : 'Not ready: Claude Code hears answers while it’s working (report_setup hears "while-working").');

package/dist/pickup.js

@@ -9,11 +9,15 @@
 //   one small request per message (the open cards, and answers too while a hold from this computer is outstanding),
 //   time-boxed short; on any error, or from a server too old to list open cards, the line is the plain reminder.
 //
+// Both also add one line when the session's pendingyou MCP server is another Pending You than the hooks' origin
+// (environment.ts): its cards would go where these hooks, and maybe its person, don't look.
+//
 // Whatever they print, Claude Code adds to the conversation. A hook must never get in the way: each is time-boxed,
 // has a hard deadline (main.ts) after which it prints only its fallback, never refreshes the sign-in itself (api.ts),
 // prints nothing when there's nothing new, never repeats an answer it handed over, and always exits 0.
 import { getJson, SignInNeeded } from "./api.js";
 import { readCredential } from "./credentials.js";
+import { environmentWarning } from "./environment.js";
 import { clip, describe, isClosed } from "./format.js";
 import { markHanded, momentOf, waitingOn, wasHanded } from "./state.js";
 /** Each request's own limit, inside the hook's 3-second deadline (main.ts). */
@@ -76,15 +80,20 @@ export async function pickup(io, options, hook = { fallback: '' }) {
     const { origin, mode } = options;
     // The hand-off's line, printed at the end unless something else was printed with it.
     let line = null;
+    // Said by either hook, signed in or not, when the session's MCP server is another Pending You (environment.ts).
+    let warning = null;
     try {
         const cwd = await sessionFolder(io);
+        warning = await environmentWarning(io, cwd, origin);
+        if (warning)
+            hook.fallback = `${warning}\n`;
         // The hand-off hears answers only while a hold from this computer is outstanding; it always asks for open cards.
         let answers = true;
         if (mode === 'handoff') {
             if ((await readCredential(io, origin)) === null)
                 return 0;
             line = REMINDER;
-            hook.fallback = `${REMINDER}\n`;
+            hook.fallback = `${[REMINDER, warning].filter(Boolean).join('\n')}\n`;
             answers = (await waitingOn(io, origin)).length > 0;
         }
         const query = new URLSearchParams([
@@ -116,8 +125,10 @@ export async function pickup(io, options, hook = { fallback: '' }) {
             ...fresh.flatMap((heard) => [...describe(heard, again(heard.requestId)), '']),
             'Tell them in one line first (“You answered in Pending You: …”), then act.',
             ...(line ? [line] : []),
+            ...(warning ? [warning] : []),
         ].join('\n')}\n`);
         line = null;
+        warning = null;
         await markHanded(io, origin, fresh.map((heard) => ({
             requestId: heard.requestId,
             moment: momentOf(heard),
@@ -133,7 +144,8 @@ export async function pickup(io, options, hook = { fallback: '' }) {
         return 0;
     }
     finally {
-        if (line)
-            io.out(`${line}\n`);
+        const last = [line, warning].filter(Boolean);
+        if (last.length)
+            io.out(`${last.join('\n')}\n`);
     }
 }

package/dist/version.js

@@ -1,2 +1,2 @@
 // The command line's version, as published (package.json). A test keeps them the same.
-export const VERSION = '0.7.0';
+export const VERSION = '0.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Pending You for Claude Code: hear your answers from Pending You in the background, and set Claude Code up in one command.",
   "license": "Apache-2.0",
   "homepage": "https://www.pendingyou.com",