pendingyou 0.9.0 → 0.10.0

package/dist/qr.js

@@ -0,0 +1,365 @@
+// A QR code for the device sign-in's link (0.10.0), so the person can scan it from the terminal with their phone
+// instead of typing the address: on a computer reached over SSH, that phone is where they approve the code. The
+// command line has no dependencies, so this is a small encoder of its own: byte mode, versions 1–9 (up to 180 bytes at
+// level M), every error correction level, and the standard's mask choice (lowest penalty). It follows Project Nayuki's
+// QR Code generator, as uqr does (the app's phone code, onboarding.tsx); apps/pendingyou/test/cli-qr.test.ts checks it
+// against uqr module for module.
+const LEVELS = {
+    L: { index: 0, format: 1 },
+    M: { index: 1, format: 0 },
+    Q: { index: 2, format: 3 },
+    H: { index: 3, format: 2 },
+};
+/** Byte mode's character count is 8 bits up to version 9; this encoder stops there. */
+const MAX_VERSION = 9;
+/** Error correction codewords per block, by level, then version (index 0 unused). */
+const ECC_PER_BLOCK = [
+    [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30],
+    [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22],
+    [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20],
+    [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24],
+];
+/** Error correction blocks, by level, then version (index 0 unused). */
+const BLOCKS = [
+    [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2],
+    [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5],
+    [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8],
+    [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8],
+];
+const bit = (value, index) => ((value >>> index) & 1) !== 0;
+/** Modules left for data and error correction once the function patterns are drawn. */
+function rawModules(version) {
+    let result = (16 * version + 128) * version + 64;
+    if (version >= 2) {
+        const align = Math.floor(version / 7) + 2;
+        result -= (25 * align - 10) * align - 55;
+        if (version >= 7)
+            result -= 36;
+    }
+    return result;
+}
+const dataCodewords = (version, level) => Math.floor(rawModules(version) / 8) -
+    (ECC_PER_BLOCK[level]?.[version] ?? 0) * (BLOCKS[level]?.[version] ?? 0);
+/** GF(256) multiplication, modulo x^8 + x^4 + x^3 + x^2 + 1. */
+function multiply(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) {
+        z = (z << 1) ^ ((z >>> 7) * 0x11d);
+        z ^= ((y >>> i) & 1) * x;
+    }
+    return z;
+}
+function divisor(degree) {
+    const result = new Array(degree).fill(0);
+    result[degree - 1] = 1;
+    let root = 1;
+    for (let i = 0; i < degree; i++) {
+        for (let j = 0; j < result.length; j++) {
+            result[j] = multiply(result[j], root);
+            if (j + 1 < result.length)
+                result[j] = result[j] ^ result[j + 1];
+        }
+        root = multiply(root, 2);
+    }
+    return result;
+}
+function remainder(data, by) {
+    const result = by.map(() => 0);
+    for (const byte of data) {
+        const factor = byte ^ result.shift();
+        result.push(0);
+        by.forEach((coefficient, index) => {
+            result[index] = result[index] ^ multiply(coefficient, factor);
+        });
+    }
+    return result;
+}
+/** The data codewords with each block's error correction, interleaved as the standard places them. */
+function interleave(data, version, level) {
+    const blocks = BLOCKS[level]?.[version];
+    const eccLength = ECC_PER_BLOCK[level]?.[version];
+    const raw = Math.floor(rawModules(version) / 8);
+    const short = blocks - (raw % blocks);
+    const shortLength = Math.floor(raw / blocks);
+    const by = divisor(eccLength);
+    const all = [];
+    for (let index = 0, at = 0; index < blocks; index++) {
+        const block = data.slice(at, at + shortLength - eccLength + (index < short ? 0 : 1));
+        at += block.length;
+        const ecc = remainder(block, by);
+        if (index < short)
+            block.push(0);
+        all.push([...block, ...ecc]);
+    }
+    const result = [];
+    for (let i = 0; i < (all[0]?.length ?? 0); i++)
+        all.forEach((block, j) => {
+            if (i !== shortLength - eccLength || j >= short)
+                result.push(block[i]);
+        });
+    return result;
+}
+class Grid {
+    version;
+    /** The level's format bits (L 1, M 0, Q 3, H 2). */
+    format;
+    size;
+    modules;
+    /** Function modules (finders, timing, alignment, format and version), which data and masks never touch. */
+    reserved;
+    constructor(version, format) {
+        this.version = version;
+        this.format = format;
+        this.size = version * 4 + 17;
+        this.modules = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+        this.reserved = Array.from({ length: this.size }, () => new Array(this.size).fill(false));
+    }
+    set(x, y, dark) {
+        ;
+        this.modules[y][x] = dark;
+        this.reserved[y][x] = true;
+    }
+    functionPatterns() {
+        for (let i = 0; i < this.size; i++) {
+            this.set(6, i, i % 2 === 0);
+            this.set(i, 6, i % 2 === 0);
+        }
+        for (const [x, y] of [
+            [3, 3],
+            [this.size - 4, 3],
+            [3, this.size - 4],
+        ])
+            for (let dy = -4; dy <= 4; dy++)
+                for (let dx = -4; dx <= 4; dx++) {
+                    const distance = Math.max(Math.abs(dx), Math.abs(dy));
+                    const [xx, yy] = [x + dx, y + dy];
+                    if (xx >= 0 && xx < this.size && yy >= 0 && yy < this.size)
+                        this.set(xx, yy, distance !== 2 && distance !== 4);
+                }
+        // Alignment patterns everywhere on the grid of positions but the three finder corners.
+        const positions = this.alignments();
+        const last = positions.length - 1;
+        for (const [i, a] of positions.entries())
+            for (const [j, b] of positions.entries()) {
+                if ((i === 0 && j === 0) || (i === 0 && j === last) || (i === last && j === 0))
+                    continue;
+                for (let dy = -2; dy <= 2; dy++)
+                    for (let dx = -2; dx <= 2; dx++)
+                        this.set(a + dx, b + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+            }
+        this.formatBits(0);
+        if (this.version >= 7) {
+            let rest = this.version;
+            for (let i = 0; i < 12; i++)
+                rest = (rest << 1) ^ ((rest >>> 11) * 0x1f25);
+            const bits = (this.version << 12) | rest;
+            for (let i = 0; i < 18; i++) {
+                const a = this.size - 11 + (i % 3);
+                const b = Math.floor(i / 3);
+                this.set(a, b, bit(bits, i));
+                this.set(b, a, bit(bits, i));
+            }
+        }
+    }
+    alignments() {
+        if (this.version === 1)
+            return [];
+        const count = Math.floor(this.version / 7) + 2;
+        const step = Math.ceil((this.version * 4 + 4) / (count * 2 - 2)) * 2;
+        const result = [6];
+        for (let at = this.size - 7; result.length < count; at -= step)
+            result.splice(1, 0, at);
+        return result;
+    }
+    formatBits(mask) {
+        const data = (this.format << 3) | mask;
+        let rest = data;
+        for (let i = 0; i < 10; i++)
+            rest = (rest << 1) ^ ((rest >>> 9) * 0x537);
+        const bits = ((data << 10) | rest) ^ 0x5412;
+        for (let i = 0; i <= 5; i++)
+            this.set(8, i, bit(bits, i));
+        this.set(8, 7, bit(bits, 6));
+        this.set(8, 8, bit(bits, 7));
+        this.set(7, 8, bit(bits, 8));
+        for (let i = 9; i < 15; i++)
+            this.set(14 - i, 8, bit(bits, i));
+        for (let i = 0; i < 8; i++)
+            this.set(this.size - 1 - i, 8, bit(bits, i));
+        for (let i = 8; i < 15; i++)
+            this.set(8, this.size - 15 + i, bit(bits, i));
+        this.set(8, this.size - 8, true);
+    }
+    codewords(data) {
+        let i = 0;
+        for (let right = this.size - 1; right >= 1; right -= 2) {
+            if (right === 6)
+                right = 5;
+            for (let vertical = 0; vertical < this.size; vertical++)
+                for (let j = 0; j < 2; j++) {
+                    const x = right - j;
+                    const upward = ((right + 1) & 2) === 0;
+                    const y = upward ? this.size - 1 - vertical : vertical;
+                    if (!this.reserved[y]?.[x] && i < data.length * 8) {
+                        ;
+                        this.modules[y][x] = bit(data[i >>> 3], 7 - (i & 7));
+                        i++;
+                    }
+                }
+        }
+    }
+    /** XORs the data modules with a mask pattern; applying it twice undoes it. */
+    mask(mask) {
+        for (let y = 0; y < this.size; y++)
+            for (let x = 0; x < this.size; x++) {
+                const flip = [
+                    (x + y) % 2 === 0,
+                    y % 2 === 0,
+                    x % 3 === 0,
+                    (x + y) % 3 === 0,
+                    (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0,
+                    ((x * y) % 2) + ((x * y) % 3) === 0,
+                    (((x * y) % 2) + ((x * y) % 3)) % 2 === 0,
+                    (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+                ][mask];
+                if (flip && !this.reserved[y]?.[x])
+                    this.modules[y][x] = !this.modules[y]?.[x];
+            }
+    }
+    /** The standard's penalty for the modules as they are: runs, boxes, finder look-alikes and imbalance. */
+    penalty() {
+        let result = 0;
+        const at = (x, y) => this.modules[y]?.[x];
+        for (const across of [true, false]) {
+            for (let line = 0; line < this.size; line++) {
+                let color = false;
+                let run = 0;
+                const history = [0, 0, 0, 0, 0, 0, 0];
+                for (let along = 0; along < this.size; along++) {
+                    const dark = across ? at(along, line) : at(line, along);
+                    if (dark === color) {
+                        run++;
+                        if (run === 5)
+                            result += 3;
+                        else if (run > 5)
+                            result++;
+                    }
+                    else {
+                        this.addHistory(run, history);
+                        if (!color)
+                            result += this.finderLike(history) * 40;
+                        color = dark;
+                        run = 1;
+                    }
+                }
+                if (color) {
+                    this.addHistory(run, history);
+                    run = 0;
+                }
+                this.addHistory(run + this.size, history);
+                result += this.finderLike(history) * 40;
+            }
+        }
+        for (let y = 0; y < this.size - 1; y++)
+            for (let x = 0; x < this.size - 1; x++) {
+                const color = at(x, y);
+                if (color === at(x + 1, y) && color === at(x, y + 1) && color === at(x + 1, y + 1))
+                    result += 3;
+            }
+        const dark = this.modules.reduce((sum, row) => sum + row.filter(Boolean).length, 0);
+        const total = this.size * this.size;
+        result += (Math.ceil(Math.abs(dark * 20 - total * 10) / total) - 1) * 10;
+        return result;
+    }
+    addHistory(run, history) {
+        history.pop();
+        history.unshift(history[0] === 0 ? run + this.size : run);
+    }
+    finderLike(history) {
+        const [a = 0, n = 0, c = 0, d = 0, e = 0, f = 0, g = 0] = history;
+        const core = n > 0 && c === n && d === n * 3 && e === n && f === n;
+        return (core && a >= n * 4 && g >= n ? 1 : 0) + (core && g >= n * 4 && a >= n ? 1 : 0);
+    }
+}
+/**
+ * `text` as a QR code in byte mode, the smallest version that holds it at level `ecc` (M unless asked), with the mask
+ * the standard's penalty prefers (or `mask`). Null when it's longer than version 9 holds.
+ */
+export function qrCode(text, options = {}) {
+    const bytes = [...new TextEncoder().encode(text)];
+    const { index: level, format } = LEVELS[options.ecc ?? 'M'];
+    let version = 1;
+    // Mode (4 bits), the count (8 bits), then the bytes.
+    const used = 4 + 8 + bytes.length * 8;
+    while (version <= MAX_VERSION && used > dataCodewords(version, level) * 8)
+        version++;
+    if (version > MAX_VERSION)
+        return null;
+    const capacity = dataCodewords(version, level) * 8;
+    const bits = [];
+    const append = (value, length) => {
+        for (let i = length - 1; i >= 0; i--)
+            bits.push((value >>> i) & 1);
+    };
+    append(0b0100, 4);
+    append(bytes.length, 8);
+    for (const byte of bytes)
+        append(byte, 8);
+    append(0, Math.min(4, capacity - bits.length));
+    append(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xec; bits.length < capacity; pad ^= 0xec ^ 0x11)
+        append(pad, 8);
+    const data = new Array(bits.length / 8).fill(0);
+    bits.forEach((value, i) => {
+        data[i >>> 3] = data[i >>> 3] | (value << (7 - (i & 7)));
+    });
+    const grid = new Grid(version, format);
+    grid.functionPatterns();
+    grid.codewords(interleave(data, version, level));
+    let mask = options.mask ?? -1;
+    if (mask < 0) {
+        let lowest = Number.POSITIVE_INFINITY;
+        for (let candidate = 0; candidate < 8; candidate++) {
+            grid.mask(candidate);
+            grid.formatBits(candidate);
+            const score = grid.penalty();
+            if (score < lowest) {
+                lowest = score;
+                mask = candidate;
+            }
+            grid.mask(candidate);
+        }
+    }
+    grid.mask(mask);
+    grid.formatBits(mask);
+    return { version, mask, modules: grid.modules.map((row) => [...row]) };
+}
+/** Dark on light whatever the terminal's colours: black text on a white background, then back to normal. */
+const ON = '\u001b[30;47m';
+const OFF = '\u001b[0m';
+/** Light modules around the code, so a camera finds its edges. */
+const QUIET = 2;
+/**
+ * The code as terminal lines: two rows of modules a line, drawn with half blocks, dark on light, with a quiet zone.
+ * Null when the text is too long for a code, or the terminal can't be trusted with colours (NO_COLOR, TERM=dumb).
+ */
+export function qrLines(text, env = {}) {
+    if (env.NO_COLOR || env.TERM === 'dumb')
+        return null;
+    const code = qrCode(text);
+    if (!code)
+        return null;
+    const size = code.modules.length + QUIET * 2;
+    const dark = (x, y) => code.modules[y - QUIET]?.[x - QUIET] === true;
+    const lines = [];
+    for (let y = 0; y < size; y += 2) {
+        let line = '';
+        for (let x = 0; x < size; x++) {
+            const top = dark(x, y);
+            const bottom = y + 1 < size && dark(x, y + 1);
+            line += top ? (bottom ? '█' : '▀') : bottom ? '▄' : ' ';
+        }
+        lines.push(`${ON}${line}${OFF}`);
+    }
+    return lines;
+}

package/dist/remote.js

@@ -0,0 +1,306 @@
+// Claude Code on a computer with no browser (0.10.0): a devbox or server reached over SSH, a container, a Raspberry
+// Pi. There `/mcp` → Authenticate sends the person's browser to a localhost on that computer, which it can't reach. So
+// `npx pendingyou init` signs the computer in once with a code the person approves on their phone, as a Claude Code
+// connection of its own ("Claude Code on devbox"; Pending You's worker/oauth/device.ts), and gives Claude Code's
+// pendingyou MCP server a headersHelper instead of OAuth: a small sh script at a stable path,
+// ~/.config/pendingyou/bin/pendingyou-mcp-headers, which Claude Code runs each time it connects (again on a 401 or 403;
+// 10 seconds to answer) and which prints {"Authorization":"Bearer <token>"} from that sign-in, and nothing else. The
+// hooks and the wake mod use the same sign-in, so one approval sets up all three.
+//
+// The script finds Node in this order: node on PATH; nvm's default ($NVM_DIR or ~/.nvm: alias/default, else the newest
+// installed); then the Node init ran with, recorded in ~/.config/pendingyou/node-path, while it's still there. Claude
+// Code may run without nvm on its PATH (a systemd service, a terminal that doesn't read ~/.profile, `ssh host claude`).
+// It runs the private copy init installed (install.ts), never npx, and its stdout is only ever that one JSON object.
+import { readFile, rm, rmdir, stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { helperToken, SignInNeeded, Unavailable } from "./api.js";
+import { cleanName, DEFAULT_ORIGIN } from "./args.js";
+import { readCredential } from "./credentials.js";
+import { configDir, writeWhole } from "./files.js";
+import { VERSION } from "./version.js";
+export const HELPER = 'pendingyou-mcp-headers';
+/** The script Claude Code runs: the same path whatever the version, so its MCP server never needs changing. */
+export const helperPath = (io) => join(configDir(io), 'bin', HELPER);
+/** Where init records the Node it ran with: the script's last way to find one. */
+export const nodePathFile = (io) => join(configDir(io), 'node-path');
+/** How long the helper waits for a refresh before it hands over the token it has (Claude Code allows 10 s). */
+export const HELPER_WAIT_MS = 7000;
+/** The PATH a check runs the helper with: as bare as a systemd service's, so it proves Node is found without PATH. */
+export const BARE_PATH = '/usr/bin:/bin';
+/**
+ * Why this computer counts as having no browser here, or null when it doesn't: a session over SSH, or Linux with no
+ * display. `init --device` and `--browser` override it.
+ */
+export function headlessReason(io) {
+    if (io.env.SSH_CONNECTION || io.env.SSH_TTY)
+        return 'an SSH session';
+    if (io.platform === 'linux' && !io.env.DISPLAY && !io.env.WAYLAND_DISPLAY)
+        return 'Linux with no display';
+    return null;
+}
+/**
+ * Whether init sets this computer up as one with no browser: `--device` (true) or `--browser` (false) when given;
+ * otherwise when it's set up that way already (`configured`: Claude Code's server signs in through the helper), so
+ * running init again keeps it, or when it looks like it has no browser. Never on Windows, where Claude Code runs a
+ * headersHelper with cmd, not sh: there `--device` signs the command line in by code, as before.
+ */
+export function isRemoteSetup(io, device, configured = false) {
+    if (io.platform === 'win32')
+        return false;
+    return device ?? (configured || headlessReason(io) !== null);
+}
+/** Whether a pendingyou MCP server signs in through our helper, for `origin`. */
+export function usesHelper(server, origin) {
+    if (!server || server === 'unknown' || !server.url || !isOurHelper(server.helper))
+        return false;
+    try {
+        return new URL(server.url).origin === origin;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The computer's name for its connection, from its hostname ("devbox.tail1234.ts.net" → "devbox"): the first label
+ * (unless it's an address), control characters out, spaces collapsed, at most 60 characters.
+ */
+export function machineOf(host) {
+    const name = /^\d+(\.\d+){3}$/.test(host.trim()) ? host.trim() : (host.split('.')[0] ?? '');
+    return cleanName(name);
+}
+/** How long Tailscale may take to say this computer's name before the hostname is used (it answers in milliseconds). */
+export const TAILSCALE_MS = 1200;
+/**
+ * Names nobody gave a computer: a cloud's own (AWS's ip-10-42-1-252 and ec2-54-…), or an address. One is still used when
+ * there's nothing better, and `login` says how to change it.
+ */
+export function isUnfriendly(name) {
+    return /^ip-\d+(-\d+){3}$/i.test(name) || /^ec2-/i.test(name) || /^\d+(\.\d+){3}$/.test(name);
+}
+/**
+ * Tailscale's name for this computer, when Tailscale is installed and answers within TAILSCALE_MS: its MagicDNS name's
+ * first label, as `tailscale status` shows it (it follows a rename in Tailscale's admin console), else the hostname it
+ * reports (`tailscale up --hostname`, or the computer's own). Null otherwise.
+ */
+export async function tailscaleName(io) {
+    const result = await io.run('tailscale', ['status', '--json'], TAILSCALE_MS);
+    if (result.code !== 0)
+        return null;
+    try {
+        const self = JSON.parse(result.stdout)
+            .Self;
+        const dns = typeof self?.DNSName === 'string' ? (self.DNSName.split('.')[0] ?? '') : '';
+        const host = typeof self?.HostName === 'string' ? machineOf(self.HostName) : '';
+        return cleanName(dns) || host || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The name a computer signs in with: `--name` when given; else Tailscale's name for it; else its hostname's first
+ * label. The phone's approval page and the Assistants page show it ("Claude Code on devbox").
+ */
+export async function computerName(io, given) {
+    if (given)
+        return { name: given, from: 'flag', unfriendly: false };
+    const tailscale = await tailscaleName(io);
+    if (tailscale)
+        return { name: tailscale, from: 'tailscale', unfriendly: isUnfriendly(tailscale) };
+    const host = machineOf(io.host);
+    return { name: host, from: 'hostname', unfriendly: isUnfriendly(host) };
+}
+/** One word for sh: as it is when it's plain, otherwise in single quotes. */
+const shWord = (text) => /^[\w@%+=:,./-]+$/.test(text) ? text : `'${text.replaceAll("'", `'\\''`)}'`;
+/** What Claude Code runs for the MCP server's headers: the script, and `--origin` when it isn't the default. */
+export function helperCommand(io, origin) {
+    return `${shWord(helperPath(io))}${origin === DEFAULT_ORIGIN ? '' : ` --origin ${shWord(origin)}`}`;
+}
+/** Whether a headersHelper command runs our script, from any folder. */
+export const isOurHelper = (command) => typeof command === 'string' && new RegExp(`(^|[\\\\/'"\\s])${HELPER}(['"]?)(\\s|$)`).test(command);
+/** The script, for this version's private copy (`cli`) and config folder. Plain POSIX sh: dash runs it on Ubuntu. */
+export function helperScript(cli, config) {
+    return `#!/bin/sh
+# Pending You's sign-in for Claude Code's pendingyou MCP server on this computer, which has no browser. Claude Code
+# runs it each time it connects (its headersHelper), and it prints {"Authorization":"Bearer <token>"} from this
+# computer's own sign-in, and nothing else. Written by npx pendingyou init (pendingyou ${VERSION}); run that again to
+# repair it. It runs pendingyou's own copy, never npx, with the first Node it finds: on PATH, nvm's default, or the
+# one init ran with.
+cli=${shWord(cli)}
+PENDINGYOU_CONFIG_DIR=${shWord(config)}
+export PENDINGYOU_CONFIG_DIR
+
+# The newest Node nvm installed whose version is $1 or starts with "$1." (any version when $1 is empty).
+newest() {
+  for dir in "$nvm/versions/node"/v*; do
+    [ -x "$dir/bin/node" ] || continue
+    version=\${dir##*/v}
+    if [ -n "$1" ]; then
+      case $version in "$1" | "$1".*) ;; *) continue ;; esac
+    fi
+    printf '%s\\n' "$version"
+  done | sort -t . -k 1,1n -k 2,2n -k 3,3n | tail -n 1
+}
+
+node=
+from=
+if found=$(command -v node 2>/dev/null) && [ -n "$found" ]; then
+  node=$found
+  from=PATH
+else
+  nvm=\${NVM_DIR:-$HOME/.nvm}
+  want=
+  [ -r "$nvm/alias/default" ] && want=$(sed -n 1p "$nvm/alias/default" | tr -d '[:space:]')
+  # An alias can name another (lts/* → lts/jod → v22.21.0).
+  hops=0
+  while [ -n "$want" ] && [ "$hops" -lt 3 ] && [ -r "$nvm/alias/$want" ]; do
+    want=$(sed -n 1p "$nvm/alias/$want" | tr -d '[:space:]')
+    hops=$((hops + 1))
+  done
+  case $want in
+    v[0-9]*) version=$(newest "\${want#v}") ;;
+    [0-9]*) version=$(newest "$want") ;;
+    *) version= ;;
+  esac
+  [ -n "$version" ] || version=$(newest '')
+  if [ -n "$version" ]; then
+    node=$nvm/versions/node/v$version/bin/node
+    from=nvm
+  else
+    recorded=
+    [ -r "$PENDINGYOU_CONFIG_DIR/node-path" ] && recorded=$(sed -n 1p "$PENDINGYOU_CONFIG_DIR/node-path")
+    if [ -n "$recorded" ] && [ -x "$recorded" ]; then
+      node=$recorded
+      from=recorded
+    fi
+  fi
+fi
+if [ -z "$node" ]; then
+  echo "pendingyou: no Node.js found (not on PATH, not in nvm, and not where init found it). Install Node, then run: npx pendingyou init" >&2
+  exit 1
+fi
+if [ ! -r "$cli" ]; then
+  echo "pendingyou: its copy of pendingyou is gone ($cli). Run: npx pendingyou init" >&2
+  exit 1
+fi
+PENDINGYOU_NODE_FROM=$from
+export PENDINGYOU_NODE_FROM
+exec "$node" "$cli" mcp-headers "$@"
+`;
+}
+/**
+ * Writes the helper for this version's private copy, and records the Node init runs with as its last resort. Throws
+ * when it can't write them.
+ */
+export async function writeHelper(io, installed) {
+    const path = helperPath(io);
+    const text = helperScript(installed.script, configDir(io));
+    const before = await readFile(path, 'utf8').catch(() => null);
+    const mode = await stat(path).then((info) => info.mode & 0o777, () => 0);
+    const recorded = await readFile(nodePathFile(io), 'utf8').catch(() => null);
+    if (recorded !== `${io.execPath}\n`)
+        await writeWhole(nodePathFile(io), `${io.execPath}\n`, { mode: 0o644 });
+    if (before === text && mode === 0o755)
+        return { path, changed: false };
+    await writeWhole(path, text, { mode: 0o755 });
+    return { path, changed: true };
+}
+/** Removes the helper and the Node it recorded (uninstall). True when there was a helper. */
+export async function removeHelper(io) {
+    const path = helperPath(io);
+    const there = await stat(path).then(() => true, () => false);
+    await rm(path, { force: true });
+    await rm(nodePathFile(io), { force: true });
+    await rmdir(dirname(path)).catch(() => { });
+    return there;
+}
+/**
+ * Runs the helper as Claude Code would at its barest (PATH /usr/bin:/bin, as a systemd service has it), in its check
+ * mode: it finds Node and runs pendingyou's copy, which says which Node it is, and nothing is signed in or printed.
+ */
+export async function checkHelper(io, origin) {
+    const path = helperPath(io);
+    const exists = await stat(path).then((info) => info.isFile(), () => false);
+    if (!exists)
+        return { ok: false, why: `${path} is gone` };
+    // Exactly as Claude Code runs it (sh -c with the command), with only HOME and a bare PATH.
+    const result = await io.run('/bin/sh', ['-c', `${helperCommand(io, origin)} --check`], 15_000, {
+        env: { HOME: io.home, PATH: BARE_PATH },
+    });
+    const line = result.stdout.trim().split('\n').at(-1) ?? '';
+    const found = /^node (.+) \(([\w-]+)\), pendingyou (\S+)$/.exec(line);
+    if (result.code !== 0 || !found)
+        return {
+            ok: false,
+            why: result.stderr
+                .trim()
+                .split('\n')
+                .at(-1)
+                ?.replace(/^pendingyou: /, '')
+                .replace(/\s*Run: npx pendingyou init\.?$/, '') || `it didn’t run (exit ${result.code})`,
+        };
+    return {
+        ok: true,
+        node: found[1],
+        from: found[2],
+        version: found[3],
+    };
+}
+/** How the helper found Node, in words. */
+export const foundBy = (from) => from === 'nvm'
+    ? 'nvm’s default'
+    : from === 'recorded'
+        ? 'the Node init ran with'
+        : from === 'PATH'
+            ? 'PATH'
+            : from;
+const originOf = (url) => {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * `pendingyou mcp-headers`: what the helper runs. Prints {"Authorization":"Bearer <token>"} to stdout and nothing else
+ * (Claude Code reads stdout as the headers), from this computer's Claude Code connection for `origin`, refreshed when
+ * it's due; every problem goes to stderr in one line, with a non-zero exit. It never hands a token to a server other
+ * than `origin`'s (CLAUDE_CODE_MCP_SERVER_URL, which Claude Code sets). `--check` says which Node runs it instead.
+ */
+export async function mcpHeaders(io, options) {
+    const login = options.origin === DEFAULT_ORIGIN
+        ? 'npx pendingyou login'
+        : `npx pendingyou login --origin ${options.origin}`;
+    if (options.check) {
+        io.out(`node ${io.execPath} (${io.env.PENDINGYOU_NODE_FROM || 'PATH'}), pendingyou ${VERSION}\n`);
+        return 0;
+    }
+    const server = io.env.CLAUDE_CODE_MCP_SERVER_URL;
+    if (server && originOf(server) !== options.origin) {
+        io.err(`pendingyou: this helper signs in to ${options.origin}, but Claude Code’s server is ${server}, so it gave no token. Run: npx pendingyou init --origin ${originOf(server) ?? server}\n`);
+        return 1;
+    }
+    const stored = await readCredential(io, options.origin);
+    if (!stored) {
+        io.err(`pendingyou: this computer isn’t signed in to Pending You (${options.origin}). Run: ${login}\n`);
+        return 1;
+    }
+    if (stored.kind !== 'connection') {
+        io.err(`pendingyou: this computer’s sign-in only hears answers, so Claude Code can’t use it. Run: ${login}\n`);
+        return 1;
+    }
+    try {
+        const token = await helperToken(io, options.origin, HELPER_WAIT_MS);
+        io.out(`${JSON.stringify({ Authorization: `Bearer ${token}` })}\n`);
+        return 0;
+    }
+    catch (error) {
+        io.err(error instanceof SignInNeeded
+            ? `pendingyou: this computer’s sign-in has ended. Run: ${login}\n`
+            : error instanceof Unavailable
+                ? `pendingyou: ${error.message} Try again in a minute.\n`
+                : 'pendingyou: something went wrong.\n');
+        return 1;
+    }
+}