pendingyou 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 0.2.1
+
+- Fixed: after `init --origin <url>` (any origin but the default), every Claude Code message was blocked with
+  `UserPromptSubmit operation blocked by hook: … There's no "--origin" command.` 0.2.0 wrote its hooks with `--origin`
+  before the command, which it couldn't read. To repair: `npx pendingyou@latest init --origin <url>` (or, if you ran
+  `uninstall` to get unblocked, the same command sets it up again).
+- Hooks now name the command first (`pendingyou@0.2.1 handoff --origin <url>`), add `--origin` only when it isn't the
+  default, and end in `|| true`.
+- Options can come before or after the command.
+- `pickup` and `handoff` never block: on any error (bad options, no network, not signed in) they exit 0, print nothing
+  for Claude Code, and leave at most a short note on stderr.
+- Running `init` again repairs hook lines an older version wrote.
+
+## 0.2.0
+
+- `login --device` for computers with no browser, and `watch` for always-on scripts.

package/README.md

@@ -19,6 +19,12 @@ Run it once on each computer. It:
 
 Your other settings are kept as they are. `npx pendingyou uninstall` removes exactly what `init` added.
 
+The hooks never get in your way: if anything goes wrong (no network, not signed in, a bad option), they print nothing
+and let your message through. Running `init` again updates them in place.
+
+**On 0.2.0 with another origin?** Its hooks blocked every message (`There's no "--origin" command`). Run
+`npx pendingyou@latest init --origin <url>` again to repair them; see [CHANGELOG.md](CHANGELOG.md).
+
 ## How Claude Code uses it
 
 After it posts a question to Pending You, Claude Code runs this in the background and keeps working:
@@ -71,7 +77,8 @@ more, then skipped. `--once` stops after the first.
 | `pickup` / `handoff` | The session-start and next-message hooks |
 | `uninstall` | Remove what `init` added, and sign out |
 
-Every command takes `--origin` (default `https://www.pendingyou.com`, or `$PENDINGYOU_ORIGIN`).
+Every command takes `--origin` (default `https://www.pendingyou.com`, or `$PENDINGYOU_ORIGIN`). Options can come
+before or after the command.
 
 ## What it can see, and where it keeps things
 

package/dist/args.js

@@ -1,5 +1,6 @@
-// The command line's arguments: one command, then its flags. No dependencies, no surprises: an unknown flag or a
-// stray argument is an error, never ignored.
+// The command line's arguments: one command and its flags, which may come before or after it (`pendingyou handoff
+// --origin <url>` and `pendingyou --origin <url> handoff` are the same; 0.2.0 wrote its hooks the second way). No
+// dependencies, no surprises: an unknown flag or a stray argument is an error, never ignored.
 export const DEFAULT_ORIGIN = 'https://www.pendingyou.com';
 /** How long `hold` waits for an answer before it lets go (4 hours). */
 export const DEFAULT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
@@ -62,14 +63,43 @@ const FLAGS = {
     uninstall: { origin: true },
     watch: { origin: true, once: false },
 };
