pendingyou 0.16.0 → 0.18.0

package/dist/herdr.js

@@ -0,0 +1,243 @@
+import { createHash } from 'node:crypto';
+import { isAbsolute, join } from 'node:path';
+import { configDir, readJson, writeWhole } from "./files.js";
+import { cut, redactText } from "./redact.js";
+export const HERDR_SOURCE = 'pendingyou';
+export const HERDR_TIMEOUT_MS = 1000;
+export const TOKEN_TTL_MS = 15 * 60_000;
+export const HERDR_EVERY_MS = 5 * 60_000;
+export const VALUE_MAX = 80;
+export const WAITING_LABEL = 'waiting on you';
+export const TOKENS = {
+    app: 'py_app',
+    agent: 'py_agent',
+    waiting: 'py_waiting',
+    card: 'py_card',
+    cards: 'py_cards',
+    urgency: 'py_urgency',
+    asked: 'py_asked',
+};
+export const TOKEN_NAMES = Object.values(TOKENS);
+export const TOKEN_NAME = /^[A-Za-z0-9_-]{1,32}$/;
+export const PANE_ID = /^[A-Za-z0-9]{1,16}:[A-Za-z0-9]{1,16}$/;
+const REQUEST_ID = /^req_[A-Za-z0-9-]{1,40}$/;
+export const HERDR_AGENTS = {
+    'claude-code': 'claude',
+    codex: 'codex',
+    opencode: 'opencode',
+    pi: 'pi',
+};
+export const URGENCIES = ['now', 'today', 'whenever'];
+export const PRESSING = ['blocking', ...URGENCIES];
+export const isUrgency = (value) => typeof value === 'string' && URGENCIES.includes(value);
+export function herdrBin(env) {
+    const bin = env.HERDR_BIN_PATH ?? '';
+    if (env.HERDR_ENV !== '1' || !bin || !isAbsolute(bin) || /[\0\r\n]/.test(bin))
+        return null;
+    return bin;
+}
+export function herdrPane(env) {
+    const bin = herdrBin(env);
+    const pane = env.HERDR_PANE_ID ?? '';
+    if (!bin || !PANE_ID.test(pane))
+        return null;
+    return { bin, pane };
+}
+export function herdrServer(env, host) {
+    const socket = env.HERDR_SOCKET_PATH ?? '';
+    if (!socket || !isAbsolute(socket) || /[\0\r\n]/.test(socket))
+        return null;
+    return createHash('sha256').update(`${host}${socket}`).digest('hex').slice(0, 16);
+}
+export function herdrTerminal(env, host) {
+    const pane = herdrPane(env);
+    if (!pane)
+        return null;
+    const server = herdrServer(env, host);
+    return { app: 'herdr', paneId: pane.pane, ...(server ? { server } : {}) };
+}
+const settingsPath = (io) => join(configDir(io), 'herdr.json');
+export async function badgesOn(io) {
+    const settings = await readJson(settingsPath(io)).catch(() => null);
+    return settings?.badges !== false;
+}
+export async function setBadges(io, on) {
+    await writeWhole(settingsPath(io), `${JSON.stringify({ version: 1, badges: on }, null, 2)}\n`, {
+        secret: true,
+    });
+}
+export async function herdrTarget(io) {
+    const pane = herdrPane(io.env);
+    if (!pane)
+        return null;
+    return (await badgesOn(io).catch(() => true)) ? pane : null;
+}
+const oneLine = (text) => [...text]
+    .map((char) => (/[\p{Cc}\p{Cf}]/u.test(char) ? ' ' : char))
+    .join('')
+    .replace(/\s+/g, ' ')
+    .trim();
+export const cleanValue = (text, max = VALUE_MAX) => cut(oneLine(text), max);
+export const cardTitle = (title) => redactText(oneLine(title), VALUE_MAX);
+export function idsToken(ids) {
+    let out = '';
+    for (const id of ids) {
+        const next = out ? `${out},${id}` : id;
+        if (next.length > VALUE_MAX)
+            break;
+        out = next;
+    }
+    return out;
+}
+const rank = (card) => [
+    card.blocking ? 0 : 1,
+    card.urgency ? URGENCIES.indexOf(card.urgency) : 1,
+    card.at,
+];
+export function mostPressing(cards) {
+    return [...cards].sort((a, b) => {
+        const [x, y] = [rank(a), rank(b)];
+        for (let index = 0; index < x.length; index++)
+            if (x[index] !== y[index])
+                return x[index] - y[index];
+        return a.requestId < b.requestId ? -1 : a.requestId > b.requestId ? 1 : 0;
+    });
+}
+export function pressingOf(cards) {
+    if (cards.some((card) => card.blocking))
+        return 'blocking';
+    const given = cards.flatMap((card) => (card.urgency ? [URGENCIES.indexOf(card.urgency)] : []));
+    return given.length ? URGENCIES[Math.min(...given)] : null;
+}
+const seqOf = (at) => String(Math.max(0, Math.floor(Number.isFinite(at) ? at : 0)));
+export function reportArgs(pane, report) {
+    const set = [];
+    const clear = [];
+    const token = (name, value) => {
+        if (value === undefined || !TOKEN_NAME.test(name))
+            return;
+        if (value === null || value === '')
+            clear.push('--clear-token', name);
+        else
+            set.push('--token', `${name}=${value}`);
+    };
+    token(TOKENS.app, report.app);
+    if (report.agent !== undefined)
+        token(TOKENS.agent, report.agent === null ? null : cleanValue(report.agent));
+    const labels = [];
+    if (report.cards !== undefined) {
+        const valid = report.cards.filter((card) => REQUEST_ID.test(card.requestId));
+        const cards = mostPressing(valid);
+        const first = cards[0];
+        token(TOKENS.waiting, cards.length ? String(cards.length) : null);
+        token(TOKENS.card, first?.title ? cardTitle(first.title) : null);
+        token(TOKENS.cards, cards.length ? idsToken(cards.map((card) => card.requestId)) : null);
+        token(TOKENS.urgency, pressingOf(cards));
+        token(TOKENS.asked, idsToken(cards.filter((card) => card.askedFirst).map((c) => c.requestId)));
+        if (cards.length)
+            labels.push('--agent', HERDR_AGENTS[report.app], '--state-label', `idle=${WAITING_LABEL}`, '--state-label', `done=${WAITING_LABEL}`);
+        else
+            labels.push('--clear-state-labels');
+    }
+    return [
+        'pane',
+        'report-metadata',
+        pane,
+        '--source',
+        HERDR_SOURCE,
+        ...set,
+        ...clear,
+        ...labels,
+        '--ttl-ms',
+        String(TOKEN_TTL_MS),
+        '--seq',
+        seqOf(report.at),
+    ];
+}
+export function clearArgs(pane, at) {
+    return [
+        'pane',
+        'report-metadata',
+        pane,
+        '--source',
+        HERDR_SOURCE,
+        ...TOKEN_NAMES.flatMap((name) => ['--clear-token', name]),
+        '--clear-state-labels',
+        '--seq',
+        seqOf(at),
+    ];
+}
+export async function runHerdr(io, pane, args) {
+    try {
+        const result = await io.run(pane.bin, args, HERDR_TIMEOUT_MS);
+        if (result.code === 0)
+            return 'written';
+        if (result.code === 124)
+            return 'timeout';
+        if (result.code === 127)
+            return 'missing';
+        return 'refused';
+    }
+    catch {
+        return 'failed';
+    }
+}
+export async function writeHerdr(io, report, pane) {
+    const target = pane === undefined ? await herdrTarget(io) : pane;
+    if (!target)
+        return 'off';
+    return runHerdr(io, target, reportArgs(target.pane, report));
+}
+export async function clearHerdr(io, at, pane) {
+    const target = pane === undefined ? await herdrTarget(io) : pane;
+    if (!target)
+        return 'off';
+    return runHerdr(io, target, clearArgs(target.pane, at));
+}
+export function reportCommand(app, fields) {
+    return [
+        'herdr',
+        'report',
+        '--app',
+        app,
+        ...(fields.session ? ['--session', fields.session] : []),
+        ...(fields.transcript ? ['--transcript', fields.transcript] : []),
+        ...(fields.closed ? ['--state', 'closed'] : []),
+        '--at',
+        seqOf(fields.at),
+    ];
+}
+export function readPayload(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return null;
+    const given = parsed;
+    if (!Array.isArray(given.cards))
+        return null;
+    const cards = [];
+    for (const card of given.cards.slice(0, 50)) {
+        if (typeof card !== 'object' || card === null)
+            continue;
+        const each = card;
+        if (typeof each.requestId !== 'string' || !REQUEST_ID.test(each.requestId))
+            continue;
+        cards.push({
+            requestId: each.requestId,
+            ...(typeof each.title === 'string' && each.title.trim()
+                ? { title: each.title.slice(0, 1000) }
+                : {}),
+            ...(isUrgency(each.urgency) ? { urgency: each.urgency } : {}),
+            ...(each.blocking === true ? { blocking: true } : {}),
+            ...(each.askedFirst === true ? { askedFirst: true } : {}),
+            at: typeof each.at === 'number' && Number.isFinite(each.at) ? each.at : 0,
+        });
+    }
+    const name = typeof given.name === 'string' && given.name.trim() ? given.name.trim() : null;
+    return { name, cards };
+}

