@pasko70/pibo 1.0.0

package/dist/debug/session.js

@@ -0,0 +1,200 @@
+import { normalizeLimit, openReadOnlyDebugDatabase, withStorePath } from "./sql.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.defaultPath}`);
+    }
+    const sessionsDb = openReadOnlyDebugDatabase(stores.sessions);
+    try {
+        const session = sessionsDb.prepare("SELECT * FROM pibo_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 = 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),
+        };
+        if (stores.chat.exists) {
+            const chatDb = 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 {
+                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)}`);
+        }
+    }
+    return lines.join("\n");
+}
+function listChildSessions(db, piboSessionId, limit) {
+    const rows = db
+        .prepare(`
+				SELECT id, pi_session_id, channel, kind, profile, parent_id, metadata_json, created_at, updated_at
+				FROM pibo_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, "web_chat_sessions"))
+        return undefined;
+    return db.prepare("SELECT * FROM web_chat_sessions WHERE pibo_session_id = ?").get(piboSessionId);
+}
+function readEventSummaries(db, piboSessionId, limit) {
+    if (!tableExists(db, "web_chat_events"))
+        return [];
+    return db
+        .prepare(`
+				SELECT type, event_id, created_at
+				FROM web_chat_events
+				WHERE pibo_session_id = ?
+				ORDER BY rowid 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,
+        owner_scope: row.owner_scope,
+        parent_id: row.parent_id,
+        origin_id: row.origin_id,
+        workspace: row.workspace,
+        title: row.title,
+        created_at: row.created_at,
+        updated_at: row.updated_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.defaultPath}`);
+    }
+    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,49 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+export const PIBO_DEBUG_STORES = [
+    {
+        name: "sessions",
+        description: "canonical Pibo Session metadata",
+        defaultPath: ".pibo/pibo-sessions.sqlite",
+    },
+    {
+        name: "chat",
+        description: "Chat Web read model, rooms, and durable chat events",
+        defaultPath: ".pibo/web-chat.sqlite",
+    },
+    {
+        name: "agents",
+        description: "custom Agent Designer profiles",
+        defaultPath: ".pibo/chat-agents.sqlite",
+    },
+    {
+        name: "auth",
+        description: "Better Auth local auth data",
+        defaultPath: ".pibo/auth.sqlite",
+    },
+    {
+        name: "bindings",
+        description: "local session binding data",
+        defaultPath: ".pibo/session-bindings.sqlite",
+    },
+    {
+        name: "reliability",
+        description: "Pibo event stream, durable jobs, and yielded runs",
+        defaultPath: ".pibo/pibo-events.sqlite",
+    },
+];
+export function resolveDebugStores(cwd = process.cwd()) {
+    return PIBO_DEBUG_STORES.map((store) => resolveDebugStore(store.name, cwd));
+}
+export function resolveDebugStore(name, cwd = process.cwd()) {
+    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 = resolve(cwd, store.defaultPath);
+    return {
+        ...store,
+        path,
+        exists: existsSync(path),
+    };
+}