@pasko70/pibo 1.0.5 → 1.2.0

package/dist/user-skills/manager.js

@@ -0,0 +1,35 @@
+import { createUserSkill, deleteUserSkill, findUserSkill, listUserSkills, readSkillMarkdown, setUserSkillEnabled, updateUserSkill, } from "./store.js";
+import { installSkillFromUrl } from "./installer.js";
+export class UserSkillManager {
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    create(input) {
+        return createUserSkill(input, this.cwd);
+    }
+    update(id, input) {
+        return updateUserSkill(id, input, this.cwd);
+    }
+    remove(id) {
+        return deleteUserSkill(id, this.cwd);
+    }
+    setEnabled(id, enabled) {
+        return setUserSkillEnabled(id, enabled, this.cwd);
+    }
+    async installFromUrl(url) {
+        return installSkillFromUrl(url, this.cwd);
+    }
+    getSkillMarkdown(id) {
+        const skill = findUserSkill(id, this.cwd);
+        if (!skill)
+            return "";
+        return readSkillMarkdown(skill, this.cwd);
+    }
+    list() {
+        return listUserSkills(this.cwd);
+    }
+    get(id) {
+        return findUserSkill(id, this.cwd);
+    }
+}

package/dist/user-skills/store.js

@@ -0,0 +1,267 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+const STORE_VERSION = 1;
+const SKILL_DIR_NAME = "user-skills";
+const STORE_FILE_NAME = "user-skills.json";
+export function defaultUserSkillStorePath(cwd = process.cwd()) {
+    return resolve(cwd, ".pibo", STORE_FILE_NAME);
+}
+export function defaultUserSkillDir(cwd = process.cwd()) {
+    return resolve(cwd, ".pibo", SKILL_DIR_NAME);
+}
+export function ensureUserSkillStorage(cwd = process.cwd()) {
+    mkdirSync(defaultUserSkillDir(cwd), { recursive: true });
+}
+export function loadUserSkillStore(cwd = process.cwd()) {
+    const path = defaultUserSkillStorePath(cwd);
+    if (!existsSync(path))
+        return { version: STORE_VERSION, skills: [] };
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid user skills store at ${path}`);
+    }
+    const data = parsed;
+    if (data.version !== STORE_VERSION || !Array.isArray(data.skills)) {
+        throw new Error(`Unsupported user skills store at ${path}`);
+    }
+    return {
+        version: STORE_VERSION,
+        skills: data.skills.map(sanitizeStoredSkill),
+    };
+}
+export function saveUserSkillStore(data, cwd = process.cwd()) {
+    const path = defaultUserSkillStorePath(cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify({ version: STORE_VERSION, skills: data.skills }, null, 2)}\n`, "utf-8");
+}
+function readUserSkillDescription(skill, cwd = process.cwd()) {
+    const markdown = readSkillMarkdown(skill, cwd);
+    const parsed = parseSkillMd(markdown);
+    return parsed.description;
+}
+export function listUserSkills(cwd = process.cwd()) {
+    const skills = loadUserSkillStore(cwd).skills;
+    for (const skill of skills) {
+        skill.description = readUserSkillDescription(skill, cwd);
+    }
+    return skills;
+}
+export function findUserSkill(idOrName, cwd = process.cwd()) {
+    const lookup = idOrName.trim();
+    const store = loadUserSkillStore(cwd);
+    const stored = store.skills.find((skill) => skill.id === lookup || skill.name === lookup);
+    if (!stored)
+        return undefined;
+    stored.description = readUserSkillDescription(stored, cwd);
+    return stored;
+}
+function validateSkillName(name, existingId, cwd = process.cwd()) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        throw new Error("Skill name is required");
+    if (trimmed.length > 64)
+        throw new Error("Skill name is too long (max 64 characters)");
+    if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) {
+        throw new Error("Skill name must be lowercase kebab-case, e.g. my-skill");
+    }
+    const store = loadUserSkillStore(cwd);
+    const existing = store.skills.find((s) => s.name === trimmed && s.id !== existingId);
+    if (existing)
+        throw new Error(`Skill name "${trimmed}" already exists`);
+    return trimmed;
+}
+export function readSkillMarkdown(skill, cwd = process.cwd()) {
+    const fullPath = resolve(cwd, skill.path);
+    if (!existsSync(fullPath))
+        return "";
+    return readFileSync(fullPath, "utf-8");
+}
+export function createUserSkill(input, cwd = process.cwd()) {
+    ensureUserSkillStorage(cwd);
+    const name = validateSkillName(input.name, undefined, cwd);
+    const description = (input.description ?? "").trim();
+    const id = randomUUID();
+    const skillDir = join(defaultUserSkillDir(cwd), name);
+    mkdirSync(skillDir, { recursive: true });
+    const skillPath = join(skillDir, "SKILL.md");
+    const incoming = input.markdown ?? "";
+    const parsedIncoming = parseSkillMd(incoming);
+    const body = parsedIncoming.body || incoming;
+    const effectiveDescription = description || parsedIncoming.description;
+    const markdown = buildSkillMd(name, effectiveDescription, body);
+    writeFileSync(skillPath, markdown, "utf-8");
+    const now = new Date().toISOString();
+    const skill = {
+        id,
+        name,
+        description: effectiveDescription,
+        path: skillPath,
+        enabled: true,
+        source: "user-created",
+        createdAt: now,
+        updatedAt: now,
+    };
+    // Do not persist description in JSON store; it lives in SKILL.md frontmatter only.
+    const storedSkill = { ...skill };
+    delete storedSkill.description;
+    const store = loadUserSkillStore(cwd);
+    store.skills.push(storedSkill);
+    store.skills.sort((a, b) => a.name.localeCompare(b.name));
+    saveUserSkillStore(store, cwd);
+    return skill;
+}
+export function updateUserSkill(id, input, cwd = process.cwd()) {
+    const store = loadUserSkillStore(cwd);
+    const index = store.skills.findIndex((s) => s.id === id);
+    if (index < 0)
+        throw new Error(`Skill "${id}" not found`);
+    const existing = store.skills[index];
+    let name = existing.name;
+    if (input.name !== undefined) {
+        name = validateSkillName(input.name, existing.id, cwd);
+    }
+    const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
+    const parsed = parseSkillMd(currentMarkdown);
+    let description = parsed.description;
+    if (input.description !== undefined) {
+        description = input.description.trim();
+    }
+    const skillDir = join(defaultUserSkillDir(cwd), name);
+    const skillPath = join(skillDir, "SKILL.md");
+    if (name !== existing.name) {
+        const oldDir = dirname(existing.path);
+        if (existsSync(oldDir) && oldDir !== skillDir) {
+            mkdirSync(dirname(skillDir), { recursive: true });
+            renameDirContents(oldDir, skillDir);
+            if (existsSync(oldDir)) {
+                rmSync(oldDir, { recursive: true, force: true });
+            }
+        }
+    }
+    if (input.markdown !== undefined) {
+        const parsedIncoming = parseSkillMd(input.markdown);
+        const body = parsedIncoming.body || input.markdown;
+        const effectiveDescription = input.description !== undefined ? description : parsedIncoming.description || description;
+        description = effectiveDescription;
+        const markdown = buildSkillMd(name, effectiveDescription, body);
+        writeFileSync(skillPath, markdown, "utf-8");
+    }
+    else if (name !== existing.name || description !== parsed.description) {
+        const currentMarkdown = existsSync(existing.path) ? readFileSync(existing.path, "utf-8") : "";
+        const { body } = parseSkillMd(currentMarkdown);
+        writeFileSync(skillPath, buildSkillMd(name, description, body), "utf-8");
+    }
+    const updated = {
+        ...existing,
+        name,
+        description,
+        path: skillPath,
+        ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),
+        updatedAt: new Date().toISOString(),
+    };
+    // Strip description before persisting to JSON store.
+    const storedUpdated = { ...updated };
+    delete storedUpdated.description;
+    store.skills[index] = storedUpdated;
+    store.skills.sort((a, b) => a.name.localeCompare(b.name));
+    saveUserSkillStore(store, cwd);
+    return updated;
+}
+export function deleteUserSkill(id, cwd = process.cwd()) {
+    const store = loadUserSkillStore(cwd);
+    const index = store.skills.findIndex((s) => s.id === id);
+    if (index < 0)
+        return undefined;
+    const [removed] = store.skills.splice(index, 1);
+    const skillDir = dirname(removed.path);
+    if (existsSync(skillDir)) {
+        rmSync(skillDir, { recursive: true, force: true });
+    }
+    saveUserSkillStore(store, cwd);
+    return removed;
+}
+export function setUserSkillEnabled(id, enabled, cwd = process.cwd()) {
+    return updateUserSkill(id, { enabled }, cwd);
+}
+function sanitizeStoredSkill(value) {
+    const candidate = value;
+    if (!candidate || typeof candidate !== "object")
+        throw new Error("Invalid user skill entry");
+    if (typeof candidate.id !== "string" || typeof candidate.name !== "string" || typeof candidate.path !== "string") {
+        throw new Error("Invalid user skill entry");
+    }
+    return {
+        id: candidate.id,
+        name: candidate.name.trim(),
+        description: "",
+        path: candidate.path.trim(),
+        enabled: candidate.enabled !== false,
+        source: isValidSource(candidate.source) ? candidate.source : "user-created",
+        sourceUrl: typeof candidate.sourceUrl === "string" ? candidate.sourceUrl.trim() : undefined,
+        createdAt: typeof candidate.createdAt === "string" ? candidate.createdAt : new Date().toISOString(),
+        updatedAt: typeof candidate.updatedAt === "string" ? candidate.updatedAt : new Date().toISOString(),
+    };
+}
+function isValidSource(source) {
+    return source === "user-created" || source === "skills.sh" || source === "github";
+}
+export function parseSkillMd(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith("---")) {
+        return { name: "", description: "", body: trimmed };
+    }
+    const endIdx = trimmed.indexOf("---", 3);
+    if (endIdx === -1) {
+        return { name: "", description: "", body: trimmed };
+    }
+    const frontmatter = trimmed.slice(3, endIdx).trim();
+    const body = trimmed.slice(endIdx + 3).trimStart();
+    const parsed = parseSimpleYaml(frontmatter);
+    return {
+        name: typeof parsed.name === "string" ? parsed.name : "",
+        description: typeof parsed.description === "string" ? parsed.description : "",
+        body,
+    };
+}
+export function buildSkillMd(name, description, body) {
+    const cleanBody = body.trimStart();
+    return `---\nname: ${name}\ndescription: ${description}\n---\n\n${cleanBody}`;
+}
+function parseSimpleYaml(text) {
+    const result = {};
+    for (const line of text.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx <= 0)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        const value = parseSimpleYamlScalar(line.slice(colonIdx + 1).trim());
+        if (key)
+            result[key] = value;
+    }
+    return result;
+}
+function parseSimpleYamlScalar(value) {
+    if (value.length >= 2) {
+        const quote = value[0];
+        if ((quote === '"' || quote === "'") && value[value.length - 1] === quote) {
+            return value.slice(1, -1);
+        }
+    }
+    return value;
+}
+function renameDirContents(oldDir, newDir) {
+    mkdirSync(newDir, { recursive: true });
+    for (const entry of readdirSync(oldDir)) {
+        const oldPath = join(oldDir, entry);
+        const newPath = join(newDir, entry);
+        const stat = statSync(oldPath);
+        if (stat.isDirectory()) {
+            renameDirContents(oldPath, newPath);
+            rmSync(oldPath, { recursive: true, force: true });
+        }
+        else {
+            writeFileSync(newPath, readFileSync(oldPath));
+        }
+    }
+}

