@pasko70/pibo 1.1.0 → 1.3.0

package/dist/apps/chat/chat-api-routes.js

@@ -0,0 +1,311 @@
+import { PiboWebHttpError } from "../../web/http.js";
+export const CHAT_WEB_API_PREFIX = "/api/chat";
+export function roomResourcePath(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/rooms/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname
+        .slice(prefix.length)
+        .split("/")
+        .filter((part) => part.length > 0);
+    if (parts.length < 1 || parts.length > 2)
+        return undefined;
+    try {
+        const roomId = decodeURIComponent(parts[0]);
+        const child = parts[1] ? decodeURIComponent(parts[1]) : undefined;
+        if (child && child !== "events" && child !== "messages" && child !== "read")
+            return undefined;
+        return { roomId, child };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid room id", 400);
+    }
+}
+export function agentResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/agents/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid agent id", 400);
+    }
+}
+export function workflowPickerKind(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/pickers/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedKind = pathname.slice(prefix.length);
+    if (!encodedKind || encodedKind.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedKind);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow picker kind", 400);
+    }
+}
+export function workflowPromptAssetResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/prompt-assets/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow prompt asset id", 400);
+    }
+}
+export function workflowDraftResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/drafts/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow draft id", 400);
+    }
+}
+export function workflowDraftActionResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/drafts/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 2 || !parts[0] || !parts[1])
+        return undefined;
+    try {
+        const action = decodeURIComponent(parts[1]);
+        if (action !== "validate" && action !== "publish")
+            return undefined;
+        return { draftId: decodeURIComponent(parts[0]), action };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow draft action", 400);
+    }
+}
+export function workflowDuplicateResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
+    const suffix = "/duplicate";
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length, -suffix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow id", 400);
+    }
+}
+export function workflowNextDraftResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
+    const suffix = "/drafts";
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length, -suffix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow id", 400);
+    }
+}
+export function workflowArchiveResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
+    const suffix = "/archive";
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length, -suffix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow id", 400);
+    }
+}
+export function workflowVersionResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 2 && parts.length !== 3)
+        return undefined;
+    if (!parts[0] || parts[1] !== "versions" || (parts.length === 3 && !parts[2]))
+        return undefined;
+    try {
+        return {
+            workflowId: decodeURIComponent(parts[0]),
+            ...(parts[2] ? { version: decodeURIComponent(parts[2]) } : {}),
+        };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow version route", 400);
+    }
+}
+export function workflowCatalogResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/workflows/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        const workflowId = decodeURIComponent(encodedId);
+        if (workflowId === "drafts" || workflowId === "pickers" || workflowId === "lifecycle-events")
+            return undefined;
+        return workflowId;
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid workflow id", 400);
+    }
+}
+export function piPackageResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/pi-packages/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid Pi package id", 400);
+    }
+}
+export function mcpServerResourceName(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/mcp-servers/`;
+    const suffix = "/description";
+    if (!pathname.startsWith(prefix) || !pathname.endsWith(suffix))
+        return undefined;
+    const encodedName = pathname.slice(prefix.length, -suffix.length);
+    if (!encodedName || encodedName.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedName);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid MCP server name", 400);
+    }
+}
+export function userSkillResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/user-skills/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid user skill id", 400);
+    }
+}
+export function projectResourcePath(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/projects/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+    if (!parts[0])
+        return undefined;
+    return { projectId: parts[0], ...(parts[1] ? { child: parts[1] } : {}) };
+}
+export function projectWorkflowSessionStartResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/projects/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 4 || !parts[0] || parts[1] !== "workflow-sessions" || !parts[2] || parts[3] !== "start")
+        return undefined;
+    try {
+        return { projectId: decodeURIComponent(parts[0]), piboSessionId: decodeURIComponent(parts[2]) };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid Project workflow session start path", 400);
+    }
+}
+export function projectWorkflowHumanActionsResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/projects/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 4 || !parts[0] || parts[1] !== "workflow-sessions" || !parts[2] || parts[3] !== "human-actions")
+        return undefined;
+    try {
+        return { projectId: decodeURIComponent(parts[0]), piboSessionId: decodeURIComponent(parts[2]) };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid Project workflow human-action path", 400);
+    }
+}
+export function projectSessionResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/project-sessions/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    return decodeURIComponent(encodedId);
+}
+export function sessionResourceId(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/sessions/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const encodedId = pathname.slice(prefix.length);
+    if (!encodedId || encodedId.includes("/"))
+        return undefined;
+    try {
+        return decodeURIComponent(encodedId);
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid session id", 400);
+    }
+}
+export function sessionActionResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/sessions/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const parts = pathname.slice(prefix.length).split("/");
+    if (parts.length !== 2 || !parts[0])
+        return undefined;
+    const action = parts[1];
+    if (action !== "read" && action !== "kill" && action !== "kill-all")
+        return undefined;
+    try {
+        return { piboSessionId: decodeURIComponent(parts[0]), action };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid session id", 400);
+    }
+}
+export function signalResource(pathname) {
+    const prefix = `${CHAT_WEB_API_PREFIX}/signals/`;
+    if (!pathname.startsWith(prefix))
+        return undefined;
+    const [kind, encodedId, extra] = pathname.slice(prefix.length).split("/");
+    if (extra || (kind !== "session" && kind !== "tree") || !encodedId)
+        return undefined;
+    try {
+        return { kind, piboSessionId: decodeURIComponent(encodedId) };
+    }
+    catch {
+        throw new PiboWebHttpError("Invalid session id", 400);
+    }
+}

package/dist/apps/chat/chat-capability-routes.js

@@ -0,0 +1,90 @@
+import { setMcpServerDescription } from "../../mcp/agent-context.js";
+import { inspectPiPackageSource } from "../../pi-packages/metadata.js";
+import { findPiPackage, listPiPackages, removePiPackage, setPiPackageEnabled, upsertPiPackage } from "../../pi-packages/store.js";
+import { PiboWebHttpError, readJsonBody, responseJson } from "../../web/http.js";
+import { CHAT_WEB_API_PREFIX, mcpServerResourceName, piPackageResourceId } from "./chat-api-routes.js";
+import { normalizeMcpServerDescriptionBody, normalizePiPackageWebSource, } from "./chat-request-normalizers.js";
+export function chatCapabilityRoute(pathname, method) {
+    if (pathname === `${CHAT_WEB_API_PREFIX}/pi-packages` && method === "GET")
+        return { kind: "pi-packages-list" };
+    if (pathname === `${CHAT_WEB_API_PREFIX}/pi-packages` && method === "POST")
+        return { kind: "pi-packages-create" };
+    const packageId = piPackageResourceId(pathname);
+    if (packageId && method === "GET")
+        return { kind: "pi-package-read", packageId };
+    if (packageId && method === "PATCH")
+        return { kind: "pi-package-update", packageId };
+    if (packageId && method === "DELETE")
+        return { kind: "pi-package-delete", packageId };
+    const serverName = mcpServerResourceName(pathname);
+    if (serverName && method === "PATCH")
+        return { kind: "mcp-server-description-update", serverName };
+    return undefined;
+}
+export function chatCapabilityRouteRequiresSameOrigin(route) {
+    return route.kind !== "pi-packages-list" && route.kind !== "pi-package-read";
+}
+export async function handleChatCapabilityRoute(options) {
+    const { route, request, cwd, invalidateBootstrapCatalogCache, agentsSelectingPiPackage } = options;
+    switch (route.kind) {
+        case "pi-packages-list":
+            return responseJson({ packages: listPiPackages() });
+        case "pi-packages-create": {
+            const body = await readJsonBody(request);
+            const source = normalizePiPackageWebSource(body.source);
+            const pkg = upsertPiPackage(await inspectPiPackageSource(source, cwd), cwd);
+            invalidateBootstrapCatalogCache();
+            return responseJson({ package: pkg }, { status: 201 });
+        }
+        case "pi-package-read": {
+            const pkg = findPiPackage(route.packageId);
+            if (!pkg)
+                throw new PiboWebHttpError("Pi package is not registered", 404);
+            return responseJson({ package: pkg });
+        }
+        case "pi-package-update": {
+            const existing = findPiPackage(route.packageId);
+            if (!existing)
+                throw new PiboWebHttpError("Pi package is not registered", 404);
+            const body = await readJsonBody(request);
+            let pkg = existing;
+            let changed = false;
+            if (body.source !== undefined) {
+                const source = normalizePiPackageWebSource(body.source);
+                pkg = upsertPiPackage(await inspectPiPackageSource(source, cwd), cwd);
+                changed = true;
+            }
+            if (body.enabled !== undefined) {
+                if (typeof body.enabled !== "boolean")
+                    throw new PiboWebHttpError("enabled must be a boolean", 400);
+                const updated = setPiPackageEnabled(pkg.id, body.enabled);
+                if (!updated)
+                    throw new PiboWebHttpError("Pi package is not registered", 404);
+                pkg = updated;
+                changed = true;
+            }
+            if (!changed)
+                throw new PiboWebHttpError("No Pi package update fields provided", 400);
+            invalidateBootstrapCatalogCache();
+            return responseJson({ package: pkg });
+        }
+        case "pi-package-delete": {
+            const existing = findPiPackage(route.packageId);
+            if (!existing)
+                throw new PiboWebHttpError("Pi package is not registered", 404);
+            const affectedAgents = agentsSelectingPiPackage(route.packageId);
+            if (affectedAgents.length > 0) {
+                throw new PiboWebHttpError(`Pi package is selected by custom agents: ${affectedAgents.map((agent) => agent.profileName).join(", ")}`, 409);
+            }
+            const removed = removePiPackage(route.packageId);
+            invalidateBootstrapCatalogCache();
+            return responseJson({ removedPackage: removed });
+        }
+        case "mcp-server-description-update": {
+            const body = await readJsonBody(request);
+            const server = await setMcpServerDescription(route.serverName, normalizeMcpServerDescriptionBody(body.description));
+            invalidateBootstrapCatalogCache();
+            return responseJson({ server });
+        }
+    }
+}

package/dist/apps/chat/chat-files.js

@@ -0,0 +1,178 @@
+import { createReadStream, existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+import os from "node:os";
+import { Readable } from "node:stream";
+import { PiboWebHttpError } from "../../web/http.js";
+export const CHAT_UPLOAD_DIR = resolve(os.homedir(), ".pibo", "uploads");
+const CHAT_FILE_ATTACHMENT_LIMIT = 10;
+export function prepareChatFileAttachments(input) {
+    const paths = normalizeChatFileAttachmentPaths(input.attachmentPaths);
+    if (!paths.length)
+        return { paths: [], attachments: [], modelContext: "", messageText: input.messageText };
+    const attachments = paths.map(chatFileAttachmentForPath);
+    const modelContext = renderAttachedChatFiles(attachments);
+    return {
+        paths,
+        attachments,
+        modelContext,
+        messageText: modelContext ? `${input.messageText.trimEnd()}\n\n${modelContext}` : input.messageText,
+    };
+}
+export async function saveUploadedChatFiles(request) {
+    const form = await request.formData();
+    const files = [];
+    for (const value of form.getAll("files")) {
+        if (isUploadedChatFile(value))
+            files.push(value);
+    }
+    if (!files.length)
+        throw new PiboWebHttpError("No files were uploaded", 400);
+    mkdirSync(CHAT_UPLOAD_DIR, { recursive: true });
+    const saved = [];
+    for (const file of files) {
+        const name = sanitizeUploadFilename(file.name);
+        const bytes = Buffer.from(await file.arrayBuffer());
+        const targetPath = writeUploadedChatFile(name, bytes);
+        saved.push({ name, path: targetPath, bytes: bytes.byteLength });
+    }
+    return { uploadDir: CHAT_UPLOAD_DIR, files: saved };
+}
+export function resolveDownloadPath(path, basePath) {
+    return isAbsolute(path) ? resolve(path) : resolve(basePath, path);
+}
+export function responseChatFileDownload(absolutePath) {
+    let stats;
+    try {
+        stats = statSync(absolutePath);
+    }
+    catch {
+        throw new PiboWebHttpError("File not found: " + absolutePath, 404);
+    }
+    if (!stats.isFile())
+        throw new PiboWebHttpError("Path is not a file: " + absolutePath, 400);
+    return new Response(Readable.toWeb(createReadStream(absolutePath)), {
+        headers: {
+            "content-type": contentTypeForDownload(absolutePath),
+            "content-length": String(stats.size),
+            "content-disposition": "attachment; filename*=UTF-8''" + encodeURIComponent(basename(absolutePath)),
+            "cache-control": "no-store",
+        },
+    });
+}
+function normalizeChatFileAttachmentPaths(value) {
+    if (value === undefined || value === null)
+        return [];
+    if (!Array.isArray(value))
+        throw new PiboWebHttpError("fileAttachmentPaths must be an array", 400);
+    if (value.length > CHAT_FILE_ATTACHMENT_LIMIT)
+        throw new PiboWebHttpError(`At most ${CHAT_FILE_ATTACHMENT_LIMIT} uploaded files can be attached`, 400);
+    const paths = [];
+    const seen = new Set();
+    for (const item of value) {
+        if (typeof item !== "string")
+            throw new PiboWebHttpError("fileAttachmentPaths entries must be strings", 400);
+        const absolutePath = resolve(item.trim());
+        if (!item.trim())
+            throw new PiboWebHttpError("fileAttachmentPaths entries must be non-empty strings", 400);
+        if (absolutePath.length > 4096)
+            throw new PiboWebHttpError("uploaded file path is too long", 400);
+        if (!isPathInsideUploadDir(absolutePath))
+            throw new PiboWebHttpError("Attached uploads must be under ~/.pibo/uploads", 400);
+        if (!seen.has(absolutePath)) {
+            seen.add(absolutePath);
+            paths.push(absolutePath);
+        }
+    }
+    return paths;
+}
+function chatFileAttachmentForPath(path) {
+    if (!existsSync(path))
+        throw new PiboWebHttpError(`Uploaded file was not found: ${path}`, 404);
+    const stats = statSync(path);
+    if (!stats.isFile())
+        throw new PiboWebHttpError(`Uploaded attachment is not a file: ${path}`, 400);
+    return { name: basename(path), path, bytes: stats.size };
+}
+function isPathInsideUploadDir(path) {
+    const uploadRelative = relative(CHAT_UPLOAD_DIR, path);
+    return uploadRelative !== "" && !uploadRelative.startsWith("..") && !isAbsolute(uploadRelative);
+}
+function renderAttachedChatFiles(attachments) {
+    const bounded = attachments.slice(0, CHAT_FILE_ATTACHMENT_LIMIT);
+    if (!bounded.length)
+        return "";
+    const lines = ["<attached-uploaded-files>"];
+    bounded.forEach((attachment, index) => {
+        lines.push(`${index + 1}. ${escapeChatFileBlockValue(attachment.name)}`);
+        lines.push(`path: ${escapeChatFileBlockValue(attachment.path)}`);
+        lines.push(`bytes: ${attachment.bytes}`);
+    });
+    lines.push("</attached-uploaded-files>");
+    return lines.join("\n");
+}
+function escapeChatFileBlockValue(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function isUploadedChatFile(value) {
+    return typeof value === "object"
+        && value !== null
+        && typeof value.name === "string"
+        && typeof value.size === "number"
+        && typeof value.arrayBuffer === "function";
+}
+function sanitizeUploadFilename(name) {
+    const cleaned = basename(name).replace(/[\u0000-\u001f\u007f]/g, "").trim();
+    const safe = cleaned.replace(/[\\/]/g, "_");
+    if (safe && !/^\.+$/.test(safe))
+        return safe;
+    return `upload-${Date.now()}`;
+}
+function writeUploadedChatFile(filename, bytes) {
+    for (let index = 0; index < 10_000; index += 1) {
+        const targetPath = uploadPathForIndex(filename, index);
+        try {
+            writeFileSync(targetPath, bytes, { flag: "wx" });
+            return targetPath;
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "EEXIST")
+                continue;
+            throw error;
+        }
+    }
+    throw new PiboWebHttpError("Could not allocate upload filename", 500);
+}
+function uploadPathForIndex(filename, index) {
+    if (index === 0)
+        return resolve(CHAT_UPLOAD_DIR, filename);
+    const extension = extname(filename);
+    const stem = filename.slice(0, filename.length - extension.length) || "upload";
+    return resolve(CHAT_UPLOAD_DIR, `${stem}-${index}${extension}`);
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+function contentTypeForDownload(path) {
+    switch (extname(path).toLowerCase()) {
+        case ".html":
+        case ".htm":
+            return "text/html; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".md":
+        case ".txt":
+        case ".log":
+            return "text/plain; charset=utf-8";
+        case ".pdf":
+            return "application/pdf";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        default:
+            return "application/octet-stream";
+    }
+}