pendingyou 0.32.3 → 0.34.0

package/dist/permission.js

@@ -5,10 +5,11 @@ import { threadNames } from "./apps/codex-wake.js";
 import { APP_NAMES } from "./apps/ids.js";
 import { DEFAULT_ORIGIN } from "./args.js";
 import { McpFailure, mcpClient, SIGN_IN_ERROR, ToolRefused } from "./bridge.js";
+import { minutes, readAnswerWait } from "./codex-answers.js";
 import { sessionLink } from "./confirm.js";
 import { connectionMachine, readCredential } from "./credentials.js";
-import { configDir, PERMISSION_FOLDER, readJson, withLock, writeWhole } from "./files.js";
-import { cut, redactCommand, redactText, redactUrl, shortPath } from "./redact.js";
+import { claudeDir, configDir, PERMISSION_FOLDER, readJson, withLock, writeWhole } from "./files.js";
+import { BLANK, cut, maskSecrets, redactCommand, redactText, redactUrl, shortPath, } from "./redact.js";
 import { machineOf } from "./remote.js";
 export const GRACE_MS = 10_000;
 export const TITLE_MAX = 90;
@@ -24,7 +25,9 @@ export const isPromptApp = (app) => PROMPT_APPS.includes(app);
 export const waitingFor = (app) => `${APP_NAMES[app]} is waiting for your OK`;
 export const isPermissionCard = (title) => typeof title === 'string' &&
     PROMPT_APPS.some((app) => title.startsWith(waitingFor(app)) ||
-        title.startsWith(`${APP_NAMES[app]} is waiting for your answer`));
+        title.startsWith(`${APP_NAMES[app]} is waiting for your answer`) ||
+        title.startsWith(`Allow ${APP_NAMES[app]} `) ||
+        title.startsWith(`Allow a subagent of ${APP_NAMES[app]}`));
 export const DEFAULT_NAME = 'Claude Code';
 const defaultName = (app) => APP_NAMES[app];
 const LEASE_STALE_MS = 120_000;
@@ -172,7 +175,10 @@ async function change(io, session, edit) {
     });
 }
 const alive = (state, now) => Boolean(state.worker && now - state.worker.at < LEASE_STALE_MS);
