pendingyou 0.11.0 → 0.12.0

package/dist/apps/codex-wake.js

@@ -1,20 +1,27 @@
-// Codex hearing answers (0.11.0): what its hooks remember about the cards a thread posted, and the listener that wakes
-// the thread when one is answered.
+// Codex hearing answers (0.11.0), and OpenCode and Pi the same way (0.12.0): what an app's hooks remember about the
+// cards a thread (OpenCode, Pi: a session) posted, and the listener that wakes the thread when one is answered.
 //
 // - `pendingyou posted --app codex` is Codex's PostToolUse hook for Pending You's card tools (post_request,
 //   update_request, reply_in_thread, cancel_request; Codex runs it only for a call that didn't fail). It records that
 //   the turn put something in front of the person (with the card's words, for the Stop check: stopcheck.ts), and which
 //   thread is waiting on which card (`session_id` is the thread's id), then makes sure that thread has a listener.
+//   OpenCode's plugin runs it from `tool.execute.after` (apps/opencode-plugin.ts), and Pi's extension from Pi's
+//   `tool_result` (apps/pi-extension.ts), with the same fields.
 // - `pendingyou listen --app codex --thread <id>` is that listener: one per thread (a lease file), detached, holding no
-//   hook's output (Codex would wait for it otherwise). It long-polls Pending You with Codex's own connection, as `watch`
-//   does, and when one of the thread's cards is the agent's move (an answer, a message, a fallback that ran) it runs
-//   `codex queue --thread <id> --message "Pending You: your person answered …"`, in the words the Claude Code wake mod
-//   uses. Never the answer itself: a program's arguments are there for any other program on the computer to read, so
-//   the agent reads the answer with get_request, as the message says. Codex starts a turn at once when the thread is
-//   loaded and idle, after the current one when it's working, or when it's next resumed. It stops when the thread has no card left waiting, or after 8
-//   hours; the next session start or message starts it again while one is (pickup.ts).
+//   hook's output (Codex would wait for it otherwise). It long-polls Pending You with the app's own connection, as
+//   `watch` does, and when one of the thread's cards is the agent's move (an answer, a message, a fallback that ran) it
+//   runs `codex queue --thread <id> --message "Pending You: your person answered …"`, in the words the Claude Code wake
+//   mod uses. Never the answer itself: a program's arguments are there for any other program on the computer to read,
+//   so the agent reads the answer with get_request, as the message says. Codex starts a turn at once when the thread is
+//   loaded and idle, after the current one when it's working, or when it's next resumed. It stops when the thread has
+//   no card left waiting, or after 8 hours; the next session start or message starts it again while one is (pickup.ts).
+// - OpenCode's listener is the plugin's child, not detached, since only the plugin can start a turn
+//   (client.session.promptAsync): it writes each wake as one JSON line on stdout, `{"wake": "<the words>",
+//   "requests": ["req_…"]}`, and the plugin answers on its stdin, `{"delivered": true}` once the turn is started (or
+//   false). Only then is it marked handed over. It stops when its stdin closes (OpenCode went), as well as when Codex's
+//   would. Pi's listener is its extension's child in just the same way (`pi.sendMessage` starts the turn).
 //
