@pasko70/pibo 1.1.0 → 1.3.0

package/dist/vscode/vsix-fetcher.js

@@ -0,0 +1,131 @@
+/**
+ * GitHub Releases interaction for the Pibo VS Code extension.
+ *
+ * `pibo vscode install` defaults to fetching the latest VSIX asset from a
+ * GitHub Release. The fetch path is pure-functional so the install command
+ * can inject a mocked fetch and a mocked spawn in tests.
+ */
+export class VsixFetchError extends Error {
+    cause;
+    constructor(message, options) {
+        super(message);
+        this.name = "VsixFetchError";
+        if (options?.cause !== undefined)
+            this.cause = options.cause;
+    }
+}
+const VSIX_ASSET_PATTERN = /\.vsix$/i;
+export function isVsixAsset(asset) {
+    return VSIX_ASSET_PATTERN.test(asset.name);
+}
+export function findVsixAsset(release) {
+    return release.assets.find(isVsixAsset);
+}
+const GITHUB_API_ROOT = "https://api.github.com";
+function buildReleaseUrl(owner, repo, tagName) {
+    const base = `${GITHUB_API_ROOT}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/releases`;
+    if (tagName)
+        return `${base}/tags/${encodeURIComponent(tagName)}`;
+    return `${base}/latest`;
+}
+function parseRelease(payload) {
+    if (typeof payload !== "object" || payload === null) {
+        throw new VsixFetchError("GitHub Releases payload is not an object");
+    }
+    const record = payload;
+    const tagName = record.tag_name;
+    const name = record.name;
+    const publishedAt = record.published_at;
+    const htmlUrl = record.html_url;
+    const rawAssets = record.assets;
+    if (typeof tagName !== "string" || typeof name !== "string" || typeof publishedAt !== "string" || typeof htmlUrl !== "string") {
+        throw new VsixFetchError("GitHub Releases payload is missing required string fields");
+    }
+    if (!Array.isArray(rawAssets)) {
+        throw new VsixFetchError("GitHub Releases payload is missing assets array");
+    }
+    const assets = [];
+    for (const raw of rawAssets) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const r = raw;
+        if (typeof r.name === "string" &&
+            typeof r.browser_download_url === "string" &&
+            typeof r.size === "number" &&
+            typeof r.content_type === "string") {
+            assets.push({
+                name: r.name,
+                browserDownloadUrl: r.browser_download_url,
+                size: r.size,
+                contentType: r.content_type,
+            });
+        }
+    }
+    return { tagName, name, publishedAt, htmlUrl, assets };
+}
+export async function fetchRelease(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const url = buildReleaseUrl(options.owner, options.repo, options.tagName);
+    let response;
+    try {
+        response = await fetchImpl(url, {
+            headers: { accept: "application/vnd.github+json", "user-agent": "pibo-cli" },
+        });
+    }
+    catch (error) {
+        throw new VsixFetchError(`Failed to call GitHub Releases API at ${url}`, { cause: error });
+    }
+    if (response.status === 404) {
+        throw new VsixFetchError(options.tagName
+            ? `GitHub release ${options.owner}/${options.repo}@${options.tagName} not found`
+            : `GitHub repository ${options.owner}/${options.repo} has no published releases`);
+    }
+    if (!response.ok) {
+        throw new VsixFetchError(`GitHub Releases API returned HTTP ${response.status}`);
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch (error) {
+        throw new VsixFetchError("GitHub Releases response was not valid JSON", { cause: error });
+    }
+    return parseRelease(payload);
+}
+export async function downloadVsixAsset(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const maxBytes = options.maxBytes ?? 64 * 1024 * 1024; // 64 MiB
+    let response;
+    try {
+        response = await fetchImpl(options.url, { headers: { "user-agent": "pibo-cli" } });
+    }
+    catch (error) {
+        throw new VsixFetchError(`Failed to download VSIX from ${options.url}`, { cause: error });
+    }
+    if (!response.ok) {
+        throw new VsixFetchError(`VSIX download returned HTTP ${response.status}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > maxBytes) {
+        throw new VsixFetchError(`VSIX download is ${arrayBuffer.byteLength} bytes, exceeding limit of ${maxBytes} bytes`);
+    }
+    return Buffer.from(arrayBuffer);
+}
+export async function fetchLatestVsix(options) {
+    const release = await fetchRelease({
+        owner: options.owner,
+        repo: options.repo,
+        tagName: options.tagName,
+        fetchImpl: options.fetchImpl,
+    });
+    const asset = findVsixAsset(release);
+    if (!asset) {
+        throw new VsixFetchError(`Release ${release.tagName} has no .vsix asset`);
+    }
+    const bytes = await downloadVsixAsset({
+        url: asset.browserDownloadUrl,
+        maxBytes: options.maxBytes,
+        fetchImpl: options.fetchImpl,
+    });
+    return { tagName: release.tagName, asset, bytes };
+}

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