@pasko70/pibo 1.0.0

package/dist/gateway/server.js

@@ -0,0 +1,221 @@
+import { createServer } from "node:net";
+import { createDefaultPiboPluginRegistry } from "../plugins/builtin.js";
+import { PiboSessionRouter } from "../core/session-router.js";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, errorResponse, isGatewayRequestFrame, } 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(encodeFrame(frame));
+        },
+    };
+}
+async function createGatewaySessionStore(options) {
+    const { createDefaultPiboSessionStore, SqlitePiboSessionStore } = await import("../sessions/sqlite-store.js");
+    return options.sessionDbPath
+        ? new SqlitePiboSessionStore(options.sessionDbPath)
+        : createDefaultPiboSessionStore();
+}
+export class PiboGatewayServer {
+    options;
+    pluginRegistry;
+    sessionStore;
+    ownsSessionStore = false;
+    router;
+    startedChannels = [];
+    connections = new Set();
+    server;
+    unsubscribe;
+    constructor(options = {}) {
+        this.options = options;
+        this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
+    }
+    async start() {
+        if (this.server)
+            return;
+        this.validateChannels();
+        this.sessionStore = this.options.sessionStore ?? (await createGatewaySessionStore(this.options));
+        this.ownsSessionStore = !this.options.sessionStore;
+        this.router = new PiboSessionRouter({
+            persistSession: this.options.persistSession,
+            pluginRegistry: this.pluginRegistry,
+            sessionStore: this.sessionStore,
+        });
+        this.unsubscribe = this.router.subscribe((event) => this.broadcastRouterEvent(event));
+        this.server = createServer((socket) => this.handleSocket(socket));
+        await this.pluginRegistry.getAuthService()?.start?.();
+        await new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(this.options.port ?? DEFAULT_GATEWAY_PORT, this.options.host ?? DEFAULT_GATEWAY_HOST, () => {
+                this.server.off("error", reject);
+                resolve();
+            });
+        });
+        if (this.options.startChannels !== false) {
+            await this.startChannels();
+        }
+    }
+    async stop() {
+        await this.stopChannels();
+        await this.pluginRegistry.getAuthService()?.stop?.();
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        for (const connection of this.connections) {
+            connection.socket.destroy();
+        }
+        this.connections.clear();
+        if (this.server) {
+            await new Promise((resolve, reject) => {
+                this.server.close((error) => (error ? reject(error) : resolve()));
+            });
+            this.server = undefined;
+        }
+        await this.router?.disposeAll();
+        this.router = undefined;
+        if (this.ownsSessionStore) {
+            this.sessionStore?.close?.();
+        }
+        this.sessionStore = undefined;
+        this.ownsSessionStore = false;
+    }
+    handleSocket(socket) {
+        const connection = createConnection(socket);
+        this.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 this.handleLine(connection, line);
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        });
+        socket.once("close", () => {
+            this.connections.delete(connection);
+        });
+        socket.once("error", () => {
+            this.connections.delete(connection);
+        });
+    }
+    async handleLine(connection, line) {
+        let frame;
+        try {
+            frame = parseJsonLine(line);
+            if (!isGatewayRequestFrame(frame)) {
+                throw new Error("Invalid request frame");
+            }
+        }
+        catch (error) {
+            connection.send(errorResponse("invalid", error));
+            return;
+        }
+        try {
+            const output = await this.requireRouter().emit(frame.event);
+            const response = {
+                type: "res",
+                id: frame.id,
+                ok: true,
+                payload: output,
+            };
+            connection.send(response);
+        }
+        catch (error) {
+            connection.send(errorResponse(frame.id, error));
+        }
+    }
+    broadcastRouterEvent(event) {
+        for (const connection of this.connections) {
+            connection.send({ type: "event", event: "router", payload: event });
+        }
+    }
+    async startChannels() {
+        const context = this.createChannelContext();
+        for (const channel of this.pluginRegistry.getChannels()) {
+            if (channel.auth.mode === "none") {
+                console.error(`Warning: channel "${channel.name}" starts without auth`);
+            }
+            await channel.start(context);
+            this.startedChannels.push(channel);
+        }
+    }
+    validateChannels() {
+        for (const channel of this.pluginRegistry.getChannels()) {
+            if (channel.auth.mode === "required" && !this.pluginRegistry.getAuthService()) {
+                throw new Error(`Channel "${channel.name}" requires auth, but no auth service is registered`);
+            }
+        }
+    }
+    async stopChannels() {
+        while (this.startedChannels.length > 0) {
+            const channel = this.startedChannels.pop();
+            await channel.stop?.();
+        }
+    }
+    createChannelContext() {
+        return {
+            emit: (event) => this.requireRouter().emit(event),
+            subscribe: (listener) => this.requireRouter().subscribe(listener),
+            getSession: (id) => this.requireSessionStore().get(id),
+            createSession: (input) => {
+                const profile = this.pluginRegistry.resolveProfileName(input.profile);
+                return this.requireSessionStore().create({ ...input, profile });
+            },
+            updateSession: (id, input) => this.requireSessionStore().update(id, input),
+            deleteSession: (id) => this.requireSessionStore().delete?.(id) ?? false,
+            findSessions: (input) => this.requireSessionStore().find(input),
+            listSessions: () => this.requireSessionStore().list?.() ?? [],
+            getGatewayActions: () => this.pluginRegistry.getGatewayActionInfos(),
+            getProfiles: () => this.pluginRegistry.getProfileInfos(),
+            getCapabilityCatalog: () => this.pluginRegistry.getCapabilityCatalog(),
+            upsertProfile: (profile) => this.pluginRegistry.upsertProfile(profile),
+            removeProfile: (name) => this.pluginRegistry.removeProfile(name),
+            upsertContextFile: (contextFile) => this.pluginRegistry.upsertContextFile(contextFile),
+            removeContextFile: (key) => this.pluginRegistry.removeContextFile(key),
+            emitProductEvent: (event) => this.pluginRegistry.emitProductEvent(event),
+            subscribeProductEvents: (listener) => this.pluginRegistry.onProductEvent(listener),
+            auth: this.pluginRegistry.getAuthService(),
+            getWebApps: () => this.pluginRegistry.getWebApps(),
+        };
+    }
+    requireRouter() {
+        if (!this.router)
+            throw new Error("Gateway router is not started");
+        return this.router;
+    }
+    requireSessionStore() {
+        if (!this.sessionStore)
+            throw new Error("Gateway session store is not started");
+        return this.sessionStore;
+    }
+}
+export async function runGatewayServer(options = {}) {
+    const server = new PiboGatewayServer(options);
+    await server.start();
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    console.error(`pibo gateway listening on ${host}:${port}`);
+    const stop = async () => {
+        await server.stop();
+    };
+    process.once("SIGINT", () => {
+        void stop().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+        void stop().finally(() => process.exit(0));
+    });
+}

