@mjasnikovs/pi-task 0.2.2 → 0.4.0

package/dist/remote/register.js

@@ -0,0 +1,149 @@
+import { broadcast } from './broadcast.js';
+import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession } from './bridge.js';
+import { setupEvents } from './events.js';
+import { HistoryBuffer } from './history.js';
+import { html } from './ui.js';
+import { qrLines } from './qr.js';
+import { startServer, formatAddresses } from './server.js';
+import { isAgentIdle } from './state.js';
+const _g = globalThis;
+if (!_g.__piRemote)
+    _g.__piRemote = { server: null, send: null };
+const S = _g.__piRemote;
+export function registerRemote(pi) {
+    const history = new HistoryBuffer(20);
+    /** Start the always-on remote server once; later calls return the live handle.
+     *  Plain chat works immediately via S.send; remote slash commands and /new
+     *  bind once any command supplies a command-capable ctx (see dispatchRemoteLine). */
+    async function ensureServer() {
+        if (S.server)
+            return S.server;
+        S.server = await startServer(text => {
+            if (text === '/new') {
+                // Route through the bridge's freshest command ctx with the same
+                // crash-safe guards as remote slash commands. The withSession
+                // rebind keeps S.send pointed at the new session's ctx.
+                dispatchRemoteNewSession(newCtx => {
+                    // newCtx.sendUserMessage bypasses the stale runtime check
+                    // (returns a Promise we deliberately discard).
+                    S.send = (msg, opts) => {
+                        void (opts ?
+                            newCtx.sendUserMessage(msg, opts)
+                            : newCtx.sendUserMessage(msg));
+                    };
+                });
+                return;
+            }
+            // Slash commands route to the bridge's command registry;
+            // plain lines fall through to onPlain and go to the agent.
+            dispatchRemoteLine(text, {
+                onPlain: plain => {
+                    // Persist remote-typed messages: they arrive via
+                    // sendUserMessage with source "extension", which the
+                    // interactive input handler skips, so record them
+                    // here for reconnect/history.
+                    history.addUserMessage(plain);
+                    if (isAgentIdle()) {
+                        S.send?.(plain);
+                    }
+                    else {
+                        S.send?.(plain, { deliverAs: 'followUp' });
+                    }
+                }
+            });
+        }, wsUrl => html(wsUrl), () => history.getEntries());
+        return S.server;
+    }
+    pi.on('session_start', (_event, ctx) => {
+        // Update shared send with fresh pi on each session (survives /new re-evaluation)
+        S.send = (text, opts) => (opts ? pi.sendUserMessage(text, opts) : pi.sendUserMessage(text));
+        setupEvents(pi, history, broadcast);
+        // Always-on: bring the remote server up automatically so no /remote is
+        // needed. Plain chat flows immediately via S.send; the local widget shows
+        // the reachable URLs. Run /remote to view the QR or fully enable remote
+        // slash commands.
+        // NOTE: we deliberately do NOT seed bridge.currentCtx here. The event ctx
+        // is the base ExtensionContext (no waitForIdle/newSession), so storing it
+        // would make a later remote /task throw. currentCtx is only ever set from
+        // a real command ctx: the /remote handler, registerBridgeCommand, and the
+        // remote-/new withSession rebind. See dispatchRemoteLine's capability guard.
+        void ensureServer().catch(err => ctx.ui.notify(`Failed to start remote: ${err.message}`, 'error'));
+    });
+    pi.on('session_shutdown', (event, _ctx) => {
+        if (event.reason === 'quit') {
+            if (S.server) {
+                S.server.stop();
+                S.server = null;
+            }
+            S.send = null;
+        }
+    });
+    pi.registerCommand('remote', {
+        description: 'Show the remote QR code & URLs (the server is always running)',
+        handler: async (args, ctx) => {
+            if (args.trim() === 'stop') {
+                if (S.server) {
+                    S.server.stop();
+                    S.server = null;
+                    ctx.ui.notify('Remote server stopped', 'info');
+                }
+                else {
+                    ctx.ui.notify('Remote server is not running', 'warning');
+                }
+                return;
+            }
+            // Capture this command-capable ctx so remote slash commands and /new
+            // work (the always-on auto-start can only bind plain chat).
+            getBridge().currentCtx = ctx;
+            try {
+                const server = await ensureServer();
+                // QR keeps encoding only the primary (Tailscale-preferred) URL.
+                const primaryUrl = `http://${server.ip}:${server.port}`;
+                const qr = await qrLines(primaryUrl);
+                // Labeled, block-aligned address lines: Tailscale + LAN when present.
+                const addrs = formatAddresses(server.ips, server.port);
+                const labelW = addrs.reduce((m, a) => Math.max(m, a.label.length), 0);
+                const addrLines = addrs.map(a => a.label ? `${a.label.padEnd(labelW)}  ${a.url}` : a.url);
+                const addrWidth = addrLines.reduce((m, l) => Math.max(m, l.length), 0);
+                if (ctx.mode === 'tui') {
+                    // eslint-disable-next-line no-control-regex -- strip ANSI SGR escapes to measure visible width
+                    const stripAnsi = (s) => s.replace(/\x1b\[[^m]*m/g, '');
+                    const visWidth = qr.reduce((max, l) => Math.max(max, stripAnsi(l).length), 0);
+                    const overlayWidth = Math.max(visWidth, addrWidth + 4, 36);
+                    // Fire-and-forget: don't await so the command handler returns immediately
+                    // (avoids "Working" lock if user runs /new before dismissing)
+                    ctx.ui
+                        .custom((_tui, _theme, _kb, done) => ({
+                        focused: false,
+                        render: w => {
+                            const c = (s, len) => ' '.repeat(Math.max(0, Math.floor((w - len) / 2))) + s;
+                            return [
+                                '',
+                                ...qr.map(l => c(l, visWidth)),
+                                '',
+                                ...addrLines.map(l => c(l, addrWidth)),
+                                '',
+                                c('Waiting for connection…', 23),
+                                c('(any key to dismiss)', 20)
+                            ];
+                        },
+                        handleInput: () => done(undefined),
+                        invalidate: () => { },
+                        dispose: () => done(undefined)
+                    }), {
+                        overlay: true,
+                        overlayOptions: { width: overlayWidth },
+                        onHandle: h => {
+                            server.onFirstConnect = () => h.hide();
+                        }
+                    })
+                        .catch(() => { });
+                }
+                ctx.ui.notify(`Remote running at ${primaryUrl}`, 'info');
+            }
+            catch (err) {
+                ctx.ui.notify(`Failed to start remote: ${err.message}`, 'error');
+            }
+        }
+    });
+}

package/dist/remote/server.d.ts

@@ -0,0 +1,31 @@
+import type { Turn } from './history.js';
+export interface LocalIPs {
+    /** Tailscale (tailscale0) IPv4 address, if the interface is up. */
+    tailscale?: string;
+    /** First non-internal, non-Tailscale IPv4 address (the LAN address). */
+    lan?: string;
+    /** Address used for the QR code / primary URL: Tailscale, else LAN, else loopback. */
+    primary: string;
+}
+export interface AddressLine {
+    /** Network label (e.g. 'Tailscale', 'LAN'); empty for the loopback fallback. */
+    label: string;
+    /** Full http:// URL for that address. */
+    url: string;
+}
+export interface ServerHandle {
+    port: number;
+    /** Primary address (Tailscale-preferred); the one the QR encodes. */
+    ip: string;
+    /** All resolved addresses, for displaying both Tailscale and LAN URLs. */
+    ips: LocalIPs;
+    stop(): void;
+    onFirstConnect: (() => void) | null;
+}
+type MessageCallback = (text: string) => void;
+export declare function getLocalIPs(nets?: NodeJS.Dict<import("node:os").NetworkInterfaceInfo[]>): LocalIPs;
+/** Build the labeled URL lines shown under the QR code. Both Tailscale and LAN
+ *  when present; a single unlabeled primary URL when neither resolves. */
+export declare function formatAddresses(ips: LocalIPs, port: number): AddressLine[];
+export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string, getHistory: () => Turn[]): Promise<ServerHandle>;
+export {};

