@pasko70/pibo 1.1.0 → 1.2.0

package/dist/user-skills/store.js

@@ -35,12 +35,26 @@ export function saveUserSkillStore(data, cwd = process.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()) {
-    return loadUserSkillStore(cwd).skills;
+    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();
-    return listUserSkills(cwd).find((skill) => skill.id === lookup || skill.name === lookup);
+    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();
@@ -71,21 +85,28 @@ export function createUserSkill(input, cwd = process.cwd()) {
     const skillDir = join(defaultUserSkillDir(cwd), name);
     mkdirSync(skillDir, { recursive: true });
     const skillPath = join(skillDir, "SKILL.md");
-    const markdown = buildSkillMd(name, description, input.markdown ?? "");
+    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,
+        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(skill);
+    store.skills.push(storedSkill);
     store.skills.sort((a, b) => a.name.localeCompare(b.name));
     saveUserSkillStore(store, cwd);
     return skill;
@@ -97,10 +118,12 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         throw new Error(`Skill "${id}" not found`);
     const existing = store.skills[index];
     let name = existing.name;
-    let description = existing.description;
     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();
     }
@@ -117,10 +140,14 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         }
     }
     if (input.markdown !== undefined) {
-        const markdown = buildSkillMd(name, description, input.markdown);
+        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 !== existing.description) {
+    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");
@@ -133,7 +160,10 @@ export function updateUserSkill(id, input, cwd = process.cwd()) {
         ...(input.enabled !== undefined ? { enabled: input.enabled } : {}),
         updatedAt: new Date().toISOString(),
     };
-    store.skills[index] = updated;
+    // 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;
@@ -164,7 +194,7 @@ function sanitizeStoredSkill(value) {
     return {
         id: candidate.id,
         name: candidate.name.trim(),
-        description: typeof candidate.description === "string" ? candidate.description.trim() : "",
+        description: "",
         path: candidate.path.trim(),
         enabled: candidate.enabled !== false,
         source: isValidSource(candidate.source) ? candidate.source : "user-created",
@@ -205,12 +235,21 @@ function parseSimpleYaml(text) {
         if (colonIdx <= 0)
             continue;
         const key = line.slice(0, colonIdx).trim();
-        const value = line.slice(colonIdx + 1).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)) {

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(", ");
+}