package/dist/gateway/tool.js

@@ -0,0 +1,69 @@
+import { Type } from "@mariozechner/pi-ai";
+import { defineTool } from "@mariozechner/pi-coding-agent";
+import { sendGatewayMessageAndWaitForReply } from "./request.js";
+const piboGatewaySendTool = defineTool({
+    name: "pibo_gateway_send",
+    label: "Pibo Gateway Send",
+    description: "Send a message through the local pibo gateway to a target session and return the target assistant reply.",
+    promptSnippet: "Send a message through the local pibo gateway to a target session and return the final assistant reply from that session.",
+    parameters: Type.Object({
+        piboSessionId: Type.String({ description: "Target Pibo gateway session id" }),
+        message: Type.String({ description: "Message to enqueue for the target session" }),
+    }),
+    async execute(_toolCallId, params) {
+        let result;
+        let response;
+        try {
+            result = await sendGatewayMessageAndWaitForReply({
+                type: "message",
+                piboSessionId: params.piboSessionId,
+                text: params.message,
+                source: "actor",
+            });
+            response = result.response;
+        }
+        catch (error) {
+            response = {
+                type: "res",
+                id: "",
+                ok: false,
+                error: { message: error instanceof Error ? error.message : String(error) },
+            };
+        }
+        if (!response.ok) {
+            const message = response.error?.message ?? "Gateway rejected the message";
+            const details = { ok: false, piboSessionId: params.piboSessionId, error: message };
+            return {
+                content: [{ type: "text", text: `Gateway error: ${message}` }],
+                details,
+            };
+        }
+        const details = {
+            ok: true,
+            piboSessionId: params.piboSessionId,
+            gatewayPayload: response.payload,
+            reply: result?.reply.text,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result?.reply
+                        ? result.reply.text
+                        : `Queued message for pibo gateway session "${params.piboSessionId}", but no assistant reply was returned.`,
+                },
+            ],
+            details,
+        };
+    },
+});
+export function createPiboGatewayToolProfiles() {
+    return [createToolProfile(piboGatewaySendTool)];
+}
+function createToolProfile(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        definition,
+    };
+}

