@pasko70/pibo 1.0.0

package/dist/tools/web-search.js

@@ -0,0 +1,137 @@
+const WEB_SEARCH_SOURCES_INCLUDE = "web_search_call.action.sources";
+function hasProviderResponsesShape(payload) {
+    return Boolean(payload && typeof payload === "object" && "input" in payload);
+}
+function hasWebSearchTool(tools) {
+    return tools.some((tool) => {
+        if (!tool || typeof tool !== "object")
+            return false;
+        const type = tool.type;
+        return type === "web_search_preview" || type === "web_search";
+    });
+}
+function isValidDomainFilter(value) {
+    const domain = value.trim();
+    return domain.length > 0 && !domain.includes("://") && !/[/?#\s]/.test(domain);
+}
+function normalizedDomainFilters(values) {
+    const domains = values?.map((value) => value.trim()).filter(isValidDomainFilter) ?? [];
+    return domains.length > 0 ? domains : undefined;
+}
+function normalizedLocation(location) {
+    if (!location)
+        return undefined;
+    const country = location.country?.trim();
+    const region = location.region?.trim();
+    const city = location.city?.trim();
+    const timezone = location.timezone?.trim();
+    if (!country && !region && !city && !timezone)
+        return undefined;
+    return {
+        type: "approximate",
+        ...(country ? { country } : {}),
+        ...(region ? { region } : {}),
+        ...(city ? { city } : {}),
+        ...(timezone ? { timezone } : {}),
+    };
+}
+export function normalizeOpenAiWebSearchConfig(options) {
+    const allowedDomains = normalizedDomainFilters(options?.allowedDomains);
+    const blockedDomains = normalizedDomainFilters(options?.blockedDomains);
+    const userLocation = normalizedLocation(options?.userLocation);
+    return {
+        external_web_access: options?.externalWebAccess ?? true,
+        search_context_size: options?.searchContextSize ?? "medium",
+        include_sources: options?.includeSources ?? true,
+        ...(allowedDomains || blockedDomains
+            ? {
+                filters: {
+                    ...(allowedDomains ? { allowed_domains: allowedDomains } : {}),
+                    ...(blockedDomains ? { blocked_domains: blockedDomains } : {}),
+                },
+            }
+            : {}),
+        ...(userLocation ? { user_location: userLocation } : {}),
+    };
+}
+function buildOpenAiWebSearchProviderTool(config) {
+    const tool = {
+        type: "web_search",
+        external_web_access: config.external_web_access,
+    };
+    if (config.search_context_size)
+        tool.search_context_size = config.search_context_size;
+    if (config.user_location)
+        tool.user_location = config.user_location;
+    if (config.filters?.allowed_domains?.length || config.filters?.blocked_domains?.length) {
+        tool.filters = {
+            ...(config.filters.allowed_domains?.length ? { allowed_domains: config.filters.allowed_domains } : {}),
+            ...(config.filters.blocked_domains?.length ? { blocked_domains: config.filters.blocked_domains } : {}),
+        };
+    }
+    return tool;
+}
+function addOpenAiWebSearchSourcesInclude(payload, config) {
+    if (!config.include_sources)
+        return {};
+    const include = Array.isArray(payload.include) ? [...payload.include] : [];
+    if (!include.includes(WEB_SEARCH_SOURCES_INCLUDE))
+        include.push(WEB_SEARCH_SOURCES_INCLUDE);
+    return { include };
+}
+export function addOpenAiWebSearchProviderTool(payload, config) {
+    if (!hasProviderResponsesShape(payload))
+        return payload;
+    const tools = Array.isArray(payload.tools) ? [...payload.tools] : [];
+    if (hasWebSearchTool(tools))
+        return payload;
+    return {
+        ...payload,
+        ...addOpenAiWebSearchSourcesInclude(payload, config),
+        tools: [...tools, buildOpenAiWebSearchProviderTool(config)],
+    };
+}
+const openAiWebSearchAdapter = {
+    provider: "openai",
+    createExtension(options) {
+        const config = normalizeOpenAiWebSearchConfig(options);
+        return (pi) => {
+            pi.on("before_agent_start", (event) => ({
+                systemPrompt: [
+                    event.systemPrompt,
+                    "# Native Web Search",
+                    "web_search is available as a Pibo native tool through the OpenAI provider adapter. Use it when current or externally sourced information is needed.",
+                ].join("\n\n"),
+            }));
+            pi.on("before_provider_request", (event) => addOpenAiWebSearchProviderTool(event.payload, config));
+        };
+    },
+};
+const WEB_SEARCH_PROVIDER_ADAPTERS = {
+    openai: openAiWebSearchAdapter,
+};
+export function getWebSearchProviderAdapter(provider) {
+    return WEB_SEARCH_PROVIDER_ADAPTERS[provider];
+}
+export function createWebSearchProviderExtension(providerTool) {
+    return getWebSearchProviderAdapter(providerTool.provider).createExtension(providerTool.options);
+}
+export function isWebSearchProviderTool(tool) {
+    return tool.providerTool?.kind === "web_search";
+}
+export function createWebSearchToolProfile(options = {}) {
+    return {
+        name: "web_search",
+        description: "Searches the web through the configured provider adapter.",
+        providerTool: {
+            kind: "web_search",
+            provider: "openai",
+            options: {
+                externalWebAccess: true,
+                searchContextSize: "medium",
+                includeSources: true,
+                ...options,
+            },
+        },
+    };
+}

package/dist/web/auth.js

@@ -0,0 +1,10 @@
+import { createUnauthenticatedError } from "../auth/types.js";
+export async function getWebAuthSession(context, request) {
+    return context.auth?.getSession(request.headers);
+}
+export async function requireWebSession(context, request) {
+    const authSession = await getWebAuthSession(context, request);
+    if (!authSession)
+        throw createUnauthenticatedError();
+    return { authSession, ownerScope: `user:${authSession.identity.userId}` };
+}

package/dist/web/channel.js

@@ -0,0 +1,151 @@
+import { createServer } from "node:http";
+import { PiboAuthError } from "../auth/types.js";
+import { requireWebSession } from "./auth.js";
+import { PiboWebHttpError, nodeRequestToWebRequest, responseHtml, responseJson, sendWebResponse } from "./http.js";
+export const DEFAULT_WEB_CHANNEL_HOST = "127.0.0.1";
+export const DEFAULT_WEB_CHANNEL_PORT = 4788;
+export const WEB_CHANNEL_NAME = "web-host";
+function redirect(location) {
+    return new Response(null, {
+        status: 302,
+        headers: { location },
+    });
+}
+function matchPrefix(pathname, prefix) {
+    return pathname === prefix || pathname.startsWith(`${prefix}/`);
+}
+function notFound() {
+    return responseJson({ error: "Not found" }, { status: 404 });
+}
+function createAppContext(channelContext) {
+    return {
+        channelContext,
+        requireSession(input) {
+            return requireWebSession(channelContext, input.request);
+        },
+    };
+}
+function firstHeaderValue(value) {
+    const raw = Array.isArray(value) ? value[0] : value;
+    return raw?.split(",")[0]?.trim() || undefined;
+}
+function isLoopbackAddress(address) {
+    return address === "::1" || address === "127.0.0.1" || address?.startsWith("127.") === true || address?.startsWith("::ffff:127.") === true;
+}
+function createRequestBaseURL(nodeRequest, host, port) {
+    if (isLoopbackAddress(nodeRequest.socket.remoteAddress)) {
+        const forwardedHost = firstHeaderValue(nodeRequest.headers["x-forwarded-host"]);
+        const forwardedProto = firstHeaderValue(nodeRequest.headers["x-forwarded-proto"]);
+        if (forwardedHost && (forwardedProto === "http" || forwardedProto === "https")) {
+            return `${forwardedProto}://${forwardedHost}`;
+        }
+    }
+    return `http://${nodeRequest.headers.host ?? `${host}:${port}`}`;
+}
+function createCanonicalRedirect(request, canonicalBaseURL) {
+    if (!canonicalBaseURL || (request.method !== "GET" && request.method !== "HEAD"))
+        return undefined;
+    const url = new URL(request.url);
+    const canonical = new URL(canonicalBaseURL);
+    if (url.origin === canonical.origin)
+        return undefined;
+    if (url.pathname !== "/" && !matchPrefix(url.pathname, "/apps") && !matchPrefix(url.pathname, "/api/auth")) {
+        return undefined;
+    }
+    return redirect(new URL(`${url.pathname}${url.search}`, canonical.origin).toString());
+}
+export function createWebHostChannel(options = {}) {
+    const host = options.host ?? DEFAULT_WEB_CHANNEL_HOST;
+    const port = options.port ?? DEFAULT_WEB_CHANNEL_PORT;
+    let server;
+    let context;
+    const requireContext = () => {
+        if (!context)
+            throw new Error("Web channel is not started");
+        return context;
+    };
+    const handleAuthRequest = async (request) => {
+        const auth = requireContext().auth;
+        if (!auth?.handleRequest) {
+            return responseJson({ error: "Auth service does not expose HTTP routes" }, { status: 500 });
+        }
+        return auth.handleRequest(request);
+    };
+    const handleRequest = async (nodeRequest, nodeResponse) => {
+        try {
+            const baseURL = createRequestBaseURL(nodeRequest, host, port);
+            const request = await nodeRequestToWebRequest(nodeRequest, baseURL);
+            const url = new URL(request.url);
+            const canonicalRedirect = createCanonicalRedirect(request, options.canonicalBaseURL);
+            if (canonicalRedirect) {
+                await sendWebResponse(nodeResponse, canonicalRedirect);
+                return;
+            }
+            if (url.pathname.startsWith("/api/auth/")) {
+                await sendWebResponse(nodeResponse, await handleAuthRequest(request));
+                return;
+            }
+            const ctx = requireContext();
+            const apps = ctx.getWebApps();
+            const app = apps.find((candidate) => matchPrefix(url.pathname, candidate.mountPath) || matchPrefix(url.pathname, candidate.apiPrefix));
+            if (app) {
+                const response = await app.handleRequest(request, createAppContext(ctx));
+                await sendWebResponse(nodeResponse, response ?? notFound());
+                return;
+            }
+            if (url.pathname === "/" && apps[0]) {
+                await sendWebResponse(nodeResponse, redirect(apps[0].mountPath));
+                return;
+            }
+            if (url.pathname === "/") {
+                await sendWebResponse(nodeResponse, responseHtml("<!doctype html><title>Pibo</title><p>No web apps registered.</p>"));
+                return;
+            }
+            await sendWebResponse(nodeResponse, notFound());
+        }
+        catch (error) {
+            const status = error instanceof PiboAuthError || error instanceof PiboWebHttpError ? error.statusCode : 500;
+            await sendWebResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+        }
+    };
+    return {
+        name: WEB_CHANNEL_NAME,
+        kind: "web",
+        description: "Same-origin HTTP host for pibo web apps and auth routes.",
+        auth: { mode: "required" },
+        async start(channelContext) {
+            if (server)
+                return;
+            context = channelContext;
+            server = createServer((request, response) => {
+                void handleRequest(request, response);
+            });
+            await new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(port, host, () => {
+                    server.off("error", reject);
+                    resolve();
+                });
+            });
+            const address = this.getAddress();
+            if (address && options.announce !== false) {
+                console.error(`pibo web host listening on http://${address.host}:${address.port}`);
+            }
+        },
+        async stop() {
+            context = undefined;
+            if (server) {
+                await new Promise((resolve, reject) => {
+                    server.close((error) => (error ? reject(error) : resolve()));
+                });
+                server = undefined;
+            }
+        },
+        getAddress() {
+            const address = server?.address();
+            if (!address || typeof address === "string")
+                return undefined;
+            return { host: address.address, port: address.port };
+        },
+    };
+}