package/dist/user-skills/types.js

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

package/dist/web/auth.js

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

package/dist/web/channel.js

@@ -1,5 +1,6 @@
 import { createServer } from "node:http";
 import { PiboAuthError } from "../auth/types.js";
+import { handleSimpleAgentApiRequest } from "../api/simple-agent-api.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";
@@ -42,6 +43,75 @@ function createRequestBaseURL(nodeRequest, host, port) {
     }
     return `http://${nodeRequest.headers.host ?? `${host}:${port}`}`;
 }
+function isActiveRunStatus(status) {
+    return typeof status === "string" && ["queued", "starting", "running", "streaming", "waiting", "blocked", "retrying", "compacting", "pausing"].includes(status);
+}
+function isActiveRunSnapshotStatus(status) {
+    return typeof status === "string" && (status === "queued" || status === "running");
+}
+function gatewayMode(options) {
+    if (process.env.PIBO_FALLBACK_MODE === "1")
+        return "fallback";
+    return options.gatewayMode ?? "unknown";
+}
+function collectActiveRuns(channelContext) {
+    const directRuns = channelContext.listRuns?.({ includeConsumed: true, includeDetached: true });
+    if (directRuns)
+        return directRuns.filter((run) => isActiveRunSnapshotStatus(run.status));
+    const sessions = channelContext.listSessions?.() ?? [];
+    const runs = [];
+    const seen = new Set();
+    for (const session of sessions) {
+        const snapshot = channelContext.snapshotSignalTree?.(session.id);
+        const snapshotObject = snapshot && typeof snapshot === "object" ? snapshot : undefined;
+        const rawSessions = snapshotObject?.sessions;
+        const sessionSnapshots = Array.isArray(rawSessions) ? rawSessions : rawSessions && typeof rawSessions === "object" ? Object.values(rawSessions) : [];
+        for (const item of sessionSnapshots) {
+            if (!item || typeof item !== "object")
+                continue;
+            const activeRuns = item.activeRuns;
+            if (!Array.isArray(activeRuns))
+                continue;
+            for (const run of activeRuns) {
+                if (!run || typeof run !== "object")
+                    continue;
+                const runId = String(run.runId ?? "");
+                const status = run.status;
+                if (!isActiveRunStatus(status))
+                    continue;
+                const key = runId || JSON.stringify(run);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                runs.push(run);
+            }
+        }
+    }
+    return runs;
+}
+function createGatewayRuntimeStatuses(channelContext) {
+    const statuses = channelContext.listSessionRuntimeStatuses?.() ?? [];
+    return statuses.map((status) => {
+        try {
+            const snapshot = channelContext.snapshotSignalSession?.(status.piboSessionId);
+            const activeTelemetry = snapshot?.sessions[status.piboSessionId]?.activeTelemetry;
+            return activeTelemetry ? { ...status, activeTelemetry } : status;
+        }
+        catch {
+            return status;
+        }
+    });
+}
+function createGatewayStatusResponse(channelContext, options) {
+    const mode = gatewayMode(options);
+    return responseJson({
+        status: "ok",
+        mode,
+        health: { status: "ok", mode },
+        runtimeStatuses: createGatewayRuntimeStatuses(channelContext),
+        activeRuns: collectActiveRuns(channelContext),
+    });
+}
 function createCanonicalRedirect(request, canonicalBaseURL) {
     if (!canonicalBaseURL || (request.method !== "GET" && request.method !== "HEAD"))
         return undefined;
@@ -81,11 +151,27 @@ export function createWebHostChannel(options = {}) {
                 await sendWebResponse(nodeResponse, canonicalRedirect);
                 return;
             }
+            if (url.pathname === "/health") {
+                await sendWebResponse(nodeResponse, responseJson({
+                    status: "ok",
+                    mode: process.env.PIBO_FALLBACK_MODE === "1" ? "fallback" : "main",
+                }));
+                return;
+            }
+            if (url.pathname === "/gateway/status") {
+                await sendWebResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options));
+                return;
+            }
             if (url.pathname.startsWith("/api/auth/")) {
                 await sendWebResponse(nodeResponse, await handleAuthRequest(request));
                 return;
             }
             const ctx = requireContext();