-// Ids, names and titles only, in ~/.config/pendingyou/codex-threads.json: never an answer.
+// Ids, names and titles only, in ~/.config/pendingyou/<app>-threads.json: never an answer.
 import { randomBytes } from 'node:crypto';
 import { mkdir, readFile, rm, stat, utimes, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -37,14 +44,37 @@ const LEASE_STALE_MS = 90_000;
 const PATIENT_AFTER_MS = 30 * 60_000;
 const PATIENT_PAUSE_MS = 30_000;
 const BACKOFF_MS = [2000, 5000, 10_000, 20_000, 30_000, 60_000];
+/** How long OpenCode's listener waits for the plugin to say whether it started the turn. */
+const REPLY_MS = 60_000;
 const REQUEST_ID = /^req_[A-Za-z0-9-]{1,40}$/;
-/** Codex's tools for the card calls the hook reads, on a Pending You server (`mcp__pendingyou__post_request`). */
-const CARD_TOOL = /^mcp__([A-Za-z0-9_]*pendingyou[A-Za-z0-9_]*)__(post_request|update_request|reply_in_thread|cancel_request)$/i;
-const statePath = (io) => join(configDir(io), 'codex-threads.json');
-const leasePath = (io, thread) => join(configDir(io), 'codex-listen', `${thread}.lease`);
+/** A thread's id: Codex's (a UUID) or an OpenCode session's (`ses_…`). */
+export const THREAD = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+/** Pending You's card tools as Codex and Pi name them: `mcp__pendingyou__post_request`. */
+const MCP_CARD_TOOL = /^mcp__([A-Za-z0-9_]*pendingyou[A-Za-z0-9_]*)__(post_request|update_request|reply_in_thread|cancel_request)$/i;
+/**
+ * The card calls the hook reads, on a Pending You server: Codex and Pi name a tool `mcp__pendingyou__post_request`,
+ * OpenCode `pendingyou_post_request` (the server's name, `_`, the tool's).
+ */
+const CARD_TOOLS = {
+    codex: MCP_CARD_TOOL,
+    opencode: /^([A-Za-z0-9_-]*pendingyou[A-Za-z0-9_-]*)_(post_request|update_request|reply_in_thread|cancel_request)$/i,
+    pi: MCP_CARD_TOOL,
+};
+/** The card tool a call was, for an app whose hooks read them; null for any other tool. */
+export function cardTool(app, name) {
+    const pattern = CARD_TOOLS[app];
+    return pattern && typeof name === 'string' ? (pattern.exec(name)?.[2] ?? null) : null;
+}
+const statePath = (io, app) => join(configDir(io), `${app}-threads.json`);
+const leasePath = (io, app, thread) => join(configDir(io), `${app}-listen`, `${thread}.lease`);
+/** What uninstall takes away for an app: its threads' record and its listeners' leases. */
+export const threadFiles = (io, app) => [
+    statePath(io, app),
+    join(configDir(io), `${app}-listen`),
+];
 const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-async function load(io) {
-    const file = await readJson(statePath(io)).catch(() => null);
+async function load(io, app) {
+    const file = await readJson(statePath(io, app)).catch(() => null);
     return {
         version: 1,
         threads: isObject(file?.threads) ? file.threads : {},
@@ -52,10 +82,10 @@ async function load(io) {
     };
 }
 /** Changes the state under its lock, dropping what's old. */
-async function change(io, edit) {
-    const path = statePath(io);
+async function change(io, app, edit) {
+    const path = statePath(io, app);
     return withLock(path, io, async () => {
-        const state = await load(io);
+        const state = await load(io, app);
         edit(state);
         const now = io.now();
         for (const [id, turn] of Object.entries(state.turns))
@@ -115,26 +145,26 @@ function nameOf(input) {
     return text(input.name, 120) ?? text(session?.label, 120);
 }
 /**
- * `pendingyou posted --app codex`: Codex's PostToolUse hook. Remembers what the turn put in front of the person and
- * which cards the thread waits on, then makes sure the thread has a listener. Prints nothing (Codex ignores it anyway);
- * never fails.
+ * `pendingyou posted --app <app>`: Codex's PostToolUse hook, and what OpenCode's plugin runs after a card call.
+ * Remembers what the turn put in front of the person and which cards the thread waits on, then (Codex) makes sure the
+ * thread has a listener; OpenCode's plugin starts its own. Prints nothing (Codex ignores it anyway); never fails.
  */
 export async function posted(io, options) {
+    const { app } = options;
     try {
         const input = JSON.parse(await io.readStdin(1000));
         if (!isObject(input))
             return 0;
-        const tool = typeof input.tool_name === 'string' ? CARD_TOOL.exec(input.tool_name) : null;
+        const call = cardTool(app, input.tool_name);
         const thread = typeof input.session_id === 'string' ? input.session_id : null;
         const turn = typeof input.turn_id === 'string' ? input.turn_id : null;
-        if (!tool || !thread)
+        if (!call || !thread)
             return 0;
-        const call = tool[2];
         const args = isObject(input.tool_input) ? input.tool_input : {};
         const output = resultOf(input.tool_response);
         const requestId = [output?.requestId, args.requestId].find((id) => typeof id === 'string' && REQUEST_ID.test(id));
         const now = io.now();
-        const state = await change(io, (state) => {
+        const state = await change(io, app, (state) => {
             if (turn && call !== 'cancel_request') {
                 const record = state.turns[turn] ?? { at: now, cards: [] };
                 record.cards = [...record.cards, wordsIn(args)].slice(-10);
@@ -162,7 +192,7 @@ export async function posted(io, options) {
             waiting.at = now;
             state.threads[thread] = waiting;
         });
-        if (Object.keys(state.threads[thread]?.cards ?? {}).length > 0)
+        if (app === 'codex' && Object.keys(state.threads[thread]?.cards ?? {}).length > 0)
             await keepListening(io, options.origin, thread);
         return 0;
     }
@@ -171,31 +201,32 @@ export async function posted(io, options) {
     }
 }
 /** Whether this turn put something in front of the person, the words of each card, and whether it was nudged. */
-export async function turnRecord(io, turn) {
-    const record = (await load(io)).turns[turn];
+export async function turnRecord(io, turn, app = 'codex') {
+    const record = (await load(io, app)).turns[turn];
     return record ? { cards: record.cards, nudged: record.nudged === true } : null;
 }
 /** Remembers that the Stop check asked this turn to go on: at most once a turn. */
-export async function markNudged(io, turn) {
+export async function markNudged(io, turn, app = 'codex') {
     const now = io.now();
-    await change(io, (state) => {
+    await change(io, app, (state) => {
         state.turns[turn] = { ...(state.turns[turn] ?? { cards: [] }), at: now, nudged: true };
     });
 }
 /** Whether a listener holds this thread now: its lease, touched within LEASE_STALE_MS. */
-async function listening(io, thread) {
-    return stat(leasePath(io, thread)).then((info) => Date.now() - info.mtimeMs < LEASE_STALE_MS, () => false);
+async function listening(io, app, thread) {
+    return stat(leasePath(io, app, thread)).then((info) => Date.now() - info.mtimeMs < LEASE_STALE_MS, () => false);
 }
 /**
- * Makes sure a thread with cards waiting on the person has a listener: starts one, detached, unless one is there or
- * Codex isn't signed in. Quick (three small reads) and never throws: the session-start and next-message hooks call it too.
+ * Makes sure a Codex thread with cards waiting on the person has a listener: starts one, detached, unless one is there
+ * or Codex isn't signed in. Quick (three small reads) and never throws: the session-start and next-message hooks call
+ * it too.
  */
 export async function keepListening(io, origin, thread) {
     try {
-        if (!/^[A-Za-z0-9][A-Za-z0-9-]{0,99}$/.test(thread))
+        if (!THREAD.test(thread))
             return;
-        const cards = (await load(io)).threads[thread]?.cards ?? {};
-        if (Object.keys(cards).length === 0 || (await listening(io, thread)))
+        const cards = (await load(io, 'codex')).threads[thread]?.cards ?? {};
+        if (Object.keys(cards).length === 0 || (await listening(io, 'codex', thread)))
             return;
         if (!(await readCredential(io, origin, 'codex')))
             return;
@@ -265,10 +296,10 @@ export function wakeMessage(ready) {
  * Takes the thread's lease, a file holding this listener's own id: null when a live listener holds it. Two listeners
  * starting at once may both write it; the one whose id isn't there at its next renewal stops.
  */
-async function takeLease(io, thread) {
-    const path = leasePath(io, thread);
+async function takeLease(io, app, thread) {
+    const path = leasePath(io, app, thread);
     await mkdir(join(path, '..'), { recursive: true, mode: 0o700 });
-    if (await listening(io, thread))
+    if (await listening(io, app, thread))
         return null;
     const id = randomBytes(8).toString('hex');
     await rm(path, { recursive: true, force: true });
@@ -281,36 +312,98 @@ async function takeLease(io, thread) {
     }
 }
 /** Renews the lease while it's still this listener's (`id`); false once another listener has taken it. */
-async function renew(io, thread, id) {
-    const path = leasePath(io, thread);
+async function renew(io, app, thread, id) {
+    const path = leasePath(io, app, thread);
     if ((await readFile(path, 'utf8').catch(() => null)) !== id)
         return false;
     const now = new Date();
     await utimes(path, now, now).catch(() => { });
     return true;
 }
+/** Codex: `codex queue`, which starts the turn itself. */
+const byCodexQueue = (io, thread) => async (message) => (await io.run('codex', ['queue', '--thread', thread, '--message', message], 30_000)).code === 0;
+/**
+ * OpenCode and Pi: the plugin (Pi: the extension) that started this listener reads the wake on stdout and starts the
+ * turn, then says on stdin whether it did. stdin closing means the plugin (the app) is gone: `gone` stops the listener.
+ */
+function byPlugin(io, gone) {
+    const queue = [];
+    let waiting = null;
+    let closed = false;
+    const settle = (line) => {
+        const resolve = waiting;
+        waiting = null;
+        resolve?.(line);
+    };
+    void (async () => {
+        try {
+            for await (const line of io.lines()) {
+                if (waiting)
+                    settle(line);
+                else
+                    queue.push(line);
+            }
+        }
+        catch { }
+        closed = true;
+        gone();
+        settle(null);
+    })();
+    const reply = () => {
+        if (queue.length)
+            return Promise.resolve(queue.shift());
+        if (closed)
+            return Promise.resolve(null);
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => settle(null), REPLY_MS);
+            timer.unref?.();
+            waiting = (line) => {
+                clearTimeout(timer);
+                resolve(line);
+            };
+        });
+    };
+    return async (message, requests) => {
+        io.out(`${JSON.stringify({ wake: message, requests })}\n`);
+        const answered = await reply();
+        try {
+            return answered !== null && JSON.parse(answered).delivered === true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
 /**
- * `pendingyou listen --app codex --thread <id>`: waits on Pending You for the thread's cards, and wakes the thread
- * with `codex queue` when one is the agent's move. Quiet; exits when the thread has none left, Codex can't be reached,
- * the sign-in ends, or after LISTEN_MS.
+ * `pendingyou listen --app <app> --thread <id>`: waits on Pending You for the thread's cards, and wakes the thread
+ * (Codex: `codex queue`; OpenCode and Pi: through the plugin or extension) when one is the agent's move. Quiet but for
+ * the wake lines it hands a plugin; exits when the thread has none left, the app can't take the wake, the sign-in ends,
+ * or after LISTEN_MS.
  */
 export async function listen(io, options) {
-    const { origin, thread } = options;
-    const lease = await takeLease(io, thread);
+    const { origin, app, thread } = options;
+    const lease = await takeLease(io, app, thread);
     if (!lease)
         return 0;
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    if (io.signal.aborted)
+        stop();
+    io.signal.addEventListener('abort', stop, { once: true });
+    const signal = controller.signal;
+    const deliver = app === 'codex' ? byCodexQueue(io, thread) : byPlugin(io, stop);
     try {
         const started = io.now();
         let since;
         let failures = 0;
-        while (io.now() - started < LISTEN_MS && !io.signal.aborted) {
-            const cards = (await load(io)).threads[thread]?.cards ?? {};
+        while (io.now() - started < LISTEN_MS && !signal.aborted) {
+            const cards = (await load(io, app)).threads[thread]?.cards ?? {};
             if (Object.keys(cards).length === 0)
                 return 0;
-            if (!(await renew(io, thread, lease)))
+            if (!(await renew(io, app, thread, lease)))
                 return 0;
             const query = new URLSearchParams({
-                source: 'codex',
+                source: app,
                 limit: '20',
                 wait: String(LONG_POLL_SECONDS),
             });
@@ -318,19 +411,19 @@ export async function listen(io, options) {
                 query.set('since', since);
             let requests;
             try {
-                const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, (LONG_POLL_SECONDS + 20) * 1000, io.signal, { app: 'codex' });
+                const { status, body } = await getJson(io, origin, `/mcp/cli/answers?${query}`, (LONG_POLL_SECONDS + 20) * 1000, signal, { app });
                 if (status !== 200)
                     throw new Unavailable(`Pending You answered ${status}.`);
                 requests = Array.isArray(body.requests) ? body.requests : [];
                 failures = 0;
             }
             catch (error) {
-                if (error instanceof SignInNeeded || io.signal.aborted)
+                if (error instanceof SignInNeeded || signal.aborted)
                     return 0;
                 // Renewed first: no pause here outlasts the lease.
-                if (!(await renew(io, thread, lease)))
+                if (!(await renew(io, app, thread, lease)))
                     return 0;
-                await io.sleep(BACKOFF_MS[Math.min(failures++, BACKOFF_MS.length - 1)], io.signal);
+                await io.sleep(BACKOFF_MS[Math.min(failures++, BACKOFF_MS.length - 1)], signal);
                 continue;
             }
             for (const heard of requests)
@@ -342,7 +435,7 @@ export async function listen(io, options) {
                 const card = cards[heard.requestId];
                 if (!card || !heard.ready)
                     continue;
-                // Handed over already (the person wrote in Codex since): nothing to wake it for.
+                // Handed over already (the person wrote in the app since): nothing to wake it for.
                 if (await wasHanded(io, origin, heard.requestId, momentOf(heard)))
                     done.push(heard.requestId);
                 else
@@ -350,10 +443,9 @@ export async function listen(io, options) {
             }
             const message = wakeMessage(ready);
             if (message) {
-                const queued = await io.run('codex', ['queue', '--thread', thread, '--message', message], 30_000);
-                // Codex doesn't know the thread (archived, gone), or can't be run from here: the hooks hand answers over.
-                if (queued.code !== 0) {
-                    await change(io, (state) => {
+                // The app doesn't know the thread (archived, gone), or can't be reached from here: the hooks hand answers over.
+                if (!(await deliver(message, ready.map(({ heard }) => heard.requestId)))) {
+                    await change(io, app, (state) => {
                         delete state.threads[thread];
                     });
                     return 0;
@@ -367,20 +459,21 @@ export async function listen(io, options) {
                 if (cards[heard.requestId] && isClosed(heard) && !done.includes(heard.requestId))
                     done.push(heard.requestId);
             if (done.length)
-                await change(io, (state) => {
+                await change(io, app, (state) => {
                     const waiting = state.threads[thread];
                     if (waiting)
                         for (const id of done)
                             delete waiting.cards[id];
                 });
             if (io.now() - started > PATIENT_AFTER_MS)
-                await io.sleep(PATIENT_PAUSE_MS, io.signal);
+                await io.sleep(PATIENT_PAUSE_MS, signal);
         }
         return 0;
     }
     finally {
+        io.signal.removeEventListener('abort', stop);
         // Only its own: a listener that took over keeps the thread.
-        if ((await readFile(leasePath(io, thread), 'utf8').catch(() => null)) === lease)
-            await rm(leasePath(io, thread), { force: true }).catch(() => { });
+        if ((await readFile(leasePath(io, app, thread), 'utf8').catch(() => null)) === lease)
+            await rm(leasePath(io, app, thread), { force: true }).catch(() => { });
     }
 }

package/dist/apps/ids.js

@@ -3,11 +3,13 @@
 // (registry.ts lists them; docs/apps.md says what a module does). Kept apart from the modules so the argument parser can
 // read the list without loading them.
 /** Every app with a module, in the order init sets them up and status lists them. */
-export const APP_IDS = ['claude-code', 'codex'];
+export const APP_IDS = ['claude-code', 'codex', 'opencode', 'pi'];
 /** What people call each app: "Claude Code on devbox" is a connection's name on the Assistants page. */
 export const APP_NAMES = {
     'claude-code': 'Claude Code',
     codex: 'Codex',
+    opencode: 'OpenCode',
+    pi: 'Pi',
 };
 /**
  * The app a command acts for when it names none: Claude Code, the only app before 0.11.0, so hook lines and helpers