package/dist/web/http.js

@@ -0,0 +1,110 @@
+export const MAX_WEB_REQUEST_BODY_BYTES = 4 * 1024 * 1024;
+export class PiboWebHttpError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "PiboWebHttpError";
+    }
+}
+export function responseJson(payload, init = {}) {
+    return new Response(JSON.stringify(payload), {
+        ...init,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+            ...init.headers,
+        },
+    });
+}
+export function responseHtml(html, init = {}) {
+    return new Response(html, {
+        ...init,
+        headers: {
+            "content-type": "text/html; charset=utf-8",
+            ...init.headers,
+        },
+    });
+}
+export async function readJsonBody(request) {
+    try {
+        const body = await request.json();
+        if (!body || typeof body !== "object")
+            throw new PiboWebHttpError("Invalid JSON body", 400);
+        return body;
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid JSON body", 400);
+    }
+}
+export async function nodeRequestToWebRequest(request, baseURL) {
+    const url = new URL(request.url ?? "/", baseURL);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(request.headers)) {
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                headers.append(key, entry);
+        }
+        else if (value !== undefined) {
+            headers.set(key, value);
+        }
+    }
+    let body;
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        const chunks = [];
+        let receivedBytes = 0;
+        for await (const chunk of request) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            receivedBytes += buffer.length;
+            if (receivedBytes > MAX_WEB_REQUEST_BODY_BYTES) {
+                throw new PiboWebHttpError("Request body too large", 413);
+            }
+            chunks.push(buffer);
+        }
+        body = Buffer.concat(chunks);
+    }
+    return new Request(url, {
+        method: request.method,
+        headers,
+        body,
+    });
+}
+export async function sendWebResponse(response, webResponse) {
+    const headers = {};
+    const setCookie = webResponse.headers.getSetCookie?.();
+    webResponse.headers.forEach((value, key) => {
+        if (key.toLowerCase() !== "set-cookie") {
+            headers[key] = value;
+        }
+    });
+    if (setCookie?.length) {
+        headers["set-cookie"] = setCookie;
+    }
+    else {
+        const setCookieHeader = webResponse.headers.get("set-cookie");
+        if (setCookieHeader) {
+            headers["set-cookie"] = setCookieHeader;
+        }
+    }
+    response.writeHead(webResponse.status, headers);
+    if (!webResponse.body) {
+        response.end();
+        return;
+    }
+    const reader = webResponse.body.getReader();
+    const cancel = () => {
+        void reader.cancel();
+    };
+    response.once("close", cancel);
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            response.write(Buffer.from(value));
+        }
+        response.end();
+    }
+    finally {
+        response.off("close", cancel);
+    }
+}