package/dist/gateway/web.js

@@ -0,0 +1,80 @@
+import { createDefaultPiboPlugins } from "../plugins/builtin.js";
+import { createPiboBetterAuthPlugin } from "../plugins/better-auth.js";
+import { createPiboChatWebPlugin } from "../plugins/chat-web.js";
+import { createPiboContextFilesPlugin } from "../plugins/context-files.js";
+import { PiboPluginRegistry } from "../plugins/registry.js";
+import { createPiboWebHostPlugin } from "../plugins/web.js";
+import { DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT } from "../web/channel.js";
+import { loadPiboConfig } from "../config/config.js";
+import { PiboGatewayServer } from "./server.js";
+const PUBLIC_WEB_CHANNEL_HOST = "0.0.0.0";
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function authBaseURL(options) {
+    return options.auth?.baseURL ?? loadPiboConfig().auth?.baseURL;
+}
+function defaultWebHost(baseURL) {
+    if (!baseURL)
+        return DEFAULT_WEB_CHANNEL_HOST;
+    try {
+        const hostname = new URL(baseURL).hostname;
+        return LOOPBACK_HOSTS.has(hostname) ? DEFAULT_WEB_CHANNEL_HOST : PUBLIC_WEB_CHANNEL_HOST;
+    }
+    catch {
+        return DEFAULT_WEB_CHANNEL_HOST;
+    }
+}
+export function resolveWebGatewayServerOptions(options = {}) {
+    const baseURL = authBaseURL(options);
+    return {
+        ...options,
+        web: {
+            ...options.web,
+            host: options.web?.host ?? defaultWebHost(baseURL),
+        },
+    };
+}
+export function createWebPiboPluginRegistry(options = {}) {
+    const resolvedOptions = resolveWebGatewayServerOptions(options);
+    return PiboPluginRegistry.create({
+        plugins: [
+            ...createDefaultPiboPlugins(),
+            createPiboBetterAuthPlugin(resolvedOptions.auth),
+            createPiboWebHostPlugin({ announce: false, canonicalBaseURL: authBaseURL(resolvedOptions), ...resolvedOptions.web }),
+            createPiboContextFilesPlugin(resolvedOptions.contextFiles),
+            createPiboChatWebPlugin(resolvedOptions.chat),
+        ],
+    });
+}
+function createChatAppURL(options, host, port) {
+    const baseURL = options.auth?.baseURL ?? loadPiboConfig().auth?.baseURL;
+    if (baseURL) {
+        try {
+            return new URL("/apps/chat", baseURL).toString();
+        }
+        catch {
+            // Fall through to the bound address below.
+        }
+    }
+    return `http://${host}:${port}/apps/chat`;
+}
+export async function runWebGatewayServer(options = {}) {
+    const resolvedOptions = resolveWebGatewayServerOptions(options);
+    const pluginRegistry = resolvedOptions.pluginRegistry ?? createWebPiboPluginRegistry(resolvedOptions);
+    const server = new PiboGatewayServer({
+        ...resolvedOptions,
+        pluginRegistry,
+    });
+    await server.start();
+    const host = resolvedOptions.web?.host ?? DEFAULT_WEB_CHANNEL_HOST;
+    const port = resolvedOptions.web?.port ?? DEFAULT_WEB_CHANNEL_PORT;
+    console.error(`pibo chat app available at ${createChatAppURL(resolvedOptions, host, port)}`);
+    const stop = async () => {
+        await server.stop();
+    };
+    process.once("SIGINT", () => {
+        void stop().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+        void stop().finally(() => process.exit(0));
+    });
+}

package/dist/index.js