+/** Options that take a value, whichever command they belong to: needed to find the command behind them. */
+const VALUE_OPTIONS = new Set(['origin', 'timeout']);
+/** Splits off the options given before the command: [those options, the command, everything after it]. */
+function splitCommand(argv) {
+    let index = 0;
+    while (index < argv.length) {
+        const arg = argv[index];
+        if (arg === '--' || !arg.startsWith('-'))
+            break;
+        index += arg.startsWith('--') && !arg.includes('=') && VALUE_OPTIONS.has(arg.slice(2)) ? 2 : 1;
+    }
+    return [argv.slice(0, index), argv[index], argv.slice(index + 1)];
+}
+/** The command the arguments name, wherever its options are; undefined when there isn't one. */
+export function commandOf(argv) {
+    return splitCommand(argv)[1];
+}
+/** The commands Claude Code's hooks run. Whatever goes wrong, they exit 0 and never block the person. */
+export const HOOK_COMMANDS = new Set(['pickup', 'handoff']);
 export function parseArgs(argv, env = {}) {
-    const [first, ...rest] = argv;
-    if (first === undefined || first === '-h' || first === '--help')
+    const [leading, first, after] = splitCommand(argv);
+    const helps = (arg) => arg === '-h' || arg === '--help';
+    const versions = (arg) => arg === '-v' || arg === '--version';
+    if (leading.some(helps))
         return { name: 'help' };
-    if (first === '-v' || first === '--version')
+    if (first === undefined) {
+        if (leading.some(versions))
+            return { name: 'version' };
+        if (leading.length === 0)
+            return { name: 'help' };
+        throw new UsageError('Which command? Like: pendingyou status');
+    }
+    if (leading.some(versions))
         return { name: 'version' };
     if (!COMMANDS.has(first))
         throw new UsageError(`There’s no “${first}” command.`);
+    const rest = [...leading, ...after];
     const allowed = FLAGS[first] ?? {};
     const flags = new Map();
     const positional = [];

package/dist/claude.js

@@ -31,16 +31,24 @@ const quote = (text) => /^[\w@%+=:,./-]+$/.test(text) ? text : `'${text.replaceA
  * How a hook runs this command line: through npx when that's how it was started (pinned to this version, from npx's
  * cache), the installed `pendingyou` when it's installed, or this very file.
  */
-export function selfCommand(io, origin) {
+export function selfCommand(io) {
     const script = io.script.replaceAll('\\', '/');
-    const base = io.env.PENDINGYOU_SELF
+    return io.env.PENDINGYOU_SELF
         ? io.env.PENDINGYOU_SELF
         : !script || script.includes('/_npx/')
             ? `npx -y --prefer-offline pendingyou@${VERSION}`
             : script.includes('/node_modules/pendingyou/')
                 ? 'pendingyou'
                 : `node ${quote(io.script)}`;
-    return origin === DEFAULT_ORIGIN ? base : `${base} --origin ${quote(origin)}`;
+}
+/**
+ * A hook's command line: the command first, then `--origin` only when it isn't the default. `|| true` keeps the hook
+ * from ever blocking the person, even when npx can't fetch the package or the command fails before it starts (Claude
+ * Code blocks a message when its UserPromptSubmit hook exits 2, and flags any other non-zero exit).
+ */
+export function hookCommand(io, origin, sub) {
+    const flag = origin === DEFAULT_ORIGIN ? '' : ` --origin ${quote(origin)}`;
+    return `${selfCommand(io)} ${sub}${flag} || true`;
 }
 /** Whether a hook command is one of ours: it runs pendingyou's `pickup` or `handoff`. */
 export function isOurHook(command, sub) {
@@ -71,7 +79,10 @@ const objectAt = (parent, key) => {
         ? value
         : null;
 };
-/** Adds (or updates) our hooks and permissions. Returns the permissions it added. */
+/**
+ * Adds our hooks and permissions, or updates our hooks in place (a new version, or a line an older version wrote, like
+ * 0.2.0's `… --origin <url> handoff`, which 0.2.0 itself can't read). Returns the permissions it added.
+ */
 export function mergeSettings(settings, commands) {
     const next = structuredClone(settings);
     let changed = false;
@@ -80,7 +91,7 @@ export function mergeSettings(settings, commands) {
         throw new PlainError('Claude Code’s settings have a “hooks” that isn’t an object, so I left them alone.');
     for (const event of Object.keys(HOOKS)) {
         const sub = HOOKS[event];
-        const wanted = `${commands[event]} ${sub}`;
+        const wanted = commands[event];
         const groups = Array.isArray(hooks[event]) ? hooks[event] : [];
         if (hooks[event] !== undefined && !Array.isArray(hooks[event]))
             throw new PlainError(`Claude Code’s ${event} hooks aren’t a list, so I left them alone.`);
@@ -231,15 +242,17 @@ export async function installClaude(io, origin) {
     steps.push(mcp.step);
     const skill = await saveSkill(io, origin, before?.skill ?? null);
     steps.push(skill.step);
-    const self = selfCommand(io, origin);
-    const commands = { SessionStart: self, UserPromptSubmit: self };
+    const commands = {
+        SessionStart: hookCommand(io, origin, HOOKS.SessionStart),
+        UserPromptSubmit: hookCommand(io, origin, HOOKS.UserPromptSubmit),
+    };
     const merged = mergeSettings(await readSettings(io), commands);
     if (merged.changed)
         await writeSettings(io, merged.settings);
     steps.push({
         ok: true,
         text: merged.changed
-            ? `Installed the session-start pickup and next-message hand-off hooks in ${settingsPath(io)}.`
+            ? `Installed or updated the session-start pickup and next-message hand-off hooks in ${settingsPath(io)}.`
             : 'The hooks were already installed.',
     });
     const manifest = {
@@ -248,10 +261,7 @@ export async function installClaude(io, origin) {
         claudeDir: claudeDir(io),
         mcpAdded: mcp.added || (before?.mcpAdded ?? false),
         skill: skill.skill,
-        hooks: {
-            SessionStart: `${self} ${HOOKS.SessionStart}`,
-            UserPromptSubmit: `${self} ${HOOKS.UserPromptSubmit}`,
-        },
+        hooks: commands,
         permissions: [...new Set([...(before?.permissions ?? []), ...merged.permissionsAdded])],
     };
     await writeWhole(manifestPath(io), `${JSON.stringify(manifest, null, 2)}\n`, { secret: true });

package/dist/cli.js

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
 // `npx pendingyou …`: runs the command line with the real computer (realIo) and exits with its code.
 import { realIo } from "./io.js";
-import { main } from "./main.js";
-main(process.argv.slice(2), realIo()).then((code) => process.exit(code), () => {
+import { isHook, main } from "./main.js";
+const argv = process.argv.slice(2);
+// A hook (pickup, handoff) exits 0 even here: it must never block the person's message.
+const failed = isHook(argv) ? 0 : 1;
+try {
+    main(argv, realIo()).then((code) => process.exit(code), () => {
+        process.stderr.write('pendingyou: Something went wrong.\n');
+        process.exit(failed);
+    });
+}
+catch {
     process.stderr.write('pendingyou: Something went wrong.\n');
-    process.exit(1);
-});
+    process.exit(failed);
+}

package/dist/main.js

@@ -1,7 +1,7 @@
 // The command line: parse the arguments, run the command, return the exit code. `cli.ts` runs it for real; tests run
 // it with their own Io.
 import { getJson, SignInNeeded, Unavailable } from "./api.js";
-import { parseArgs, USAGE, UsageError } from "./args.js";
+import { commandOf, HOOK_COMMANDS, parseArgs, USAGE, UsageError } from "./args.js";
 import { claudeState, installClaude, uninstallClaude } from "./claude.js";
 import { readCredential, signedInOrigins, updateCredential } from "./credentials.js";
 import { PlainError } from "./errors.js";
@@ -143,18 +143,33 @@ async function run(io, command) {
             return watch(io, command);
     }
 }
+/**
+ * Whether these arguments run a Claude Code hook (pickup or handoff). A hook must never get in the way of the person:
+ * Claude Code blocks their message when a UserPromptSubmit hook exits 2 and flags any other failure, so a hook exits 0
+ * whatever goes wrong, with at most a short note on stderr (which Claude Code doesn't add to the conversation).
+ */
+export const isHook = (argv) => HOOK_COMMANDS.has(commandOf(argv) ?? '');
 export async function main(argv, io) {
+    const hook = isHook(argv);
     let command;
     try {
         command = parseArgs(argv, io.env);
     }
     catch (error) {
+        if (hook) {
+            const message = error instanceof UsageError ? error.message : 'Something went wrong.';
+            io.err(`pendingyou: ${message} Skipped this hook; run npx pendingyou@latest init to repair it.\n`);
+            return 0;
+        }
         if (error instanceof UsageError) {
             io.err(`${error.message}\n\n${USAGE}`);
             return 2;
         }
         throw error;
     }
+    // `pickup --help` and the like: nothing for Claude Code to add to the conversation.
+    if (hook && !HOOK_COMMANDS.has(command.name))
+        return 0;
     try {
         return await run(io, command);
     }
@@ -167,6 +182,6 @@ export async function main(argv, io) {
             ? error.message
             : 'Something went wrong.';
         io.err(`pendingyou: ${message}\n`);
-        return 1;
+        return hook ? 0 : 1;
     }
 }

package/dist/version.js

@@ -1,2 +1,2 @@
 // The command line's version, as published (package.json). A test keeps them the same.
-export const VERSION = '0.2.0';
+export const VERSION = '0.2.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pendingyou",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Pending You for Claude Code: hear your answers from Pending You in the background, and set Claude Code up in one command.",
   "license": "Apache-2.0",
   "homepage": "https://www.pendingyou.com",
@@ -11,6 +11,7 @@
   "files": [
     "dist",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "engines": {