package/dist/index.js

@@ -1,6 +1,7 @@
 export { getJson, SignInNeeded, Unavailable } from "./api.js";
 export { DEFAULT_ORIGIN, parseArgs } from "./args.js";
 export { readCredential, updateCredential } from "./credentials.js";
+export { attest, ensureMachine, machinePath, proveConnections, readMachine, thumbprintOf, } from "./machine.js";
 export { main } from "./main.js";
 export { CLIENT_NAME, deviceLink, discover, register, revoke, SCOPE, signIn, signInWithDevice, startDevice, waitForDevices, } from "./oauth.js";
 export { qrCode, qrLines } from "./qr.js";

package/dist/init.js

@@ -5,6 +5,7 @@ import { hookCommand } from "./claude.js";
 import { readCredential, saveConnectionClient } from "./credentials.js";
 import { hookLine, originArgs } from "./hooks.js";
 import { installCli, pruneCli, removeCli } from "./install.js";
+import { keyForSignIn, proveConnections } from "./machine.js";
 import { headlessReason, helperCommand, removeHelper, writeHelper } from "./remote.js";
 import { FINISH_SAY } from "./setup.js";
 import { removeShim, shimPath, writeShim } from "./shim.js";
@@ -145,12 +146,16 @@ export async function init(io, options) {
     if (options.login) {
         if (ctx.headless && !options.device)
             io.out(`No browser here (${ctx.headless}), so you approve with a code on your phone.\n`);
+        const key = await keyForSignIn(io);
         signed = await signInApps(io, going.map((each) => ({ app: each.app.id, kind: each.signIn })), {
             origin: options.origin,
             device: options.device,
             browser: options.browser,
             ...(options.machine ? { machine: options.machine } : {}),
+            key,
         });
+        if (key)
+            await proveConnections(io, options.origin, [...signed].flatMap(([app, how]) => (how === 'already' ? [app] : [])), key);
     }
     else
         io.out(going.length === 1

package/dist/io.js

@@ -155,6 +155,65 @@ async function openBrowser(url) {
     const result = await runProgram(command, args, 10_000);
     return result.code === 0;
 }
+function keys(signal) {
+    return {
+        [Symbol.asyncIterator]() {
+            const stdin = process.stdin;
+            const queue = [];
+            let waiting = null;
+            let done = false;
+            const raw = stdin.isTTY === true;
+            const onData = (chunk) => {
+                const resolve = waiting;
+                waiting = null;
+                if (resolve)
+                    resolve({ value: chunk, done: false });
+                else
+                    queue.push(chunk);
+            };
+            const end = () => {
+                if (done)
+                    return;
+                done = true;
+                stdin.off('data', onData);
+                stdin.off('end', end);
+                signal.removeEventListener('abort', end);
+                if (raw)
+                    stdin.setRawMode(false);
+                stdin.pause();
+                const resolve = waiting;
+                waiting = null;
+                resolve?.({ value: undefined, done: true });
+            };
+            if (raw)
+                stdin.setRawMode(true);
+            stdin.setEncoding('utf8');
+            stdin.on('data', onData);
+            stdin.on('end', end);
+            stdin.resume();
+            if (signal.aborted)
+                end();
+            else
+                signal.addEventListener('abort', end, { once: true });
+            return {
+                next: () => {
+                    const chunk = queue.shift();
+                    if (chunk !== undefined)
+                        return Promise.resolve({ value: chunk, done: false });
+                    if (done)
+                        return Promise.resolve({ value: undefined, done: true });
+                    return new Promise((resolve) => {
+                        waiting = resolve;
+                    });
+                },
+                return: () => {
+                    end();
+                    return Promise.resolve({ value: undefined, done: true });
+                },
+            };
+        },
+    };
+}
 function background(script, args) {
     if (!script)
         return;
@@ -202,5 +261,7 @@ export function realIo() {
         uptime: () => process.uptime() * 1000,
         background: (args) => background(process.argv[1] ?? '', args),
         ppid: process.ppid,
+        keys: () => keys(controller.signal),
+        columns: () => process.stdout.columns || 80,
     };
 }

package/dist/machine-command.js

@@ -0,0 +1,101 @@
+import { APP_NAMES } from "./apps/ids.js";
+import { readCredential, signedInSlots } from "./credentials.js";
+import { originArgs } from "./hooks.js";
+import { attest, clockOffset, machinePath, readMachine, rotateMachine } from "./machine.js";
+import { computerName } from "./remote.js";
+import { checkSignIn } from "./signin.js";
+export async function machineStatus(io, origin) {
+    const flag = originArgs(origin);
+    const machine = await readMachine(io);
+    if (!machine) {
+        io.out(`This computer has no key yet. npx -y pendingyou@latest init${flag} makes one, and proves it to Pending You.\n`);
+        return 1;
+    }
+    const lines = [
+        `This computer’s key: ${machinePath(io)} (made ${machine.createdAt.slice(0, 10)})`,
+        `Its fingerprint: ${machine.thumbprint}`,
+    ];
+    let ready = true;
+    const apps = [];
+    for (const slot of await signedInSlots(io))
+        if (slot.origin === origin &&
+            (await readCredential(io, origin, slot.app))?.kind === 'connection')
+            apps.push(slot.app);
+    lines.push(apps.length
+        ? `At ${origin}:`
+        : `No agent here is signed in to ${origin} with a connection of its own, so there’s nothing to prove there.`);
+    for (const app of apps) {
+        const check = await checkSignIn(io, origin, app);
+        const name = APP_NAMES[app];
+        if (check.state !== 'ok') {
+            ready = false;
+            lines.push(check.state === 'unreachable'
+                ? `  ${name}: Pending You couldn’t be reached.`
+                : `  ${name}: not signed in; run npx -y pendingyou@latest init${flag}.`);
+            continue;
+        }
+        const key = check.for?.machineKey;
+        if (key === machine.thumbprint) {
+            lines.push(`  ${name}: known by this key${check.for?.machine ? ` (as ${check.for.machine})` : ''}.`);
+            continue;
+        }
+        ready = false;
+        lines.push(key
+            ? `  ${name}: known by another key, this computer’s before it was replaced. Once that computer is removed from your Pending You account, npx -y pendingyou@latest init${flag} proves this one.`
+            : `  ${name}: not yet. npx -y pendingyou@latest init${flag} proves this key, with nothing to approve.`);
+    }
+    io.out(`${lines.join('\n')}\n`);
+    return ready ? 0 : 1;
+}
+export async function machineAttest(io, command) {
+    const machine = await readMachine(io);
+    if (!machine) {
+        io.err(`pendingyou: This computer has no key yet. Run npx -y pendingyou@latest init${originArgs(command.origin)} first.\n`);
+        return 1;
+    }
+    const name = command.machine ?? (await computerName(io)).name;
+    const offset = await clockOffset(io, command.origin);
+    const attestation = await attest(machine, {
+        aud: `${command.origin}/oauth/device`,
+        client_id: command.clientId,
+        name,
+        ...(command.cnf ? { cnf: { jkt: command.cnf } } : {}),
+    }, io.now() + offset);
+    io.out(`${attestation}\n`);
+    return 0;
+}
+export async function machineRotate(io, command) {
+    const flag = originArgs(command.origin);
+    const had = await readMachine(io).then((machine) => machine !== null, () => true);
+    if (had && !command.yes) {
+        if (!io.interactive) {
+            io.err('pendingyou: This replaces this computer’s key, and Pending You will know it as a new computer. Run it again with --yes to go ahead.\n');
+            return 1;
+        }
+        const answer = await io.ask('Replace this computer’s key? Pending You will know it as a new computer. [y/N] ');
+        if (!/^y(es)?$/i.test(answer.trim())) {
+            io.out('Kept this computer’s key.\n');
+            return 1;
+        }
+    }
+    const { before, machine } = await rotateMachine(io);
+    const lines = [
+        `New key for this computer: ${machinePath(io)}`,
+        `Its fingerprint: ${machine.thumbprint}${before ? ` (it was ${before})` : ''}`,
+        before
+            ? `Pending You knows this computer’s connections by the old key until that computer is removed from your account; then npx -y pendingyou@latest init${flag} proves this one for them.`
+            : `npx -y pendingyou@latest init${flag} proves it to Pending You.`,
+    ];
+    io.out(`${lines.join('\n')}\n`);
+    return 0;
+}
+export function machine(io, command) {
+    switch (command.sub) {
+        case 'status':
+            return machineStatus(io, command.origin);
+        case 'attest':
+            return machineAttest(io, command);
+        case 'rotate':
+            return machineRotate(io, command);
+    }
+}

package/dist/machine.js

@@ -0,0 +1,151 @@
+import { createHash, randomBytes, webcrypto } from 'node:crypto';
+import { chmod, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { sendJson } from "./api.js";
+import { connectionMachine, ignoreFolder, readCredential } from "./credentials.js";
+import { PlainError } from "./errors.js";
+import { configDir, readJson, withLock, writeWhole } from "./files.js";
+import { discover } from "./oauth.js";
+import { machineOf } from "./remote.js";
+export const ATTESTATION_TYPE = 'pendingyou-machine+jwt';
+const ATTESTATION_SECONDS = 300;
+export const MACHINE_PATH = '/mcp/cli/machine';
+export const machinePath = (io) => join(configDir(io), 'machine.json');
+const base64url = (bytes) => Buffer.from(bytes).toString('base64url');
+const isCoordinate = (value) => typeof value === 'string' &&
+    /^[A-Za-z0-9_-]{43}$/.test(value) &&
+    Buffer.from(value, 'base64url').length === 32;
+export function thumbprintOf(jwk) {
+    return createHash('sha256')
+        .update(JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y }))
+        .digest('base64url');
+}
+function keyOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const { kty, crv, x, y, d } = value;
+    if (kty !== 'EC' || crv !== 'P-256' || !isCoordinate(x) || !isCoordinate(y) || !isCoordinate(d))
+        return null;
+    return { kty, crv, x, y, d };
+}
+async function loaded(key, createdAt) {
+    const signer = await webcrypto.subtle.importKey('jwk', key, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
+    const jwk = { kty: key.kty, crv: key.crv, x: key.x, y: key.y };
+    return { thumbprint: thumbprintOf(jwk), createdAt, jwk, signer };
+}
+const unreadable = (path) => new PlainError(`This computer’s key (${path}) can’t be read. Run npx pendingyou machine rotate to make a new one.`);
+export async function readMachine(io) {
+    const path = machinePath(io);
+    let file;
+    try {
+        file = await readJson(path);
+    }
+    catch {
+        throw unreadable(path);
+    }
+    if (file === null)
+        return null;
+    const key = file?.version === 1 && typeof file.createdAt === 'string' ? keyOf(file.key) : null;
+    if (!key || typeof file?.createdAt !== 'string')
+        throw unreadable(path);
+    if ((await stat(path)).mode & 0o077)
+        await chmod(path, 0o600);
+    try {
+        return await loaded(key, file.createdAt);
+    }
+    catch {
+        throw unreadable(path);
+    }
+}
+async function writeNew(io) {
+    const pair = await webcrypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, [
+        'sign',
+        'verify',
+    ]);
+    const key = keyOf(await webcrypto.subtle.exportKey('jwk', pair.privateKey));
+    if (!key)
+        throw new PlainError('This computer’s key couldn’t be made.');
+    const createdAt = new Date(io.now()).toISOString();
+    const file = {
+        version: 1,
+        createdAt,
+        key: { kty: key.kty, crv: key.crv, x: key.x, y: key.y, d: key.d },
+    };
+    await writeWhole(machinePath(io), `${JSON.stringify(file, null, 2)}\n`, { secret: true });
+    await ignoreFolder(io).catch(() => { });
+    return loaded(key, createdAt);
+}
+export async function ensureMachine(io) {
+    return withLock(machinePath(io), io, async () => {
+        const machine = await readMachine(io);
+        return machine ? { machine, made: false } : { machine: await writeNew(io), made: true };
+    });
+}
+export async function rotateMachine(io) {
+    return withLock(machinePath(io), io, async () => {
+        const before = await readMachine(io).catch(() => null);
+        return { before: before?.thumbprint ?? null, machine: await writeNew(io) };
+    });
+}
+export async function attest(machine, claims, now) {
+    const iat = Math.floor(now / 1000);
+    const header = { typ: ATTESTATION_TYPE, alg: 'ES256', jwk: machine.jwk };
+    const payload = {
+        ...claims,
+        iat,
+        exp: iat + ATTESTATION_SECONDS,
+        jti: randomBytes(16).toString('base64url'),
+    };
+    const signing = `${base64url(JSON.stringify(header))}.${base64url(JSON.stringify(payload))}`;
+    const signature = await webcrypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, machine.signer, Buffer.from(signing));
+    return `${signing}.${base64url(new Uint8Array(signature))}`;
+}
+export async function keyForSignIn(io) {
+    try {
+        const { machine, made } = await ensureMachine(io);
+        if (made)
+            io.out(`Made this computer’s key for Pending You (${machinePath(io)}): it stays on this computer, and Pending You knows the computer by it.\n`);
+        return machine;
+    }
+    catch (error) {
+        io.err(`pendingyou: ${error instanceof PlainError ? error.message : 'This computer’s key couldn’t be made.'} Signing in without it.\n`);
+        return null;
+    }
+}
+export async function clockOffset(io, origin) {
+    return discover(io, origin, 5000).then((metadata) => metadata.clockOffsetMs ?? 0, () => 0);
+}
+export async function proveConnections(io, origin, apps, machine) {
+    const results = new Map();
+    const connected = [];
+    for (const app of apps) {
+        const credential = await readCredential(io, origin, app);
+        if (credential?.kind === 'connection')
+            connected.push({ app, clientId: credential.clientId });
+    }
+    if (connected.length === 0)
+        return results;
+    const offset = await clockOffset(io, origin);
+    for (const { app, clientId } of connected) {
+        try {
+            const attestation = await attest(machine, {
+                aud: `${origin}${MACHINE_PATH}`,
+                client_id: clientId,
+                name: (await connectionMachine(io, origin, app)) ?? machineOf(io.host),
+            }, io.now() + offset);
+            const { status, body } = await sendJson(io, origin, MACHINE_PATH, { attestation }, 15_000, { app });
+            const said = body.connection;
+            results.set(app, status === 200 && (said === 'joined' || said === 'already' || said === 'elsewhere')
+                ? said
+                : status === 404
+                    ? 'absent'
+                    : status >= 400 && status < 500
+                        ? 'refused'
+                        : 'failed');
+        }
+        catch {
+            results.set(app, 'failed');
+        }
+    }
+    return results;
+}