package/dist/web/types.js

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

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@pasko70/pibo",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Minimal TypeScript wrapper around Pi Coding Agent.",
+  "files": [
+    "dist",
+    "context",
+    ".codex/skills/pi-agent-harness/SKILL.md",
+    ".codex/skills/pi-agent-harness/agents/openai.yaml",
+    "README.md",
+    "src/mcp/LICENSE.mcp-cli"
+  ],
+  "bin": {
+    "pibo": "dist/bin/pibo.js"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "dev": "tsx src/bin/pibo.ts",
+    "profile": "tsx src/bin/pibo.ts profile",
+    "tui": "tsx src/bin/pibo.ts tui",
+    "tui:routed": "tsx src/bin/pibo.ts tui:routed",
+    "tui:gateway": "tsx src/bin/pibo.ts tui gateway-producer",
+    "gateway": "tsx src/bin/pibo.ts gateway",
+    "gateway:web": "npm run web-ui:build && tsx src/bin/pibo.ts gateway:web",
+    "client": "tsx src/bin/pibo.ts client",
+    "chat-ui:build": "vite build --config src/apps/chat-ui/vite.config.ts",
+    "chat-ui:typecheck": "tsc -p src/apps/chat-ui/tsconfig.json --noEmit",
+    "context-files-ui:build": "vite build --config src/apps/context-files-ui/vite.config.ts",
+    "context-files-ui:typecheck": "tsc -p src/apps/context-files-ui/tsconfig.json --noEmit",
+    "web-ui:build": "npm run chat-ui:build && npm run context-files-ui:build",
+    "build": "tsc -p tsconfig.json && npm run web-ui:build",
+    "start": "node dist/bin/pibo.js",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit && npm run chat-ui:typecheck && npm run context-files-ui:typecheck",
+    "clean": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@mariozechner/pi-ai": "^0.70.2",
+    "@mariozechner/pi-coding-agent": "^0.70.2",
+    "@mdxeditor/editor": "^3.55.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@tailwindcss/vite": "^4.2.4",
+    "@tanstack/react-query": "^5.100.7",
+    "@tanstack/react-router": "^1.168.25",
+    "@tanstack/react-start": "^1.167.50",
+    "@uiw/react-json-view": "^2.0.0-alpha.41",
+    "better-auth": "^1.6.9",
+    "commander": "^14.0.3",
+    "lexical": "^0.35.0",
+    "lucide-react": "^0.545.0",
+    "prismjs": "^1.30.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "tailwindcss": "^4.2.4"
+  },
+  "devDependencies": {
+    "@tanstack/router-plugin": "^1.167.28",
+    "@types/node": "^25.6.0",
+    "@types/prismjs": "^1.26.6",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.10",
+    "vite-tsconfig-paths": "^5.1.4"
+  }
+}

package/src/mcp/LICENSE.mcp-cli

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.