package/dist/remote/server.js

@@ -0,0 +1,126 @@
+import { createServer } from 'node:http';
+import { networkInterfaces } from 'node:os';
+import { WebSocketServer } from 'ws';
+import { addClient, removeClient, clientCount, broadcast, sendTo } from './broadcast.js';
+import { getBridge, answerPrompt } from './bridge.js';
+import { isClientMessage } from './protocol.js';
+export function getLocalIPs(nets = networkInterfaces()) {
+    // Prefer Tailscale when available.
+    let tailscale;
+    for (const net of nets['tailscale0'] ?? []) {
+        if (net.family === 'IPv4') {
+            tailscale = net.address;
+            break;
+        }
+    }
+    // LAN = first non-internal IPv4 that isn't the Tailscale interface.
+    let lan;
+    for (const [name, iface] of Object.entries(nets)) {
+        if (!iface || name === 'tailscale0')
+            continue;
+        for (const net of iface) {
+            if (net.family === 'IPv4' && !net.internal) {
+                lan = net.address;
+                break;
+            }
+        }
+        if (lan)
+            break;
+    }
+    return { tailscale, lan, primary: tailscale ?? lan ?? '127.0.0.1' };
+}
+/** Build the labeled URL lines shown under the QR code. Both Tailscale and LAN
+ *  when present; a single unlabeled primary URL when neither resolves. */
+export function formatAddresses(ips, port) {
+    const out = [];
+    if (ips.tailscale)
+        out.push({ label: 'Tailscale', url: `http://${ips.tailscale}:${port}` });
+    if (ips.lan)
+        out.push({ label: 'LAN', url: `http://${ips.lan}:${port}` });
+    if (out.length === 0)
+        out.push({ label: '', url: `http://${ips.primary}:${port}` });
+    return out;
+}
+async function tryBind(port) {
+    return new Promise(resolve => {
+        const s = createServer();
+        s.listen(port, '0.0.0.0', () => {
+            s.close(() => resolve(true));
+        });
+        s.on('error', () => resolve(false));
+    });
+}
+async function findPort(start, max) {
+    for (let p = start; p < start + max; p++) {
+        if (await tryBind(p))
+            return p;
+    }
+    throw new Error(`No free port found in range ${start}–${start + max - 1}`);
+}
+export async function startServer(onMessage, getHtml, getHistory) {
+    const port = await findPort(8800, 100);
+    const ips = getLocalIPs();
+    const ip = ips.primary;
+    const wsUrl = `ws://${ip}:${port}/ws`;
+    const httpServer = createServer((req, res) => {
+        if (req.method === 'GET' && (req.url === '/' || req.url === '')) {
+            const body = getHtml(wsUrl);
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(body);
+        }
+        else {
+            res.writeHead(404);
+            res.end('Not found');
+        }
+    });
+    const wss = new WebSocketServer({ server: httpServer, path: '/ws' });
+    const handle = {
+        port,
+        ip,
+        ips,
+        onFirstConnect: null,
+        stop() {
+            wss.close();
+            httpServer.close();
+        }
+    };
+    wss.on('connection', ws => {
+        addClient(ws);
+        handle.onFirstConnect?.();
+        handle.onFirstConnect = null;
+        sendTo(ws, { type: 'history', turns: getHistory() });
+        const bridge = getBridge();
+        for (const [key, lines] of bridge.activeWidgets) {
+            sendTo(ws, { type: 'widget', key, lines });
+        }
+        if (bridge.activePrompt)
+            sendTo(ws, bridge.activePrompt);
+        broadcast({ type: 'client_count', count: clientCount() });
+        ws.on('message', data => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return; // ignore malformed JSON
+            }
+            if (!isClientMessage(msg))
+                return;
+            if (msg.type === 'prompt_answer') {
+                answerPrompt(msg.id, msg.value);
+                return;
+            }
+            // type === 'message': ignore while a prompt is pending (composer is
+            // disabled in the browser; this is the server-side guard).
+            if (getBridge().activePrompt)
+                return;
+            onMessage(msg.text);
+        });
+        ws.on('close', () => {
+            removeClient(ws);
+            broadcast({ type: 'client_count', count: clientCount() });
+        });
+    });
+    await new Promise(resolve => httpServer.listen(port, '0.0.0.0', resolve));
+    return handle;
+}

package/dist/remote/state.d.ts

@@ -0,0 +1,2 @@
+export declare function isAgentIdle(): boolean;
+export declare function setAgentIdle(idle: boolean): void;

package/dist/remote/state.js

@@ -0,0 +1,7 @@
+let _isAgentIdle = true;
+export function isAgentIdle() {
+    return _isAgentIdle;
+}
+export function setAgentIdle(idle) {
+    _isAgentIdle = idle;
+}

package/dist/remote/ui.d.ts

@@ -0,0 +1 @@
+export declare function html(wsUrl: string): string;