@pasko70/pibo 1.9.9 → 1.9.10

package/dist/debug/session.js

@@ -0,0 +1,230 @@
+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

@@ -0,0 +1,238 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,72 @@
+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");
+}