@@ -0,0 +1,23 @@
+export { createDefaultPiboProfile, createDefaultPiboPluginRegistry, createDefaultPiboPlugins, createGatewayProducerPiboPluginRegistry, createGatewayProducerPiboProfile, piboCorePlugin, piboGatewayProducerPlugin, } from "./plugins/builtin.js";
+export { createPiboBetterAuthPlugin } from "./plugins/better-auth.js";
+export { createPiboChatWebPlugin } from "./plugins/chat-web.js";
+export { createPiboContextFilesPlugin } from "./plugins/context-files.js";
+export { createPiboWebHostPlugin } from "./plugins/web.js";
+export { createChatWebApp } from "./apps/chat/web-app.js";
+export { createBetterAuthService } from "./auth/better-auth.js";
+export { InitialSessionContext, InitialSessionContextBuilder, } from "./core/profiles.js";
+export { definePiboPlugin, PiboPluginRegistry } from "./plugins/registry.js";
+export { createPiboGatewayToolProfiles } from "./gateway/tool.js";
+export { createPiboRuntime, inspectPiboProfile, runPiboTui } from "./core/runtime.js";
+export { PiboSessionRouter } from "./core/session-router.js";
+export { PiboReliabilityStore, createDefaultPiboReliabilityStore } from "./reliability/store.js";
+export { PiboGatewayServer, runGatewayServer } from "./gateway/server.js";
+export { createWebPiboPluginRegistry, resolveWebGatewayServerOptions, runWebGatewayServer } from "./gateway/web.js";
+export { runGatewayClient } from "./gateway/client.js";
+export { LOCAL_TUI_CHANNEL_NAME, LocalRoutedTuiClient, createLocalRoutedTuiClient, createLocalRoutedTuiExtension, runLocalRoutedTui, } from "./local/tui.js";
+export { createWebHostChannel, DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT, WEB_CHANNEL_NAME } from "./web/channel.js";
+export { sendGatewayEvent, sendGatewayMessageAndWaitForReply } from "./gateway/request.js";
+export { createSubagentToolDefinitions, createSubagentToolName, } from "./subagents/tool.js";
+export { InMemoryPiboSessionStore, createPiSessionId, createPiboSessionId, createPiboSession, } from "./sessions/store.js";
+export { runPiboCli } from "./cli.js";
+export { DEFAULT_PIBO_CONFIG_PATH, PIBO_CONFIG_KEYS, deletePiboConfigValue, getDisplayPiboConfigValue, getPiboConfigValue, isPiboConfigKeySecret, loadPiboConfig, redactPiboConfig, savePiboConfig, setPiboConfigValue, } from "./config/config.js";

package/dist/local/client.js

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { PiboSessionRouter } from "../core/session-router.js";
+import { createDefaultPiboPluginRegistry } from "../plugins/builtin.js";
+import { getDefaultPiboWorkspace } from "../core/workspace.js";
+import { InMemoryPiboSessionStore, } from "../sessions/store.js";
+export const LOCAL_TUI_CHANNEL_NAME = "local-tui";
+export class LocalRoutedTuiClient {
+    router;
+    piboSession;
+    capabilities;
+    unsubscribe;
+    eventListeners = new Set();
+    closed = false;
+    constructor(router, piboSession, capabilities) {
+        this.router = router;
+        this.piboSession = piboSession;
+        this.capabilities = capabilities;
+        this.unsubscribe = router.subscribe((event) => {
+            if (event.piboSessionId !== this.piboSession.id)
+                return;
+            for (const listener of this.eventListeners) {
+                listener(event);
+            }
+        });
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    sendMessage(text) {
+        return this.router.emit({
+            type: "message",
+            piboSessionId: this.piboSession.id,
+            id: randomUUID(),
+            text,
+            source: "ui",
+        });
+    }
+    sendExecution(action, params) {
+        const event = params === undefined
+            ? { type: "execution", piboSessionId: this.piboSession.id, id: randomUUID(), action }
+            : { type: "execution", piboSessionId: this.piboSession.id, id: randomUUID(), action, params };
+        return this.router.emit(event);
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.unsubscribe();
+        this.eventListeners.clear();
+        await this.router.disposeAll();
+    }
+}
+export function createLocalRoutedTuiClient(options = {}) {
+    const registry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
+    const profileName = registry.resolveProfileName(options.profile ?? "pibo-minimal");
+    const profile = registry.createProfile(profileName);
+    const sessionName = options.sessionName ?? "default";
+    const workspace = options.cwd ?? getDefaultPiboWorkspace();
+    const sessionStore = new InMemoryPiboSessionStore();
+    const piboSession = sessionStore.create({
+        channel: LOCAL_TUI_CHANNEL_NAME,
+        kind: "local",
+        profile: profileName,
+        title: sessionName,
+        workspace,
+    });
+    const router = new PiboSessionRouter({
+        cwd: workspace,
+        persistSession: options.persistSession,
+        thinkingLevel: options.thinkingLevel,
+        pluginRegistry: registry,
+        profile,
+        sessionStore,
+    });
+    return new LocalRoutedTuiClient(router, piboSession, { actions: registry.getGatewayActionInfos() });
+}