pendingyou 0.9.0 → 0.11.0

package/dist/credentials.js

@@ -1,10 +1,40 @@
-// The command line's sign-in, one per Pending You address (production, staging, a local server), in
-// ~/.config/pendingyou/credentials.json: readable only by you (0600, in a 0700 folder), written whole, never printed
-// and never logged. A file someone loosened is tightened again on the next read.
-import { chmod, stat } from 'node:fs/promises';
+// This computer's sign-ins, one per app per Pending You address (production, staging, a local server), in
+// ~/.config/pendingyou/credentials.json: readable only by you (0600, in a 0700 folder with a .gitignore of `*`, so a
+// dotfiles repository never takes it), written whole, never printed and never logged. A file someone loosened is
+// tightened again on the next read.
+//
+// Since 0.11.0 each app has its own (Codex's beside Claude Code's): each is that app's own connection on Pending You
+// ("Codex on devbox"), or, for an app whose MCP server signs in by itself, a sign-in that only hears its answers.
+// Claude Code's stays under the address itself, where 0.10.0 kept the only one; every other app's is under
+// `<address>#<app>`. A 0.10.0 command line still running (a hold, a refresh it started) rewrites the file with the
+// entries it read, so it keeps the others as they are.
+import { chmod, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { configDir, readJson, withLock, writeWhole } from "./files.js";
+import { DEFAULT_APP, isAppId } from "./apps/ids.js";
+import { configDir, readJson, readText, withLock, writeWhole } from "./files.js";
 export const credentialsPath = (io) => join(configDir(io), 'credentials.json');
+/** Where an app's sign-in for `origin` is kept: Claude Code's under the address itself, another app's beside it. */
+export const slotOf = (origin, app = DEFAULT_APP) => app === DEFAULT_APP ? origin : `${origin}#${app}`;
+/** The address and app a key of the file is for; null for a key no app of this version knows. */
+export function slotParts(key) {
+    const at = key.indexOf('#');
+    if (at < 0)
+        return { origin: key, app: DEFAULT_APP };
+    const app = key.slice(at + 1);
+    return isAppId(app) && app !== DEFAULT_APP ? { origin: key.slice(0, at), app } : null;
+}
+/**
+ * Keeps the config folder out of version control: a `.gitignore` of `*`, for anyone whose dotfiles repository holds
+ * ~/.config. Written once; a file of the person's own there is left as it is.
+ */
+export async function ignoreFolder(io) {
+    const path = join(configDir(io), '.gitignore');
+    if ((await readText(path).catch(() => null)) !== null)
+        return;
+    await writeWhole(path, '# Pending You keeps sign-ins here: never commit them.\n*\n', {
+        mode: 0o600,
+    });
+}
 function valid(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -31,29 +61,79 @@ async function readAll(io) {
         await chmod(path, 0o600);
     return file;
 }
-export async function readCredential(io, origin) {
-    const entry = (await readAll(io)).origins[origin];
+/** An app's sign-in for `origin` (Claude Code's when none is named). */
+export async function readCredential(io, origin, app = DEFAULT_APP) {
+    const entry = (await readAll(io)).origins[slotOf(origin, app)];
     return valid(entry) ? entry : null;
 }
-/** Every origin with a sign-in. */
-export async function signedInOrigins(io) {
+/** Every sign-in this computer has: its address and app. */
+export async function signedInSlots(io) {
     const all = await readAll(io);
-    return Object.keys(all.origins).filter((origin) => valid(all.origins[origin]));
+    return Object.keys(all.origins).flatMap((key) => {
+        const slot = slotParts(key);
+        return slot && valid(all.origins[key]) ? [slot] : [];
+    });
+}
+/** Every address with a sign-in, for any app. */
+export async function signedInOrigins(io) {
+    return [...new Set((await signedInSlots(io)).map((slot) => slot.origin))];
 }
-/** Changes one origin's sign-in (null removes it), under the lock, from the file as it is now. */
-export async function updateCredential(io, origin, change) {
+/** Changes one app's sign-in for `origin` (null removes it), under the lock, from the file as it is now. */
+export async function updateCredential(io, origin, change, app = DEFAULT_APP) {
     const path = credentialsPath(io);
-    return withLock(path, io, async () => {
+    const key = slotOf(origin, app);
+    const next = await withLock(path, io, async () => {
         const all = await readAll(io);
-        const current = all.origins[origin];
-        const next = await change(valid(current) ? current : null);
-        if (next)
-            all.origins[origin] = next;
+        const current = all.origins[key];
+        const changed = await change(valid(current) ? current : null);
+        if (changed)
+            all.origins[key] = changed;
         else
-            delete all.origins[origin];
+            delete all.origins[key];
         await writeWhole(path, `${JSON.stringify({ version: 1, origins: all.origins }, null, 2)}\n`, {
             secret: true,
         });
-        return next;
+        return changed;
+    });
+    await ignoreFolder(io).catch(() => { });
+    return next;
+}
+export const clientsPath = (io) => join(configDir(io), 'clients.json');
+async function readClients(io) {
+    const file = await readJson(clientsPath(io)).catch(() => null);
+    return file && typeof file.origins === 'object' && file.origins !== null
+        ? file
+        : { version: 1, origins: {} };
+}
+/** The client this computer's connection for `origin` signed in with last, if any. */
+export async function connectionClient(io, origin, app = DEFAULT_APP) {
+    const entry = (await readClients(io)).origins[slotOf(origin, app)];
+    return typeof entry?.clientId === 'string' ? entry.clientId : null;
+}
+/** The name this computer's connection for `origin` signed in with ("devbox"), if it's known. */
+export async function connectionMachine(io, origin, app = DEFAULT_APP) {
+    const entry = (await readClients(io)).origins[slotOf(origin, app)];
+    return typeof entry?.machine === 'string' && entry.machine ? entry.machine : null;
+}
+/**
+ * Remembers the client this computer's connection for `origin` signed in with, or with null forgets it (uninstall),
+ * removing the file once it holds none.
+ */
+export async function saveConnectionClient(io, origin, clientId, machine, app = DEFAULT_APP) {
+    const path = clientsPath(io);
+    const key = slotOf(origin, app);
+    if (!clientId && !(await connectionClient(io, origin, app)))
+        return;
+    await withLock(path, io, async () => {
+        const file = await readClients(io);
+        if (clientId)
+            file.origins[key] = { clientId, ...(machine ? { machine } : {}) };
+        else
+            delete file.origins[key];
+        const text = `${JSON.stringify({ version: 1, origins: file.origins }, null, 2)}\n`;
+        if (Object.keys(file.origins).length === 0)
+            await rm(path, { force: true });
+        else
+            await writeWhole(path, text, { secret: true });
     });
 }

package/dist/environment.js

@@ -7,6 +7,8 @@
 // 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 { codexServer } from "./apps/codex.js";
+import { DEFAULT_APP } from "./apps/ids.js";
 import { claudeJsonPath, MCP_NAME } from "./claude.js";
 import { claudeDir, readText } from "./files.js";
 /**
@@ -86,10 +88,15 @@ export function differs(server, origin) {
 }
 /** 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) {
+/**
+ * The hook's warning for this folder, or null when the two agree or can't be told. Never throws. Codex's server is the
+ * one in its own config (~/.codex/config.toml), for every folder.
+ */
+export async function environmentWarning(io, folder, origin, app = DEFAULT_APP) {
     try {
-        const server = await serverForFolder(io, folder);
+        const server = app === 'codex'
+            ? await codexServer(io).then((found) => found?.url ? { url: found.url, scope: 'user' } : null)
+            : await serverForFolder(io, folder);
         return differs(server, origin) ? mismatchLine(server, origin) : null;
     }
     catch {

package/dist/files.js

@@ -34,15 +34,15 @@ export async function readJson(path) {
 }
 /**
  * Writes a whole file at once. `secret` files and their folder are private to you (0600 and 0700), however they were
- * before; other files keep the mode they had.
+ * before; a `mode` given is the file's (a script's 0755); other files keep the mode they had.
  */
 export async function writeWhole(path, text, options = {}) {
     const folder = dirname(path);
     await mkdir(folder, { recursive: true, ...(options.secret ? { mode: 0o700 } : {}) });
     if (options.secret)
         await chmod(folder, 0o700);
-    let mode = options.secret ? 0o600 : 0o644;
-    if (!options.secret) {
+    let mode = options.mode ?? (options.secret ? 0o600 : 0o644);
+    if (!options.secret && options.mode === undefined) {
         try {
             mode = (await stat(path)).mode & 0o777;
         }

package/dist/hold.js

@@ -4,20 +4,42 @@
 // person; a fallback that ran; or it closed. Then it prints a few lines and exits, and Claude Code, which re-invokes
 // the model when a background command ends, wakes up with the answer, even if it was idle at the prompt.
 //
-// It lets go cleanly after --timeout (4 hours by default), on Ctrl-C or when Claude Code stops it, saying how the
-// answer will still arrive. Exit codes: 0 when it heard something or stopped cleanly; 1 when it can't wait at all
-// (not signed in, no such request, bad arguments).
+// It lets go cleanly after --timeout (4 hours by default), on Ctrl-C or when Claude Code stops it (a background
+// command's own time limit can stop it sooner). Since 0.10.0 it then says to start it again in the background, with the
+// exact command: a session without the wake mod (Claude Code before 2.1.287, or no plugin and no init) has nothing
+// else to wake it, and two sessions missed answers overnight when it said not to (2026-10-04). Exit codes: 0 when it
+// heard something or stopped cleanly; 1 when it can't wait at all (not signed in, no such request, bad arguments).
 import { getJson, SignInNeeded, Unavailable } from "./api.js";
+import { DEFAULT_APP } from "./apps/ids.js";
+import { DEFAULT_ORIGIN, DEFAULT_TIMEOUT_MS } from "./args.js";
 import { readCredential } from "./credentials.js";
-import { describe, isClosed } from "./format.js";
-import { markHanded, momentOf, startWaiting, stopWaiting } from "./state.js";
+import { describe } from "./format.js";
+import { markHanded, momentOf } from "./state.js";
 /** The longest one long poll asks the server to wait. */
 export const LONG_POLL_SECONDS = 25;
 /** After this long, a pause between long polls: an answer hours later needn't arrive within seconds. */
 const PATIENT_AFTER_MS = 30 * 60 * 1000;
 const PATIENT_PAUSE_MS = 30_000;
 const BACKOFF_MS = [2000, 5000, 10_000, 20_000, 30_000, 60_000];
-const holdCommand = (requestId) => `npx pendingyou hold ${requestId}`;
+/** A duration as `--timeout` takes it: 4h, 90m or 45s. */
+export function durationText(ms) {
+    if (ms % 3_600_000 === 0)
+        return `${ms / 3_600_000}h`;
+    if (ms % 60_000 === 0)
+        return `${ms / 60_000}m`;
+    return `${Math.round(ms / 1000)}s`;
+}
+/**
+ * The command that holds for this request again, as it was started: its origin and timeout when they aren't the
+ * defaults (`--origin` rather than PENDINGYOU_ORIGIN=…, so init's `Bash(npx pendingyou hold:*)` still allows it).
+ */
+export function holdCommand(requestId, origin = DEFAULT_ORIGIN, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    return [
+        `npx pendingyou hold ${requestId}`,
+        ...(origin === DEFAULT_ORIGIN ? [] : [`--origin ${origin}`]),
+        ...(timeoutMs === DEFAULT_TIMEOUT_MS ? [] : [`--timeout ${durationText(timeoutMs)}`]),
+    ].join(' ');
+}
 const minutes = (ms) => {
     if (ms < 60_000)
         return `${Math.round(ms / 1000)} seconds`;
@@ -29,6 +51,7 @@ const minutes = (ms) => {
 };
 export async function hold(io, options) {
     const { origin, requestId } = options;
+    const again = holdCommand(requestId, origin, options.timeoutMs);
     const started = io.now();
     const deadline = started + options.timeoutMs;
     const print = (lines) => io.out(`${lines.join('\n')}\n`);
@@ -43,28 +66,27 @@ export async function hold(io, options) {
     };
     if (!(await readCredential(io, origin)))
         return signInNeeded(false);
-    await startWaiting(io, origin, requestId, io.cwd).catch(() => { });
     let failures = 0;
     for (;;) {
         if (io.signal.aborted) {
             print([
                 `Pending You: stopped waiting on ${requestId}.`,
-                'Their answer still reaches you with your next message or session; or call get_request at a breakpoint.',
+                `If you’re still waiting on their answer, start it again as a background command: ${again}`,
             ]);
             return 0;
         }
         const left = deadline - io.now();
         if (left <= 0) {
             print([
-                `Pending You: no answer on ${requestId} after ${minutes(options.timeoutMs)}, so I stopped waiting.`,
-                'Don’t start another hold now. Their answer reaches you with your next message or session, or check list_pending at a breakpoint.',
+                `Pending You: no answer on ${requestId} after ${minutes(options.timeoutMs)}, so this hold stopped.`,
+                `Start it again now as a background command, so their answer still wakes you: ${again}`,
             ]);
             return 0;
         }
         const wait = Math.max(1, Math.min(LONG_POLL_SECONDS, Math.floor(left / 1000)));
         let result;
         try {
-            result = await getJson(io, origin, `/mcp/cli/requests/${encodeURIComponent(requestId)}?wait=${wait}`, (wait + 20) * 1000, io.signal);
+            result = await getJson(io, origin, `/mcp/cli/requests/${encodeURIComponent(requestId)}?wait=${wait}&source=${DEFAULT_APP}`, (wait + 20) * 1000, io.signal);
         }
         catch (error) {
             if (io.signal.aborted)
@@ -80,7 +102,6 @@ export async function hold(io, options) {
         }
         failures = 0;
         if (result.status === 404) {
-            await stopWaiting(io, origin, [requestId]).catch(() => { });
             print([
                 `Pending You: can’t find ${requestId} among your person’s Claude Code questions on ${origin}.`,
                 'Check the id from post_request. If this Claude Code signed in to Pending You as someone else, use get_request instead.',
@@ -93,10 +114,8 @@ export async function hold(io, options) {
             continue;
         }
         if (heard.ready) {
-            print(describe(heard, `run \`${holdCommand(requestId)}\` in the background again`));
-            await markHanded(io, origin, [
-                { requestId, moment: momentOf(heard), closed: isClosed(heard) },
-            ]).catch(() => { });
+            print(describe(heard, `run \`${again}\` in the background again`));
+            await markHanded(io, origin, [{ requestId, moment: momentOf(heard) }]).catch(() => { });
             return 0;
         }
         if (io.now() - started > PATIENT_AFTER_MS)

package/dist/hooks.js

@@ -0,0 +1,117 @@
+// Agents' hook definitions, as init writes them (0.11.0). Claude Code's settings.json `hooks` and Codex's hooks.json
+// share one shape:
+//
+//   { "<Event>": [ { "matcher": "…", "hooks": [ { "type": "command", "command": "…", "timeout": 10 } ] } ] }
+//
+// Ours are recognised by what they run (pendingyou and the command: pickup, handoff, stopcheck, posted), whatever
+// version or path wrote them, so init updates them in place and uninstall takes out exactly them. Every other entry is
+// kept as it was, in its place. Each line runs the shim (shim.ts) by its fixed path, with the app it's for:
+//
+//   "<config>/bin/pendingyou-hook" pickup --app claude-code || true
+//
+// `|| true` keeps a hook from ever blocking the person, even when the shim can't start (Claude Code blocks a message
+// when its UserPromptSubmit hook exits 2, and flags any other failure).
+import { DEFAULT_ORIGIN } from "./args.js";
+import { PlainError } from "./errors.js";
+import { shellQuote } from "./install.js";
+/** Seconds an agent gives each hook; they time-box themselves well inside it (main.ts's 3-second deadline). */
+export const HOOK_TIMEOUT = 10;
+/** One word for sh: as it is when it's plain, otherwise in single quotes. */
+export const shWord = (text) => /^[\w@%+=:,./-]+$/.test(text) ? text : `'${text.replaceAll("'", `'\\''`)}'`;
+/** `--origin <it>`, for a command line, only when it isn't production. */
+export const originArgs = (origin) => origin === DEFAULT_ORIGIN ? '' : ` --origin ${shWord(origin)}`;
+/** A hook's command line through the shim: the command first, then the app, then `--origin` off production. */
+export function hookLine(shim, origin, app, sub) {
+    return `${shellQuote(shim)} ${sub} --app ${app}${originArgs(origin)} || true`;
+}
+/** Whether a hook command is one of ours: it runs pendingyou's `sub` (pickup, handoff, stopcheck, posted). */
+export function isOurHook(command, sub) {
+    if (typeof command !== 'string' || !command.includes('pendingyou'))
+        return false;
+    return new RegExp(`\\s${sub}(\\s|$)`).test(command);
+}
+const objectAt = (parent, key) => {
+    const value = parent[key];
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+};
+/** The hooks object of a settings file; an error (and no changes) when it isn't an object. */
+export function hooksOf(settings, where) {
+    const hooks = objectAt(settings, 'hooks');
+    if (settings.hooks !== undefined && hooks === null)
+        throw new PlainError(`${where} has a “hooks” that isn’t an object, so I left it alone.`);
+    return hooks ?? {};
+}
+/** Our hook for `sub` under `event`, if there is one. */
+export function findHook(hooks, event, sub) {
+    const groups = hooks[event];
+    if (!Array.isArray(groups))
+        return undefined;
+    return groups
+        .flatMap((group) => group?.hooks ?? [])
+        .find((hook) => isOurHook(hook?.command, sub));
+}
+/**
+ * Adds our hooks, or updates them in place (a new command, a line an older version wrote, one copied from another
+ * app): `lines` holds each event's command line. Returns the hooks (a copy) and whether anything changed.
+ */
+export function mergeHooks(hooks, specs, lines, where) {
+    const next = structuredClone(hooks);
+    let changed = false;
+    for (const spec of specs) {
+        const wanted = lines[spec.event];
+        if (wanted === undefined)
+            continue;
+        if (next[spec.event] !== undefined && !Array.isArray(next[spec.event]))
+            throw new PlainError(`${where}’s ${spec.event} hooks aren’t a list, so I left them alone.`);
+        const groups = Array.isArray(next[spec.event]) ? next[spec.event] : [];
+        const ours = groups.filter((group) => (group?.hooks ?? []).some((hook) => isOurHook(hook?.command, spec.sub)));
+        if (ours.length === 0) {
+            groups.push({
+                ...(spec.matcher ? { matcher: spec.matcher } : {}),
+                hooks: [{ type: 'command', command: wanted, timeout: HOOK_TIMEOUT }],
+            });
+            changed = true;
+        }
+        for (const group of ours) {
+            for (const hook of group.hooks ?? [])
+                if (isOurHook(hook.command, spec.sub) &&
+                    (hook.command !== wanted || hook.timeout !== HOOK_TIMEOUT)) {
+                    hook.command = wanted;
+                    hook.timeout = HOOK_TIMEOUT;
+                    changed = true;
+                }
+            // The matcher is ours to set only on a group that holds nothing but our hook.
+            const alone = (group.hooks ?? []).every((hook) => isOurHook(hook.command, spec.sub));
+            if (alone && spec.matcher && group.matcher !== spec.matcher) {
+                group.matcher = spec.matcher;
+                changed = true;
+            }
+        }
+        next[spec.event] = groups;
+    }
+    return { hooks: next, changed };
+}
+/** Takes our hooks out and leaves everything else as it was; an event left with no groups goes. */
+export function removeHooks(hooks, specs) {
+    const next = structuredClone(hooks);
+    let changed = false;
+    for (const spec of specs) {
+        if (!Array.isArray(next[spec.event]))
+            continue;
+        const groups = [];
+        for (const group of next[spec.event]) {
+            const kept = (group?.hooks ?? []).filter((hook) => !isOurHook(hook?.command, spec.sub));
+            if (kept.length !== (group?.hooks ?? []).length)
+                changed = true;
+            if (kept.length > 0 || !Array.isArray(group?.hooks))
+                groups.push({ ...group, hooks: kept });
+        }
+        if (groups.length)
+            next[spec.event] = groups;
+        else
+            delete next[spec.event];
+    }
+    return { hooks: next, changed };
+}

package/dist/index.js

@@ -3,5 +3,8 @@ export { getJson, SignInNeeded, Unavailable } from "./api.js";
 export { DEFAULT_ORIGIN, parseArgs } from "./args.js";
 export { readCredential, updateCredential } from "./credentials.js";
 export { main } from "./main.js";
-export { CLIENT_NAME, discover, register, revoke, SCOPE, signIn, signInWithDevice, } from "./oauth.js";
+export { CLIENT_NAME, deviceLink, discover, register, revoke, SCOPE, signIn, signInWithDevice, startDevice, waitForDevices, } from "./oauth.js";
+export { qrCode, qrLines } from "./qr.js";
+/** What the person says to an agent to finish setting up (0.11.0): the app's setup pages say the same. */
+export { FINISH_SAY } from "./setup.js";
 export { VERSION } from "./version.js";