@pasko70/pibo 1.9.9 → 1.9.10

package/dist/gateway/client.js

@@ -0,0 +1,200 @@
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, } from "./protocol.js";
+import { parsePiboThinkingLevel } from "../core/thinking.js";
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeFrame(socket, frame) {
+    socket.write(encodeFrame(frame));
+}
+function printResponse(frame) {
+    if (frame.ok)
+        return;
+    console.error(`\nerror: ${frame.error?.message ?? "request failed"}`);
+}
+function isSessionStatus(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (typeof candidate.piboSessionId === "string" &&
+        typeof candidate.queuedMessages === "number" &&
+        typeof candidate.processing === "boolean");
+}
+function printExecutionResult(event) {
+    if (event.action === "status" && isSessionStatus(event.result)) {
+        console.error(`status: session=${event.result.piboSessionId} queued=${event.result.queuedMessages} processing=${event.result.processing} streaming=${event.result.streaming}`);
+        return;
+    }
+    if (event.action === "clear_queue" && event.result && typeof event.result === "object") {
+        const cleared = event.result.cleared;
+        console.error(`clear: removed ${typeof cleared === "number" ? cleared : 0} queued message(s)`);
+        return;
+    }
+    console.error(`${event.action}: ${JSON.stringify(event.result)}`);
+}
+function printIncomingMessage(event, state) {
+    if (event.source === "user")
+        return;
+    if (event.eventId && state.visibleIncomingEventIds.has(event.eventId))
+        return;
+    if (event.eventId)
+        state.visibleIncomingEventIds.add(event.eventId);
+    const source = event.source ?? "external";
+    console.error(`\nincoming ${source}> ${event.text}`);
+}
+function printEvent(frame, piboSessionId, state) {
+    if (frame.type !== "event" || frame.event !== "router")
+        return;
+    const event = frame.payload;
+    if (event.piboSessionId !== piboSessionId)
+        return;
+    if (event.type === "message_queued") {
+        printIncomingMessage(event, state);
+        return;
+    }
+    if (event.type === "assistant_delta") {
+        state.sawAssistantDelta = true;
+        output.write(event.text);
+        return;
+    }
+    if (event.type === "thinking_started") {
+        state.sawThinkingDelta = false;
+        if (state.showThinking)
+            output.write("\nthinking> ");
+        return;
+    }
+    if (event.type === "thinking_delta") {
+        if (!state.showThinking)
+            return;
+        state.sawThinkingDelta = true;
+        output.write(event.text);
+        return;
+    }
+    if (event.type === "thinking_finished") {
+        if (!state.showThinking)
+            return;
+        if (!state.sawThinkingDelta && event.text)
+            output.write(event.text);
+        state.sawThinkingDelta = false;
+        output.write("\n");
+        return;
+    }
+    if (event.type === "assistant_message") {
+        if (!state.sawAssistantDelta) {
+            output.write(event.text);
+        }
+        state.sawAssistantDelta = false;
+        output.write("\n");
+        return;
+    }
+    if (event.type === "session_error") {
+        console.error(`\nsession error: ${event.error}`);
+        return;
+    }
+    if (event.type === "execution_result") {
+        printExecutionResult(event);
+        return;
+    }
+    if (event.type === "message_started") {
+        state.sawAssistantDelta = false;
+        printIncomingMessage(event, state);
+        output.write("assistant> ");
+    }
+}
+export async function runGatewayClient(options = {}) {
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    const piboSessionId = options.piboSessionId ?? "default";
+    const socket = connect({ host, port });
+    socket.setEncoding("utf-8");
+    await new Promise((resolve, reject) => {
+        socket.once("connect", resolve);
+        socket.once("error", reject);
+    });
+    console.error(`connected to pibo gateway at ${host}:${port}`);
+    console.error(`session: ${piboSessionId}`);
+    console.error("type a message, /status, /clear, /abort, /thinking [level], /thinking-show, or /quit");
+    let buffer = "";
+    const renderState = {
+        visibleIncomingEventIds: new Set(),
+        sawAssistantDelta: false,
+        showThinking: false,
+        sawThinkingDelta: false,
+    };
+    socket.on("data", (chunk) => {
+        buffer += chunk;
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            const frame = line ? parseJsonLine(line) : undefined;
+            if (frame?.type === "res") {
+                printResponse(frame);
+            }
+            else if (frame?.type === "event") {
+                printEvent(frame, piboSessionId, renderState);
+            }
+            newlineIndex = buffer.indexOf("\n");
+        }
+    });
+    const rl = readline.createInterface({ input, output });
+    try {
+        while (!socket.destroyed) {
+            const text = (await rl.question("you> ")).trim();
+            if (!text)
+                continue;
+            if (text === "/quit" || text === "/exit")
+                break;
+            if (text === "/thinking-show") {
+                renderState.showThinking = !renderState.showThinking;
+                console.error(`thinking display: ${renderState.showThinking ? "on" : "off"}`);
+                continue;
+            }
+            if (text === "/thinking" || text.startsWith("/thinking ")) {
+                const level = text.slice("/thinking".length).trim();
+                let params;
+                try {
+                    params = level ? { level: parsePiboThinkingLevel(level) } : undefined;
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    continue;
+                }
+                writeFrame(socket, {
+                    type: "req",
+                    id: randomUUID(),
+                    event: params === undefined
+                        ? { type: "execution", piboSessionId, action: "thinking" }
+                        : { type: "execution", piboSessionId, action: "thinking", params },
+                });
+                continue;
+            }
+            if (text === "/status" || text === "/clear" || text === "/abort") {
+                const action = text === "/status" ? "status" : text === "/clear" ? "clear_queue" : "abort";
+                writeFrame(socket, {
+                    type: "req",
+                    id: randomUUID(),
+                    event: { type: "execution", piboSessionId, action },
+                });
+                continue;
+            }
+            writeFrame(socket, {
+                type: "req",
+                id: randomUUID(),
+                event: { type: "message", piboSessionId, text, source: "user" },
+            });
+        }
+    }
+    finally {
+        rl.close();
+        socket.end();
+    }
+}

