@pasko70/pibo 1.9.7 → 1.9.9

package/dist/debug/session.js

@@ -1,230 +0,0 @@
-import { normalizeLimit, openReadOnlyDebugDatabase, withStorePath } from "./sql.js";
-import { formatNextCommands } from "./next-commands.js";
-export function parseDebugSessionInput(input) {
-    const raw = input.trim();
-    if (!raw)
-        throw new Error("Session input is required");
-    const pathname = raw.startsWith("http://") || raw.startsWith("https://") ? new URL(raw).pathname : raw;
-    const roomMatch = /^\/apps\/chat\/rooms\/([^/]+)\/sessions\/([^/]+)\/?$/.exec(pathname);
-    if (roomMatch) {
-        return { raw, roomId: decodeURIComponent(roomMatch[1]), piboSessionId: decodeURIComponent(roomMatch[2]) };
-    }
-    const sessionMatch = /^\/apps\/chat\/sessions\/([^/]+)\/?$/.exec(pathname);
-    if (sessionMatch) {
-        return { raw, piboSessionId: decodeURIComponent(sessionMatch[1]) };
-    }
-    return { raw, piboSessionId: raw };
-}
-export function inspectDebugSession(input, stores, options = {}) {
-    const parsed = parseDebugSessionInput(input);
-    const limit = normalizeLimit(options.limit);
-    if (!stores.sessions.exists) {
-        throw new Error(`Debug store "sessions" not found at ${stores.sessions.path}`);
-    }
-    const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
-    try {
-        const session = sessionsDb.prepare("SELECT * FROM sessions WHERE id = ?").get(parsed.piboSessionId);
-        if (!session)
-            throw new Error(`Pibo session "${parsed.piboSessionId}" not found`);
-        const metadata = parseObject(session.metadata_json);
-        const sessionRoomId = session.room_id ?? stringValue(metadata.chatRoomId);
-        const warnings = parsed.roomId && sessionRoomId && parsed.roomId !== sessionRoomId
-            ? [`URL roomId "${parsed.roomId}" does not match session metadata chatRoomId "${sessionRoomId}".`]
-            : [];
-        const summary = {
-            input: parsed,
-            warnings,
-            session: compactSessionRow(session),
-            metadata,
-            room: {
-                urlRoomId: parsed.roomId,
-                sessionRoomId,
-                matches: parsed.roomId && sessionRoomId ? parsed.roomId === sessionRoomId : undefined,
-            },
-            children: listChildSessions(sessionsDb, parsed.piboSessionId, limit),
-        };
-        summary.nextCommands = [
-            `pibo debug messages ${parsed.piboSessionId} list`,
-            `pibo debug final ${parsed.piboSessionId}`,
-            `pibo debug trace ${parsed.piboSessionId} --check`,
-            `pibo debug failures ${parsed.piboSessionId}`,
-            `pibo debug events ${parsed.piboSessionId} --limit 20`,
-        ];
-        if (stores.chat.exists) {
-            const chatDb = stores.chat.path === stores.sessions.path ? sessionsDb : openReadOnlyDebugDatabase(stores.chat);
-            try {
-                summary.chat = readChatSession(chatDb, parsed.piboSessionId);
-                if (options.events)
-                    summary.events = readEventSummaries(chatDb, parsed.piboSessionId, limit);
-            }
-            catch (error) {
-                throw withStorePath(error, stores.chat);
-            }
-            finally {
-                if (chatDb !== sessionsDb)
-                    chatDb.close();
-            }
-        }
-        return summary;
-    }
-    catch (error) {
-        throw withStorePath(error, stores.sessions);
-    }
-    finally {
-        sessionsDb.close();
-    }
-}
-export function formatDebugSessionSummary(summary) {
-    const lines = [];
-    lines.push(`piboSessionId: ${summary.input.piboSessionId}`);
-    if (summary.input.roomId)
-        lines.push(`urlRoomId: ${summary.input.roomId}`);
-    if (summary.room.sessionRoomId)
-        lines.push(`sessionRoomId: ${summary.room.sessionRoomId}`);
-    if (summary.room.matches !== undefined)
-        lines.push(`roomMatch: ${String(summary.room.matches)}`);
-    for (const warning of summary.warnings)
-        lines.push(`warning: ${warning}`);
-    lines.push("");
-    lines.push("Session:");
-    for (const [key, value] of Object.entries(summary.session)) {
-        lines.push(`  ${key}: ${formatValue(value)}`);
-    }
-    if (Object.keys(summary.metadata).length) {
-        lines.push("");
-        lines.push("Metadata:");
-        for (const [key, value] of Object.entries(summary.metadata)) {
-            lines.push(`  ${key}: ${formatValue(value)}`);
-        }
-    }
-    lines.push("");
-    lines.push(`Children: ${summary.children.length}`);
-    for (const child of summary.children) {
-        lines.push(`  ${formatValue(child.id)}\t${formatValue(child.profile)}\t${formatValue(child.kind)}\t${formatValue(child.subagentName)}\t${formatValue(child.threadKey)}`);
-    }
-    if (summary.chat) {
-        lines.push("");
-        lines.push("Chat Web:");
-        for (const [key, value] of Object.entries(summary.chat)) {
-            lines.push(`  ${key}: ${formatValue(value)}`);
-        }
-    }
-    if (summary.events) {
-        lines.push("");
-        lines.push(`Events: ${summary.events.length}`);
-        for (const event of summary.events) {
-            lines.push(`  ${formatValue(event.created_at)}\t${formatValue(event.type)}\t${formatValue(event.event_id)}`);
-        }
-    }
-    lines.push(...formatNextCommands(summary.nextCommands ?? []));
-    return lines.join("\n");
-}
-function listChildSessions(db, piboSessionId, limit) {
-    const rows = db
-        .prepare(`
-				SELECT id, pi_session_id, channel, kind, profile, room_id, root_session_id, parent_id, origin_id, workspace, title, status, metadata_json, created_at, updated_at, last_activity_at
-				FROM sessions
-				WHERE parent_id = ?
-				ORDER BY created_at
-				LIMIT ?
-			`)
-        .all(piboSessionId, limit);
-    return rows.map((row) => {
-        const metadata = parseObject(row.metadata_json);
-        return {
-            id: row.id,
-            pi_session_id: row.pi_session_id,
-            channel: row.channel,
-            kind: row.kind,
-            profile: row.profile,
-            parent_id: row.parent_id,
-            subagentName: stringValue(metadata.subagentName),
-            subagentToolName: stringValue(metadata.subagentToolName),
-            threadKey: stringValue(metadata.threadKey),
-            chatRoomId: stringValue(metadata.chatRoomId),
-            created_at: row.created_at,
-            updated_at: row.updated_at,
-        };
-    });
-}
-function readChatSession(db, piboSessionId) {
-    if (!tableExists(db, "sessions"))
-        return undefined;
-    return db.prepare(`
-		SELECT
-			s.id AS pibo_session_id,
-			s.room_id,
-			s.root_session_id,
-			s.status,
-			s.last_activity_at,
-			stats.message_count,
-			stats.tool_call_count,
-			stats.error_count,
-			stats.last_event_stream_id,
-			nav.child_count,
-			nav.sort_key
-		FROM sessions s
-		LEFT JOIN session_stats stats ON stats.session_id = s.id
-		LEFT JOIN session_navigation nav ON nav.session_id = s.id
-		WHERE s.id = ?
-	`).get(piboSessionId);
-}
-function readEventSummaries(db, piboSessionId, limit) {
-    if (!tableExists(db, "event_log"))
-        return [];
-    return db
-        .prepare(`
-				SELECT type, event_id, created_at, stream_id
-				FROM event_log
-				WHERE session_id = ?
-				ORDER BY stream_id DESC
-				LIMIT ?
-			`)
-        .all(piboSessionId, limit);
-}
-function tableExists(db, table) {
-    const row = db.prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?").get(table);
-    return row !== undefined;
-}
-function compactSessionRow(row) {
-    return {
-        id: row.id,
-        pi_session_id: row.pi_session_id,
-        channel: row.channel,
-        kind: row.kind,
-        profile: row.profile,
-        parent_id: row.parent_id,
-        origin_id: row.origin_id,
-        workspace: row.workspace,
-        title: row.title,
-        status: row.status,
-        room_id: row.room_id,
-        root_session_id: row.root_session_id,
-        created_at: row.created_at,
-        updated_at: row.updated_at,
-        last_activity_at: row.last_activity_at,
-    };
-}
-function parseObject(value) {
-    if (!value)
-        return {};
-    try {
-        const parsed = JSON.parse(value);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            return {};
-        return parsed;
-    }
-    catch {
-        return {};
-    }
-}
-function stringValue(value) {
-    return typeof value === "string" && value ? value : undefined;
-}
-function formatValue(value) {
-    if (value === null || value === undefined)
-        return "";
-    if (typeof value === "object")
-        return JSON.stringify(value);
-    return String(value);
-}

