@pasko70/pibo 1.0.0

package/dist/remote/channel.js

@@ -0,0 +1,176 @@
+import { createServer } from "node:net";
+import { DEFAULT_REMOTE_AGENT_HOST, DEFAULT_REMOTE_AGENT_PORT, REMOTE_AGENT_CHANNEL_NAME, encodeRemoteAgentFrame, isRemoteAgentRequestFrame, remoteAgentErrorResponse, } from "./protocol.js";
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        throw new Error("Invalid JSON frame");
+    }
+}
+function createConnection(socket) {
+    return {
+        socket,
+        send(frame) {
+            if (socket.destroyed)
+                return;
+            socket.write(encodeRemoteAgentFrame(frame));
+        },
+    };
+}
+export function createRemoteAgentChannel(options = {}) {
+    const host = options.host ?? DEFAULT_REMOTE_AGENT_HOST;
+    const port = options.port ?? DEFAULT_REMOTE_AGENT_PORT;
+    const defaultProfile = options.defaultProfile ?? "pibo-minimal";
+    const connections = new Set();
+    let server;
+    let unsubscribe;
+    let context;
+    const requireContext = () => {
+        if (!context)
+            throw new Error("Remote agent channel is not started");
+        return context;
+    };
+    const handleRequest = async (connection, frame) => {
+        const ctx = requireContext();
+        if (frame.type === "remote_attach") {
+            const binding = ctx.resolveSession({
+                channel: REMOTE_AGENT_CHANNEL_NAME,
+                externalId: frame.sessionName,
+                defaultProfile: frame.profile ?? defaultProfile,
+            });
+            connection.binding = binding;
+            return {
+                type: "remote_res",
+                id: frame.id,
+                ok: true,
+                payload: {
+                    binding,
+                    capabilities: {
+                        actions: ctx.getGatewayActions(),
+                    },
+                },
+            };
+        }
+        if (frame.type === "remote_capabilities") {
+            return {
+                type: "remote_res",
+                id: frame.id,
+                ok: true,
+                payload: {
+                    actions: ctx.getGatewayActions(),
+                },
+            };
+        }
+        if (!connection.binding) {
+            throw new Error("Remote agent client is not attached");
+        }
+        const sessionKey = connection.binding.sessionKey;
+        const output = frame.input.type === "message"
+            ? await ctx.emit({
+                type: "message",
+                sessionKey,
+                id: frame.id,
+                text: frame.input.text,
+                source: "ui",
+            })
+            : await ctx.emit({
+                type: "execution",
+                sessionKey,
+                id: frame.id,
+                action: frame.input.action,
+                params: frame.input.params,
+            });
+        return { type: "remote_res", id: frame.id, ok: true, payload: output };
+    };
+    const handleLine = async (connection, line) => {
+        let frame;
+        try {
+            frame = parseJsonLine(line);
+            if (!isRemoteAgentRequestFrame(frame)) {
+                throw new Error("Invalid remote agent request frame");
+            }
+        }
+        catch (error) {
+            connection.send(remoteAgentErrorResponse("invalid", error));
+            return;
+        }
+        try {
+            connection.send(await handleRequest(connection, frame));
+        }
+        catch (error) {
+            connection.send(remoteAgentErrorResponse(frame.id, error));
+        }
+    };
+    const handleSocket = (socket) => {
+        const connection = createConnection(socket);
+        connections.add(connection);
+        let buffer = "";
+        socket.setEncoding("utf-8");
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (line) {
+                    void handleLine(connection, line);
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        });
+        socket.once("close", () => connections.delete(connection));
+        socket.once("error", () => connections.delete(connection));
+    };
+    return {
+        name: REMOTE_AGENT_CHANNEL_NAME,
+        kind: "local",
+        description: "Local Pi Coding Agent style remote-control channel for pibo sessions.",
+        auth: { mode: "trusted-local" },
+        async start(channelContext) {
+            if (server)
+                return;
+            context = channelContext;
+            unsubscribe = channelContext.subscribe((event) => {
+                for (const connection of connections) {
+                    if (connection.binding?.sessionKey === event.sessionKey) {
+                        connection.send({ type: "remote_event", sessionKey: event.sessionKey, payload: event });
+                    }
+                }
+            });
+            server = createServer((socket) => handleSocket(socket));
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(port, host, () => {
+                    server.off("error", reject);
+                    resolve();
+                });
+            });
+            const address = this.getAddress();
+            if (address && options.announce !== false) {
+                console.error(`pibo remote agent channel listening on ${address.host}:${address.port}`);
+            }
+        },
+        async stop() {
+            unsubscribe?.();
+            unsubscribe = undefined;
+            context = undefined;
+            for (const connection of connections) {
+                connection.socket.destroy();
+            }
+            connections.clear();
+            if (server) {
+                await new Promise((resolve, reject) => {
+                    server.close((error) => (error ? reject(error) : resolve()));
+                });
+                server = undefined;
+            }
+        },
+        getAddress() {
+            const address = server?.address();
+            if (!address || typeof address === "string")
+                return undefined;
+            return { host: address.address, port: address.port };
+        },
+    };
+}

