pendingyou 0.32.3 → 0.34.0

package/dist/claude.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { rm, rmdir, stat } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { DEFAULT_ORIGIN } from "./args.js";
+import { CHANNEL, CHANNEL_CLAUDE } from "./channel.js";
 import { PlainError } from "./errors.js";
 import { claudeDir, configDir, readJson, readText, writeWhole } from "./files.js";
 import { findHook, hooksOf, mergeHooks, originArgs, removeHooks } from "./hooks.js";
@@ -11,7 +12,7 @@ import { atLeast, claudeVersion, isOurModDir, loadsMods, modDir, PLUGIN_DIRS, pl
 import { removePermissionFiles } from "./permission.js";
 import { removePresenceFiles } from "./presence.js";
 import { helperPath } from "./remote.js";
-import { readShim, SHIM } from "./shim.js";
+import { readShim, SHIM, shimPath } from "./shim.js";
 import { VERSION } from "./version.js";
 export { isOurHook } from "./hooks.js";
 export const MCP_NAME = 'pendingyou';
@@ -192,6 +193,105 @@ export function helperServer(url, command) {
         text: `claude mcp add-json --scope user ${MCP_NAME} ${quote(json)}`,
     };
 }
+export function channelEntry(io, origin) {
+    return {
+        type: 'stdio',
+        command: shimPath(io),
+        args: [
+            'channel',
+            '--app',
+            'claude-code',
+            ...(origin === DEFAULT_ORIGIN ? [] : ['--origin', origin]),
+        ],
+    };
+}
+export async function channelFromFile(io) {
+    let parsed;
+    try {
+        const text = await readText(claudeJsonPath(io));
+        if (text === null)
+            return 'unknown';
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return 'unknown';
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return 'unknown';
+    const servers = objectAt(parsed, 'mcpServers');
+    return servers ? objectAt(servers, CHANNEL) : null;
+}
+const sameEntry = (entry, wanted) => entry.command === wanted.command && JSON.stringify(entry.args) === JSON.stringify(wanted.args);
+async function applyChannel(io, origin, wanted, before, progress) {
+    const entry = channelEntry(io, origin);
+    const now = await channelFromFile(io);
+    const remove = () => io.run('claude', ['mcp', 'remove', '--scope', 'user', CHANNEL], MCP_TIMEOUT_MS);
+    if (!wanted) {
+        if (!before?.channel || now === null)
+            return { step: null, registered: false };
+        progress('Removing the permission channel from Claude Code (this can take a minute)…\n');
+        const removed = await remove();
+        return removed.code === 0
+            ? {
+                step: { ok: true, text: `Took out the permission channel (${CHANNEL}).` },
+                registered: false,
+            }
+            : {
+                step: {
+                    ok: false,
+                    text: `Couldn’t take out the permission channel. Run: claude mcp remove --scope user ${CHANNEL}`,
+                },
+                registered: true,
+            };
+    }
+    if (now !== null && now !== 'unknown' && sameEntry(now, entry))
+        return {
+            step: { ok: true, text: 'The permission channel was already registered.' },
+            registered: true,
+        };
+    const json = JSON.stringify(entry);
+    const add = `claude mcp add-json --scope user ${CHANNEL} ${quote(json)}`;
+    if (now !== null && now !== 'unknown') {
+        progress('Updating the permission channel in Claude Code (this can take a minute)…\n');
+        if ((await remove()).code !== 0)
+            return {
+                step: {
+                    ok: false,
+                    text: `Couldn’t update the permission channel. Run:\n  claude mcp remove --scope user ${CHANNEL}\n    ${add}`,
+                },
+                registered: false,
+            };
+    }
+    else
+        progress('Adding the permission channel to Claude Code (this can take a minute)…\n');
+    const added = await io.run('claude', ['mcp', 'add-json', '--scope', 'user', CHANNEL, json], MCP_TIMEOUT_MS);
+    if (added.code !== 0)
+        return {
+            step: { ok: false, text: `Claude Code didn’t add the permission channel. Run: ${add}` },
+            registered: false,
+        };
+    return {
+        step: {
+            ok: true,
+            text: `Added the permission channel (${CHANNEL}): start Claude Code with npx pendingyou claude and a prompt’s card has Allow and Deny. The first answer wins, there or in the terminal.`,
+        },
+        registered: true,
+    };
+}
+export async function claudeWithChannel(io, args) {
+    if (!io.handOver)
+        throw new PlainError('This can’t start Claude Code here.');
+    if ((await channelFromFile(io)) === null)
+        io.err('pendingyou: the permission channel isn’t set up, so Claude Code’s prompts get no Allow or Deny on their cards. Run: npx pendingyou@latest init\n');
+    const code = await io.handOver('claude', [
+        '--dangerously-load-development-channels',
+        `server:${CHANNEL}`,
+        ...args,
+    ]);
+    if (code === 127)
+        io.err('pendingyou: Claude Code isn’t installed here (no claude on PATH).\n');
+    return code;
+}
 async function applyMcp(io, origin, plan, helper, progress) {
     const url = `${origin}/mcp`;
     const add = helper
@@ -363,6 +463,10 @@ export async function installClaude(io, origin, options) {
                 ? `${merged.permissionChanged ? 'Took out the permission-prompt hooks' : 'Left out the permission-prompt hooks'}, as you asked: no card when Claude Code waits for your OK. To turn them on: npx pendingyou init --permission-cards${flag}`
                 : `${merged.permissionChanged ? 'Took out' : 'Left out'} the permission-prompt hooks: ${blocker}.`,
     });
+    const found = claudeVersion(options.version);
+    const channel = await applyChannel(io, origin, Boolean(permissionLines) && found !== null && atLeast(found, CHANNEL_CLAUDE), before, options.progress);
+    if (channel.step)
+        report(channel.step);
     const mod = await addMod(io, merged.settings, options.copy, options.version);
     if (mod.step)
         report(mod.step);
@@ -387,6 +491,7 @@ export async function installClaude(io, origin, options) {
         ...(options.plugin ? { plugin: true } : {}),
         permissionHooks: permissionLines,
         permissionCards: wanted,
+        ...(channel.registered ? { channel: true } : {}),
     };
     await writeWhole(manifestPath(io), `${JSON.stringify(manifest, null, 2)}\n`, { secret: true });
     return steps;
@@ -458,6 +563,16 @@ export async function uninstallClaude(io) {
     const skill = await removeSkill(manifest?.skill ?? null);
     if (skill)
         steps.push(skill);
+    if (manifest?.channel && (await channelFromFile(io)) !== null) {
+        io.out('Removing the permission channel from Claude Code (this can take a minute)…\n');
+        const result = await io.run('claude', ['mcp', 'remove', '--scope', 'user', CHANNEL], MCP_TIMEOUT_MS);
+        steps.push(result.code === 0
+            ? { ok: true, text: `Removed the permission channel (${CHANNEL}) from Claude Code.` }
+            : {
+                ok: false,
+                text: `Couldn’t remove the permission channel. Run: claude mcp remove --scope user ${CHANNEL}`,
+            });
+    }
     if (manifest?.mcpAdded) {
         io.out('Removing the pendingyou MCP server from Claude Code (this can take a minute)…\n');
         const result = await io.run('claude', ['mcp', 'remove', '--scope', 'user', MCP_NAME], MCP_TIMEOUT_MS);
@@ -523,6 +638,7 @@ export async function claudeState(io) {
         permission,
         notify,
         presence: Boolean(ours('SessionEnd')),
+        channel: await channelFromFile(io).then((entry) => entry === 'unknown' ? 'unknown' : entry !== null),
         form: form ? { ...form, runs: await hookRuns(form), shim } : null,
         mod,
         plugins,

package/dist/codex-answers.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { configDir, readJson } from "./files.js";
+import { HOOK_TIMEOUT } from "./hooks.js";
+export const ANSWER_WAIT_MAX = 10;
+export const ANSWER_MARGIN_S = 30;
+export const ANSWER_DEADLINE_MARGIN_MS = 20_000;
+export const codexManifestPath = (io) => join(configDir(io), 'codex.json');
+export const isAnswerWait = (value) => typeof value === 'number' && Number.isInteger(value) && value >= 0 && value <= ANSWER_WAIT_MAX;
+export async function readAnswerWait(io) {
+    const manifest = await readJson(codexManifestPath(io)).catch(() => null);
+    const wait = manifest?.answerWait;
+    return isAnswerWait(wait) ? wait : 0;
+}
+export const permissionTimeout = (wait) => wait > 0 ? wait * 60 + ANSWER_MARGIN_S : HOOK_TIMEOUT;
+export const minutes = (wait) => `${wait} minute${wait === 1 ? '' : 's'}`;

package/dist/io.js

@@ -68,6 +68,29 @@ export function execProgram(command, args, options) {
         child.stdin?.end(options.stdin);
     });
 }
+let handedTo = null;
+function handOver(command, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, [...args], { stdio: 'inherit' });
+        }
+        catch {
+            resolve(127);
+            return;
+        }
+        handedTo = (signal) => {
+            if (signal !== 'SIGINT')
+                child.kill(signal);
+        };
+        const done = (code) => {
+            handedTo = null;
+            resolve(code);
+        };
+        child.on('error', (error) => done(error.code === 'ENOENT' ? 127 : 1));
+        child.on('exit', (code, signal) => done(code ?? (signal === 'SIGINT' ? 130 : signal === 'SIGTERM' ? 143 : 1)));
+    });
+}
 export function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal?.aborted || ms <= 0) {
@@ -232,6 +255,8 @@ export function realIo() {
     const controller = new AbortController();
     for (const name of ['SIGINT', 'SIGTERM', 'SIGHUP'])
         process.on(name, () => {
+            if (handedTo)
+                return handedTo(name);
             if (controller.signal.aborted)
                 process.exit(130);
             controller.abort();
@@ -250,6 +275,7 @@ export function realIo() {
         ask,
         run: runProgram,
         exec: execProgram,
+        handOver,
         openBrowser,
         readStdin,
         lines: () => lines(controller.signal, () => controller.abort()),

package/dist/main.js

@@ -1,9 +1,13 @@
 import { HOOK_DEADLINE_MS, refreshInBackground, SignInNeeded, Unavailable } from "./api.js";
+import { setAnswerWait } from "./apps/codex.js";
 import { listen, listenHanded, posted } from "./apps/codex-wake.js";
 import { DEFAULT_APP } from "./apps/ids.js";
 import { appModule } from "./apps/registry.js";
 import { commandOf, HOOK_COMMANDS, parseArgs, USAGE, UsageError } from "./args.js";
 import { bridge } from "./bridge.js";
+import { channel } from "./channel.js";
+import { claudeWithChannel } from "./claude.js";
+import { ANSWER_DEADLINE_MARGIN_MS, readAnswerWait } from "./codex-answers.js";
 import { PlainError } from "./errors.js";
 import { hold } from "./hold.js";
 import { init, status, uninstall } from "./init.js";
@@ -83,6 +87,8 @@ async function run(io, command, hook = { fallback: '' }) {
             return uninstall(io, command);
         case 'watch':
             return watch(io, command);
+        case 'codex-answers':
+            return setAnswerWait(io, command);
         case 'refresh':
             try {
                 await refreshInBackground(io, command.origin, command.force, command.app ?? DEFAULT_APP);
@@ -93,6 +99,10 @@ async function run(io, command, hook = { fallback: '' }) {
             return mcpHeaders(io, command);
         case 'mcp':
             return bridge(io, command);
+        case 'channel':
+            return channel(io, command);
+        case 'claude':
+            return claudeWithChannel(io, command.args);
         case 'herdr':
             return (await import("./herdr/command.js")).herdr(io, command);
         case 'machine':
@@ -102,6 +112,12 @@ async function run(io, command, hook = { fallback: '' }) {
     }
 }
 export { HOOK_DEADLINE_MS };
+async function deadlineOf(io, command) {
+    if (command.name !== 'permission' || command.app !== 'codex')
+        return HOOK_DEADLINE_MS;
+    const wait = await readAnswerWait(io).catch(() => 0);
+    return wait > 0 ? wait * 60_000 + ANSWER_DEADLINE_MARGIN_MS : HOOK_DEADLINE_MS;
+}
 async function runHook(io, command) {
     const hook = { fallback: '' };
     const controller = new AbortController();
@@ -121,9 +137,10 @@ async function runHook(io, command) {
         },
         signal: controller.signal,
     };
+    const limit = await deadlineOf(io, command);
     let timer;
     const deadline = new Promise((resolve) => {
-        timer = setTimeout(() => resolve('deadline'), Math.max(0, HOOK_DEADLINE_MS - io.uptime()));
+        timer = setTimeout(() => resolve('deadline'), Math.max(0, limit - io.uptime()));
     });
     try {
         const outcome = await Promise.race([run(hookIo, command, hook), deadline]);