package/dist/main.js

@@ -5,8 +5,10 @@ import { appModule } from "./apps/registry.js";
 import { commandOf, HOOK_COMMANDS, parseArgs, USAGE, UsageError } from "./args.js";
 import { bridge } from "./bridge.js";
 import { PlainError } from "./errors.js";
+import { herdr } from "./herdr/command.js";
 import { hold } from "./hold.js";
 import { init, status, uninstall } from "./init.js";
+import { machine } from "./machine-command.js";
 import { OAuthError } from "./oauth.js";
 import { isPromptApp, permissionHook, permissionWorker } from "./permission.js";
 import { pickup } from "./pickup.js";
@@ -92,6 +94,10 @@ async function run(io, command, hook = { fallback: '' }) {
             return mcpHeaders(io, command);
         case 'mcp':
             return bridge(io, command);
+        case 'herdr':
+            return herdr(io, command);
+        case 'machine':
+            return machine(io, command);
     }
 }
 export const HOOK_DEADLINE_MS = 3000;

package/dist/oauth.js

@@ -14,6 +14,7 @@ export class OAuthError extends Error {
         this.code = code;
     }
 }
+export const serverNow = (io, metadata) => io.now() + (metadata.clockOffsetMs ?? 0);
 const base64url = (bytes) => bytes.toString('base64').replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
 export function pkce() {
     const verifier = base64url(randomBytes(32));
@@ -28,7 +29,11 @@ export async function discover(io, origin, timeoutMs = 15_000) {
     });
     if (!response.ok)
         throw new OAuthError('discovery', `Pending You at ${origin} didn’t answer (${response.status}).`);