package/dist/remote/client.js

@@ -0,0 +1,92 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { DEFAULT_REMOTE_AGENT_HOST, DEFAULT_REMOTE_AGENT_PORT } from "./protocol.js";
+import { RemoteAgentSessionClient } from "./session-client.js";
+function isSessionStatus(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.sessionKey === "string" &&
+        typeof candidate.queuedMessages === "number" &&
+        typeof candidate.processing === "boolean");
+}
+function printResponse(frame) {
+    if (frame.ok)
+        return;
+    console.error(`\nerror: ${frame.error?.message ?? "request failed"}`);
+}
+function printExecutionResult(event) {
+    if (event.action === "status" && isSessionStatus(event.result)) {
+        console.error(`status: session=${event.result.sessionKey} queued=${event.result.queuedMessages} processing=${event.result.processing} streaming=${event.result.streaming}`);
+        return;
+    }
+    if (event.action === "clear_queue" && event.result && typeof event.result === "object") {
+        const cleared = event.result.cleared;
+        console.error(`clear: removed ${typeof cleared === "number" ? cleared : 0} queued message(s)`);
+        return;
+    }
+    console.error(`${event.action}: ${JSON.stringify(event.result)}`);
+}
+function printEvent(event, state) {
+    if (event.type === "assistant_delta") {
+        state.sawAssistantDelta = true;
+        output.write(event.text);
+        return;
+    }
+    if (event.type === "assistant_message") {
+        if (!state.sawAssistantDelta) {
+            output.write(event.text);
+        }
+        state.sawAssistantDelta = false;
+        output.write("\n");
+        return;
+    }
+    if (event.type === "message_started") {
+        state.sawAssistantDelta = false;
+        output.write("assistant> ");
+        return;
+    }
+    if (event.type === "session_error") {
+        console.error(`\nsession error: ${event.error}`);
+        return;
+    }
+    if (event.type === "execution_result") {
+        printExecutionResult(event);
+    }
+}
+export async function runRemoteAgentClient(options = {}) {
+    const resolvedOptions = {
+        host: options.host ?? DEFAULT_REMOTE_AGENT_HOST,
+        port: options.port ?? DEFAULT_REMOTE_AGENT_PORT,
+        sessionName: options.sessionName ?? "default",
+        profile: options.profile ?? "pibo-minimal",
+    };
+    const client = await RemoteAgentSessionClient.connect(resolvedOptions);
+    const slashCommands = client.getSlashCommands();
+    console.error(`connected to pibo remote agent at ${resolvedOptions.host}:${resolvedOptions.port}`);
+    console.error(`session: ${client.binding.sessionKey}`);
+    console.error(`profile: ${client.binding.originalProfile}`);
+    console.error(`commands: ${[...slashCommands.keys(), "/quit"].join(", ")}`);
+    const renderState = { sawAssistantDelta: false };
+    client.onEvent((event) => printEvent(event, renderState));
+    const rl = readline.createInterface({ input, output });
+    try {
+        while (true) {
+            const text = (await rl.question("remote> ")).trim();
+            if (!text)
+                continue;
+            if (text === "/quit" || text === "/exit")
+                break;
+            const action = slashCommands.get(text);
+            if (action) {
+                client.sendExecution(action).then(printResponse).catch((error) => console.error(`\nerror: ${error.message}`));
+                continue;
+            }
+            client.sendMessage(text).then(printResponse).catch((error) => console.error(`\nerror: ${error.message}`));
+        }
+    }
+    finally {
+        rl.close();
+        client.close();
+    }
+}

