pendingyou 0.16.0 → 0.18.0

package/dist/herdr/popup.js

@@ -0,0 +1,271 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { APP_NAMES } from "../apps/ids.js";
+import { configDir } from "../files.js";
+import { cleanValue } from "../herdr.js";
+import { headlessReason } from "../remote.js";
+import { readWaiting } from "./panes.js";
+import { HerdrError, herdrRequest } from "./socket.js";
+export const REFRESH_MS = 3000;
+export const DEMO = [
+    {
+        paneId: 'w1:p1',
+        workspaceId: 'w1',
+        tabId: 'w1:t1',
+        workspace: 'billing',
+        tab: 'webhooks',
+        app: 'claude-code',
+        agent: 'Wren',
+        herdrAgent: 'claude',
+        status: 'idle',
+        waiting: 2,
+        card: 'Deploy billing-webhooks to staging?',
+        cards: ['req_0f3a0000000000000001', 'req_9c1d0000000000000002'],
+        pressing: 'blocking',
+        asked: [],
+    },
+    {
+        paneId: 'w2:p3',
+        workspaceId: 'w2',
+        tabId: 'w2:t1',
+        workspace: 'infra',
+        tab: 'review',
+        app: 'codex',
+        agent: 'infra',
+        herdrAgent: 'codex',
+        status: 'done',
+        waiting: 1,
+        card: 'Which DNS host for the new domain?',
+        cards: ['req_77b20000000000000003'],
+        pressing: 'now',
+        asked: [],
+    },
+    {
+        paneId: 'w3:p1',
+        workspaceId: 'w3',
+        tabId: 'w3:t2',
+        workspace: 'docs',
+        tab: 'site',
+        app: 'opencode',
+        agent: 'Sam',
+        herdrAgent: 'opencode',
+        status: 'idle',
+        waiting: 1,
+        card: 'Publish the pricing page today?',
+        cards: ['req_5e4c0000000000000004'],
+        pressing: 'today',
+        asked: [],
+    },
+];
+export function popupKey(state, key) {
+    const count = state.panes.length;
+    const move = (by) => [
+        { ...state, selected: count ? (state.selected + by + count) % count : 0, note: '' },
+        { kind: 'none' },
+    ];
+    const chosen = state.panes[state.selected];
+    switch (key) {
+        case 'q':
+        case '\x1b':
+        case '\x03':
+        case '\x04':
+            return [state, { kind: 'close' }];
+        case 'j':
+        case '\x1b[B':
+        case '\x1bOB':
+            return move(1);
+        case 'k':
+        case '\x1b[A':
+        case '\x1bOA':
+            return move(-1);
+        case 'r':
+            return [state, { kind: 'refresh' }];
+        case 'a':
+            return [state, { kind: 'queue' }];
+        case '\r':
+        case '\n':
+        case 'o':
+            return chosen ? [state, { kind: 'open', pane: chosen }] : [state, { kind: 'queue' }];
+        case 't':
+            return chosen ? [state, { kind: 'focus', pane: chosen }] : [state, { kind: 'none' }];
+        default:
+            return [state, { kind: 'none' }];
+    }
+}
+export const hyperlink = (url) => `\x1b]8;;${url}\x1b\\${url}\x1b]8;;\x1b\\`;
+export const cardUrl = (origin, requestId) => `${origin}/app/r/${encodeURIComponent(requestId)}`;
+const appName = (app) => (app ? APP_NAMES[app] : 'an agent');
+export function popupLines(state, width) {
+    const room = Math.max(30, width - 2);
+    const fit = (text, max = room) => cleanValue(text, max);
+    const count = state.panes.length;
+    const heading = count
+        ? `Pending You · ${count === 1 ? '1 agent in Herdr is' : `${count} agents in Herdr are`} waiting on you${state.demo ? ' (demo)' : ''}`
+        : `Pending You${state.demo ? ' (demo)' : ''}`;
+    const lines = [`\x1b[1m${fit(heading)}\x1b[0m`, ''];
+    if (!count)
+        lines.push(fit('Nothing in Herdr is waiting on you.'), fit('Cards from your other assistants are in Pending You: press a to open it.'));
+    for (const [index, pane] of state.panes.entries()) {
+        const chosen = index === state.selected;
+        const tag = pane.pressing ?? '';
+        const title = fit(`⏳ ${pane.card ?? 'A card'}`, Math.max(10, room - tag.length - 3));
+        const gap = ' '.repeat(Math.max(1, room - 2 - [...title].length - tag.length));
+        const first = `${chosen ? '▸ ' : '  '}${title}${gap}${tag}`;
+        const where = [
+            pane.agent ? `${pane.agent} (${appName(pane.app)})` : appName(pane.app),
+            `${pane.workspace} › ${pane.tab}`,
+            pane.paneId,
+            ...(pane.waiting > 1 ? [`${pane.waiting} waiting`] : []),
+        ].join(' · ');
+        lines.push(chosen ? `\x1b[7m${first}\x1b[0m` : first, `    ${fit(where, room - 4)}`);
+    }
+    lines.push('', fit(`${count ? '↑↓ choose · enter open the card · t take me there · ' : ''}a all your cards · q close`));
+    if (state.note)
+        lines.push('', state.note);
+    return lines;
+}
+const frame = (lines) => `\x1b[?25l\x1b[2J\x1b[H${lines.join('\r\n')}`;
+export async function originFor(io, app, fallback) {
+    if (!app)
+        return fallback;
+    try {
+        const manifest = JSON.parse(await readFile(join(configDir(io), `${app}.json`), 'utf8'));
+        const origin = manifest?.origin;
+        return typeof origin === 'string' && /^https?:\/\/[^\s/]+$/.test(origin) ? origin : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+async function openPage(io, url, what) {
+    const opened = headlessReason(io) ? false : await io.openBrowser(url).catch(() => false);
+    return `${opened ? `Opened ${what} in your browser:` : `Open ${what}: Ctrl-click (or ⌘-click)`} ${hyperlink(url)}`;
+}
+export async function cardsPopup(io, place, options) {
+    const width = () => io.columns?.() ?? 80;
+    let state = { panes: [], selected: 0, note: '', demo: options.demo };
+    const load = async () => {
+        if (options.demo)
+            return [...DEMO];
+        if (!place.socket)
+            throw new HerdrError('unreachable', 'Run this from Herdr: no socket here.');
+        return (await readWaiting(place.socket)).waiting;
+    };
+    const refresh = async () => {
+        try {
+            const panes = await load();
+            const keep = state.panes[state.selected]?.paneId;
+            const at = panes.findIndex((pane) => pane.paneId === keep);
+            state = {
+                ...state,
+                panes,
+                selected: at >= 0 ? at : Math.max(0, Math.min(state.selected, panes.length - 1)),
+            };
+        }
+        catch (error) {
+            state = {
+                ...state,
+                note: error instanceof HerdrError ? error.message : 'Herdr isn’t answering.',
+            };
+        }
+    };
+    await refresh();
+    const draw = () => io.out(frame(popupLines(state, width())));
+    draw();
+    const act = async (action) => {
+        switch (action.kind) {
+            case 'close':
+                return true;
+            case 'refresh':
+                await refresh();
+                return false;
+            case 'queue': {
+                const origin = await originFor(io, state.panes[0]?.app ?? null, options.origin);
+                state = { ...state, note: await openPage(io, `${origin}/app`, 'your cards') };
+                return false;
+            }
+            case 'open': {
+                const requestId = action.pane.cards[0];
+                const origin = await originFor(io, action.pane.app, options.origin);
+                const url = requestId ? cardUrl(origin, requestId) : `${origin}/app`;
+                state = { ...state, note: await openPage(io, url, requestId ? 'the card' : 'your cards') };
+                return false;
+            }
+            case 'focus':
+                if (options.demo) {
+                    state = { ...state, note: `Demo: this would take you to ${action.pane.paneId}.` };
+                    return false;
+                }
+                try {
+                    await herdrRequest(place.socket ?? '', 'pane.focus', { pane_id: action.pane.paneId });
+                    return true;
+                }
+                catch (error) {
+                    state = {
+                        ...state,
+                        note: error instanceof HerdrError ? error.message : 'Herdr couldn’t go there.',
+                    };
+                    return false;
+                }
+            default:
+                return false;
+        }
+    };
+    const keys = io.keys?.()[Symbol.asyncIterator]();
+    if (!keys)
+        return 0;
+    let pending = keys.next();
+    try {
+        for (;;) {
+            const next = await Promise.race([
+                pending,
+                options.demo
+                    ? new Promise(() => { })
+                    : io.sleep(REFRESH_MS, io.signal).then(() => 'tick'),
+            ]);
+            if (io.signal.aborted)
+                return 0;
+            if (next === 'tick') {
+                await refresh();
+                draw();
+                continue;
+            }
+            if (next.done)
+                return 0;
+            pending = keys.next();
+            for (const key of splitKeys(next.value)) {
+                const [after, action] = popupKey(state, key);
+                state = after;
+                if (await act(action))
+                    return 0;
+            }
+            draw();
+        }
+    }
+    finally {
+        await keys.return?.();
+        io.out('\x1b[?25h');
+    }
+}
+const ESC = '\u001b';
+export function splitKeys(chunk) {
+    const keys = [];
+    let index = 0;
+    while (index < chunk.length) {
+        const kind = chunk[index + 1];
+        if (chunk[index] === ESC && (kind === '[' || kind === 'O')) {
+            let end = index + 2;
+            if (kind === '[')
+                while (end < chunk.length && /[0-9;]/.test(chunk[end]))
+                    end++;
+            if (end < chunk.length && /[A-Za-z~]/.test(chunk[end])) {
+                keys.push(chunk.slice(index, end + 1));
+                index = end + 1;
+                continue;
+            }
+        }
+        keys.push(chunk[index]);
+        index++;
+    }
+    return keys;
+}

package/dist/herdr/socket.js

@@ -0,0 +1,123 @@
+import { createConnection } from 'node:net';
+import { PlainError } from "../errors.js";
+export const REQUEST_MS = 5000;
+const BUFFER_MAX = 16 * 1024 * 1024;
+export class HerdrError extends PlainError {
+    name = 'HerdrError';
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+let sent = 0;
+const nextId = () => `pendingyou-${process.pid}-${++sent}`;
+function errorOf(message) {
+    const error = isObject(message.error) ? message.error : {};
+    return new HerdrError(typeof error.code === 'string' ? error.code : 'error', typeof error.message === 'string' ? error.message : 'Herdr refused it.');
+}
+export function herdrRequest(socketPath, method, params = {}, timeoutMs = REQUEST_MS) {
+    return new Promise((resolve, reject) => {
+        const id = nextId();
+        let buffer = '';
+        let settled = false;
+        const socket = createConnection(socketPath);
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const timer = setTimeout(() => finish(new HerdrError('timeout', `Herdr didn’t answer ${method} in time.`)), timeoutMs);
+        socket.setEncoding('utf8');
+        socket.on('connect', () => socket.write(`${JSON.stringify({ id, method, params })}\n`));
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            for (let end = buffer.indexOf('\n'); end !== -1; end = buffer.indexOf('\n')) {
+                const line = buffer.slice(0, end);
+                buffer = buffer.slice(end + 1);
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!isObject(message) || (message.id !== id && message.id !== ''))
+                    continue;
+                if (message.error !== undefined)
+                    return finish(errorOf(message));
+                return finish(null, message.result);
+            }
+            if (buffer.length > BUFFER_MAX)
+                finish(new HerdrError('too_large', 'Herdr’s answer was too big.'));
+        });
+        socket.on('error', (error) => finish(new HerdrError('unreachable', `Herdr isn’t reachable here (${error.code ?? 'error'}).`)));
+        socket.on('close', () => finish(new HerdrError('closed', 'Herdr closed the connection.')));
+    });
+}
+export function herdrSubscribe(socketPath, subscriptions, onEvent) {
+    const id = nextId();
+    const socket = createConnection(socketPath);
+    let buffer = '';
+    let ended = false;
+    let start = () => { };
+    let failStart = () => { };
+    const started = new Promise((resolve, reject) => {
+        start = resolve;
+        failStart = reject;
+    });
+    started.catch(() => { });
+    let finish = () => { };
+    const done = new Promise((resolve) => {
+        finish = resolve;
+    });
+    const end = (how) => {
+        if (ended)
+            return;
+        ended = true;
+        failStart(new HerdrError(how, 'The subscription ended before it started.'));
+        socket.destroy();
+        finish(how);
+    };
+    socket.setEncoding('utf8');
+    socket.on('connect', () => socket.write(`${JSON.stringify({ id, method: 'events.subscribe', params: { subscriptions } })}\n`));
+    socket.on('data', (chunk) => {
+        buffer += chunk;
+        for (let at = buffer.indexOf('\n'); at !== -1; at = buffer.indexOf('\n')) {
+            const line = buffer.slice(0, at);
+            buffer = buffer.slice(at + 1);
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isObject(message))
+                continue;
+            if (message.id === id || message.id === '') {
+                if (message.error !== undefined)
+                    return end(errorOf(message).code === 'events_lost' ? 'lost' : 'refused');
+                start();
+                continue;
+            }
+            if (typeof message.event === 'string' && isObject(message.data))
+                try {
+                    onEvent({ event: message.event, data: message.data });
+                }
+                catch { }
+        }
+        if (buffer.length > BUFFER_MAX)
+            end('lost');
+    });
+    socket.on('error', () => end('closed'));
+    socket.on('close', () => end('closed'));
+    return { started, done, stop: () => end('stopped') };
+}

