pendingyou 0.9.0 → 0.11.0

package/dist/apps/codex.js

@@ -0,0 +1,615 @@
+// Codex CLI (0.11.0): what `pendingyou init` sets up for it, `status`'s section and `uninstall`. Facts from Codex's own
+// source (0.160.0, 2026-10-04; docs/assistants/codex.md has the details):
+//
+// - Its MCP server is a table in ~/.codex/config.toml (or $CODEX_HOME's), [mcp_servers.pendingyou], edited in place with
+//   everything else in the file kept as it was (toml.ts). It signs in through this computer's own connection ("Codex on
+//   devbox"): `http_headers_helper` runs the headers helper with `--app codex` (sh -c, a stripped environment, 10
+//   seconds; stdout one JSON object of strings), which may give Authorization from Codex 0.152 (0.148–0.151 refused that
+//   header). `default_tools_approval_mode = "approve"` lets Pending You's tools run without asking each time. A stored
+//   OAuth token would win over the helper, so `codex mcp logout pendingyou` goes first. With `--oauth` the table has no
+//   helper and the person signs Codex in with `codex mcp login pendingyou`. `codex mcp add --url` isn't used: it starts
+//   an OAuth sign-in in the browser at once.
+// - Its skill is ~/.agents/skills/pendingyou/SKILL.md: the guide's stub, as for Claude Code.
+// - Its hooks are in ~/.codex/hooks.json, Claude Code's shape: SessionStart (pickup; startup, resume or clear),
+//   UserPromptSubmit (handoff), PostToolUse on Pending You's card tools (posted: codex-wake.ts) and Stop (stopcheck),
+//   each through the shim with `--app codex`. Codex runs a hook only while the person trusts its exact definition (a
+//   hash of it, under [hooks.state."<file>:<event>:<group>:<handler>"] in config.toml), and skips an untrusted or
+//   changed one without a word: the shim keeps definitions the same across versions, new entries go at the end (the
+//   key is positional), and uninstall moves the person's own hooks' trust when theirs move up. `status` checks each.
+// - It's woken by `codex queue` (0.149; it starts a turn on an idle thread when Codex's shared background server runs,
+//   which it does by itself from 0.157): codex-wake.ts.
+// - Codex's /import can copy Claude Code's Pending You server (without its headersHelper, so it never signs in) and its
+//   hooks (with Claude Code's app): init replaces both.
+import { createHash } from 'node:crypto';
+import { realpath, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { removeSkill, saveSkill } from "../claude.js";
+import { readCredential } from "../credentials.js";
+import { configDir, readJson, readText, writeWhole } from "../files.js";
+import { isOurHook, mergeHooks, originArgs, removeHooks, } from "../hooks.js";
+import { atLeast } from "../mod.js";
+import { checkHelper, foundBy, headlessReason, helperCommand, helperPath, isOurHelper, } from "../remote.js";
+import { connectionTitle, FINISH_SAY, setupOf, setupStatus } from "../setup.js";
+import { basicString, definedInline, headerOf, renameTable, tableSpans, tableValues, withTable, } from "../toml.js";
+import { APP_NAMES } from "./ids.js";
+const NAME = APP_NAMES.codex;
+const SERVER = ['mcp_servers', 'pendingyou'];
+/** From here its helper may give Authorization (and it runs again after a 401): the oldest Codex init sets up. */
+export const CODEX_MIN = '0.152.0';
+/** From here interactive Codex starts its shared background server by itself, so `codex queue` wakes an idle thread. */
+export const CODEX_WAKE = '0.157.0';
+/** The Pending You tools whose calls the PostToolUse hook reads (codex-wake.ts). */
+const CARD_TOOLS = '^mcp__pendingyou__(post_request|update_request|reply_in_thread|cancel_request)$';
+/** Codex's hooks, by event: the command each runs, and its matcher. */
+export const CODEX_HOOKS = [
+    { event: 'SessionStart', sub: 'pickup', matcher: 'startup|resume|clear' },
+    { event: 'UserPromptSubmit', sub: 'handoff' },
+    { event: 'PostToolUse', sub: 'posted', matcher: CARD_TOOLS },
+    { event: 'Stop', sub: 'stopcheck' },
+];
+/** Each event as Codex names it in a hook's trust key. */
+const EVENT_LABELS = {
+    SessionStart: 'session_start',
+    UserPromptSubmit: 'user_prompt_submit',
+    PostToolUse: 'post_tool_use',
+    Stop: 'stop',
+};
+/** What a hook's trust ignores the matcher of: events whose matcher Codex doesn't read. */
+const NO_MATCHER = new Set(['UserPromptSubmit', 'Stop']);
+/** Keys of the server's table that sign it in some other way: they go when it signs in through the helper. */
+const SIGN_IN_KEYS = new Set([
+    'bearer_token_env_var',
+    'http_headers',
+    'env_http_headers',
+    'http_headers_helper',
+    'oauth',
+    'oauth_resource',
+    'scopes',
+]);
+/** Codex's own folder: $CODEX_HOME (as Codex resolves it) or ~/.codex. */
+async function codexHome(io) {
+    const set = io.env.CODEX_HOME;
+    if (set)
+        return realpath(set).catch(() => set);
+    return join(io.home, '.codex');
+}
+const configPath = async (io) => join(await codexHome(io), 'config.toml');
+const hooksPath = async (io) => join(await codexHome(io), 'hooks.json');
+export const codexSkillPath = (io) => join(io.home, '.agents', 'skills', 'pendingyou', 'SKILL.md');
+const manifestPath = (io) => join(configDir(io), 'codex.json');
+export const readCodexManifest = (io) => readJson(manifestPath(io)).catch(() => null);
+/** Reads Codex's pendingyou server from its config (read only); null when there's none or no config. */
+export async function codexServer(io) {
+    const doc = await readText(await configPath(io)).catch(() => null);
+    if (doc === null)
+        return null;
+    if (definedInline(doc, SERVER))
+        return { url: null, helper: null, approval: null, inline: true };
+    if (tableSpans(doc, SERVER).length === 0)
+        return null;
+    const values = tableValues(doc, SERVER);
+    const text = (key) => (typeof values[key] === 'string' ? values[key] : null);
+    return {
+        url: text('url'),
+        helper: text('http_headers_helper'),
+        approval: text('default_tools_approval_mode'),
+        inline: false,
+    };
+}
+const sameUrl = (a, b) => a.replace(/\/+$/, '') === b.replace(/\/+$/, '');
+/** The server's table as init writes it: ours first, then whatever else the person had in it (sign-in keys aside). */
+function serverTable(doc, url, helper) {
+    const kept = [];
+    const span = tableSpans(doc, SERVER).find((each) => {
+        const first = doc.slice(each.start, each.end).split('\n')[0] ?? '';
+        return first.replace(/\s+/g, '').replace(/#.*$/, '') === headerOf(SERVER);
+    });
+    if (span)
+        for (const line of doc.slice(span.start, span.end).split('\n').slice(1)) {
+            const key = /^\s*([A-Za-z0-9_-]+)\s*=/.exec(line)?.[1];
+            if (key && (SIGN_IN_KEYS.has(key) || key === 'url' || key === 'default_tools_approval_mode'))
+                continue;
+            kept.push(line);
+        }
+    while (kept.length && kept.at(-1)?.trim() === '')
+        kept.pop();
+    return `${[
+        headerOf(SERVER),
+        `url = ${basicString(url)}`,
+        ...(helper ? [`http_headers_helper = ${basicString(helper)}`] : []),
+        'default_tools_approval_mode = "approve"',
+        ...kept,
+    ].join('\n')}\n`;
+}
+/** The JSON a hook's trust hashes, its keys sorted at every level, as Codex serializes it. */
+function sorted(value) {
+    if (Array.isArray(value))
+        return value.map(sorted);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.keys(value)
+            .sort()
+            .map((key) => [key, sorted(value[key])]));
+    return value;
+}
+/**
+ * What Codex trusts a hook by: "sha256:" and the hash of its definition (its event, its matcher where Codex reads one,
+ * and the handler: type, command, timeout, async, statusMessage), keys sorted, as Codex hashes it (0.129 on).
+ */
+export function hookHash(event, matcher, handler) {
+    const identity = {
+        event_name: EVENT_LABELS[event] ?? event,
+        ...(matcher !== undefined && !NO_MATCHER.has(event) ? { matcher } : {}),
+        hooks: [
+            {
+                type: 'command',
+                command: handler.command,
+                timeout: handler.timeout ?? 600,
+                async: handler.async ?? false,
+                ...(handler.statusMessage !== undefined ? { statusMessage: handler.statusMessage } : {}),
+            },
+        ],
+    };
+    return `sha256:${createHash('sha256')
+        .update(JSON.stringify(sorted(identity)))
+        .digest('hex')}`;
+}
+/** A hook's trust key: its file, its event, and where it sits in that event's list. */
+const trustKey = (file, event, group, handler) => `${file}:${EVENT_LABELS[event] ?? event}:${group}:${handler}`;
+/** hooks.json as Codex reads it: an object of `description` and `hooks` only (it ignores a file with anything else). */
+async function readHooksFile(io) {
+    const path = await hooksPath(io);
+    const text = await readText(path).catch(() => null);
+    if (text === null || text.trim() === '')
+        return { path, json: {} };
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { path, invalid: `${path} isn’t valid JSON, so I left it alone.` };
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return { path, invalid: `${path} isn’t a JSON object, so I left it alone.` };
+    const extra = Object.keys(parsed).filter((key) => key !== 'description' && key !== 'hooks');
+    if (extra.length)
+        return {
+            path,
+            invalid: `${path} has keys Codex doesn’t read (${extra.join(', ')}), so Codex ignores the whole file: I left it alone.`,
+        };
+    return { path, json: parsed };
+}
+async function hookTrust(io) {
+    const file = await readHooksFile(io);
+    const config = (await readText(await configPath(io)).catch(() => null)) ?? '';
+    const hooks = 'json' in file && file.json.hooks && typeof file.json.hooks === 'object'
+        ? file.json.hooks
+        : {};
+    return CODEX_HOOKS.map((spec) => {
+        const groups = Array.isArray(hooks[spec.event]) ? hooks[spec.event] : [];
+        for (const [g, group] of groups.entries())
+            for (const [h, handler] of (group?.hooks ?? []).entries()) {
+                if (typeof handler?.command !== 'string' || !isOurHook(handler.command, spec.sub))
+                    continue;
+                const state = tableValues(config, ['hooks', 'state', trustKey(file.path, spec.event, g, h)]);
+                if (state.enabled === false)
+                    return { event: spec.event, trust: 'off' };
+                const hash = hookHash(spec.event, group.matcher, {
+                    command: handler.command,
+                    ...(typeof handler.timeout === 'number' ? { timeout: handler.timeout } : {}),
+                });
+                return {
+                    event: spec.event,
+                    trust: state.trusted_hash === hash
+                        ? 'trusted'
+                        : typeof state.trusted_hash === 'string'
+                            ? 'changed'
+                            : 'untrusted',
+                };
+            }
+        return { event: spec.event, trust: 'missing' };
+    });
+}
+/** Whether `codex mcp list` says Codex holds an OAuth sign-in for its pendingyou server; null when it can't say. */
+async function signedInByItself(io) {
+    const result = await io.run('codex', ['mcp', 'list', '--json'], 30_000);
+    if (result.code !== 0)
+        return null;
+    try {
+        const servers = JSON.parse(result.stdout);
+        const ours = Array.isArray(servers)
+            ? servers.find((server) => server?.name === 'pendingyou')
+            : null;
+        return ours ? ours.auth_status === 'o_auth' : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether to move a server that signs in by itself to this computer's sign-in (the same rule as Claude Code's). */
+async function switches(io, ctx) {
+    if (ctx.headless || ctx.yes)
+        return true;
+    if (!io.interactive)
+        return false;
+    io.out('Codex signs in to Pending You by itself here (codex mcp login). init can move it to this computer’s own sign-in, which its hooks use too: one sign-in for both. The connection it has now stays on your Assistants page until you remove it, and answers to cards it asked through that one won’t reach Codex by themselves.\n');
+    const answer = await io.ask('Switch Codex to this computer’s sign-in? [Y/n] ');
+    return !/^\s*no?\s*$/i.test(answer);
+}
+/** Writes Codex's config (its mode kept), or says why it couldn't. */
+async function writeConfig(path, text) {
+    return writeWhole(path, text).then(() => true, () => false);
+}
+/**
+ * The config without Codex's trust of our hooks (they're going), and with the person's own hooks' trust moved where
+ * removing ours moves them: Codex keys trust by a hook's place in its event's list, so a hook that moves up would
+ * otherwise need trusting again. Every move is to a lower place, so going in order never lands on a key in use.
+ */
+function keepTheirTrust(config, file, before) {
+    let next = config;
+    const state = (event, group, handler) => [
+        'hooks',
+        'state',
+        trustKey(file, event, group, handler),
+    ];
+    for (const spec of CODEX_HOOKS) {
+        const groups = Array.isArray(before[spec.event]) ? before[spec.event] : [];
+        for (const [g, group] of groups.entries())
+            for (const [h, hook] of (Array.isArray(group?.hooks) ? group.hooks : []).entries())
+                if (isOurHook(hook?.command, spec.sub))
+                    next = withTable(next, state(spec.event, g, h), null);
+        let at = 0;
+        for (const [g, group] of groups.entries()) {
+            if (!Array.isArray(group?.hooks)) {
+                at++;
+                continue;
+            }
+            const kept = group.hooks.flatMap((hook, h) => (isOurHook(hook?.command, spec.sub) ? [] : [h]));
+            if (kept.length === 0)
+                continue;
+            for (const [h, was] of kept.entries())
+                if (g !== at || was !== h)
+                    next = renameTable(next, state(spec.event, g, was), state(spec.event, at, h));
+            at++;
+        }
+    }
+    return next;
+}
+export const codex = {
+    id: 'codex',
+    name: NAME,
+    minVersion: CODEX_MIN,
+    async detect(io) {
+        const result = await io.run('codex', ['--version'], 20_000);
+        if (result.code !== 0)
+            return null;
+        return { version: /(\d+\.\d+\.\d+)/.exec(result.stdout)?.[1] ?? 'installed' };
+    },
+    async installed(io) {
+        return (await readCodexManifest(io)) !== null;
+    },
+    async usesHelper(io, origin) {
+        if (io.platform === 'win32')
+            return false;
+        const server = await codexServer(io);
+        return Boolean(server?.url && isOurHelper(server.helper) && new URL(server.url).origin === origin);
+    },
+    async prepare(io, ctx, detected) {
+        const url = `${ctx.origin}/mcp`;
+        const flag = originArgs(ctx.origin);
+        const skip = (step) => ({
+            app: codex,
+            detected,
+            signIn: null,
+            skipped: step,
+            install: async () => [],
+            next: () => null,
+        });
+        // Codex runs its helper and hooks with sh: not on Windows, where its setup message sets it up.
+        if (io.platform === 'win32')
+            return skip({
+                ok: true,
+                text: 'Codex on Windows isn’t set up by init yet: paste Pending You’s setup message for Codex into it instead.',
+            });
+        const helperMode = !ctx.oauth;
+        const server = await codexServer(io).catch(() => null);
+        if (server?.inline)
+            return skip({
+                ok: false,
+                text: `Codex’s config (${await configPath(io)}) defines pendingyou in a way I can’t edit safely (an inline table or dotted keys). Make it a [mcp_servers.pendingyou] table, or take it out, then run init again${flag ? ` with${flag}` : ''}.`,
+            });
+        let mode = helperMode ? 'helper' : 'oauth';
+        let action = 'add';
+        let note = null;
+        if (server?.url && !sameUrl(server.url, url)) {
+            ctx.progress(`Codex’s pendingyou MCP server points at ${server.url}, not ${url}.\n`);
+            const replace = ctx.yes ||
+                (io.interactive && /^\s*y(es)?\s*$/i.test(await io.ask(`Replace it with ${url}? [y/N] `)));
+            if (!replace)
+                return skip({
+                    ok: false,
+                    text: `Kept Codex’s pendingyou MCP server at ${server.url}, so Codex isn’t set up for ${ctx.origin}. To use ${url}, run init again with --yes.`,
+                });
+            action = 'write';
+        }
+        else if (server) {
+            const ours = isOurHelper(server.helper);
+            if (ours && helperMode)
+                action =
+                    server.helper === helperCommand(io, ctx.origin, 'codex') && server.approval === 'approve'
+                        ? 'keep'
+                        : 'write';
+            else if (ours)
+                action = 'write';
+            // Signing in by itself, as --oauth asks: kept, once its tools run without asking.
+            else if (!helperMode && !server.helper)
+                action = server.approval === 'approve' ? 'keep' : 'write';
+            else if (server.helper) {
+                mode = 'oauth';
+                action = 'keep';
+                note = {
+                    ok: false,
+                    text: `Kept Codex’s pendingyou MCP server: it signs in through a headers helper of its own (${server.helper}).`,
+                };
+            }
+            else if ((await signedInByItself(io)) !== true) {
+                // Never signed in: copied from Claude Code by /import (which leaves its helper behind), or left half-made.
+                action = 'write';
+            }
+            else if (await switches(io, ctx))
+                action = 'write';
+            else {
+                mode = 'oauth';
+                action = 'keep';
+                note = {
+                    ok: true,
+                    text: `Kept Codex’s own sign-in to Pending You (${url}). To move it to this computer’s, run: npx -y pendingyou@latest init --app codex --yes${flag}`,
+                };
+            }
+        }
+        const version = detected.version;
+        return {
+            app: codex,
+            detected,
+            signIn: mode === 'helper' ? 'connection' : 'hear',
+            install: async (ictx) => {
+                const steps = [];
+                const report = (step) => {
+                    steps.push(step);
+                    ictx.report(step);
+                };
+                const before = await readCodexManifest(io);
+                const config = await configPath(io);
+                // The MCP server: a stored OAuth sign-in would win over the helper, so it goes first.
+                let added = before?.mcpAdded ?? false;
+                if (note)
+                    report(note);
+                else if (action === 'keep')
+                    report({
+                        ok: true,
+                        text: mode === 'helper'
+                            ? `The pendingyou MCP server (${url}) already signs in through this computer’s sign-in.`
+                            : `The pendingyou MCP server (${url}) was already in Codex.`,
+                    });
+                else if (mode === 'helper' && !ictx.helper)
+                    report({
+                        ok: false,
+                        text: 'Didn’t add Codex’s pendingyou MCP server: it signs in through pendingyou’s own copy, which isn’t installed. Run init again.',
+                    });
+                else {
+                    if (mode === 'helper' && server)
+                        await io.run('codex', ['mcp', 'logout', 'pendingyou'], 60_000);
+                    const doc = (await readText(config).catch(() => null)) ?? '';
+                    const next = withTable(doc, SERVER, serverTable(doc, url, mode === 'helper' ? ictx.helper : null));
+                    if (await writeConfig(config, next)) {
+                        added = true;
+                        report({
+                            ok: true,
+                            text: !server
+                                ? `Added the pendingyou MCP server (${url}) to ${config}${mode === 'helper' ? ', signed in through this computer’s sign-in' : ''}; its tools run without asking.`
+                                : server.url && !sameUrl(server.url, url)
+                                    ? `Replaced Codex’s pendingyou MCP server (was ${server.url}) with ${url}.`
+                                    : mode === 'helper'
+                                        ? `Switched Codex’s pendingyou MCP server (${url}) to this computer’s sign-in: one sign-in for it and its hooks.`
+                                        : server.helper
+                                            ? `Switched Codex’s pendingyou MCP server (${url}) to Codex’s own sign-in: run codex mcp login pendingyou.`
+                                            : `Codex’s pendingyou MCP server (${url}) signs in by itself, and its tools now run without asking.`,
+                        });
+                    }
+                    else
+                        report({
+                            ok: false,
+                            text: `Couldn’t write ${config}, so Codex has no pendingyou MCP server. Run init again.`,
+                        });
+                }
+                const skill = await saveSkill(io, ictx.origin, codexSkillPath(io), before?.skill ?? null);
+                report(skill.step);
+                // The hooks, through the shim: new ones at the end of each list (Codex keys trust by position).
+                const lines = Object.fromEntries(CODEX_HOOKS.map((spec) => [spec.event, ictx.hookLine(spec.sub)]));
+                const file = await readHooksFile(io);
+                if ('invalid' in file)
+                    report({ ok: false, text: file.invalid });
+                else {
+                    try {
+                        const hooks = file.json.hooks && typeof file.json.hooks === 'object'
+                            ? file.json.hooks
+                            : {};
+                        const merged = mergeHooks(hooks, CODEX_HOOKS, lines, file.path);
+                        if (merged.changed)
+                            await writeWhole(file.path, `${JSON.stringify({ ...file.json, hooks: merged.hooks }, null, 2)}\n`);
+                        report({
+                            ok: true,
+                            text: merged.changed
+                                ? `Installed or updated Codex’s session-start pickup, next-message hand-off, card and Stop check hooks in ${file.path}. Codex asks you to trust them once.`
+                                : 'Codex’s hooks were already installed.',
+                        });
+                    }
+                    catch (error) {
+                        report({
+                            ok: false,
+                            text: error instanceof Error ? error.message : `Couldn’t update ${file.path}.`,
+                        });
+                    }
+                }
+                if (!atLeast(version, CODEX_WAKE))
+                    report({
+                        ok: true,
+                        text: `Codex ${version} wakes an idle thread with your answer only while its background server runs, which Codex starts by itself from ${CODEX_WAKE}. Until you update, an answer reaches a thread when you next write in it.`,
+                    });
+                const manifest = {
+                    version: 1,
+                    origin: ictx.origin,
+                    codexHome: await codexHome(io),
+                    mcpAdded: added,
+                    skill: skill.skill,
+                    hooks: lines,
+                    helper: mode === 'helper' ? ictx.helper : null,
+                    setup: { since: new Date(io.now()).toISOString() },
+                };
+                await writeWhole(manifestPath(io), `${JSON.stringify(manifest, null, 2)}\n`, {
+                    secret: true,
+                });
+                return steps;
+            },
+            next: () => {
+                const login = mode === 'oauth' && action !== 'keep';
+                const start = `start codex here, or in the folder you work in, and choose “Trust all and continue” when it asks about hooks (or trust Pending You’s in /hooks)`;
+                return {
+                    lines: [
+                        `Next: ${login ? 'run codex mcp login pendingyou, then ' : ''}${start}.`,
+                        'Then say this to it:',
+                        '',
+                        FINISH_SAY,
+                    ],
+                    together: `- Codex: ${login ? 'run codex mcp login pendingyou, then ' : ''}${start}, then say the line below to it.`,
+                    say: true,
+                };
+            },
+        };
+    },
+    async uninstall(io) {
+        const manifest = await readCodexManifest(io);
+        const steps = [];
+        const file = await readHooksFile(io);
+        const config = await configPath(io);
+        let doc = (await readText(config).catch(() => null)) ?? null;
+        if ('json' in file) {
+            const hooks = file.json.hooks && typeof file.json.hooks === 'object' ? file.json.hooks : {};
+            const removed = removeHooks(hooks, CODEX_HOOKS);
+            if (removed.changed) {
+                const rest = { ...file.json, hooks: removed.hooks };
+                if (Object.keys(removed.hooks).length === 0)
+                    delete rest.hooks;
+                if (Object.keys(rest).length === 0)
+                    await rm(file.path, { force: true });
+                else
+                    await writeWhole(file.path, `${JSON.stringify(rest, null, 2)}\n`);
+                // The person's own hooks that moved up keep the trust they had.
+                if (doc !== null)
+                    doc = keepTheirTrust(doc, file.path, hooks);
+            }
+            steps.push({
+                ok: true,
+                text: removed.changed
+                    ? 'Removed the Pending You hooks from Codex.'
+                    : 'No Pending You hooks were in Codex.',
+            });
+        }
+        if (manifest?.mcpAdded && doc !== null && tableSpans(doc, SERVER).length) {
+            doc = withTable(doc, SERVER, null);
+            steps.push({ ok: true, text: 'Removed the pendingyou MCP server from Codex.' });
+        }
+        if (doc !== null && doc !== (await readText(config).catch(() => null)))
+            await writeConfig(config, doc);
+        const skill = await removeSkill(manifest?.skill ?? null);
+        if (skill)
+            steps.push(skill);
+        await rm(join(configDir(io), 'codex-threads.json'), { force: true });
+        await rm(join(configDir(io), 'codex-listen'), { recursive: true, force: true });
+        await rm(manifestPath(io), { force: true });
+        return steps;
+    },
+    async status(io, ctx) {
+        const { origin, signIn } = ctx;
+        const flag = originArgs(origin);
+        const [detected, server, manifest, trust, skill] = await Promise.all([
+            codex.detect(io),
+            codexServer(io),
+            readCodexManifest(io),
+            hookTrust(io),
+            readText(codexSkillPath(io)).catch(() => null),
+        ]);
+        const credential = await readCredential(io, origin, 'codex');
+        const url = `${origin}/mcp`;
+        const why = headlessReason(io);
+        const mark = (ok) => (ok ? 'ok     ' : 'missing');
+        const helped = Boolean(server?.url && sameUrl(server.url, url) && isOurHelper(server.helper));
+        const helper = helped || Boolean(manifest?.helper) || (!server && !manifest);
+        const fix = `npx pendingyou ${helped ? 'login --app codex' : 'init --app codex'}${flag}`;
+        const connected = credential?.kind === 'connection';
+        const signOk = signIn.state === 'ok' && (!helper || connected);
+        const title = signIn.state === 'ok' && signIn.for ? connectionTitle(signIn.for) : `${NAME} on this computer`;
+        const signText = signIn.state === 'ok'
+            ? helper
+                ? connected
+                    ? `this computer’s own connection, ${title}; Codex here asks and hears through it`
+                    : `this computer’s sign-in for Codex only hears answers, so Codex here can’t use it; run ${fix}`
+                : `hears for ${signIn.connections} Codex connection${signIn.connections === 1 ? '' : 's'}`
+            : signIn.state === 'ended'
+                ? `ended; run ${fix}`
+                : signIn.state === 'none'
+                    ? `not signed in; run ${fix}`
+                    : 'Pending You couldn’t be reached';
+        const mcpOk = Boolean(server?.url && sameUrl(server.url, url) && (!helper || helped));
+        const mcpText = !server
+            ? `not added; run npx pendingyou init --app codex${flag}`
+            : server.inline
+                ? `defined in a way init can’t edit (an inline table or dotted keys) in ${await configPath(io)}`
+                : !server.url || !sameUrl(server.url, url)
+                    ? `points at ${server.url}, not ${url}; run npx pendingyou init --app codex${flag} to replace it`
+                    : helped
+                        ? `pendingyou (${server.url}), signed in through ${helperPath(io)} --app codex${server.approval === 'approve' ? '; its tools run without asking' : ''}`
+                        : helper
+                            ? `pendingyou (${server.url}) signs in by itself; run npx pendingyou init --app codex${flag} to use this computer’s sign-in`
+                            : `pendingyou (${server.url}), signed in by Codex itself`;
+        const check = helper ? await checkHelper(io, origin, 'codex') : null;
+        const words = {
+            trusted: 'trusted',
+            changed: 'changed since you trusted it',
+            untrusted: 'not trusted yet',
+            off: 'turned off',
+            missing: 'missing',
+        };
+        const hooksOk = trust.every((hook) => hook.trust === 'trusted');
+        const hooksText = trust.some((hook) => hook.trust === 'missing')
+            ? `not installed; run npx pendingyou init --app codex${flag}`
+            : `${trust.map((hook) => `${hook.event} ${words[hook.trust]}`).join(', ')}${hooksOk ? '' : '. Start codex and choose “Trust all and continue”, or trust them in /hooks: Codex skips a hook you haven’t trusted'}`;
+        const wakes = detected ? atLeast(detected.version, CODEX_WAKE) : false;
+        const lines = [
+            `Pending You for Codex · ${origin}${why ? ` · no browser here (${why})` : ''}`,
+            `  ${mark(signOk)} Sign-in: ${signText}`,
+            `  ${mark(detected !== null)} Codex: ${detected?.version ?? 'not found on PATH'}`,
+            `  ${mark(mcpOk)} MCP server: ${mcpText}`,
+            ...(check
+                ? [
+                    `  ${mark(check.ok)} Sign-in helper: ${check.ok
+                        ? `${check.node} (${foundBy(check.from)}) runs pendingyou ${check.version}, even in Codex’s stripped environment`
+                        : `${check.why}; run npx pendingyou init --app codex${flag}`}`,
+                ]
+                : []),
+            `  ${mark(skill !== null)} Skill: ${skill !== null ? `saved (${codexSkillPath(io)})` : `not saved; run npx pendingyou init --app codex${flag}`}`,
+            `  ${mark(hooksOk)} Hooks: ${hooksText}`,
+            `  ${mark(wakes)} Wake: ${wakes ? 'codex queue wakes a thread when you answer, even while it’s idle' : `needs Codex ${CODEX_WAKE} or later${detected ? ` (this is ${detected.version})` : ''}; until then an answer reaches a thread when you next write in it`}`,
+        ];
+        const setup = setupStatus(NAME, signIn.state === 'ok' ? setupOf(signIn.for) : null);
+        if (setup)
+            lines.push(`  ${setup === 'finished' ? 'ok     ' : '       '} Setup: ${setup}`);
+        const reaches = !helper || (signOk && mcpOk && check?.ok === true);
+        const ready = reaches && signIn.state === 'ok' && mcpOk && hooksOk;
+        lines.push(ready
+            ? 'Ready: Codex hears answers right away (report_setup hears "instant").'
+            : reaches && mcpOk
+                ? 'Not ready: Codex hears answers only while it’s working until the lines marked missing are fixed.'
+                : 'Not ready: Codex here can’t reach Pending You until the lines marked missing are fixed.');
+        return { lines, ready };
+    },
+};

package/dist/apps/ids.js

@@ -0,0 +1,24 @@
+// The apps `pendingyou init` sets up (0.11.0), by the id Pending You knows each by: a connection's `source`, and what
+// the hooks send as `source` so a session only ever hears its own app's cards. Each has a module in this folder
+// (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'];
+/** 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',
+};
+/**
+ * The app a command acts for when it names none: Claude Code, the only app before 0.11.0, so hook lines and helpers
+ * written by 0.10.0 keep meaning what they meant.
+ */
+export const DEFAULT_APP = 'claude-code';
+export const isAppId = (text) => APP_IDS.includes(text);
+/** "Claude Code and Codex", "Claude Code, Codex and OpenCode" (or "… or …"). */
+export function namesOf(apps, joiner = 'and') {
+    const names = apps.map((app) => APP_NAMES[app]);
+    if (names.length <= 1)
+        return names[0] ?? '';
+    return `${names.slice(0, -1).join(', ')} ${joiner} ${names.at(-1)}`;
+}

package/dist/apps/registry.js

@@ -0,0 +1,12 @@
+// Every app module, in the order init sets them up and status lists them (ids.ts has the same order). Adding an app is
+// a module of its own beside these (docs/apps.md) and one line here.
+import { claudeCode } from "./claude-code.js";
+import { codex } from "./codex.js";
+export { atLeast } from "../mod.js";
+export const APPS = [claudeCode, codex];
+export function appModule(id) {
+    const found = APPS.find((app) => app.id === id);
+    if (!found)
+        throw new Error(`no module for ${id}`);
+    return found;
+}

package/dist/apps/types.js

@@ -0,0 +1 @@
+export {};