package/dist/remote/examples/tui-controller.js

@@ -0,0 +1,263 @@
+import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
+import { InitialSessionContextBuilder } from "../../core/profiles.js";
+import { runPiboTui } from "../../core/runtime.js";
+import { DEFAULT_REMOTE_AGENT_HOST, DEFAULT_REMOTE_AGENT_PORT, } from "../protocol.js";
+import { createRemoteSlashCommandMap, RemoteAgentSessionClient } from "../session-client.js";
+const LOCAL_PI_TUI_COMMANDS = new Set([
+    "settings",
+    "model",
+    "scoped-models",
+    "export",
+    "import",
+    "share",
+    "copy",
+    "name",
+    "session",
+    "changelog",
+    "hotkeys",
+    "fork",
+    "clone",
+    "tree",
+    "login",
+    "logout",
+    "new",
+    "compact",
+    "reload",
+    "debug",
+    "resume",
+    "quit",
+]);
+const REMOTE_MESSAGE_TYPE = "pibo.remote";
+function createRemoteControllerProfile() {
+    return new InitialSessionContextBuilder("pibo-remote-controller")
+        .withBuiltinTools("disabled")
+        .createSession();
+}
+function bg(color, text) {
+    return `\x1b[48;5;${color}m${text}\x1b[0m`;
+}
+function fg(color, text) {
+    return `\x1b[38;5;${color}m${text}\x1b[0m`;
+}
+function bold(text) {
+    return `\x1b[1m${text}\x1b[22m`;
+}
+function getRemoteMessageStyle(role) {
+    if (role === "user") {
+        return { label: "you -> remote", bgColor: 24, labelColor: 117 };
+    }
+    if (role === "assistant") {
+        return { label: "remote assistant", bgColor: 22, labelColor: 120 };
+    }
+    if (role === "execution") {
+        return { label: "remote execution", bgColor: 58, labelColor: 229 };
+    }
+    if (role === "error") {
+        return { label: "remote error", bgColor: 52, labelColor: 210 };
+    }
+    return { label: "remote session", bgColor: 236, labelColor: 250 };
+}
+function createRemoteMessageComponent(content, details) {
+    const style = getRemoteMessageStyle(details.role);
+    const container = new Container();
+    const box = new Box(1, 1, (text) => bg(style.bgColor, text));
+    box.addChild(new Text(bold(fg(style.labelColor, style.label)), 0, 0));
+    box.addChild(new Spacer(1));
+    box.addChild(new Text(content, 0, 0));
+    container.addChild(new Spacer(1));
+    container.addChild(box);
+    return container;
+}
+function createTuiSlashCommandMap(capabilities) {
+    const commands = createRemoteSlashCommandMap(capabilities);
+    for (const command of commands.keys()) {
+        if (LOCAL_PI_TUI_COMMANDS.has(command.slice(1))) {
+            commands.delete(command);
+        }
+    }
+    return commands;
+}
+function createRemoteAutocompleteProvider(current, allowedCommands) {
+    return {
+        async getSuggestions(lines, cursorLine, cursorCol, options) {
+            const suggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
+            const beforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
+            if (!suggestions || !beforeCursor.startsWith("/") || beforeCursor.includes(" ")) {
+                return suggestions;
+            }
+            const items = suggestions.items.filter((item) => allowedCommands.has(item.value));
+            return items.length > 0 ? { ...suggestions, items } : null;
+        },
+        applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+            return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+        },
+        shouldTriggerFileCompletion: current.shouldTriggerFileCompletion
+            ? (lines, cursorLine, cursorCol) => current.shouldTriggerFileCompletion(lines, cursorLine, cursorCol)
+            : undefined,
+    };
+}
+function isSessionStatus(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.sessionKey === "string" &&
+        typeof candidate.queuedMessages === "number" &&
+        typeof candidate.processing === "boolean");
+}
+function formatExecutionResult(event) {
+    if (event.action === "status" && isSessionStatus(event.result)) {
+        return `status: session=${event.result.sessionKey} queued=${event.result.queuedMessages} processing=${event.result.processing} streaming=${event.result.streaming}`;
+    }
+    if (event.action === "clear_queue" && event.result && typeof event.result === "object") {
+        const cleared = event.result.cleared;
+        return `clear: removed ${typeof cleared === "number" ? cleared : 0} queued message(s)`;
+    }
+    return `${event.action}: ${JSON.stringify(event.result)}`;
+}
+function sendTuiMessage(pi, content, details) {
+    pi.sendMessage({
+        customType: REMOTE_MESSAGE_TYPE,
+        content,
+        display: true,
+        details,
+    });
+}
+function formatConnectedMessage(client, slashCommands) {
+    const commands = [...slashCommands.keys()].join(", ") || "none";
+    return [
+        `Connected to pibo remote session ${client.binding.sessionKey}.`,
+        `Profile: ${client.binding.originalProfile}`,
+        `Remote commands: ${commands}`,
+        "Pi TUI built-in slash commands stay local.",
+    ].join("\n");
+}
+export function createRemoteAgentTuiExtension(options = {}) {
+    const resolvedOptions = {
+        host: options.host ?? DEFAULT_REMOTE_AGENT_HOST,
+        port: options.port ?? DEFAULT_REMOTE_AGENT_PORT,
+        sessionName: options.sessionName ?? "default",
+        profile: options.profile ?? "pibo-minimal",
+    };
+    return (pi) => {
+        let client;
+        let connectPromise;
+        let slashCommands = new Map();
+        let context;
+        let assistantBuffer = "";
+        let autocompleteRefreshed = false;
+        const registeredCommands = new Set();
+        pi.registerMessageRenderer(REMOTE_MESSAGE_TYPE, (message) => {
+            return createRemoteMessageComponent(String(message.content), message.details ?? { role: "system" });
+        });
+        const setStatus = (text) => {
+            context?.ui.setStatus("pibo.remote", text);
+        };
+        const handleRemoteEvent = (event) => {
+            if (event.type === "message_started") {
+                assistantBuffer = "";
+                setStatus("remote running");
+                return;
+            }
+            if (event.type === "assistant_delta") {
+                assistantBuffer += event.text;
+                return;
+            }
+            if (event.type === "assistant_message") {
+                sendTuiMessage(pi, event.text || assistantBuffer, { role: "assistant", event });
+                assistantBuffer = "";
+                setStatus("remote connected");
+                return;
+            }
+            if (event.type === "execution_result") {
+                sendTuiMessage(pi, formatExecutionResult(event), { role: "execution", event });
+                setStatus("remote connected");
+                return;
+            }
+            if (event.type === "session_error") {
+                sendTuiMessage(pi, `Remote error: ${event.error}`, { role: "error", event });
+                setStatus("remote error");
+            }
+        };
+        const ensureClient = async (ctx) => {
+            context = ctx;
+            if (client)
+                return client;
+            if (connectPromise)
+                return connectPromise;
+            setStatus("remote connecting");
+            connectPromise = RemoteAgentSessionClient.connect(resolvedOptions)
+                .then((connectedClient) => {
+                client = connectedClient;
+                slashCommands = createTuiSlashCommandMap(connectedClient.capabilities);
+                for (const [slashCommand, action] of slashCommands) {
+                    const name = slashCommand.slice(1);
+                    if (registeredCommands.has(name))
+                        continue;
+                    registeredCommands.add(name);
+                    const description = connectedClient.capabilities.actions.find((candidate) => candidate.name === action)?.description ??
+                        `Run remote gateway action "${action}".`;
+                    pi.registerCommand(name, {
+                        description,
+                        async handler() {
+                            sendTuiMessage(pi, slashCommand, { role: "user" });
+                            await connectedClient.sendExecution(action);
+                        },
+                    });
+                }
+                if (!autocompleteRefreshed) {
+                    const allowedCommands = new Set([...slashCommands.keys()].map((command) => command.slice(1)));
+                    allowedCommands.add("quit");
+                    ctx.ui.addAutocompleteProvider((current) => createRemoteAutocompleteProvider(current, allowedCommands));
+                    autocompleteRefreshed = true;
+                }
+                connectedClient.onEvent(handleRemoteEvent);
+                setStatus("remote connected");
+                sendTuiMessage(pi, formatConnectedMessage(connectedClient, slashCommands), { role: "system" });
+                return connectedClient;
+            })
+                .catch((error) => {
+                connectPromise = undefined;
+                setStatus("remote offline");
+                sendTuiMessage(pi, `Remote connection failed: ${error.message}`, { role: "error" });
+                throw error;
+            });
+            return connectPromise;
+        };
+        pi.on("session_start", async (_event, ctx) => {
+            await ensureClient(ctx).catch(() => { });
+        });
+        pi.on("session_shutdown", () => {
+            client?.close();
+            client = undefined;
+            connectPromise = undefined;
+        });
+        pi.on("input", async (event, ctx) => {
+            const text = event.text.trim();
+            if (!text)
+                return { action: "continue" };
+            try {
+                const connectedClient = await ensureClient(ctx);
+                sendTuiMessage(pi, text, { role: "user" });
+                const action = slashCommands.get(text);
+                if (action) {
+                    await connectedClient.sendExecution(action);
+                }
+                else {
+                    await connectedClient.sendMessage(event.text);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                sendTuiMessage(pi, `Remote request failed: ${message}`, { role: "error" });
+            }
+            return { action: "handled" };
+        });
+    };
+}
+export async function runRemoteAgentTui(options = {}) {
+    await runPiboTui({
+        persistSession: false,
+        profile: createRemoteControllerProfile(),
+        extensionFactories: [createRemoteAgentTuiExtension(options)],
+    });
+}

package/dist/remote/protocol.js

@@ -0,0 +1,55 @@
+export const DEFAULT_REMOTE_AGENT_HOST = "127.0.0.1";
+export const DEFAULT_REMOTE_AGENT_PORT = 4790;
+export const REMOTE_AGENT_CHANNEL_NAME = "remote-agent";
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    if (typeof value === "object") {
+        return Object.values(value).every(isJsonValue);
+    }
+    return false;
+}
+export function encodeRemoteAgentFrame(frame) {
+    return `${JSON.stringify(frame)}\n`;
+}
+export function remoteAgentErrorResponse(id, error) {
+    return {
+        type: "remote_res",
+        id,
+        ok: false,
+        error: { message: error instanceof Error ? error.message : String(error) },
+    };
+}
+export function isRemoteAgentRequestFrame(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const frame = value;
+    if (typeof frame.id !== "string")
+        return false;
+    if (frame.type === "remote_attach") {
+        return (typeof frame.sessionName === "string" &&
+            frame.sessionName.length > 0 &&
+            (frame.profile === undefined || typeof frame.profile === "string"));
+    }
+    if (frame.type === "remote_input") {
+        if (!frame.input || typeof frame.input !== "object")
+            return false;
+        const input = frame.input;
+        if (input.type === "message")
+            return typeof input.text === "string";
+        if (input.type === "execution") {
+            return typeof input.action === "string" && (input.params === undefined || isJsonValue(input.params));
+        }
+    }
+    if (frame.type === "remote_capabilities") {
+        return true;
+    }
+    return false;
+}