package/dist/debug/sql.js

@@ -1,238 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-const DEFAULT_QUERY_LIMIT = 50;
-const MAX_QUERY_LIMIT = 1000;
-const MUTATING_KEYWORDS = new Set([
-    "alter",
-    "attach",
-    "create",
-    "delete",
-    "detach",
-    "drop",
-    "insert",
-    "replace",
-    "update",
-    "vacuum",
-]);
-const READ_ONLY_PRAGMAS = new Set(["table_info", "index_list", "index_info"]);
-export function normalizeLimit(value) {
-    const raw = value === undefined ? DEFAULT_QUERY_LIMIT : Number(value);
-    if (!Number.isInteger(raw) || raw < 1) {
-        throw new Error("Limit must be a positive integer");
-    }
-    return Math.min(raw, MAX_QUERY_LIMIT);
-}
-export function listTables(store) {
-    return withReadOnlyDatabase(store, (db) => db
-        .prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
-        .all().map((row) => row.name));
-}
-export function getStoreSchema(store) {
-    return withReadOnlyDatabase(store, (db) => {
-        const tables = listTablesFromDb(db);
-        return tables.map((table) => ({
-            name: table,
-            columns: db.prepare(`PRAGMA table_info(${quoteIdentifier(table)})`).all().map((column) => ({
-                name: column.name,
-                type: column.type,
-                notNull: column.notnull === 1,
-                primaryKey: column.pk > 0,
-            })),
-            indexes: db.prepare(`PRAGMA index_list(${quoteIdentifier(table)})`).all().map((index) => ({
-                name: index.name,
-                unique: index.unique === 1,
-                origin: index.origin,
-                partial: index.partial === 1,
-            })),
-        }));
-    });
-}
-export function runReadOnlyQuery(store, sql, options = {}) {
-    const limit = normalizeLimit(options.limit);
-    const statement = validateReadOnlySql(sql);
-    return withReadOnlyDatabase(store, (db) => {
-        const hasLimit = hasToken(statement, "limit");
-        const isPragma = firstToken(statement) === "pragma";
-        const query = hasLimit || isPragma ? statement : `SELECT * FROM (${statement}) LIMIT ?`;
-        const params = hasLimit || isPragma ? [] : [limit + 1];
-        const rows = db.prepare(query).all(...params);
-        const limited = rows.length > limit;
-        return {
-            store: store.name,
-            path: store.path,
-            rows: rows.slice(0, limit),
-            limited,
-        };
-    });
-}
-export function formatRows(rows, options = {}) {
-    if (rows.length === 0)
-        return "rows: 0";
-    const columns = Object.keys(rows[0] ?? {});
-    const lines = [columns.join("\t")];
-    for (const row of rows) {
-        lines.push(columns.map((column) => formatCell(row[column])).join("\t"));
-    }
-    lines.push(`rows: ${rows.length}${options.limited ? " (limited)" : ""}`);
-    return lines.join("\n");
-}
-export function formatJson(value) {
-    return JSON.stringify(value, null, 2);
-}
-export function openReadOnlyDebugDatabase(store) {
-    if (!store.exists) {
-        throw new Error(`Debug store "${store.name}" not found at ${store.path}`);
-    }
-    const db = new DatabaseSync(store.path, { readOnly: true });
-    db.exec("PRAGMA busy_timeout = 5000");
-    return db;
-}
-function withReadOnlyDatabase(store, action) {
-    const db = openReadOnlyDebugDatabase(store);
-    try {
-        return action(db);
-    }
-    catch (error) {
-        throw withStorePath(error, store);
-    }
-    finally {
-        db.close();
-    }
-}
-export function withStorePath(error, store) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.startsWith("Debug store "))
-        return error instanceof Error ? error : new Error(message);
-    if (!/database is locked/i.test(message))
-        return error instanceof Error ? error : new Error(message);
-    return new Error(`Debug store "${store.name}" at ${store.path} is locked: ${message}`);
-}
-function listTablesFromDb(db) {
-    return db
-        .prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
-        .all().map((row) => row.name);
-}
-function validateReadOnlySql(sql) {
-    const statement = normalizeSingleStatement(sql);
-    const token = firstToken(statement);
-    if (token === "pragma") {
-        const match = /^pragma\s+([a-z_][a-z0-9_]*)\s*\(/i.exec(statement);
-        if (!match || !READ_ONLY_PRAGMAS.has(match[1].toLowerCase())) {
-            throw new Error("Only read-only PRAGMA table_info(...), index_list(...), and index_info(...) are allowed");
-        }
-        return statement;
-    }
-    const tokens = readSqlTokens(statement);
-    for (const item of tokens) {
-        if (MUTATING_KEYWORDS.has(item)) {
-            throw new Error(`Mutating SQL is not allowed: ${item}`);
-        }
-    }
-    if (token === "select")
-        return statement;
-    if (token === "with" && tokens.includes("select"))
-        return statement;
-    throw new Error("Only SELECT, WITH ... SELECT, and read-only PRAGMA statements are allowed");
-}
-function normalizeSingleStatement(sql) {
-    let statement = sql.trim();
-    if (!statement)
-        throw new Error("SQL query is required");
-    if (statement.endsWith(";"))
-        statement = statement.slice(0, -1).trim();
-    if (containsSemicolon(statement)) {
-        throw new Error("Only one SQL statement is allowed");
-    }
-    return statement;
-}
-function firstToken(sql) {
-    return readSqlTokens(sql)[0] ?? "";
-}
-function hasToken(sql, token) {
-    return readSqlTokens(sql).includes(token);
-}
-function readSqlTokens(sql) {
-    const tokens = [];
-    let quote = null;
-    let current = "";
-    for (let index = 0; index < sql.length; index += 1) {
-        const char = sql[index];
-        const next = sql[index + 1];
-        if (quote) {
-            if (char === quote) {
-                if (next === quote) {
-                    index += 1;
-                }
-                else {
-                    quote = null;
-                }
-            }
-            continue;
-        }
-        if (char === "-" && next === "-") {
-            index += 2;
-            while (index < sql.length && sql[index] !== "\n")
-                index += 1;
-            flushToken();
-            continue;
-        }
-        if (char === "/" && next === "*") {
-            index += 2;
-            while (index < sql.length && !(sql[index] === "*" && sql[index + 1] === "/"))
-                index += 1;
-            index += 1;
-            flushToken();
-            continue;
-        }
-        if (char === "'" || char === '"' || char === "`") {
-            flushToken();
-            quote = char;
-            continue;
-        }
-        if (/[A-Za-z0-9_]/.test(char)) {
-            current += char.toLowerCase();
-            continue;
-        }
-        flushToken();
-    }
-    flushToken();
-    return tokens;
-    function flushToken() {
-        if (!current)
-            return;
-        tokens.push(current);
-        current = "";
-    }
-}
-function containsSemicolon(sql) {
-    let quote = null;
-    for (let index = 0; index < sql.length; index += 1) {
-        const char = sql[index];
-        const next = sql[index + 1];
-        if (quote) {
-            if (char === quote) {
-                if (next === quote)
-                    index += 1;
-                else
-                    quote = null;
-            }
-            continue;
-        }
-        if (char === "'" || char === '"' || char === "`") {
-            quote = char;
-            continue;
-        }
-        if (char === ";")
-            return true;
-    }
-    return false;
-}
-function quoteIdentifier(value) {
-    return `"${value.replaceAll('"', '""')}"`;
-}
-function formatCell(value) {
-    if (value === null || value === undefined)
-        return "";
-    if (typeof value === "object")
-        return JSON.stringify(value);
-    return String(value).replaceAll("\n", "\\n");
-}

package/dist/debug/stores.js

@@ -1,54 +0,0 @@
-import { existsSync } from "node:fs";
-import { piboHomePath } from "../core/pibo-home.js";
-export const PIBO_DEBUG_STORES = [
-    {
-        name: "pibo-data",
-        description: "current unified Chat Web and Pibo Session data",
-        defaultPath: "pibo.sqlite",
-    },
-    {
-        name: "sessions",
-        description: "V2 alias for Pibo Session metadata in pibo.sqlite",
-        defaultPath: "pibo.sqlite",
-    },
-    {
-        name: "chat",
-        description: "V2 alias for Chat Web rooms, messages, events, observations, and stats in pibo.sqlite",
-        defaultPath: "pibo.sqlite",
-    },
-    {
-        name: "agents",
-        description: "custom Agent Designer profiles",
-        defaultPath: "chat-agents.sqlite",
-    },
-    {
-        name: "auth",
-        description: "Better Auth local auth data",
-        defaultPath: "auth.sqlite",
-    },
-    {
-        name: "bindings",
-        description: "local session binding data",
-        defaultPath: "session-bindings.sqlite",
-    },
-    {
-        name: "reliability",
-        description: "Pibo event stream, durable jobs, and yielded runs",
-        defaultPath: "pibo-events.sqlite",
-    },
-];
-export function resolveDebugStores() {
-    return PIBO_DEBUG_STORES.map((store) => resolveDebugStore(store.name));
-}
-export function resolveDebugStore(name) {
-    const store = PIBO_DEBUG_STORES.find((item) => item.name === name);
-    if (!store) {
-        throw new Error(`Unknown debug store "${name}". Use one of: ${PIBO_DEBUG_STORES.map((item) => item.name).join(", ")}`);
-    }
-    const path = piboHomePath(store.defaultPath);
-    return {
-        ...store,
-        path,
-        exists: existsSync(path),
-    };
-}

package/dist/debug/summary.js

@@ -1,72 +0,0 @@
-import { inspectDebugEvents } from "./events.js";
-import { inspectDebugMessageShow, inspectDebugMessagesList } from "./messages.js";
-import { formatNextCommands } from "./next-commands.js";
-import { inspectDebugSession, parseDebugSessionInput } from "./session.js";
-import { inspectDebugTrace } from "./trace.js";
-export async function inspectDebugSummary(input, stores) {
-    const parsed = parseDebugSessionInput(input);
-    const session = inspectDebugSession(input, stores, {});
-    const messages = inspectDebugMessagesList(parsed.piboSessionId, stores.chat, { limit: 1000 }).messages;
-    const final = inspectDebugMessageShow(parsed.piboSessionId, stores.chat, "assistant:last", { maxBytes: 240 });
-    let traceStatus;
-    try {
-        traceStatus = (await inspectDebugTrace(parsed.piboSessionId, stores, { check: true })).status;
-    }
-    catch {
-        traceStatus = undefined;
-    }
-    const failedToolCallCount = inspectDebugEvents(parsed.piboSessionId, stores.chat, { type: "tool_execution_finished", fields: ["isError", "result.status", "result.details.status"], limit: 1000 }).events.filter((event) => event.isError === true || event["result.status"] === "error" || event["result.details.status"] === "error" || event["result.details.status"] === "failed").length;
-    const messageCounts = messages.reduce((counts, message) => {
-        counts[message.role] = (counts[message.role] ?? 0) + 1;
-        return counts;
-    }, {});
-    return {
-        piboSessionId: parsed.piboSessionId,
-        status: session.session.status,
-        traceStatus,
-        roomId: session.room.sessionRoomId,
-        title: session.session.title,
-        createdAt: session.session.created_at,
-        updatedAt: session.session.updated_at,
-        lastActivityAt: session.session.last_activity_at,
-        messages: messageCounts,
-        finalAssistant: final.message ? { available: true, bytes: final.message.contentBytes, streamId: final.message.streamId, preview: final.message.preview } : { available: false },
-        toolCallCount: session.chat?.tool_call_count,
-        failedToolCallCount,
-        nextCommands: [
-            `pibo debug final ${parsed.piboSessionId}`,
-            `pibo debug failures ${parsed.piboSessionId}`,
-            `pibo debug messages ${parsed.piboSessionId} list`,
-            `pibo debug trace ${parsed.piboSessionId} --check`,
-            `pibo debug events ${parsed.piboSessionId} --limit 20`,
-        ],
-    };
-}
-export function formatDebugSummary(result) {
-    const lines = [];
-    lines.push(`piboSessionId: ${result.piboSessionId}`);
-    if (result.status !== undefined)
-        lines.push(`status: ${result.status}`);
-    if (result.traceStatus)
-        lines.push(`traceStatus: ${result.traceStatus}`);
-    if (result.roomId)
-        lines.push(`roomId: ${result.roomId}`);
-    if (result.title)
-        lines.push(`title: ${result.title}`);
-    if (result.createdAt)
-        lines.push(`createdAt: ${result.createdAt}`);
-    if (result.updatedAt)
-        lines.push(`updatedAt: ${result.updatedAt}`);
-    if (result.lastActivityAt)
-        lines.push(`lastActivityAt: ${result.lastActivityAt}`);
-    lines.push(`messages: ${Object.entries(result.messages).map(([role, count]) => `${count} ${role}`).join(", ") || "0"}`);
-    if (result.finalAssistant?.available)
-        lines.push(`finalAssistant: available, ${result.finalAssistant.bytes} bytes, stream_id=${result.finalAssistant.streamId}`);
-    else
-        lines.push("finalAssistant: unavailable");
-    if (result.toolCallCount !== undefined)
-        lines.push(`toolCalls: ${result.toolCallCount}`);
-    lines.push(`failures: ${result.failedToolCallCount} tool executions`);
-    lines.push(...formatNextCommands(result.nextCommands));
-    return lines.join("\n");
-}