@pasko70/pibo 1.0.0

package/dist/plugins/core-tools.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import { Type } from "@mariozechner/pi-ai";
+import { defineTool } from "@mariozechner/pi-coding-agent";
+const DEFAULT_MAX_OUTPUT_CHARS = 20000;
+function truncate(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, maxChars)}\n[truncated ${value.length - maxChars} chars]`;
+}
+const piboExecTool = defineTool({
+    name: "pibo_exec",
+    label: "Pibo Exec",
+    description: "Run a shell command on this machine with full agent privileges.",
+    promptSnippet: "Run a shell command on this machine. Use directly for short commands, or wrap with pibo_run_start for long-running commands.",
+    parameters: Type.Object({
+        command: Type.String({ description: "Shell command to run through bash -lc" }),
+        cwd: Type.Optional(Type.String({ description: "Working directory. Defaults to the pibo runtime cwd." })),
+        timeoutMs: Type.Optional(Type.Number({ description: "Optional timeout in milliseconds. Omit for no timeout." })),
+        maxOutputChars: Type.Optional(Type.Number({ description: "Maximum stdout/stderr chars returned per stream" })),
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        const cwd = params.cwd ?? ctx.cwd;
+        const maxOutputChars = Math.max(0, params.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS);
+        const result = await new Promise((resolve, reject) => {
+            const child = spawn("bash", ["-lc", params.command], {
+                cwd,
+                env: process.env,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timeout = params.timeoutMs && params.timeoutMs > 0
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill("SIGTERM");
+                }, params.timeoutMs)
+                : undefined;
+            const abort = () => {
+                timedOut = false;
+                child.kill("SIGTERM");
+            };
+            signal?.addEventListener("abort", abort, { once: true });
+            child.stdout?.on("data", (chunk) => {
+                stdout += String(chunk);
+            });
+            child.stderr?.on("data", (chunk) => {
+                stderr += String(chunk);
+            });
+            child.once("error", (error) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                signal?.removeEventListener("abort", abort);
+                reject(error);
+            });
+            child.once("close", (exitCode, exitSignal) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                signal?.removeEventListener("abort", abort);
+                resolve({
+                    command: params.command,
+                    cwd,
+                    exitCode,
+                    signal: exitSignal,
+                    stdout: truncate(stdout, maxOutputChars),
+                    stderr: truncate(stderr, maxOutputChars),
+                    timedOut,
+                });
+            });
+        });
+        const text = [
+            `exitCode: ${result.exitCode}`,
+            result.signal ? `signal: ${result.signal}` : undefined,
+            result.timedOut ? "timedOut: true" : undefined,
+            result.stdout ? `stdout:\n${result.stdout}` : undefined,
+            result.stderr ? `stderr:\n${result.stderr}` : undefined,
+        ].filter(Boolean).join("\n\n");
+        return {
+            content: [{ type: "text", text }],
+            details: result,
+            isError: result.exitCode !== 0,
+        };
+    },
+});
+export function createPiboCoreToolProfiles() {
+    return [createToolProfile(piboExecTool)];
+}
+function createToolProfile(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        definition,
+    };
+}

package/dist/plugins/example.js

@@ -0,0 +1,67 @@
+import { Type } from "@mariozechner/pi-ai";
+import { defineTool } from "@mariozechner/pi-coding-agent";
+import { InitialSessionContextBuilder } from "../core/profiles.js";
+import { definePiboPlugin } from "./registry.js";
+const EXAMPLE_SKILL = "pibo-example-plugin";
+const EXAMPLE_TOOL = "pibo_example_plugin_note";
+const piboExamplePluginTool = defineTool({
+    name: EXAMPLE_TOOL,
+    label: "Pibo Example Plugin Note",
+    description: "Return a short note from the minimal pibo example plugin.",
+    promptSnippet: "Use this tool to verify that a pibo plugin can add a custom tool.",
+    parameters: Type.Object({
+        note: Type.String({ description: "Short note to return from the example plugin tool" }),
+    }),
+    async execute(_toolCallId, params) {
+        return {
+            content: [{ type: "text", text: `Example plugin note: ${params.note}` }],
+            details: {
+                plugin: "pibo.example",
+                note: params.note,
+            },
+        };
+    },
+});
+export const piboExamplePlugin = definePiboPlugin({
+    id: "pibo.example",
+    name: "Pibo Example Plugin",
+    register(api) {
+        let stopExampleChannel;
+        api.registerSkill({
+            name: EXAMPLE_SKILL,
+            path: "examples/skills/pibo-example-plugin/SKILL.md",
+        });
+        api.registerTool(createToolProfile(piboExamplePluginTool));
+        api.registerProfile({
+            name: "pibo-example-plugin",
+            aliases: ["example-plugin"],
+            description: "Minimal profile that demonstrates plugin-provided skills and tools.",
+            create(context) {
+                return new InitialSessionContextBuilder("pibo-example-plugin")
+                    .addSkill(context.getSkill(EXAMPLE_SKILL))
+                    .addTool(context.getTool(EXAMPLE_TOOL))
+                    .createSession();
+            },
+        });
+        api.registerChannel({
+            name: "pibo-example-channel",
+            kind: "custom",
+            description: "Minimal no-op channel that demonstrates plugin channel registration.",
+            auth: { mode: "trusted-local" },
+            start(context) {
+                stopExampleChannel = context.subscribe(() => { });
+            },
+            stop() {
+                stopExampleChannel?.();
+                stopExampleChannel = undefined;
+            },
+        });
+    },
+});
+function createToolProfile(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        definition,
+    };
+}

package/dist/plugins/registry.js

@@ -0,0 +1,368 @@
+import { randomUUID } from "node:crypto";
+import { listInstalledCliToolAgentContexts } from "../tools/registry.js";
+import { listPiPackages } from "../pi-packages/store.js";
+function getWebAppRoutes(app) {
+    return [
+        { label: "mountPath", prefix: app.mountPath },
+        { label: "apiPrefix", prefix: app.apiPrefix },
+    ];
+}
+function validateWebRoute(appName, label, prefix) {
+    if (!prefix.startsWith("/")) {
+        throw new Error(`Web app "${appName}" ${label} must start with "/"`);
+    }
+    if (prefix.length > 1 && prefix.endsWith("/")) {
+        throw new Error(`Web app "${appName}" ${label} must not end with "/"`);
+    }
+}
+function webRoutesOverlap(left, right) {
+    return left === right || left === "/" || right === "/" || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+export class PiboPluginRegistry {
+    tools = new Map();
+    subagents = new Map();
+    skills = new Map();
+    contextFiles = new Map();
+    profiles = new Map();
+    profileAliases = new Map();
+    gatewayActions = new Map();
+    gatewaySlashCommands = new Map();
+    channels = new Map();
+    authService;
+    webApps = new Map();
+    eventListeners = new Set();
+    productEventListeners = new Set();
+    pluginIds = new Set();
+    pluginNames = new Map();
+    eventErrors = [];
+    static create(options = {}) {
+        const registry = new PiboPluginRegistry();
+        for (const plugin of options.plugins ?? []) {
+            registry.registerPlugin(plugin);
+        }
+        return registry;
+    }
+    registerPlugin(plugin) {
+        if (this.pluginIds.has(plugin.id)) {
+            throw new Error(`Plugin "${plugin.id}" is already registered`);
+        }
+        this.pluginIds.add(plugin.id);
+        this.pluginNames.set(plugin.id, plugin.name ?? plugin.id);
+        plugin.register(this.createApi(plugin.id));
+    }
+    registerTool(tool) {
+        this.addUnique(this.tools, tool.name, tool, "tool");
+    }
+    registerTools(tools) {
+        for (const tool of tools) {
+            this.registerTool(tool);
+        }
+    }
+    registerSubagent(subagent) {
+        this.addUnique(this.subagents, subagent.name, subagent, "subagent");
+    }
+    registerSubagents(subagents) {
+        for (const subagent of subagents) {
+            this.registerSubagent(subagent);
+        }
+    }
+    registerSkill(skill) {
+        this.addUnique(this.skills, skill.name, skill, "skill");
+    }
+    registerContextFile(contextFile) {
+        this.addUnique(this.contextFiles, contextFileKey(contextFile), contextFile, "context file");
+    }
+    upsertContextFile(contextFile) {
+        this.contextFiles.set(contextFileKey(contextFile), contextFile);
+    }
+    removeContextFile(key) {
+        this.contextFiles.delete(key);
+    }
+    registerProfile(profile) {
+        this.addUnique(this.profiles, profile.name, profile, "profile");
+        this.registerProfileAliases(profile);
+    }
+    upsertProfile(profile) {
+        this.profiles.set(profile.name, profile);
+        for (const [alias, profileName] of this.profileAliases.entries()) {
+            if (profileName === profile.name)
+                this.profileAliases.delete(alias);
+        }
+        this.registerProfileAliases(profile);
+    }
+    removeProfile(name) {
+        const resolvedName = this.profileAliases.get(name) ?? name;
+        if (!this.profiles.delete(resolvedName))
+            return;
+        for (const [alias, profileName] of this.profileAliases.entries()) {
+            if (profileName === resolvedName)
+                this.profileAliases.delete(alias);
+        }
+    }
+    registerGatewayAction(action) {
+        const slashCommands = this.getGatewaySlashCommandsToRegister(action);
+        this.addUnique(this.gatewayActions, action.name, action, "gateway action");
+        for (const slashCommand of slashCommands) {
+            this.gatewaySlashCommands.set(slashCommand, action.name);
+        }
+    }
+    registerChannel(channel) {
+        this.addUnique(this.channels, channel.name, channel, "channel");
+    }
+    registerAuthService(service) {
+        if (this.authService) {
+            throw new Error(`Auth service "${this.authService.name}" is already registered`);
+        }
+        this.authService = service;
+    }
+    registerWebApp(app) {
+        if (this.webApps.has(app.name)) {
+            throw new Error(`Duplicate web app "${app.name}"`);
+        }
+        this.validateWebAppRoutes(app);
+        this.webApps.set(app.name, app);
+    }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+    }
+    onProductEvent(listener) {
+        this.productEventListeners.add(listener);
+        return () => {
+            this.productEventListeners.delete(listener);
+        };
+    }
+    createProfile(name) {
+        const resolvedName = this.resolveProfileName(name);
+        const profile = this.profiles.get(resolvedName);
+        if (!profile)
+            throw new Error(`Unknown profile "${name}"`);
+        return profile.create(this.createProfileBuildContext());
+    }
+    getProfileNames() {
+        return [...this.profiles.keys()];
+    }
+    getProfileInfos() {
+        const context = this.createProfileBuildContext();
+        return [...this.profiles.values()].map((profile) => {
+            const sessionContext = profile.create(context);
+            return {
+                name: profile.name,
+                description: profile.description,
+                aliases: [...(profile.aliases ?? [])],
+                nativeTools: sessionContext.tools.filter((tool) => tool.enabled !== false).map((tool) => tool.name),
+                skills: sessionContext.skills.filter((skill) => skill.enabled !== false).map((skill) => skill.name),
+                contextFiles: sessionContext.contextFiles.filter((contextFile) => contextFile.enabled !== false).map(contextFileKey),
+                subagents: sessionContext.subagents.filter((subagent) => subagent.enabled !== false),
+                mcpServers: [...sessionContext.mcpServers],
+                piPackages: sessionContext.piPackages.filter((pkg) => pkg.enabled !== false).map((pkg) => pkg.id),
+                builtinTools: sessionContext.builtinTools,
+                builtinToolNames: [...sessionContext.builtinToolNames],
+                autoContextFiles: sessionContext.autoContextFiles,
+                runControl: sessionContext.toolPackages.runControl === true,
+            };
+        });
+    }
+    getCapabilityCatalog() {
+        return {
+            nativeTools: [...this.tools.values()].map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                yieldable: tool.yieldable !== false,
+                hasDefinition: tool.definition !== undefined,
+                pluginId: tool.pluginId,
+                pluginName: tool.pluginId ? this.pluginNames.get(tool.pluginId) : undefined,
+                ...(tool.providerTool ? { providerTool: tool.providerTool } : {}),
+            })),
+            skills: [...this.skills.values()].map((skill) => ({
+                name: skill.name,
+                path: skill.path,
+            })),
+            subagents: [...this.subagents.values()].map((subagent) => ({
+                name: subagent.name,
+                description: subagent.description,
+                targetProfile: subagent.targetProfile,
+                timeoutMs: subagent.timeoutMs,
+                maxDepth: subagent.maxDepth,
+            })),
+            contextFiles: [...this.contextFiles.entries()].map(([key, contextFile]) => ({
+                key,
+                label: contextFile.label,
+                path: contextFile.path,
+                scope: contextFile.scope ?? "global",
+                source: contextFile.source ?? "plugin",
+                pluginId: contextFile.pluginId,
+                pluginName: contextFile.pluginId ? this.pluginNames.get(contextFile.pluginId) : undefined,
+                agentProfileName: contextFile.agentProfileName,
+            })),
+            packages: [
+                {
+                    name: "pibo-run-control",
+                    description: "Expose pibo_run_* tools as one package for yielded native tools and subagents.",
+                    toolNames: [
+                        "pibo_run_start",
+                        "pibo_run_list",
+                        "pibo_run_status",
+                        "pibo_run_wait",
+                        "pibo_run_read",
+                        "pibo_run_cancel",
+                        "pibo_run_ack",
+                    ],
+                },
+            ],
+            piboTools: listInstalledCliToolAgentContexts(),
+            mcpServers: [],
+            piPackages: listPiPackages(),
+        };
+    }
+    resolveProfileName(name) {
+        const resolvedName = this.profileAliases.get(name) ?? name;
+        if (!this.profiles.has(resolvedName)) {
+            throw new Error(`Unknown profile "${name}". Available profiles: ${this.getProfileNames().join(", ")}`);
+        }
+        return resolvedName;
+    }
+    getGatewayAction(name) {
+        return this.gatewayActions.get(name);
+    }
+    getGatewayActionInfos() {
+        return [...this.gatewayActions.values()]
+            .filter((action) => action.hidden !== true)
+            .map((action) => ({
+            name: action.name,
+            description: action.description,
+            slashCommands: [...(action.slashCommands ?? [])],
+        }));
+    }
+    getChannels() {
+        return [...this.channels.values()];
+    }
+    getAuthService() {
+        return this.authService;
+    }
+    getWebApps() {
+        return [...this.webApps.values()];
+    }
+    getEventErrors() {
+        return [...this.eventErrors];
+    }
+    notifyEvent(event) {
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this.eventErrors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    emitProductEvent(input) {
+        const event = {
+            ...input,
+            id: input.id ?? randomUUID(),
+            createdAt: input.createdAt ?? new Date().toISOString(),
+        };
+        for (const listener of this.productEventListeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this.eventErrors.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        return event;
+    }
+    createApi(pluginId) {
+        const withPluginToolContext = (tool) => ({ ...tool, pluginId: tool.pluginId ?? pluginId });
+        const withPluginContext = (contextFile) => (contextFile.source === "managed" ? contextFile : { ...contextFile, pluginId: contextFile.pluginId ?? pluginId });
+        return {
+            registerTool: (tool) => this.registerTool(withPluginToolContext(tool)),
+            registerTools: (tools) => this.registerTools(tools.map(withPluginToolContext)),
+            registerSubagent: (subagent) => this.registerSubagent(subagent),
+            registerSubagents: (subagents) => this.registerSubagents(subagents),
+            registerSkill: (skill) => this.registerSkill(skill),
+            registerContextFile: (contextFile) => this.registerContextFile(withPluginContext(contextFile)),
+            upsertContextFile: (contextFile) => this.upsertContextFile(withPluginContext(contextFile)),
+            removeContextFile: (key) => this.removeContextFile(key),
+            registerProfile: (profile) => this.registerProfile(profile),
+            registerGatewayAction: (action) => this.registerGatewayAction(action),
+            registerChannel: (channel) => this.registerChannel(channel),
+            registerAuthService: (service) => this.registerAuthService(service),
+            registerWebApp: (app) => this.registerWebApp(app),
+            onEvent: (listener) => this.onEvent(listener),
+            emitProductEvent: (event) => this.emitProductEvent(event),
+            onProductEvent: (listener) => this.onProductEvent(listener),
+        };
+    }
+    createProfileBuildContext() {
+        return {
+            getTool: (name) => this.getRequired(this.tools, name, "tool"),
+            getTools: (names) => names.map((name) => this.getRequired(this.tools, name, "tool")),
+            getSkill: (name) => this.getRequired(this.skills, name, "skill"),
+            getContextFile: (key) => this.getRequired(this.contextFiles, key, "context file"),
+            getSubagent: (name) => this.getRequired(this.subagents, name, "subagent"),
+            getSubagents: (names) => names.map((name) => this.getRequired(this.subagents, name, "subagent")),
+        };
+    }
+    getRequired(map, key, label) {
+        const value = map.get(key);
+        if (!value) {
+            throw new Error(`Unknown ${label} "${key}"`);
+        }
+        return value;
+    }
+    registerProfileAliases(profile) {
+        for (const alias of profile.aliases ?? []) {
+            const existingAliasProfile = this.profileAliases.get(alias);
+            if (this.profiles.has(alias) || (existingAliasProfile && existingAliasProfile !== profile.name)) {
+                throw new Error(`Profile alias "${alias}" is already registered`);
+            }
+            this.profileAliases.set(alias, profile.name);
+        }
+    }
+    addUnique(map, key, value, label) {
+        if (map.has(key)) {
+            throw new Error(`Duplicate ${label} "${key}"`);
+        }
+        map.set(key, value);
+    }
+    validateWebAppRoutes(app) {
+        const routes = getWebAppRoutes(app);
+        for (const route of routes) {
+            validateWebRoute(app.name, route.label, route.prefix);
+        }
+        for (const existing of this.webApps.values()) {
+            for (const route of routes) {
+                for (const existingRoute of getWebAppRoutes(existing)) {
+                    if (webRoutesOverlap(route.prefix, existingRoute.prefix)) {
+                        throw new Error(`Web app route "${route.prefix}" for "${app.name}" overlaps ${existingRoute.label} "${existingRoute.prefix}" from web app "${existing.name}"`);
+                    }
+                }
+            }
+        }
+    }
+    getGatewaySlashCommandsToRegister(action) {
+        if (action.hidden === true)
+            return [];
+        const slashCommands = [];
+        for (const slashCommand of action.slashCommands ?? []) {
+            if (!slashCommand || slashCommand.startsWith("/") || /\s/.test(slashCommand)) {
+                throw new Error(`Invalid slash command "${slashCommand}" for gateway action "${action.name}"`);
+            }
+            const existingAction = this.gatewaySlashCommands.get(slashCommand);
+            if (existingAction) {
+                throw new Error(`Duplicate slash command "${slashCommand}" for gateway actions "${existingAction}" and "${action.name}"`);
+            }
+            if (slashCommands.includes(slashCommand)) {
+                throw new Error(`Duplicate slash command "${slashCommand}" for gateway action "${action.name}"`);
+            }
+            slashCommands.push(slashCommand);
+        }
+        return slashCommands;
+    }
+}
+function contextFileKey(contextFile) {
+    return contextFile.key ?? contextFile.label ?? contextFile.path;
+}
+export function definePiboPlugin(plugin) {
+    return plugin;
+}

package/dist/plugins/remote-agent.js

@@ -0,0 +1,9 @@
+import { createRemoteAgentChannel } from "../remote/channel.js";
+import { definePiboPlugin } from "./registry.js";
+export const piboRemoteAgentPlugin = definePiboPlugin({
+    id: "pibo.remote-agent",
+    name: "Pibo Remote Agent",
+    register(api) {
+        api.registerChannel(createRemoteAgentChannel());
+    },
+});

package/dist/plugins/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/web.js

@@ -0,0 +1,11 @@
+import { createWebHostChannel } from "../web/channel.js";
+import { definePiboPlugin } from "./registry.js";
+export function createPiboWebHostPlugin(options = {}) {
+    return definePiboPlugin({
+        id: "pibo.web-host",
+        name: "Pibo Web Host",
+        register(api) {
+            api.registerChannel(createWebHostChannel(options));
+        },
+    });
+}