@pasko70/pibo 1.1.0 → 1.3.0

package/dist/gateway/pidfile.js

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { piboHomePath } from "../core/pibo-home.js";
+function gatewayPidPath() {
+    return piboHomePath("gateway.pid");
+}
+function fallbackGatewayPidPath() {
+    return piboHomePath("gateway-fallback.pid");
+}
+export function readPidFile() {
+    try {
+        const path = gatewayPidPath();
+        if (!existsSync(path))
+            return undefined;
+        const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
+        if (Number.isNaN(pid))
+            return undefined;
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function clearPidFile() {
+    try {
+        const path = gatewayPidPath();
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+export function writeGatewayPid() {
+    const existingPid = readPidFile();
+    if (existingPid !== undefined && existingPid !== process.pid) {
+        throw new Error(`Gateway already running (PID ${existingPid})`);
+    }
+    writeFileSync(gatewayPidPath(), String(process.pid), "utf-8");
+}
+export function readFallbackPidFile() {
+    try {
+        const path = fallbackGatewayPidPath();
+        if (!existsSync(path))
+            return undefined;
+        const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
+        if (Number.isNaN(pid))
+            return undefined;
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+export function clearFallbackPidFile() {
+    try {
+        const path = fallbackGatewayPidPath();
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+export function writeFallbackGatewayPid() {
+    const existingPid = readFallbackPidFile();
+    if (existingPid !== undefined && existingPid !== process.pid) {
+        throw new Error(`Fallback gateway already running (PID ${existingPid})`);
+    }
+    writeFileSync(fallbackGatewayPidPath(), String(process.pid), "utf-8");
+}

package/dist/gateway/protocol.js

@@ -33,6 +33,22 @@ export function isGatewayRequestFrame(value) {
     }
     return false;
 }
+export function isGatewaySubscribeFrame(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const frame = value;
+    if (frame.type !== "subscribe" || typeof frame.id !== "string")
+        return false;
+    if (!frame.subscription || typeof frame.subscription !== "object")
+        return false;
+    const subscription = frame.subscription;
+    if (subscription.type === "legacy-all")
+        return true;
+    if (subscription.type === "session") {
+        return typeof subscription.piboSessionId === "string" && subscription.piboSessionId.length > 0;
+    }
+    return false;
+}
 export function encodeFrame(frame) {
     return `${JSON.stringify(frame)}\n`;
 }

package/dist/gateway/server.js

@@ -1,7 +1,11 @@
 import { createServer } from "node:net";
-import { createDefaultPiboPluginRegistry } from "../plugins/builtin.js";
+import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
 import { PiboSessionRouter } from "../core/session-router.js";
-import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, errorResponse, isGatewayRequestFrame, } from "./protocol.js";
+import { loadPiboModelDefaults, selectRequestedModelProfile } from "../core/model-defaults.js";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, errorResponse, isGatewayRequestFrame, isGatewaySubscribeFrame, } from "./protocol.js";
+import { clearFallbackPidFile, clearPidFile, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
+const DEFAULT_MAX_BACKPRESSURE_FRAMES = 1_000;
+const DEFAULT_MAX_BACKPRESSURE_BYTES = 4 * 1024 * 1024;
 function parseJsonLine(line) {
     try {
         return JSON.parse(line);
@@ -10,21 +14,110 @@ function parseJsonLine(line) {
         throw new Error("Invalid JSON frame");
     }
 }
-function createConnection(socket) {
-    return {
+function classifyGatewayEvent(event) {
+    if (event.type === "assistant_delta" || event.type === "thinking_delta" || event.type === "tool_execution_updated") {
+        return "live-delta";
+    }
+    if (event.type === "pi_event")
+        return "debug";
+    if (event.type === "session_error" || event.type === "execution_result" || event.type.endsWith("_finished")) {
+        return "critical";
+    }
+    return "structural";
+}
+function isDroppableRouterEvent(event) {
+    const eventClass = classifyGatewayEvent(event);
+    return eventClass === "live-delta" || eventClass === "debug";
+}
+function createConnection(socket, options) {
+    const queue = [];
+    const diagnostics = {
+        slow: false,
+        queuedFrames: 0,
+        queuedBytes: 0,
+        droppedEvents: 0,
+        closedForBackpressure: false,
+        subscription: { type: "legacy-all" },
+    };
+    function syncDiagnostics() {
+        diagnostics.queuedFrames = queue.length;
+        diagnostics.queuedBytes = queue.reduce((sum, item) => sum + item.bytes, 0);
+    }
+    function recordDroppedEvent() {
+        diagnostics.droppedEvents += 1;
+        options.onDroppedEvent();
+    }
+    function closeForBackpressure() {
+        if (!diagnostics.closedForBackpressure) {
+            diagnostics.closedForBackpressure = true;
+            options.onClosedForBackpressure();
+        }
+        socket.destroy(new Error("Gateway client closed because its send backlog exceeded the backpressure limit"));
+    }
+    function tryFlush() {
+        if (socket.destroyed)
+            return;
+        diagnostics.slow = false;
+        while (queue.length > 0) {
+            const next = queue[0];
+            const accepted = socket.write(encodeFrame(next.frame));
+            queue.shift();
+            syncDiagnostics();
+            if (!accepted) {
+                diagnostics.slow = true;
+                return;
+            }
+        }
+    }
+    socket.on("drain", tryFlush);
+    const connection = {
         socket,
-        send(frame) {
+        subscription: diagnostics.subscription,
+        diagnostics,
+        send(frame, sendOptions = {}) {
             if (socket.destroyed)
                 return;
-            socket.write(encodeFrame(frame));
+            const encoded = encodeFrame(frame);
+            if (!diagnostics.slow && queue.length === 0) {
+                const accepted = socket.write(encoded);
+                if (accepted)
+                    return;
+                diagnostics.slow = true;
+            }
+            const queued = { frame, bytes: Buffer.byteLength(encoded), droppable: sendOptions.droppable === true };
+            if (queued.droppable && (queue.length >= options.maxBackpressureFrames || diagnostics.queuedBytes + queued.bytes > options.maxBackpressureBytes)) {
+                recordDroppedEvent();
+                return;
+            }
+            queue.push(queued);
+            syncDiagnostics();
+            if (queue.length > options.maxBackpressureFrames || diagnostics.queuedBytes > options.maxBackpressureBytes) {
+                const dropIndex = queue.findIndex((item) => item.droppable);
+                if (dropIndex >= 0) {
+                    queue.splice(dropIndex, 1);
+                    recordDroppedEvent();
+                    syncDiagnostics();
+                }
+                else {
+                    closeForBackpressure();
+                }
+            }
+        },
+        matches(event) {
+            if (connection.subscription.type === "legacy-all")
+                return true;
+            return event.piboSessionId === connection.subscription.piboSessionId;
         },
     };
+    return connection;
 }
 async function createGatewaySessionStore(options) {
-    const { createDefaultPiboSessionStore, SqlitePiboSessionStore } = await import("../sessions/sqlite-store.js");
-    return options.sessionDbPath
-        ? new SqlitePiboSessionStore(options.sessionDbPath)
-        : createDefaultPiboSessionStore();
+    if (options.sessionDbPath) {
+        const { SqlitePiboSessionStore } = await import("../sessions/sqlite-store.js");
+        return new SqlitePiboSessionStore(options.sessionDbPath);
+    }
+    const { createDefaultPiboDataSessionStore } = await import("../sessions/pibo-data-store.js");
+    return createDefaultPiboDataSessionStore();
 }
 export class PiboGatewayServer {
     options;
@@ -34,6 +127,8 @@ export class PiboGatewayServer {
     router;
     startedChannels = [];
     connections = new Set();
+    droppedRouterEvents = 0;
+    closedSlowClients = 0;
     server;
     unsubscribe;
     constructor(options = {}) {
@@ -89,7 +184,16 @@ export class PiboGatewayServer {
         this.ownsSessionStore = false;
     }
     handleSocket(socket) {
-        const connection = createConnection(socket);
+        const connection = createConnection(socket, {
+            maxBackpressureFrames: this.options.maxBackpressureFrames ?? DEFAULT_MAX_BACKPRESSURE_FRAMES,
+            maxBackpressureBytes: this.options.maxBackpressureBytes ?? DEFAULT_MAX_BACKPRESSURE_BYTES,
+            onDroppedEvent: () => {
+                this.droppedRouterEvents += 1;
+            },
+            onClosedForBackpressure: () => {
+                this.closedSlowClients += 1;
+            },
+        });
         this.connections.add(connection);
         let buffer = "";
         socket.setEncoding("utf-8");
@@ -116,14 +220,21 @@ export class PiboGatewayServer {
         let frame;
         try {
             frame = parseJsonLine(line);
-            if (!isGatewayRequestFrame(frame)) {
-                throw new Error("Invalid request frame");
-            }
         }
         catch (error) {
             connection.send(errorResponse("invalid", error));
             return;
         }
+        if (isGatewaySubscribeFrame(frame)) {
+            connection.subscription = frame.subscription;
+            connection.diagnostics.subscription = frame.subscription;
+            connection.send({ type: "res", id: frame.id, ok: true, payload: { subscription: frame.subscription } });
+            return;
+        }
+        if (!isGatewayRequestFrame(frame)) {
+            connection.send(errorResponse("invalid", new Error("Invalid request frame")));
+            return;
+        }
         try {
             const output = await this.requireRouter().emit(frame.event);
             const response = {
@@ -140,9 +251,21 @@ export class PiboGatewayServer {
     }
     broadcastRouterEvent(event) {
         for (const connection of this.connections) {
-            connection.send({ type: "event", event: "router", payload: event });
+            if (!connection.matches(event))
+                continue;
+            connection.send({ type: "event", event: "router", payload: event }, { droppable: isDroppableRouterEvent(event) });
         }
     }
+    getDiagnostics() {
+        const connectionDetails = [...this.connections].map((connection) => ({ ...connection.diagnostics }));
+        return {
+            connections: connectionDetails.length,
+            slowConnections: connectionDetails.filter((connection) => connection.slow).length,
+            droppedEvents: this.droppedRouterEvents,
+            closedSlowClients: this.closedSlowClients,
+            connectionDetails,
+        };
+    }
     async startChannels() {
         const context = this.createChannelContext();
         for (const channel of this.pluginRegistry.getChannels()) {
@@ -172,16 +295,29 @@ export class PiboGatewayServer {
             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 });
+                const profile = resolvePiboProfileNameFromRegistryOrDefault(this.pluginRegistry, input.profile);
+                const profileContext = createPiboProfileFromRegistryOrDefault(this.pluginRegistry, profile);
+                const activeModel = input.activeModel ?? selectRequestedModelProfile(profileContext, loadPiboModelDefaults());
+                return this.requireSessionStore().create({ ...input, profile, activeModel });
             },
             updateSession: (id, input) => this.requireSessionStore().update(id, input),
+            setLiveSessionActiveModel: (id, model) => this.requireRouter().setLiveSessionActiveModel(id, model),
+            reportSessionError: (id, error, options) => this.requireRouter().reportSessionError(id, error, options),
             deleteSession: (id) => this.requireSessionStore().delete?.(id) ?? false,
             findSessions: (input) => this.requireSessionStore().find(input),
             listSessions: () => this.requireSessionStore().list?.() ?? [],
+            getSessionRuntimeStatus: (piboSessionId) => this.requireRouter().getSessionRuntimeStatus(piboSessionId),
+            listSessionRuntimeStatuses: () => this.requireRouter().listSessionRuntimeStatuses(),
+            listRuns: (options) => this.requireRouter().listRuns(options),
+            snapshotSignalSession: (piboSessionId) => this.requireRouter().snapshotSignalSession(piboSessionId),
+            snapshotSignalTree: (rootPiboSessionId) => this.requireRouter().snapshotSignalTree(rootPiboSessionId),
+            subscribeSignalTree: (rootPiboSessionId, listener) => this.requireRouter().subscribeSignalTree(rootPiboSessionId, listener),
             getGatewayActions: () => this.pluginRegistry.getGatewayActionInfos(),
             getProfiles: () => this.pluginRegistry.getProfileInfos(),
+            createProfile: (name) => this.pluginRegistry.createProfile(name),
             getCapabilityCatalog: () => this.pluginRegistry.getCapabilityCatalog(),
+            getRalphStopConditionDefinitions: () => this.pluginRegistry.getRalphStopConditionDefinitions(),
+            getRalphStopConditionInfos: () => this.pluginRegistry.getRalphStopConditionInfos(),
             upsertProfile: (profile) => this.pluginRegistry.upsertProfile(profile),
             removeProfile: (name) => this.pluginRegistry.removeProfile(name),
             upsertContextFile: (contextFile) => this.pluginRegistry.upsertContextFile(contextFile),
@@ -208,11 +344,30 @@ export class PiboGatewayServer {
 export async function runGatewayServer(options = {}) {
     const server = new PiboGatewayServer(options);
     await server.start();
+    try {
+        if (process.env.PIBO_FALLBACK_MODE === "1") {
+            writeFallbackGatewayPid();
+        }
+        else {
+            writeGatewayPid();
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        await server.stop();
+        process.exit(1);
+    }
     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();
+        if (process.env.PIBO_FALLBACK_MODE === "1") {
+            clearFallbackPidFile();
+        }
+        else {
+            clearPidFile();
+        }
     };
     process.once("SIGINT", () => {
         void stop().finally(() => process.exit(0));

package/dist/gateway/tool.js

@@ -1,62 +1,65 @@
 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",
+export function createPiboGatewaySendTool(sendGatewayMessage = sendGatewayMessageAndWaitForReply) {
+    return 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 sendGatewayMessage({
+                    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,
-                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) },
+                gatewayPayload: response.payload,
+                reply: result?.reply?.text,
             };
-        }
-        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}` }],
+                content: [
+                    {
+                        type: "text",
+                        text: result?.reply
+                            ? result.reply.text
+                            : `Queued message for pibo gateway session "${params.piboSessionId}", but no assistant reply was returned.`,
+                    },
+                ],
                 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,
-        };
-    },
-});
+        },
+    });
+}
+const piboGatewaySendTool = createPiboGatewaySendTool();
 export function createPiboGatewayToolProfiles() {
     return [createToolProfile(piboGatewaySendTool)];
 }

package/dist/gateway/web.js

@@ -1,14 +1,43 @@
+import { existsSync, readFileSync } from "node:fs";
 import { createDefaultPiboPlugins } from "../plugins/builtin.js";
 import { createPiboBetterAuthPlugin } from "../plugins/better-auth.js";
 import { createPiboChatWebPlugin } from "../plugins/chat-web.js";
+import { createPiboChatVscodeWebPlugin } from "../plugins/chat-vscode-web.js";
 import { createPiboContextFilesPlugin } from "../plugins/context-files.js";
+import { createPiboCronPlugin } from "../cron/plugin.js";
+import { createPiboRalphPlugin } from "../ralph/plugin.js";
+import { createPiboDevAuthPlugin } from "../plugins/dev-auth.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";
+import { clearFallbackPidFile, clearPidFile, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
 const PUBLIC_WEB_CHANNEL_HOST = "0.0.0.0";
 const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function isDockerRuntime() {
+    if (existsSync("/.dockerenv"))
+        return true;
+    try {
+        const cgroup = readFileSync("/proc/1/cgroup", "utf-8");
+        return /docker|kubepods|containerd/.test(cgroup);
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveWebGatewayAuthMode(options = {}) {
+    if (!options.devAuth) {
+        if (process.env.PIBO_DEV_AUTH === "1") {
+            throw new Error("PIBO_DEV_AUTH no longer activates dev auth for gateway:web; use the Docker worker entrypoint instead.");
+        }
+        return "better-auth";
+    }
+    if (!isDockerRuntime()) {
+        throw new Error("Pibo dev auth can only be enabled inside a Docker worker runtime.");
+    }
+    return "dev-auth";
+}
 function authBaseURL(options) {
     return options.auth?.baseURL ?? loadPiboConfig().auth?.baseURL;
 }
@@ -33,19 +62,43 @@ export function resolveWebGatewayServerOptions(options = {}) {
         },
     };
 }
+function webGatewayMode(options, useDevAuth) {
+    if (useDevAuth)
+        return "dev";
+    if (options.web?.port === 4808)
+        return "dev";
+    const baseURL = authBaseURL(options);
+    if (baseURL) {
+        try {
+            if (new URL(baseURL).hostname.startsWith("dev."))
+                return "dev";
+        }
+        catch {
+            // Fall through to production mode.
+        }
+    }
+    return "prod";
+}
 export function createWebPiboPluginRegistry(options = {}) {
     const resolvedOptions = resolveWebGatewayServerOptions(options);
+    const useDevAuth = resolveWebGatewayAuthMode(resolvedOptions) === "dev-auth";
     return PiboPluginRegistry.create({
         plugins: [
             ...createDefaultPiboPlugins(),
-            createPiboBetterAuthPlugin(resolvedOptions.auth),
-            createPiboWebHostPlugin({ announce: false, canonicalBaseURL: authBaseURL(resolvedOptions), ...resolvedOptions.web }),
+            useDevAuth ? createPiboDevAuthPlugin() : createPiboBetterAuthPlugin(resolvedOptions.auth),
+            createPiboWebHostPlugin({ announce: false, canonicalBaseURL: useDevAuth ? undefined : authBaseURL(resolvedOptions), gatewayMode: webGatewayMode(resolvedOptions, useDevAuth), ...resolvedOptions.web }),
+            createPiboCronPlugin({ cronStorePath: resolvedOptions.chat?.cronStorePath, dataStorePath: resolvedOptions.chat?.dataStorePath, dataPayloadRootDir: resolvedOptions.chat?.dataPayloadRootDir }),
+            createPiboRalphPlugin({ ralphStorePath: resolvedOptions.chat?.ralphStorePath, dataStorePath: resolvedOptions.chat?.dataStorePath, dataPayloadRootDir: resolvedOptions.chat?.dataPayloadRootDir }),
             createPiboContextFilesPlugin(resolvedOptions.contextFiles),
             createPiboChatWebPlugin(resolvedOptions.chat),
+            createPiboChatVscodeWebPlugin(),
         ],
     });
 }
 function createChatAppURL(options, host, port) {
+    if (options.devAuth) {
+        return `http://${host}:${port}/apps/chat`;
+    }
     const baseURL = options.auth?.baseURL ?? loadPiboConfig().auth?.baseURL;
     if (baseURL) {
         try {
@@ -65,11 +118,30 @@ export async function runWebGatewayServer(options = {}) {
         pluginRegistry,
     });
     await server.start();
+    try {
+        if (process.env.PIBO_FALLBACK_MODE === "1") {
+            writeFallbackGatewayPid();
+        }
+        else {
+            writeGatewayPid();
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        await server.stop();
+        process.exit(1);
+    }
     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();
+        if (process.env.PIBO_FALLBACK_MODE === "1") {
+            clearFallbackPidFile();
+        }
+        else {
+            clearPidFile();
+        }
     };
     process.once("SIGINT", () => {
         void stop().finally(() => process.exit(0));

package/dist/index.js

@@ -11,6 +11,7 @@ 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 { InMemoryPiboSignalRegistry, createPiboSignalRegistry } from "./signals/registry.js";
 export { PiboGatewayServer, runGatewayServer } from "./gateway/server.js";
 export { createWebPiboPluginRegistry, resolveWebGatewayServerOptions, runWebGatewayServer } from "./gateway/web.js";
 export { runGatewayClient } from "./gateway/client.js";
@@ -20,4 +21,5 @@ export { sendGatewayEvent, sendGatewayMessageAndWaitForReply } from "./gateway/r
 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";
+export { DEFAULT_PIBO_CONFIG_PATH, PIBO_CONFIG_KEYS, deletePiboConfigValue, getDefaultPiboConfigPath, getDisplayPiboConfigValue, getPiboConfigValue, isPiboConfigKeySecret, loadPiboConfig, redactPiboConfig, savePiboConfig, setPiboConfigValue, } from "./config/config.js";
+export * from "./tools/runtime/index.js";

package/dist/local/client.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { PiboSessionRouter } from "../core/session-router.js";
-import { createDefaultPiboPluginRegistry } from "../plugins/builtin.js";
+import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
 import { getDefaultPiboWorkspace } from "../core/workspace.js";
 import { InMemoryPiboSessionStore, } from "../sessions/store.js";
 export const LOCAL_TUI_CHANNEL_NAME = "local-tui";
@@ -53,8 +53,8 @@ export class LocalRoutedTuiClient {
 }
 export function createLocalRoutedTuiClient(options = {}) {
     const registry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
-    const profileName = registry.resolveProfileName(options.profile ?? "pibo-minimal");
-    const profile = registry.createProfile(profileName);
+    const profileName = resolvePiboProfileNameFromRegistryOrDefault(registry, options.profile);
+    const profile = createPiboProfileFromRegistryOrDefault(registry, profileName);
     const sessionName = options.sessionName ?? "default";
     const workspace = options.cwd ?? getDefaultPiboWorkspace();
     const sessionStore = new InMemoryPiboSessionStore();