package/dist/herdr/watch.js

@@ -0,0 +1,179 @@
+import { randomBytes } from 'node:crypto';
+import { mkdir, readFile, rm, stat, utimes, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { due, emptyNotices, look } from "./notice.js";
+import { readWaiting } from "./panes.js";
+import { agentView, pluginOff, viewOn } from "./plugin.js";
+import { HerdrError, herdrRequest, herdrSubscribe } from "./socket.js";
+export const LEASE_STALE_MS = 60_000;
+export const RENEW_MS = 20_000;
+const TICK_MS = 1000;
+const AGAIN_MS = 2000;
+export const SUBSCRIPTIONS = [
+    { type: 'pane.updated' },
+    { type: 'pane.closed' },
+    { type: 'pane.moved' },
+    { type: 'pane.focused' },
+    { type: 'tab.focused' },
+    { type: 'workspace.focused' },
+];
+const leasePath = (place) => join(place.stateDir, 'watch.lease');
+export async function watching(place) {
+    return stat(leasePath(place)).then((info) => Date.now() - info.mtimeMs < LEASE_STALE_MS, () => false);
+}
+async function takeLease(place) {
+    const path = leasePath(place);
+    await mkdir(place.stateDir, { recursive: true, mode: 0o700 });
+    if (await watching(place))
+        return null;
+    const id = randomBytes(8).toString('hex');
+    await rm(path, { force: true });
+    try {
+        await writeFile(path, JSON.stringify({ id, pid: process.pid }), { flag: 'wx', mode: 0o600 });
+        return id;
+    }
+    catch {
+        return null;
+    }
+}
+async function holder(place) {
+    try {
+        const held = JSON.parse(await readFile(leasePath(place), 'utf8'));
+        return typeof held.id === 'string' && typeof held.pid === 'number'
+            ? { id: held.id, pid: held.pid }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function renew(place, id) {
+    if ((await holder(place))?.id !== id)
+        return false;
+    const now = new Date();
+    await utimes(leasePath(place), now, now).catch(() => { });
+    return true;
+}
+export async function stopWatcher(place) {
+    const held = await holder(place);
+    await rm(leasePath(place), { force: true }).catch(() => { });
+    if (!held)
+        return false;
+    try {
+        process.kill(held.pid, 'SIGTERM');
+    }
+    catch { }
+    return true;
+}
+export async function pluginEnabled(socket, pluginId) {
+    try {
+        const result = await herdrRequest(socket, 'plugin.list', {
+            plugin_id: pluginId,
+        });
+        const plugins = Array.isArray(result?.plugins) ? result.plugins : [];
+        return plugins.some((plugin) => typeof plugin === 'object' &&
+            plugin !== null &&
+            plugin.plugin_id === pluginId &&
+            plugin.enabled === true);
+    }
+    catch (error) {
+        if (error instanceof HerdrError && error.code === 'plugin_not_found')
+            return false;
+        throw error;
+    }
+}
+export async function showToast(socket, toast) {
+    try {
+        const result = await herdrRequest(socket, 'notification.show', { title: toast.title, body: toast.body, sound: 'request' });
+        return result?.shown === true ? 'shown' : String(result?.reason ?? 'not shown');
+    }
+    catch (error) {
+        return error instanceof HerdrError ? error.code : 'failed';
+    }
+}
+export async function reapplyView(place) {
+    if (!place.socket || !(await viewOn(place)))
+        return;
+    await herdrRequest(place.socket, 'agent.view.set', agentView(place.id)).catch(() => { });
+}
+export async function watchStep(io, socket, state, options) {
+    let last = options.last;
+    let next = state;
+    if (options.read) {
+        const { snapshot, waiting } = await readWaiting(socket);
+        last = { waiting, viewing: snapshot.focusedTab };
+        next = look(next, last.waiting, io.now());
+    }
+    const decided = due(next, last.waiting, io.now(), last.viewing);
+    next = decided.state;
+    const toast = decided.toast ? await showToast(socket, decided.toast) : null;
+    return { state: next, last, toast };
+}
+export async function watch(io, place, options) {
+    if (!place.socket || (await pluginOff(place)))
+        return 0;
+    if (options.ensure) {
+        await reapplyView(place);
+        if (!(await watching(place)))
+            io.background(['herdr', 'watch']);
+        return 0;
+    }
+    const lease = await takeLease(place);
+    if (!lease)
+        return 0;
+    const socket = place.socket;
+    let state = emptyNotices();
+    let last = { waiting: [], viewing: null };
+    try {
+        while (!io.signal.aborted) {
+            if (!(await renew(place, lease)) || !(await pluginEnabled(socket, place.id)))
+                return 0;
+            const live = { changed: true, ending: null };
+            const subscription = herdrSubscribe(socket, SUBSCRIPTIONS, () => {
+                live.changed = true;
+            });
+            void subscription.done.then((how) => {
+                live.ending = how;
+            });
+            try {
+                await subscription.started;
+            }
+            catch { }
+            state = { ...state, seeded: false };
+            let checked = io.now();
+            while (live.ending === null && !io.signal.aborted) {
+                try {
+                    const step = await watchStep(io, socket, state, { read: live.changed, last });
+                    live.changed = false;
+                    state = step.state;
+                    last = step.last;
+                }
+                catch {
+                    live.changed = true;
+                }
+                if (io.now() - checked >= RENEW_MS) {
+                    checked = io.now();
+                    live.changed = true;
+                    const enabled = await pluginEnabled(socket, place.id).catch(() => true);
+                    if (!(await renew(place, lease)) || !enabled || (await pluginOff(place))) {
+                        subscription.stop();
+                        return 0;
+                    }
+                }
+                await io.sleep(TICK_MS, io.signal);
+            }
+            subscription.stop();
+            if (live.ending === 'closed' || live.ending === 'stopped')
+                return 0;
+            await io.sleep(AGAIN_MS, io.signal);
+        }
+        return 0;
+    }
+    catch {
+        return 0;
+    }
+    finally {
+        if ((await holder(place))?.id === lease)
+            await rm(leasePath(place), { force: true }).catch(() => { });
+    }
+}