pendingyou 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,72 @@
 # Changelog
 
+## 0.12.0 (2026-10-04)
+
+- The stdio bridge, `pendingyou mcp --app <app>`: a local MCP server for an agent that can't give its MCP client a
+  header from a command (Claude Code's headersHelper, Codex's http_headers_helper), so its `pendingyou` server signs in
+  through this computer's own sign-in all the same, with no second sign-in. The agent runs it by a path that never
+  changes, `~/.config/pendingyou/bin/pendingyou-mcp --app <app>` (`--origin` off production), a small script that finds
+  Node as the headers helper does and runs this version's private copy, so the agent's config never changes on an
+  upgrade. It passes each JSON-RPC line from stdin on to `<origin>/mcp` with the agent's own connection, and each
+  answer back on a line of its own (a JSON body, or each event of a stream), with nothing else on stdout and only a few
+  plain lines on stderr. It keeps the server's session id, sends the protocol version the handshake agreed (and a
+  2026-07-28 request's own headers), starts a session again when the server forgot it, refreshes the sign-in once after
+  a 401 (in the background, as the helper does) and then answers with an error saying to run `npx -y
+  pendingyou@latest init`; Pending You unreachable, a problem on its side, a redirect (never followed: the token goes
+  nowhere else) or a cut-off answer each get a plain JSON-RPC error. It waits for what's under way when stdin closes,
+  and stops at once on SIGTERM. `--check` says which Node runs it. A module asks for it with `bridged` (docs/apps.md
+  has the contract), and init writes the launcher only then.
+- OpenCode (1.17.0 or later; read from 1.18.34's source): `init` finds `opencode` beside Claude Code and Codex and sets
+  it up with the same one approval, as its own connection ("OpenCode on Ann-MBP", a device sign-in with
+  `assistant=opencode` and a client of its own). Its `pendingyou` MCP server runs the bridge, in OpenCode's global
+  config (`~/.config/opencode/opencode.json` or `.jsonc`), edited in place by a small JSON-with-comments editor that
+  keeps every comment and byte around it; a file it can't read or edit safely is left alone, with the entry to add by
+  hand, and a new file gets OpenCode's `$schema`. A remote server at this Pending You that signs in by itself is moved
+  as Codex's is (asked at a terminal, kept with nobody to ask), keeping its `enabled` and `timeout`; one at another
+  Pending You is replaced only once the person says so. `--oauth` writes a remote server instead (`opencode mcp auth
+  pendingyou`). A `permission` that would make OpenCode ask (`"ask"`, or a catch-all rule) gets `"pendingyou_*":
+  "allow"`; a rule of the person's that names Pending You is kept. The skill goes in
+  `~/.config/opencode/skills/pendingyou/SKILL.md`, unless OpenCode already reads the one Claude Code's or Codex's init
+  saved (a second would be a duplicate).
+- OpenCode's plugin, `~/.config/opencode/plugins/pendingyou.js`: one line re-exporting it from this version's private
+  copy, which OpenCode loads at startup. It runs the hooks' script for what it decides: each message carries the
+  hand-off (as a part the model reads and the TUI doesn't show), and a session's first message what a session start
+  says (the setup line while setup isn't finished: `handoff` takes `source` for that); the cards a session posts are
+  remembered (`posted`); a session that goes idle with something for the person left only in chat is asked once to put
+  it on a card, never for the turn its own prompt started, one the person stopped or a subagent's, with a toast saying
+  why; and when a card is answered, a listener per session (`listen --app opencode`, the plugin's child) hands the
+  plugin the wake mod's words, and the plugin starts the turn in that session (`client.session.promptAsync`), idle or
+  busy. The answer itself never leaves Pending You but through `get_request`. Its own prompts carry
+  `metadata.pendingyou`. `init` ends: restart OpenCode (`/exit`, then `opencode --continue`); it finishes setting up the
+  first time you write to it. `status` checks the bridge as OpenCode runs it and with a handshake; `uninstall` gives the
+  config back as it was. Not on Windows yet.
+- Pi (pi.dev, the `pi` command; 0.99.0 or later, whose MCP client came in 0.99.0; read from 1.0.2's source): `init`
+  finds `pi` and sets it up with the others, on the same one approval, as its own connection ("Pi on Ann-MBP"). Its
+  `pendingyou` server runs the bridge, in `~/.pi/agent/mcp.json` (or `$PI_CODING_AGENT_DIR`'s), with `"exposure":
+  "direct"`, without which Pi's model reaches an MCP server's tools only from scripts. Only that member is written,
+  every other byte of the file as it was (a small JSON editor, `json.ts`, that checks each edit by reading it back); a
+  file that isn't JSON, or a `mcpServers` that isn't an object, is left alone, with the entry to add by hand. A server
+  at another Pending You is replaced only once the person says so; one Pi signs in to by itself (`pi mcp login`) is
+  moved on Yes (the default) at a terminal, or `--yes`; one with a command or an Authorization of its own is kept.
+  `--oauth` writes Pending You's address instead, signed in with `pi mcp login pendingyou`, as pi.dev's own client
+  (`oauth.clientRegistration: "cimd"`) from Pi 1.0.1. The skill goes in `~/.pi/agent/skills/pendingyou/SKILL.md`,
+  unless the same stub is already in `~/.agents/skills` (Codex's), which Pi reads too.
+- Pi's extension, in place of hooks (Pi has none): `~/.config/pendingyou/pi/pendingyou.js`, listed in Pi's
+  `settings.json` `extensions` by a path that never changes (upgrading rewrites the file). It runs the hooks' script for
+  Pi: as a session starts (`pickup`, for Pi's next turn), with each message (`handoff`), after Pending You's card tools
+  (`posted --app pi`) and as a run settles (`stopcheck`: a run that left the person something only in chat goes on
+  once). When a card is answered, written back on or its fallback comes due, the listener the extension keeps per
+  session (`listen --app pi`, the same as OpenCode's) hands it the wake mod's words, and the extension starts the turn
+  (`pi.sendMessage`, at once when Pi is idle, after the run when it's busy), never with the answer in it. In Pi's
+  terminal the first session finishes setting up by itself: the session start's setup line starts the turn, once Pending
+  You's tools are there (Pi waits for MCP servers only before a typed prompt), and Pi's line waits 10 minutes after the
+  last, so two sessions reloaded together don't both set up. `init` ends: `/reload` in each Pi session that's open, or
+  start `pi`. `status` checks the bridge as Pi runs it and with a handshake; `uninstall` gives both files back as they
+  were (or takes away the ones `init` made). Not on Windows yet.
+- `hold` inside Pi (which marks its processes `AI_AGENT=pi`, `PI_CODING_AGENT=true`) answers at once: Pi's shell waits
+  for a command to end, so a hold would stop the session for hours. The extension wakes the session anyway; without
+  it, `hold` says to check with `get_request` instead.
+
 ## 0.11.0
 
 - One step for the coding agents on a computer (Darin, 2026-10-04): `npx -y pendingyou@latest init` finds Claude Code

package/README.md

@@ -1,29 +1,32 @@
 # pendingyou
 
 Pending You for your coding agents. Your agents ask you in [Pending You](https://www.pendingyou.com) when you're away;
-this command sets Claude Code and Codex up to ask there and to hear your answer the moment it's ready, even while they
-sit idle at the prompt.
+this command sets Claude Code, Codex, OpenCode and Pi up to ask there and to hear your answer the moment it's ready,
+even while they sit idle at the prompt.
 
 ```sh
 npx -y pendingyou@latest init
 ```
 
-Run it once on each computer, in a terminal. It finds the agents on the computer (Claude Code, Codex; `--app` names
-some), says what it found, and for each one:
+Run it once on each computer, in a terminal. It finds the agents on the computer (Claude Code, Codex, OpenCode, Pi;
+`--app` names some), says what it found, and for each one:
 
 - connects it to Pending You through **this computer's own sign-in**: its own connection ("Claude Code on Ann-MBP",
   "Codex on Ann-MBP" on your Assistants page), which its MCP server and its hooks share, so there's nothing to
   Authenticate in the agent and no second sign-in,
 - signs them all in with **one approval**: your browser opens on Pending You with one card naming each agent and this
   computer, and you press Allow once (over SSH: a code and a QR code for your phone, [below](#a-computer-with-no-browser)),
-- adds the Pending You MCP server for every project, signed in through a small helper script, and lets the agent use
-  Pending You's tools without asking each time,
+- adds the Pending You MCP server for every project, signed in through a small helper script (OpenCode and Pi:
+  through a small local bridge, [below](#opencode)), and lets the agent use Pending You's tools without asking each
+  time,
 - saves the Pending You skill (Claude Code: `~/.claude/skills/pendingyou/SKILL.md`; Codex:
-  `~/.agents/skills/pendingyou/SKILL.md`),
+  `~/.agents/skills/pendingyou/SKILL.md`; OpenCode reads either, else `~/.config/opencode/skills/pendingyou/SKILL.md`;
+  Pi reads Codex's, else `~/.pi/agent/skills/pendingyou/SKILL.md`),
 - adds the hooks that hand it your answers: a new session picks up answers that arrived while nothing was running,
   your next message brings a waiting answer with it, and a check when it finishes a turn catches what it left you only
   in chat ([below](#nothing-left-only-in-chat)),
-- and wakes it when you answer: Claude Code 2.1.287 or later through the wake mod, Codex through `codex queue`.
+- and wakes it when you answer: Claude Code 2.1.287 or later through the wake mod, Codex through `codex queue`, OpenCode
+  through its plugin and Pi through its extension (which also do the hooks' work there).
 
 Then it says what to do next, and the one sentence to say if it's needed:
 
@@ -42,7 +45,8 @@ stands. `npx pendingyou uninstall` removes exactly what `init` added.
 
 Your other settings are kept as they are: `init` merges into Claude Code's `~/.claude/settings.json`, Codex's
 `~/.codex/config.toml` (its `[mcp_servers.pendingyou]` table and nothing else, every other line as it was) and
-`~/.codex/hooks.json`, and running it again changes nothing it doesn't need to.
+`~/.codex/hooks.json`, OpenCode's config and Pi's `~/.pi/agent/mcp.json` and `settings.json` (Pending You's own entry
+in each, every other byte as it was), and running it again changes nothing it doesn't need to.
 
 **A pendingyou server that's there already** is decided on before anyone signs in. One at another Pending You
 (staging, say) is named and replaced only once you say so (`--yes` replaces it without asking); keep it and that agent
@@ -97,6 +101,65 @@ it with `codex queue`: “Pending You: your person answered “…” (req_…).
 answer itself never goes in a command's arguments, where other programs could see it). Codex starts a turn at
 once when the thread is open and idle, after the current one when it's working, or when you next open it.
 
+## OpenCode
+
+OpenCode 1.17.0 or later. Its MCP clients can't take a header from a command, so `init` gives it a local server instead:
+the stdio bridge, `pendingyou mcp`, which passes each message on to Pending You with OpenCode's own connection here
+("OpenCode on Ann-MBP"), so there's still one sign-in and nothing to Authenticate. In OpenCode's global config
+(`~/.config/opencode/opencode.json` or `.jsonc`, edited in place with your comments and everything else kept):
+
+```json
+"mcp": {
+  "pendingyou": {
+    "type": "local",
+    "command": ["/Users/ann/.config/pendingyou/bin/pendingyou-mcp", "--app", "opencode"]
+  }
+}
+```
+
+That path never changes: upgrading rewrites the small script there, never OpenCode's config. If your config's
+`permission` makes OpenCode ask (`"ask"`), `init` adds `"pendingyou_*": "allow"` so a question you're away for doesn't
+wait on a prompt; a rule of your own for Pending You's tools is kept. `--oauth` adds `{"type": "remote", "url":
+"https://www.pendingyou.com/mcp"}` instead, which you sign in to with `opencode mcp auth pendingyou`.
+
+And a plugin, `~/.config/opencode/plugins/pendingyou.js`, one line that loads this version's from its private copy. It
+does in OpenCode what the hooks do elsewhere, through the same hooks' script: each message you send carries the
+reminder and any answer waiting (hidden in OpenCode's view, read by the model), a session's first message also says
+what setup has left, a session that left you a question in chat is asked once to put it on a card (with a toast saying
+why), and when you answer a card a session posted, the plugin starts a turn in that session: “Pending You: your person
+answered “…” (req_…). Call get_request …” (never the answer itself). That works while OpenCode is open, idle or busy.
+
+Then restart OpenCode (`/exit`, then `opencode --continue`): it finishes setting up the first time you write to it.
+
+## Pi
+
+Pi 0.99.0 or later (pi.dev, the `pi` command; its MCP client came in 0.99.0). Like OpenCode, Pi runs the bridge as a
+local server, with its own connection here ("Pi on Ann-MBP"). In `~/.pi/agent/mcp.json` (or `$PI_CODING_AGENT_DIR`'s,
+edited in place, everything else kept):
+
+```json
+"pendingyou": {
+  "command": "/Users/ann/.config/pendingyou/bin/pendingyou-mcp",
+  "args": ["--app", "pi"],
+  "exposure": "direct",
+  "description": "Ask your person through Pending You when a decision, fact or step is theirs, and hear their answers."
+}
+```
+
+`direct` puts Pending You's tools in front of Pi's model (Pi's default leaves an MCP server's tools to scripts). Pi asks
+nobody before it runs a tool, so there's nothing to allow. `--oauth` adds Pending You's address instead, which you sign
+in to with `pi mcp login pendingyou` (from Pi 1.0.1 as pi.dev's own client).
+
+Pi has no hooks, so `init` gives it an extension: `~/.config/pendingyou/pi/pendingyou.js`, in the `extensions` of Pi's
+`~/.pi/agent/settings.json`, by a path that never changes (upgrading rewrites the file, never your settings). It runs
+the same hooks' script as a session starts, with each message, after Pending You's card tools and as a run ends (a run
+that leaves you something only in chat goes on once), and when you answer a card a session posted it starts a turn in
+that session, idle or busy: “Pending You: your person answered “…” (req_…). Call get_request …” (never the answer
+itself). In Pi's terminal the first session finishes setting up by itself, once Pending You's tools are there.
+
+Then run `/reload` in each Pi session that's open, or start `pi`. Pi's shell waits for a command to end, so in Pi
+`npx pendingyou hold` answers at once instead of waiting.
+
 ## Nothing left only in chat
 
 Deep into a long conversation, Claude Code tends to end a turn with a question for you, a step only you can do, or a
@@ -130,7 +193,8 @@ costs a request: this folder's open cards, given up after 1.5 seconds.
 
 Codex gets the same two (0.11.0). Its Stop check reads Codex's final message, and whether the turn posted, updated or
 replied on a card comes from Codex's own hook for Pending You's tools in that turn; it asks once a turn at most, for an
-action card titled “Confirm in Codex on <computer>: <step>” when it asked you to type something there.
+action card titled “Confirm in Codex on <computer>: <step>” when it asked you to type something there. OpenCode's plugin
+and Pi's extension (0.12.0) do the same in theirs.
 
 **On 0.2.0 with another origin?** Its hooks blocked every message (`There's no "--origin" command`). Run
 `npx pendingyou@latest init --origin <url>` again to repair them; see [CHANGELOG.md](CHANGELOG.md).
@@ -228,11 +292,11 @@ more, then skipped. `--once` stops after the first.
 | `pickup` / `handoff` | The session-start and next-message hooks (`--app`) |
 | `stopcheck` | The Stop hook: items for you left only in chat (`--app`) |
 | `uninstall` | Remove what `init` added, and sign out (`--app`) |
-| `mcp --app <app>` | Not yet: a stdio MCP server for an agent that can't run a headers helper |
+| `mcp --app <app>` | The stdio bridge: a local MCP server for an agent that can't run a headers helper (OpenCode, Pi), which passes each message on to Pending You with that agent's own sign-in here (`--check`) |
 
 Every command takes `--origin` (default `https://www.pendingyou.com`, or `$PENDINGYOU_ORIGIN`). `--app` takes
-`claude-code` or `codex` (several with commas where a command sets up or reports several); with none, a command that
-acts for one agent acts for Claude Code. Options can come before or after the command.
+`claude-code`, `codex`, `opencode` or `pi` (several with commas where a command sets up or reports several); with none,
+a command that acts for one agent acts for Claude Code. Options can come before or after the command.
 
 ## What it can see, and where it keeps things
 
@@ -247,11 +311,13 @@ Pending You (Claude Code says which server it's for; Codex's is the one `init` w
 sign-in each agent's connection used, so signing in again keeps it.
 
 `state.json` beside them remembers which answers were already handed over (ids only) and how many session starts
-reminded an unfinished setup; `claude-code.json` and `codex.json` what `init` added; `codex-threads.json` which cards
-each Codex thread waits on (ids, names and titles: never an answer); and `cli/` the hooks' copy 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) and `~/.codex/config.toml` only to see whether the agent has a `pendingyou` MCP server and where it
-points. Nothing is sent anywhere but Pending You.
+reminded an unfinished setup, and when; `claude-code.json`, `codex.json`, `opencode.json` and `pi.json` what `init`
+added; `codex-threads.json`, `opencode-threads.json` and `pi-threads.json` which cards each Codex thread or OpenCode or
+Pi session waits on (ids, names and titles: never an answer); `pi/` Pi's extension; and `cli/` the hooks' copy 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), `~/.codex/config.toml`, OpenCode's config and Pi's `mcp.json` only to see
+whether the agent has a `pendingyou` MCP server and where it points. Nothing is sent anywhere but Pending You. OpenCode's plugin reads its session's messages only when it goes idle, for the check that
+nothing was left in chat, and hands the hooks' script just that turn's words and tool names.
 
 The wake mod runs inside Claude Code and reaches Pending You only through the session's own connection, with
 `get_request` on the session's own cards (and, in `init`'s copy, `whoami` to see whether setup is finished). It keeps

package/dist/api.js

@@ -131,19 +131,21 @@ async function hookToken(io, origin, force, signal, app) {
     throw new Unavailable('The sign-in is being refreshed in the background.');
 }
 /**
- * The token `pendingyou mcp-headers` hands an app's MCP server (remote.ts). The app runs the helper each time it
- * connects and gives it 10 seconds, so, as for a hook, a refresh is never made in this process: within 5 minutes of
- * expiry it starts `pendingyou refresh` detached and waits for its token, up to `waitMs`, then uses the old one while it
- * still works. A token handed over has at least 10 seconds left; the app runs the helper again on a 401.
+ * The token `pendingyou mcp-headers` hands an app's MCP server (remote.ts), and the stdio bridge sends with each
+ * message (bridge.ts). The app runs the helper each time it connects and gives it 10 seconds, and the bridge may be
+ * stopped at any moment, so, as for a hook, a refresh is never made in this process: within 5 minutes of expiry it
+ * starts `pendingyou refresh` detached and waits for its token, up to `waitMs`, then uses the old one while it still
+ * works. A token handed over has at least 10 seconds left; the app runs the helper again on a 401. `force` (the bridge,
+ * after a 401) refreshes whatever the expiry says, and hands over only the new token.
  */
-export async function helperToken(io, origin, waitMs, app = DEFAULT_APP) {
+export async function helperToken(io, origin, waitMs, app = DEFAULT_APP, force = false) {
     const stored = await readCredential(io, origin, app);
     if (!stored)
         throw new SignInNeeded(false);
-    if (stored.expiresAt - io.now() > SOON_MS)
+    if (!force && stored.expiresAt - io.now() > SOON_MS)
         return stored.accessToken;
     if (!(await isLocked(credentialsPath(io))))
-        io.background(refreshArgs(origin, app));
+        io.background(refreshArgs(origin, app, force));
     const until = io.now() + waitMs;
     while (io.now() < until) {
         await io.sleep(100);
@@ -153,7 +155,7 @@ export async function helperToken(io, origin, waitMs, app = DEFAULT_APP) {
         if (current.refreshToken !== stored.refreshToken)
             return current.accessToken;
     }
-    if (stored.expiresAt - io.now() > USABLE_MS)
+    if (!force && stored.expiresAt - io.now() > USABLE_MS)
         return stored.accessToken;
     throw new Unavailable('Pending You couldn’t be reached to refresh the sign-in.');
 }