@pasko70/pibo 1.0.5 → 1.2.0

package/dist/remote/client.js

@@ -1,92 +0,0 @@
-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

@@ -1,263 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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;
-}

package/dist/remote/session-client.js

@@ -1,189 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { connect } from "node:net";
-import { DEFAULT_REMOTE_AGENT_HOST, DEFAULT_REMOTE_AGENT_PORT, encodeRemoteAgentFrame, } from "./protocol.js";
-function parseJsonLine(line) {
-    try {
-        return JSON.parse(line);
-    }
-    catch {
-        return undefined;
-    }
-}
-function isBinding(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return typeof candidate.sessionKey === "string" && typeof candidate.originalProfile === "string";
-}
-function isCapabilities(value) {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return Array.isArray(candidate.actions);
-}
-export function createRemoteSlashCommandMap(capabilities) {
-    const commands = new Map();
-    for (const action of capabilities.actions) {
-        for (const slashCommand of action.slashCommands) {
-            commands.set(`/${slashCommand}`, action.name);
-        }
-    }
-    return commands;
-}
-export class RemoteAgentSessionClient {
-    socket;
-    binding;
-    capabilities;
-    eventListeners = new Set();
-    pendingResponses = new Map();
-    buffer = "";
-    constructor(socket, attached) {
-        this.socket = socket;
-        this.binding = attached.binding;
-        this.capabilities = attached.capabilities;
-        this.socket.on("data", (chunk) => this.handleData(String(chunk)));
-        this.socket.once("close", () => this.rejectPendingResponses(new Error("Remote agent connection closed")));
-        this.socket.once("error", (error) => this.rejectPendingResponses(error));
-    }
-    static async connect(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 socket = connect({ host: resolvedOptions.host, port: resolvedOptions.port });
-        socket.setEncoding("utf-8");
-        await new Promise((resolve, reject) => {
-            socket.once("connect", resolve);
-            socket.once("error", reject);
-        });
-        const attached = await attachRemoteAgent(socket, resolvedOptions);
-        return new RemoteAgentSessionClient(socket, attached);
-    }
-    onEvent(listener) {
-        this.eventListeners.add(listener);
-        return () => this.eventListeners.delete(listener);
-    }
-    getSlashCommands() {
-        return createRemoteSlashCommandMap(this.capabilities);
-    }
-    sendMessage(text) {
-        return this.sendInput({ type: "message", text });
-    }
-    sendExecution(action, params) {
-        return this.sendInput(params === undefined ? { type: "execution", action } : { type: "execution", action, params });
-    }
-    close() {
-        this.socket.end();
-    }
-    sendInput(input) {
-        return this.sendRequest({ type: "remote_input", id: randomUUID(), input });
-    }
-    sendRequest(frame) {
-        if (this.socket.destroyed) {
-            return Promise.reject(new Error("Remote agent connection is closed"));
-        }
-        return new Promise((resolve, reject) => {
-            this.pendingResponses.set(frame.id, { resolve, reject });
-            this.socket.write(encodeRemoteAgentFrame(frame));
-        });
-    }
-    handleData(chunk) {
-        this.buffer += chunk;
-        let newlineIndex = this.buffer.indexOf("\n");
-        while (newlineIndex !== -1) {
-            const line = this.buffer.slice(0, newlineIndex).trim();
-            this.buffer = this.buffer.slice(newlineIndex + 1);
-            this.handleFrame(line ? parseJsonLine(line) : undefined);
-            newlineIndex = this.buffer.indexOf("\n");
-        }
-    }
-    handleFrame(frame) {
-        if (!frame)
-            return;
-        if (frame.type === "remote_res") {
-            const pending = this.pendingResponses.get(frame.id);
-            if (!pending)
-                return;
-            this.pendingResponses.delete(frame.id);
-            if (frame.ok) {
-                pending.resolve(frame);
-            }
-            else {
-                pending.reject(new Error(frame.error?.message ?? "Remote request failed"));
-            }
-            return;
-        }
-        if (frame.type === "remote_event") {
-            for (const listener of this.eventListeners) {
-                listener(frame.payload);
-            }
-        }
-    }
-    rejectPendingResponses(error) {
-        for (const pending of this.pendingResponses.values()) {
-            pending.reject(error);
-        }
-        this.pendingResponses.clear();
-    }
-}
-async function attachRemoteAgent(socket, options) {
-    const id = randomUUID();
-    return await new Promise((resolve, reject) => {
-        let buffer = "";
-        const cleanup = () => {
-            socket.off("data", onData);
-            socket.off("error", onError);
-            socket.off("close", onClose);
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const onClose = () => {
-            cleanup();
-            reject(new Error("Remote agent connection closed before attach completed"));
-        };
-        const onData = (chunk) => {
-            buffer += String(chunk);
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const line = buffer.slice(0, newlineIndex).trim();
-                buffer = buffer.slice(newlineIndex + 1);
-                const frame = line ? parseJsonLine(line) : undefined;
-                if (frame?.type === "remote_res" && frame.id === id) {
-                    cleanup();
-                    if (!frame.ok) {
-                        reject(new Error(frame.error?.message ?? "Remote attach failed"));
-                        return;
-                    }
-                    const payload = frame.payload;
-                    if (!isBinding(payload?.binding)) {
-                        reject(new Error("Remote attach response did not include a binding"));
-                        return;
-                    }
-                    if (!isCapabilities(payload.capabilities)) {
-                        reject(new Error("Remote attach response did not include capabilities"));
-                        return;
-                    }
-                    resolve({
-                        binding: payload.binding,
-                        capabilities: payload.capabilities,
-                    });
-                    return;
-                }
-                newlineIndex = buffer.indexOf("\n");
-            }
-        };
-        socket.on("data", onData);
-        socket.once("error", onError);
-        socket.once("close", onClose);
-        socket.write(encodeRemoteAgentFrame({
-            type: "remote_attach",
-            id,
-            sessionName: options.sessionName,
-            profile: options.profile,
-        }));
-    });
-}

package/dist/sessions/bindings.js

@@ -1,41 +0,0 @@
-import { randomUUID } from "node:crypto";
-export function createPiboSessionId() {
-    return randomUUID();
-}
-export function createSessionBinding(input, now = new Date().toISOString()) {
-    return {
-        sessionKey: input.sessionKey ?? createDefaultSessionKey(input),
-        sessionId: input.sessionId ?? createPiboSessionId(),
-        parentSessionKey: input.parentSessionKey,
-        parentSessionId: input.parentSessionId,
-        channel: input.channel,
-        externalId: input.externalId,
-        originalProfile: input.defaultProfile,
-        workspace: input.workspace,
-        createdAt: now,
-        updatedAt: now,
-    };
-}
-export function createDefaultSessionKey(input) {
-    return `${input.channel}:${input.externalId}`;
-}
-export class InMemorySessionBindingStore {
-    bySessionKey = new Map();
-    byChannelExternalId = new Map();
-    get(sessionKey) {
-        return this.bySessionKey.get(sessionKey);
-    }
-    list() {
-        return [...this.bySessionKey.values()];
-    }
-    resolve(input) {
-        const channelExternalId = createDefaultSessionKey(input);
-        const existing = this.byChannelExternalId.get(channelExternalId);
-        if (existing)
-            return existing;
-        const binding = createSessionBinding(input);
-        this.bySessionKey.set(binding.sessionKey, binding);
-        this.byChannelExternalId.set(channelExternalId, binding);
-        return binding;
-    }
-}