+            const simpleApiResponse = await handleSimpleAgentApiRequest(request, ctx);
+            if (simpleApiResponse) {
+                await sendWebResponse(nodeResponse, simpleApiResponse);
+                return;
+            }
             const apps = ctx.getWebApps();
             const app = apps.find((candidate) => matchPrefix(url.pathname, candidate.mountPath) || matchPrefix(url.pathname, candidate.apiPrefix));
             if (app) {

package/dist/web/http.js

@@ -1,4 +1,6 @@
+import { gzipSync } from "node:zlib";
 export const MAX_WEB_REQUEST_BODY_BYTES = 4 * 1024 * 1024;
+const MIN_COMPRESS_RESPONSE_BYTES = 1024;
 export class PiboWebHttpError extends Error {
     statusCode;
     constructor(message, statusCode) {
@@ -69,21 +71,22 @@ export async function nodeRequestToWebRequest(request, baseURL) {
     });
 }
 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;
+    const headers = responseHeaders(webResponse);
+    const compressEncoding = preferredResponseEncoding(response.req?.headers["accept-encoding"], webResponse);
+    if (compressEncoding && webResponse.body) {
+        const body = await readResponseBody(webResponse);
+        if (body.length >= MIN_COMPRESS_RESPONSE_BYTES) {
+            const compressed = gzipSync(body, { level: 1 });
+            headers["content-encoding"] = compressEncoding;
+            headers["content-length"] = String(compressed.length);
+            headers.vary = appendVary(headers.vary, "accept-encoding");
+            response.writeHead(webResponse.status, headers);
+            response.end(compressed);
+            return;
         }
+        response.writeHead(webResponse.status, headers);
+        response.end(body);
+        return;
     }
     response.writeHead(webResponse.status, headers);
     if (!webResponse.body) {
@@ -108,3 +111,65 @@ export async function sendWebResponse(response, webResponse) {
         response.off("close", cancel);
     }
 }
+function responseHeaders(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;
+    }
+    return headers;
+}
+function preferredResponseEncoding(acceptEncoding, webResponse) {
+    if (!responseCanBeCompressed(webResponse))
+        return undefined;
+    return acceptsEncoding(acceptEncoding, "gzip") ? "gzip" : undefined;
+}
+function acceptsEncoding(acceptEncoding, encoding) {
+    const accepted = Array.isArray(acceptEncoding) ? acceptEncoding.join(",") : acceptEncoding ?? "";
+    return accepted.split(",").some((entry) => {
+        const [name, ...parameters] = entry.trim().split(";").map((part) => part.trim());
+        if (name !== encoding && name !== "*")
+            return false;
+        const q = parameters.find((parameter) => parameter.toLowerCase().startsWith("q="));
+        if (!q)
+            return true;
+        const weight = Number(q.slice(2));
+        return Number.isFinite(weight) && weight > 0;
+    });
+}
+function responseCanBeCompressed(webResponse) {
+    if (webResponse.status === 204 || webResponse.status === 304)
+        return false;
+    if (webResponse.headers.has("content-encoding"))
+        return false;
+    const contentType = webResponse.headers.get("content-type") ?? "";
+    return /^application\/json\b/.test(contentType);
+}
+async function readResponseBody(webResponse) {
+    const chunks = [];
+    const reader = webResponse.body.getReader();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(Buffer.from(value));
+    }
+    return Buffer.concat(chunks);
+}
+function appendVary(existing, value) {
+    const values = Array.isArray(existing) ? existing.flatMap((item) => item.split(",")) : (existing ?? "").split(",");
+    const normalized = values.map((item) => item.trim()).filter(Boolean);
+    if (!normalized.some((item) => item.toLowerCase() === value.toLowerCase()))
+        normalized.push(value);
+    return normalized.join(", ");
+}