package/dist/gateway/fallback.js

@@ -0,0 +1,155 @@
+import { spawn } from "node:child_process";
+import { createConnection } from "node:net";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { clearFallbackPidFile, readFallbackPidFile, } from "./pidfile.js";
+export const FALLBACK_GATEWAY_PORT = 4790;
+export const FALLBACK_WEB_PORT = 4791;
+export const FALLBACK_HOST = "0.0.0.0";
+const BACKUP_DIR = join(homedir(), ".pibo", "stable");
+const FALLBACK_BIN_PATH = join(BACKUP_DIR, "dist", "bin", "pibo.js");
+function isPortReachable(host, port, timeout = 2000) {
+    return new Promise((resolve) => {
+        const socket = createConnection(port, host);
+        const onError = () => {
+            socket.destroy();
+            resolve(false);
+        };
+        socket.setTimeout(timeout);
+        socket.once("connect", () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("error", onError);
+        socket.once("timeout", onError);
+    });
+}
+function waitForFallbackUp(maxRetries = 30, intervalMs = 1000) {
+    return new Promise((resolve) => {
+        const check = async () => {
+            for (let i = 0; i < maxRetries; i++) {
+                if (await isPortReachable("127.0.0.1", FALLBACK_GATEWAY_PORT, 2000)) {
+                    try {
+                        const res = await fetch(`http://127.0.0.1:${FALLBACK_WEB_PORT}/health`, {
+                            signal: AbortSignal.timeout(2000),
+                        });
+                        if (res.ok) {
+                            resolve(true);
+                            return;
+                        }
+                    }
+                    catch { }
+                }
+                await new Promise((r) => setTimeout(r, intervalMs));
+            }
+            resolve(false);
+        };
+        void check();
+    });
+}
+function waitForFallbackDown(maxRetries = 20, intervalMs = 500) {
+    return new Promise((resolve) => {
+        const check = async () => {
+            for (let i = 0; i < maxRetries; i++) {
+                if (!(await isPortReachable("127.0.0.1", FALLBACK_GATEWAY_PORT, 1000))) {
+                    resolve(true);
+                    return;
+                }
+                await new Promise((r) => setTimeout(r, intervalMs));
+            }
+            resolve(false);
+        };
+        void check();
+    });
+}
+export function getFallbackStatus() {
+    const pid = readFallbackPidFile();
+    return { running: pid !== undefined, pid: pid ?? undefined };
+}
+export function resolveFallbackWebGatewayServerOptions() {
+    return {
+        host: FALLBACK_HOST,
+        port: FALLBACK_GATEWAY_PORT,
+        web: { host: FALLBACK_HOST, port: FALLBACK_WEB_PORT },
+    };
+}
+export async function startFallback() {
+    if (!existsSync(BACKUP_DIR)) {
+        throw new Error(`No backup found at ${BACKUP_DIR}. Run "pibo gateway backup install" first.`);
+    }
+    if (!existsSync(FALLBACK_BIN_PATH)) {
+        throw new Error(`Fallback build not found at ${FALLBACK_BIN_PATH}. Run "pibo gateway backup update" first.`);
+    }
+    const status = getFallbackStatus();
+    if (status.running) {
+        console.log(`Fallback is already running (PID ${status.pid})`);
+        return;
+    }
+    if (await isPortReachable("127.0.0.1", FALLBACK_GATEWAY_PORT, 1000)) {
+        throw new Error(`Port ${FALLBACK_GATEWAY_PORT} is already in use`);
+    }
+    if (await isPortReachable("127.0.0.1", FALLBACK_WEB_PORT, 1000)) {
+        throw new Error(`Port ${FALLBACK_WEB_PORT} is already in use`);
+    }
+    const child = spawn(process.execPath, [FALLBACK_BIN_PATH, "gateway", "fallback", "run"], {
+        detached: true,
+        stdio: "ignore",
+        cwd: BACKUP_DIR,
+        env: { ...process.env, PIBO_FALLBACK_MODE: "1" },
+    });
+    child.unref();
+    console.error("Waiting for fallback gateway to come online...");
+    const up = await waitForFallbackUp(30, 1000);
+    if (!up) {
+        throw new Error("Fallback gateway did not come online in time");
+    }
+    console.log("Fallback gateway started");
+    console.log(`  Gateway: 0.0.0.0:${FALLBACK_GATEWAY_PORT}`);
+    console.log(`  Web App: http://0.0.0.0:${FALLBACK_WEB_PORT}/apps/chat`);
+}
+export async function runFallbackGatewayServer() {
+    if (process.env.PIBO_FALLBACK_MODE !== "1") {
+        throw new Error("gateway fallback run requires PIBO_FALLBACK_MODE=1");
+    }
+    const { runWebGatewayServer } = await import("./web.js");
+    await runWebGatewayServer(resolveFallbackWebGatewayServerOptions());
+}
+export async function stopFallback(force = false) {
+    const pid = readFallbackPidFile();
+    const reachable = await isPortReachable("127.0.0.1", FALLBACK_GATEWAY_PORT);
+    if (!reachable && !pid) {
+        console.log("Fallback is not running.");
+        clearFallbackPidFile();
+        return;
+    }
+    if (pid) {
+        console.error(`Stopping fallback (PID ${pid})...`);
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch { }
+    }
+    console.error("Waiting for fallback to shut down...");
+    const down = await waitForFallbackDown(20, 500);
+    if (!down && force && pid) {
+        console.error("Force-killing fallback...");
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch { }
+        const killed = await waitForFallbackDown(10, 500);
+        if (!killed) {
+            console.error("Fallback did not shut down even with SIGKILL.");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    else if (!down) {
+        console.error("Fallback did not shut down gracefully. Use --force to kill.");
+        process.exitCode = 1;
+        return;
+    }
+    clearFallbackPidFile();
+    console.log("Fallback stopped.");
+}

package/dist/gateway/pidfile.js

@@ -0,0 +1,130 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getPiboHome, piboHomePath } from "../core/pibo-home.js";
+function gatewayPidPath() {
+    return piboHomePath("gateway.pid");
+}
+function fallbackGatewayPidPath() {
+    return piboHomePath("gateway-fallback.pid");
+}
+function legacyGatewayPidPaths() {
+    try {
+        const home = getPiboHome();
+        return readdirSync(home)
+            .filter((name) => /^gateway-\d+\.pid$/.test(name))
+            .map((name) => join(home, name));
+    }
+    catch {
+        return [];
+    }
+}
+function storedPid(path) {
+    try {
+        if (!existsSync(path))
+            return undefined;
+        const pid = parseInt(readFileSync(path, "utf-8").trim(), 10);
+        return Number.isNaN(pid) ? undefined : pid;
+    }
+    catch {
+        return undefined;
+    }
+}
+function livePid(path) {
+    const pid = storedPid(path);
+    if (pid === undefined)
+        return undefined;
+    try {
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch (error) {
+        if (error.code === "EPERM")
+            return pid;
+        return undefined;
+    }
+}
+function claimPidFile(path, label) {
+    mkdirSync(dirname(path), { recursive: true });
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            writeFileSync(path, String(process.pid), { encoding: "utf-8", flag: "wx" });
+            return;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const existingPid = livePid(path);
+            if (existingPid === process.pid)
+                return;
+            if (existingPid !== undefined)
+                throw new Error(`${label} already running (PID ${existingPid})`);
+            try {
+                unlinkSync(path);
+            }
+            catch (unlinkError) {
+                if (unlinkError.code !== "ENOENT")
+                    throw unlinkError;
+            }
+        }
+    }
+    throw new Error(`Unable to claim ${label.toLowerCase()} PID file`);
+}
+function clearPidFileIfOwned(path) {
+    try {
+        if (storedPid(path) === process.pid)
+            unlinkSync(path);
+    }
+    catch {
+        // ignore
+    }
+}
+export function readPidFile() {
+    return livePid(gatewayPidPath()) ?? legacyGatewayPidPaths().map(livePid).find((pid) => pid !== undefined);
+}
+export function clearPidFile() {
+    try {
+        const path = gatewayPidPath();
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    catch {
+        // ignore
+    }
+}
+export function releaseGatewayPid() {
+    clearPidFileIfOwned(gatewayPidPath());
+}
+export function writeGatewayPid() {
+    const existingPid = readPidFile();
+    if (existingPid !== undefined && existingPid !== process.pid) {
+        throw new Error(`Gateway already running (PID ${existingPid})`);
+    }
+    for (const path of legacyGatewayPidPaths()) {
+        if (livePid(path) !== undefined)
+            continue;
+        try {
+            unlinkSync(path);
+        }
+        catch { }
+    }
+    claimPidFile(gatewayPidPath(), "Gateway");
+}
+export function readFallbackPidFile() {
+    return livePid(fallbackGatewayPidPath());
+}
+export function clearFallbackPidFile() {
+    try {
+        const path = fallbackGatewayPidPath();
+        if (existsSync(path))
+            unlinkSync(path);
+    }
+    catch {
+        // ignore
+    }
+}
+export function releaseFallbackGatewayPid() {
+    clearPidFileIfOwned(fallbackGatewayPidPath());
+}
+export function writeFallbackGatewayPid() {
+    claimPidFile(fallbackGatewayPidPath(), "Fallback gateway");
+}

package/dist/gateway/protocol.js

@@ -0,0 +1,62 @@
+export const DEFAULT_GATEWAY_HOST = "127.0.0.1";
+export const DEFAULT_GATEWAY_PORT = 4789;
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    if (typeof value === "object") {
+        return Object.values(value).every(isJsonValue);
+    }
+    return false;
+}
+export function isGatewayRequestFrame(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const frame = value;
+    if (frame.type !== "req" || typeof frame.id !== "string")
+        return false;
+    if (!frame.event || typeof frame.event !== "object")
+        return false;
+    const event = frame.event;
+    if (typeof event.piboSessionId !== "string" || event.piboSessionId.length === 0)
+        return false;
+    if (event.type === "message")
+        return typeof event.text === "string";
+    if (event.type === "execution") {
+        return typeof event.action === "string" && (event.params === undefined || isJsonValue(event.params));
+    }
+    return false;
+}
+export function isGatewaySubscribeFrame(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const frame = value;
+    if (frame.type !== "subscribe" || typeof frame.id !== "string")
+        return false;
+    if (!frame.subscription || typeof frame.subscription !== "object")
+        return false;
+    const subscription = frame.subscription;
+    if (subscription.type === "legacy-all")
+        return true;
+    if (subscription.type === "session") {
+        return typeof subscription.piboSessionId === "string" && subscription.piboSessionId.length > 0;
+    }
+    return false;
+}
+export function encodeFrame(frame) {
+    return `${JSON.stringify(frame)}\n`;
+}
+export function errorResponse(id, error) {
+    return {
+        type: "res",
+        id,
+        ok: false,
+        error: { message: error instanceof Error ? error.message : String(error) },
+    };
+}

package/dist/gateway/request.js

@@ -0,0 +1,155 @@
+import { randomUUID } from "node:crypto";
+import { connect } from "node:net";
+import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, } from "./protocol.js";
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeFrame(socket, frame) {
+    socket.write(encodeFrame(frame));
+}
+export async function sendGatewayEvent(event, options = {}) {
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    const timeoutMs = options.timeoutMs ?? 5000;
+    const id = randomUUID();
+    const eventWithId = { ...event, id: event.id ?? id };
+    return await new Promise((resolve, reject) => {
+        const socket = connect({ host, port });
+        socket.setEncoding("utf-8");
+        let buffer = "";
+        let settled = false;
+        const timeout = setTimeout(() => {
+            finish(new Error(`Timed out waiting for gateway response at ${host}:${port}`));
+        }, timeoutMs);
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.end();
+            if (result instanceof Error) {
+                reject(result);
+            }
+            else {
+                resolve(result);
+            }
+        };
+        socket.once("connect", () => {
+            writeFrame(socket, { type: "req", id, event: eventWithId });
+        });
+        socket.once("error", finish);
+        socket.once("close", () => {
+            finish(new Error("Gateway connection closed before response"));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                const frame = line ? parseJsonLine(line) : undefined;
+                if (frame?.type === "res" && frame.id === id) {
+                    finish(frame);
+                    return;
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        });
+    });
+}
+export async function sendGatewayMessageAndWaitForReply(event, options = {}) {
+    const host = options.host ?? DEFAULT_GATEWAY_HOST;
+    const port = options.port ?? DEFAULT_GATEWAY_PORT;
+    const timeoutMs = options.timeoutMs ?? 120000;
+    const id = randomUUID();
+    const eventWithId = { ...event, id: event.id ?? id };
+    return await new Promise((resolve, reject) => {
+        const socket = connect({ host, port });
+        socket.setEncoding("utf-8");
+        let buffer = "";
+        let settled = false;
+        let response;
+        let reply;
+        let messageFinished = false;
+        const timeout = setTimeout(() => {
+            finish(new Error(`Timed out waiting for assistant reply from session "${event.piboSessionId}"`));
+        }, timeoutMs);
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.end();
+            if (result instanceof Error) {
+                reject(result);
+            }
+            else {
+                resolve(result);
+            }
+        };
+        const finishCompletedReply = () => {
+            if (!response?.ok || !messageFinished)
+                return;
+            finish(reply
+                ? { response, reply }
+                : new Error(`Session "${eventWithId.piboSessionId}" finished without an assistant reply`));
+        };
+        const handleFrame = (frame) => {
+            if (frame.type === "res" && frame.id === id) {
+                response = frame;
+                if (!frame.ok) {
+                    finish(new Error(frame.error?.message ?? "Gateway rejected the message"));
+                }
+                else {
+                    finishCompletedReply();
+                }
+                return;
+            }
+            if (frame.type !== "event" || frame.event !== "router")
+                return;
+            const output = frame.payload;
+            if (output.type === "session_error" &&
+                output.piboSessionId === eventWithId.piboSessionId &&
+                output.eventId === eventWithId.id) {
+                finish(new Error(output.error));
+                return;
+            }
+            if (output.piboSessionId !== eventWithId.piboSessionId || !("eventId" in output) || output.eventId !== eventWithId.id)
+                return;
+            if (output.type === "assistant_message") {
+                reply = output;
+            }
+            else if (output.type === "message_finished") {
+                messageFinished = true;
+                finishCompletedReply();
+            }
+        };
+        socket.once("connect", () => {
+            writeFrame(socket, { type: "req", id, event: eventWithId });
+        });
+        socket.once("error", finish);
+        socket.once("close", () => {
+            finish(new Error("Gateway connection closed before assistant reply"));
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                const frame = line ? parseJsonLine(line) : undefined;
+                if (frame) {
+                    handleFrame(frame);
+                    if (settled)
+                        return;
+                }
+                newlineIndex = buffer.indexOf("\n");
+            }
+        });
+    });
+}