-const seen = (prompt) => !prompt.quiet || prompt.shown !== undefined || prompt.waited !== undefined;
+const seen = (prompt) => !prompt.quiet ||
+    prompt.shown !== undefined ||
+    prompt.waited !== undefined ||
+    prompt.relay !== undefined;
 const unchecked = (prompt) => !seen(prompt) && !prompt.notice;
 function claim(state, now) {
     if (alive(state, now))
@@ -217,6 +223,27 @@ function reasonOf(app, input) {
     return reason || null;
 }
 const wentOn = (agent, now) => (prompt) => Boolean(prompt.quiet) && (prompt.agent ?? '') === agent && prompt.at <= now - BATCH_MS;
+function closeCards(state, settled, how) {
+    const cards = settled.flatMap((prompt) => (prompt.card ? [{ ...prompt.card, how }] : []));
+    if (cards.length)
+        state.closing = [...(state.closing ?? []), ...cards];
+}
+function keepNewest(state) {
+    closeCards(state, state.prompts.slice(0, -MAX_PROMPTS), 'answered');
+    state.prompts = state.prompts.slice(-MAX_PROMPTS);
+}
+const ADOPT_MS = 30_000;
+function adopt(state, prompt) {
+    const own = state.prompts.find((each) => each.relay?.own &&
+        each.tool === prompt.tool &&
+        Math.abs(prompt.at - each.relay.at) <= ADOPT_MS);
+    if (!own?.relay)
+        return false;
+    const { at: _at, quiet: _quiet, ...hook } = prompt;
+    Object.assign(own, hook);
+    delete own.relay.own;
+    return true;
+}
 async function asked(io, origin, input, app) {
     if (io.platform === 'win32')
         return;
@@ -273,10 +300,12 @@ async function asked(io, origin, input, app) {
         const kept = app === 'claude-code'
             ? next.prompts.filter((each) => !wentOn(agent, now)(each))
             : next.prompts;
+        closeCards(next, next.prompts.filter((each) => !kept.includes(each)), 'answered');
         next.prompts = kept;
-        if (!next.prompts.some((each) => each.key === prompt.key))
+        const adopted = app === 'claude-code' ? adopt(next, prompt) : false;
+        if (!adopted && !next.prompts.some((each) => each.key === prompt.key))
             next.prompts.push(prompt);
-        next.prompts = next.prompts.slice(-MAX_PROMPTS);
+        keepNewest(next);
         delete next.settled;
         next.at = now;
         worker = claim(next, now);
@@ -299,10 +328,11 @@ async function settle(io, session, which, how) {
         const left = state.prompts.filter((prompt) => !which(prompt));
         if (left.length === state.prompts.length)
             return state;
+        closeCards(state, state.prompts.filter((prompt) => !left.includes(prompt)), how);
         state.prompts = left;
         state.settled = how;
         state.at = now;
-        if (!state.card && left.length === 0)
+        if (!state.card && !state.closing?.length && left.length === 0)
             return alive(state, now) ? state : null;
         worker = claim(state, now);
         return state;
@@ -322,7 +352,11 @@ async function ran(io, input, app) {
         return;
     const exact = before.prompts.some((prompt) => prompt.key === key);
     const movedOn = wentOn(agent, io.now());
-    await settle(io, where.session, (prompt) => prompt.key === key || (app === 'codex' ? !exact && prompt.tool === tool : movedOn(prompt)), 'answered');
+    await settle(io, where.session, (prompt) => prompt.key === key ||
+        (app === 'codex'
+            ? !exact && prompt.tool === tool
+            : movedOn(prompt) ||
+                (!exact && Boolean(prompt.relay?.own) && prompt.tool === tool && !agent)), 'answered');
 }
 export async function endPrompts(io, session) {
     try {
@@ -423,6 +457,11 @@ export async function permissionHook(io, options) {
             return 0;
         switch (input.hook_event_name) {
             case 'PermissionRequest':
+                if (app === 'codex') {
+                    const wait = await readAnswerWait(io);
+                    if (wait > 0 && (await askFirst(io, options.origin, input, wait)))
+                        break;
+                }
                 await asked(io, options.origin, input, app);
                 break;
             case 'PostToolUse':
@@ -447,7 +486,7 @@ export async function permissionHook(io, options) {
 const dueOf = (prompt, grace) => Math.min(prompt.quiet ? (prompt.waited ?? Number.POSITIVE_INFINITY) : prompt.at + grace, prompt.shown ?? Number.POSITIVE_INFINITY);
 const shownOf = (prompts) => (prompts.filter((prompt) => !prompt.notice).at(-1) ?? prompts.at(-1));
 export function planFor(state, now, grace, quietGrace = QUIET_GRACE_MS) {
-    const plan = cardPlan(state, now, grace);
+    const plan = relayPlan(state, now, grace, cardPlan(state, now, grace));
     const pending = state.prompts.filter(unchecked);
     if (pending.length === 0)
         return plan;
@@ -460,8 +499,26 @@ export function planFor(state, now, grace, quietGrace = QUIET_GRACE_MS) {
         return { kind: 'wait', ms: Math.min(plan.ms, check) };
     return plan;
 }
+function relayPlan(state, now, grace, then) {
+    const closing = state.closing?.[0];
+    if (closing)
+        return { kind: 'close', card: closing };
+    const waiting = state.prompts.filter((prompt) => prompt.relay && !prompt.card && !prompt.failed);
+    if (waiting.length === 0)
+        return then;
+    const dueAt = (prompt) => Math.min(Math.min(prompt.at, prompt.relay.at) + grace, prompt.shown ?? Number.POSITIVE_INFINITY);
+    const first = waiting.reduce((soonest, prompt) => dueAt(prompt) < dueAt(soonest) ? prompt : soonest);
+    const due = dueAt(first) - now;
+    if (due <= 0)
+        return { kind: 'relay', prompt: first };
+    if (then.kind === 'done')
+        return { kind: 'wait', ms: due };
+    if (then.kind === 'wait')
+        return { kind: 'wait', ms: Math.min(then.ms, due) };
+    return then;
+}
 function cardPlan(state, now, grace) {
-    const prompts = state.prompts.filter(seen);
+    const prompts = state.prompts.filter((prompt) => seen(prompt) && !prompt.relay);
     if (prompts.length === 0)
         return state.card ? { kind: 'cancel' } : { kind: 'done' };
     if (state.card) {
@@ -481,7 +538,7 @@ function graceOf(env) {
     const given = Number(env.PENDINGYOU_PERMISSION_GRACE_MS);
     return Number.isInteger(given) && given >= 0 ? given : GRACE_MS;
 }
-async function computerOf(io, origin, app) {
+export async function computerOf(io, origin, app) {
     const named = await connectionMachine(io, origin, app).catch(() => null);
     return cut(named ?? (machineOf(io.host) || 'this computer'), 60);
 }
@@ -873,6 +930,7 @@ async function post(io, client, state, prompt, worker) {
         blocking: false,
         urgency: 'now',
         askedFirst: { where: 'terminal', askedAt: new Date(prompt.at).toISOString() },
+        permissionPrompt: { app: appOf(state), relay: false },
     });
     const requestId = idOf(result, 'requestId', 'req_');
     const version = typeof result.version === 'number' ? result.version : 1;
@@ -886,6 +944,89 @@ async function post(io, client, state, prompt, worker) {
     if (!kept)
         await withdraw(io, client, card, state, 'answered').catch(() => { });
 }
+export const ALLOW = 'allow';
+export const DENY = 'deny';
+export const IN_TERMINAL = 'terminal';
+export function relayTitle(state, prompt, name) {
+    const app = appOf(state);
+    const who = name === defaultName(app) ? APP_NAMES[app] : `${APP_NAMES[app]} (${name})`;
+    const subject = byAgent(state, prompt) ? `a subagent of ${who}` : who;
+    const doing = prompt.doing.startsWith('to ')
+        ? prompt.doing
+        : `to use ${toolName(prompt.tool ?? '')}`;
+    return cut(`Allow ${subject} ${doing}?`, TITLE_MAX);
+}
+async function postRelay(io, client, state, prompt, worker) {
+    const relay = prompt.relay;
+    const app = appOf(state);
+    const name = await nameOf(io, state);
+    await client.call('whoami', { name });
+    const areaId = state.areaId ?? (await areaFor(io, client, state, name));
+    const machine = await computerOf(io, state.origin, app);
+    const title = relayTitle(state, prompt, name);
+    const who = name === defaultName(app) ? APP_NAMES[app] : `${APP_NAMES[app]} (${name})`;
+    const where = `in ${tilde(io, state.cwd)} on ${machine}`;
+    const asker = byAgent(state, prompt)
+        ? `A subagent${prompt.agentType ? ` (${prompt.agentType})` : ''} of ${who}, ${where},`
+        : `${who} ${where}`;
+    const wants = prompt.doing.startsWith('to ')
+        ? `wants your OK ${prompt.doing}`
+        : `wants your OK to use ${toolName(prompt.tool ?? '')}`;
+    const why = relay.description ? ` It says: “${relay.description}”.` : '';
+    const answer = relay.unserializable
+        ? `Part of it couldn’t be shown, so only Deny is here; to allow it, answer in ${APP_NAMES[app]} on ${machine}.`
+        : `Allow or Deny here, or answer in ${APP_NAMES[app]} on ${machine}: the first answer wins.`;
+    const session = createHash('sha256').update(state.session).digest('hex').slice(0, 24);
+    const result = await client.call('post_request', {
+        idempotencyKey: `${app}-relay:${session}:${relay.id}:${relay.at}`,
+        areaId,
+        session: { label: name, machine, cwd: cut(tilde(io, state.cwd), 300) },
+        kind: 'choice',
+        intent: 'approve',
+        title,
+        summary: cut(`${asker} ${wants}.${why} ${answer}`, 400),
+        options: relay.unserializable
+            ? [
+                { id: DENY, label: 'Deny' },
+                { id: IN_TERMINAL, label: `I’ll answer in ${APP_NAMES[app]}` },
+            ]
+            : [
+                { id: ALLOW, label: 'Allow', detail: 'This call only. Nothing is allowed after it.' },
+                { id: DENY, label: 'Deny' },
+            ],
+        artifacts: [
+            {
+                kind: 'code',
+                title: prompt.tool === 'Bash' ? 'The command' : `${toolName(prompt.tool ?? '')}’s input`,
+                ref: `permission-${relay.id}`,
+                lang: relay.lang,
+                lines: relay.lines,
+            },
+        ],
+        context: { ...contextOf(state, prompt), trace: [{ state: 'paused', text: title }] },
+        blocking: false,
+        urgency: 'now',
+        askedFirst: { where: 'terminal', askedAt: new Date(prompt.at).toISOString() },
+        permissionPrompt: { app, relay: true },
+    });
+    const requestId = idOf(result, 'requestId', 'req_');
+    const version = typeof result.version === 'number' ? result.version : 1;
+    if (!requestId)
+        throw new McpFailure(-32000, 'Pending You posted no card.');
+    const card = { requestId, version, key: prompt.key, name };
+    const id = promptId(prompt);
+    let kept = false;
+    const ours = await record(io, state.session, worker, (state) => {
+        const now = state.prompts.find((each) => promptId(each) === id && each.relay?.id === relay.id);
+        if (!now)
+            return;
+        now.card = card;
+        state.areaId = areaId;
+        kept = true;
+    });
+    if (!ours || !kept)
+        await withdraw(io, client, card, state, 'answered').catch(() => { });
+}
 async function stillOpen(client, card) {
     const now = await client.call('get_request', { requestId: card.requestId, name: card.name });
     const open = ['pending', 'snoozed', 'delegated'].includes(text(now.status)) && now.turn !== 'agent';
@@ -985,7 +1126,7 @@ async function letGo(io, session, worker, grace) {
             return state;
         }
         delete state.worker;
-        return state.prompts.length === 0 && !state.card ? null : state;
+        return state.prompts.length === 0 && !state.card && !state.closing?.length ? null : state;
     });
     return done;
 }
@@ -1038,6 +1179,17 @@ export async function permissionWorker(io, options) {
                     await post(io, client, state, plan.prompt, worker);
                 else if (plan.kind === 'update')
                     await update(io, client, state, plan.prompt, worker);
+                else if (plan.kind === 'relay')
+                    await postRelay(io, client, state, plan.prompt, worker);
+                else if (plan.kind === 'close') {
+                    const card = plan.card;
+                    await withdraw(io, client, card, state, card.how);
+                    await record(io, session, worker, (state) => {
+                        state.closing = state.closing?.filter((each) => each.requestId !== card.requestId);
+                        if (!state.closing?.length)
+                            delete state.closing;
+                    });
+                }
                 else {
                     const card = state.card;
                     await withdraw(io, client, card, state, state.settled ?? 'answered');
@@ -1057,8 +1209,17 @@ export async function permissionWorker(io, options) {
                 if (failures >= BACKOFF_MS.length) {
                     failures = 0;
                     await record(io, session, worker, (state) => {
-                        if (plan.kind === 'post')
-                            state.prompts = state.prompts.map((prompt) => ({ ...prompt, failed: true }));
+                        if (plan.kind === 'relay') {
+                            const id = promptId(plan.prompt);
+                            state.prompts = state.prompts.map((prompt) => promptId(prompt) === id ? { ...prompt, failed: true } : prompt);
+                        }
+                        else if (plan.kind === 'close') {
+                            state.closing = state.closing?.filter((each) => each.requestId !== plan.card.requestId);
+                            if (!state.closing?.length)
+                                delete state.closing;
+                        }
+                        else if (plan.kind === 'post')
+                            state.prompts = state.prompts.map((prompt) => prompt.relay ? prompt : { ...prompt, failed: true });
                         else if (plan.kind === 'update' && state.card)
                             state.card = { ...state.card, key: plan.prompt.key };
                         else
@@ -1075,9 +1236,339 @@ export async function permissionWorker(io, options) {
         await client?.close().catch(() => { });
     }
 }
+export const RELAY_MATCH_MS = 5000;
+function fit(prompt, heard) {
+    if (prompt.relay || prompt.notice || prompt.tool !== heard.tool)
+        return null;
+    if (Math.abs(prompt.at - heard.relay.at) > RELAY_MATCH_MS)
+        return null;
+    const input = heard.relay.lines.join(' ').replace(/\s+/g, ' ');
+    return prompt.what
+        .split(BLANK)
+        .map((part) => part.replace(/\s+/g, ' ').trim())
+        .filter((part) => part.length >= 3 && input.includes(part)).length;
+}
+function bestFit(prompts, heard) {
+    let best = null;
+    for (const prompt of prompts) {
+        const score = fit(prompt, heard);
+        if (score === null)
+            continue;
+        const apart = Math.abs(prompt.at - heard.relay.at);
+        if (!best ||
+            score > best.score ||
+            (score === best.score && apart < Math.abs(best.prompt.at - heard.relay.at)))
+            best = { prompt, score };
+    }
+    return best?.prompt ?? null;
+}
+async function sessionsFrom(io, first) {
+    const names = await readdir(folderOf(io)).catch(() => []);
+    const others = names
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => name.slice(0, -'.json'.length))
+        .filter((session) => SESSION.test(session) && session !== first);
+    return first ? [first, ...others] : others;
+}
+const transcriptOf = (io, cwd, session) => join(claudeDir(io), 'projects', cwd.replace(/[^A-Za-z0-9]/g, '-'), `${session}.jsonl`);
+export async function recordRelay(io, origin, heard, options) {
+    if (io.platform === 'win32')
+        return null;
+    if ((await readCredential(io, origin, CLAUDE))?.kind !== 'connection')
+        return null;
+    for (const session of await sessionsFrom(io, options.session)) {
+        const before = await load(io, session);
+        if (!before || !bestFit(before.prompts, heard))
+            continue;
+        let worker = null;
+        let matched = false;
+        const state = await change(io, session, (state) => {
+            const prompt = state ? bestFit(state.prompts, heard) : null;
+            if (!state || !prompt)
+                return state;
+            prompt.relay = heard.relay;
+            delete prompt.failed;
+            matched = true;
+            delete state.settled;
+            worker = claim(state, io.now());
+            return state;
+        });
+        if (!matched || !state)
+            continue;
+        if (worker)
+            startWorker(io, state.origin, session, worker);
+        return session;
+    }
+    if (!options.last)
+        return null;
+    const session = options.session ?? `channel-${io.ppid ?? process.pid}`;
+    const now = io.now();
+    const prompt = {
+        key: promptKey(heard.tool, { relay: heard.relay.id }),
+        tool: heard.tool.slice(0, 100),
+        ...heard.words,
+        at: heard.relay.at,
+        relay: { ...heard.relay, own: true },
+    };
+    let worker = null;
+    await change(io, session, (state) => {
+        const next = state ?? {
+            version: 1,
+            origin,
+            session,
+            cwd: options.cwd,
+            ...(options.session ? { transcript: transcriptOf(io, options.cwd, options.session) } : {}),
+            prompts: [],
+            at: now,
+        };
+        if (next.prompts.some((each) => each.relay?.id === heard.relay.id))
+            return next;
+        next.prompts.push(prompt);
+        keepNewest(next);
+        delete next.settled;
+        next.at = now;
+        worker = claim(next, now);
+        return next;
+    });
+    if (worker)
+        startWorker(io, origin, session, worker);
+    return session;
+}
+export async function relayedPrompt(io, session, id) {
+    const state = await load(io, session);
+    const prompt = state?.prompts.find((each) => each.relay?.id === id);
+    return state && prompt ? { state, prompt } : null;
+}
+export async function answeredOnCard(io, session, id) {
+    await change(io, session, (state) => {
+        if (!state)
+            return null;
+        const left = state.prompts.filter((prompt) => prompt.relay?.id !== id);
+        if (left.length === state.prompts.length)
+            return state;
+        state.prompts = left;
+        state.at = io.now();
+        if (left.length === 0 && !state.card && !state.closing?.length && !alive(state, io.now()))
+            return null;
+        return state;
+    });
+}
 export async function removePermissionFiles(io) {
     const folder = folderOf(io);
     const there = await stat(folder).then(() => true, () => false);
     await rm(folder, { recursive: true, force: true });
     return there;
 }
+export const ANSWER_READ_MS = 2000;
+const ANSWER_CALL_MS = 8000;
+const ANSWER_INPUT_MAX = 40_000;
+const ANSWER_LINES_MAX = 400;
+const ANSWER_LINE_MAX = 2000;
+export const DENIED = 'Denied in Pending You.';
+export function codexDecision(verdict) {
+    const decision = verdict === 'allow' ? { behavior: 'allow' } : { behavior: 'deny', message: DENIED };
+    return JSON.stringify({
+        hookSpecificOutput: { hookEventName: 'PermissionRequest', decision },
+    });
+}
+export function codexInputLines(tool, input) {
+    const { description: _, ...rest } = input;
+    const command = commandText(rest.command);
+    const patch = command || text(rest.patch) || text(rest.input);
+    let lines;
+    let lang = 'text';
+    if (tool === 'apply_patch' && patch)
+        lines = patch.split('\n');
+    else if (command) {
+        lines = command.split('\n');
+        lang = 'shell';
+    }
+    else
+        lines = Object.entries(rest).flatMap(([key, value]) => `${key}: ${typeof value === 'string' ? value : JSON.stringify(value)}`.split('\n'));
+    const kept = [];
+    let size = 0;
+    for (const line of lines) {
+        if (kept.length >= ANSWER_LINES_MAX ||
+            line.length > ANSWER_LINE_MAX ||
+            size + line.length > ANSWER_INPUT_MAX) {
+            kept.push('… (cut here: too long to show whole)');
+            return { lines: kept, lang, cut: true };
+        }
+        kept.push(maskSecrets(line));
+        size += line.length;
+    }
+    return { lines: kept.length ? kept : [''], lang, cut: false };
+}
+function tapOf(card, partial) {
+    if (!['answered', 'resolved'].includes(text(card.status)))
+        return null;
+    const answer = isObject(card.answer) ? card.answer : null;
+    const picked = Array.isArray(answer?.choiceIds) ? answer.choiceIds : [];
+    if (picked.length !== 1)
+        return 'terminal';
+    if (picked[0] === DENY)
+        return 'deny';
+    if (picked[0] === ALLOW && !partial)
+        return 'allow';
+    return 'terminal';
+}
+async function askFirst(io, origin, input, wait) {
+    if (io.platform === 'win32')
+        return false;
+    const where = whereOf(input);
+    const tool = text(input.tool_name);
+    if (!where || !tool)
+        return false;
+    if ((await readCredential(io, origin, 'codex'))?.kind !== 'connection')
+        return false;
+    const started = io.now();
+    const toolInput = isObject(input.tool_input) ? input.tool_input : {};
+    const cwd = text(input.cwd) || io.cwd;
+    const known = await load(io, where.session).catch(() => null);
+    const state = {
+        version: 1,
+        origin,
+        app: 'codex',
+        session: where.session,
+        cwd,
+        prompts: [],
+        ...(known?.areaId && known.cwd === cwd ? { areaId: known.areaId } : {}),
+        at: started,
+    };
+    const prompt = {
+        key: promptKey(tool, keyInput('codex', toolInput)),
+        tool: tool.slice(0, 100),
+        ...promptWords(tool, toolInput, io.home, 'codex'),
+        at: started,
+    };
+    const shown = codexInputLines(tool, toolInput);
+    let client = null;
+    let card;
+    let machine;
+    try {
+        client = await mcpClient(io, origin, 'codex', ANSWER_CALL_MS);
+        const name = await nameOf(io, state);
+        await client.call('whoami', { name });
+        const areaId = state.areaId ?? (await areaFor(io, client, state, name));
+        machine = await computerOf(io, origin, 'codex');
+        const title = relayTitle(state, prompt, name);
+        const who = name === defaultName('codex') ? APP_NAMES.codex : `${APP_NAMES.codex} (${name})`;
+        const wants = prompt.doing.startsWith('to ')
+            ? `wants your OK ${prompt.doing}`
+            : `wants your OK to use ${toolName(tool)}`;
+        const reason = reasonOf('codex', toolInput);
+        const why = reason ? ` It says: “${reason}”.` : '';
+        const answer = shown.cut
+            ? ' It’s too long to show whole, so only Deny is here; to allow it, choose “I’ll answer in Codex” and answer in its terminal.'
+            : ` Allow or Deny here: Codex waits up to ${minutes(wait)} for you, showing nothing, then asks in its terminal.`;
+        const session = createHash('sha256').update(where.session).digest('hex').slice(0, 24);
+        const result = await client.call('post_request', {
+            idempotencyKey: `codex-ask:${session}:${prompt.key}:${started}`,
+            areaId,
+            session: { label: name, machine, cwd: cut(tilde(io, cwd), 300) },
+            kind: 'choice',
+            intent: 'approve',
+            title,
+            summary: cut(`${who} in ${tilde(io, cwd)} on ${machine} ${wants}.${why}${answer}`, 400),
+            options: shown.cut
+                ? [
+                    { id: DENY, label: 'Deny' },
+                    { id: IN_TERMINAL, label: `I’ll answer in ${APP_NAMES.codex}` },
+                ]
+                : [
+                    { id: ALLOW, label: 'Allow', detail: 'This call only. Nothing is allowed after it.' },
+                    { id: DENY, label: 'Deny' },
+                ],
+            artifacts: [
+                {
+                    kind: 'code',
+                    title: shown.lang === 'shell' ? 'The command' : `${toolName(tool)}’s input`,
+                    ref: `permission-${prompt.key.slice(0, 16)}`,
+                    lang: shown.lang,
+                    lines: shown.lines,
+                },
+            ],
+            context: { ...contextOf(state, prompt), trace: [{ state: 'paused', text: title }] },
+            blocking: false,
+            urgency: 'now',
+            permissionPrompt: { app: 'codex', relay: true },
+        });
+        const requestId = idOf(result, 'requestId', 'req_');
+        if (!requestId)
+            throw new McpFailure(-32000, 'Pending You posted no card.');
+        card = {
+            requestId,
+            version: typeof result.version === 'number' ? result.version : 1,
+            key: prompt.key,
+            name,
+        };
+    }
+    catch {
+        await client?.close().catch(() => { });
+        return false;
+    }
+    const pending = client;
+    const read = () => pending.call('get_request', { requestId: card.requestId, name: card.name });
+    const say = async (tap, now) => {
+        if (tap !== 'terminal')
+            io.out(`${codexDecision(tap)}\n`);
+        if (now.status !== 'answered' || typeof now.version !== 'number')
+            return;
+        await pending
+            .call('ack_answer', {
+            requestId: card.requestId,
+            name: card.name,
+            expectedVersion: now.version,
+            outcome: cut(tap === 'allow'
+                ? `Allowed in Codex on ${machine}.`
+                : tap === 'deny'
+                    ? `Denied in Codex on ${machine}.`
+                    : `Not allowed or denied here: Codex asks in its terminal on ${machine} now.`, 200),
+        })
+            .catch(() => { });
+    };
+    const until = started + wait * 60_000;
+    try {
+        while (!io.signal.aborted && io.now() < until) {
+            await io.sleep(Math.min(ANSWER_READ_MS, until - io.now()), io.signal);
+            if (io.signal.aborted)
+                return true;
+            let now;
+            try {
+                now = await read();
+            }
+            catch (error) {
+                if (error instanceof McpFailure && error.code === SIGN_IN_ERROR)
+                    break;
+                continue;
+            }
+            if (['pending', 'snoozed', 'delegated'].includes(text(now.status)))
+                continue;
+            const tap = tapOf(now, shown.cut);
+            if (tap)
+                await say(tap, now);
+            return true;
+        }
+        if (io.signal.aborted)
+            return true;
+        try {
+            await pending.call('cancel_request', {
+                requestId: card.requestId,
+                name: card.name,
+                reason: cut(`No answer here in ${minutes(wait)}, so Codex is asking in its terminal on ${machine} now.`, 200),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof ToolRefused))
+                return true;
+            const now = await read().catch(() => null);
+            const tap = now ? tapOf(now, shown.cut) : null;
+            if (now && tap)
+                await say(tap, now);
+        }
+        return true;
+    }
+    finally {
+        await pending.close().catch(() => { });
+    }
+}

package/dist/redact.js

@@ -234,6 +234,12 @@ export function cut(text, max = SUMMARY_MAX) {
 export function redactText(text, max = SUMMARY_MAX) {
     return cut(tidy(redactTokens(redactSchemes(redactHeaders(redactUrls(text))))), max);
 }
+export function maskSecrets(text) {
+    return text
+        .split('\n')
+        .map((line) => redactTokens(redactFlags(redactNamedValues(redactSchemes(redactHeaders(redactUrls(line)))))))
+        .join('\n');
+}
 const INLINE_CODE = /(?:^|[\s;&|(`$/])(?:(?:ba|z|da|k)?sh|fish|python[0-9.]*|node(?:js)?|deno|bun|ruby|perl|php|osascript|pwsh|powershell|lua|Rscript)\b[^;&|]*?\s(?:-c|-e|-E|--eval|-p|--print|-r|-Command|-command|-EncodedCommand)(?=\s|=|$)/i;
 const TAKES_SECRET = /\bsudo\s+(?:-\w+\s+)*-S\b|--password-stdin|\b(?:ch)?passwd\b|\bhtpasswd\b|\bsecurity\s+(?:add|set|import)-|\bsecrets?\s+(?:set|put|add|create|edit)\b|\bvault\s+(?:kv\s+)?(?:put|write)\b|\bkubectl\s+create\s+secret\b|\bop\s+(?:item|read|run|inject)\b|\bssh-add\b|\bgpg\b|\bpass\s+(?:insert|edit)\b|\bbase64\s+(?:-d|-D|--decode)\b/i;
 export function unsafeCommand(command) {

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.32.3';
+export const VERSION = '0.34.0';