-    const metadata = (await response.json());
+    const said = Date.parse(response.headers.get('date') ?? '');
+    const metadata = {
+        ...(await response.json()),
+        ...(io.now && Number.isFinite(said) ? { clockOffsetMs: said - io.now() } : {}),
+    };
     const sameOrigin = (url) => {
         try {
             return url !== undefined && new URL(url).origin === origin;
@@ -218,17 +223,23 @@ export async function revoke(io, origin, clientId, refreshToken) {
 export async function startDevice(io, options) {
     const metadata = await discover(io, options.origin);
     const assistant = options.assistant ?? (options.connection ? 'claude-code' : undefined);
-    const begin = (client) => io.fetch(`${options.origin}/oauth/device`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
-        body: new URLSearchParams({
-            client_id: client,
-            scope: SCOPE,
-            ...(options.machine ? { machine: options.machine } : {}),
-            ...(assistant ? { assistant } : {}),
-        }).toString(),
-        signal: AbortSignal.timeout(15_000),
-    });
+    const begin = async (client) => {
+        const attestation = options.attest
+            ? await options.attest(client, serverNow(io, metadata))
+            : null;
+        return io.fetch(`${options.origin}/oauth/device`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded', accept: 'application/json' },
+            body: new URLSearchParams({
+                client_id: client,
+                scope: SCOPE,
+                ...(options.machine ? { machine: options.machine } : {}),
+                ...(assistant ? { assistant } : {}),
+                ...(attestation ? { machine_attestation: attestation } : {}),
+            }).toString(),
+            signal: AbortSignal.timeout(15_000),
+        });
+    };
     let clientId = options.clientId || (await register(io, metadata));
     let started = await begin(clientId);
     if (started.status === 401 && options.clientId) {