@pasko70/pibo 1.1.0 → 1.2.0

package/dist/cron/store.js

@@ -0,0 +1,349 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { piboHomePath } from "../core/pibo-home.js";
+import { computeNextRunAt, validateSchedule } from "./schedule.js";
+function nowIso(now = new Date()) {
+    return now.toISOString();
+}
+function parseJson(json) {
+    return JSON.parse(json);
+}
+function jobFromRow(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        description: row.description ?? undefined,
+        enabled: row.enabled === 1,
+        target: parseTarget(row.target_json),
+        profile: row.profile,
+        prompt: row.prompt,
+        schedule: parseJson(row.schedule_json),
+        scheduleUi: row.schedule_ui_json ? parseJson(row.schedule_ui_json) : undefined,
+        deleteAfterRun: row.delete_after_run === 1,
+        state: parseJson(row.state_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function runFromRow(row) {
+    return {
+        id: row.id,
+        jobId: row.job_id,
+        piboSessionId: row.pibo_session_id ?? undefined,
+        status: row.status,
+        reason: row.reason ?? undefined,
+        error: row.error ?? undefined,
+        startedAt: row.started_at ?? undefined,
+        completedAt: row.completed_at ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function defaultName(prompt) {
+    const normalized = prompt.replace(/\s+/g, " ").trim();
+    return normalized ? normalized.slice(0, 80) : "Scheduled job";
+}
+function normalizeTarget(target) {
+    if (target.kind === "room")
+        return { kind: "room", roomId: String(target.roomId ?? "").trim() };
+    return { kind: "default-chat" };
+}
+function parseTarget(json) {
+    return normalizeTarget(parseJson(json));
+}
+function targetJson(target) {
+    return JSON.stringify(normalizeTarget(target));
+}
+function validateJobInput(input) {
+    if (!input.profile.trim())
+        throw new Error("profile is required");
+    if (!input.prompt.trim())
+        throw new Error("prompt is required");
+    if (input.target.kind === "room" && !input.target.roomId.trim())
+        throw new Error("target.roomId is required");
+    validateSchedule(input.schedule);
+}
+export class PiboCronStore {
+    db;
+    constructor(options = {}) {
+        const dbPath = options.path ?? piboHomePath("pibo-cron.sqlite");
+        const resolved = dbPath === ":memory:" ? dbPath : resolve(dbPath);
+        if (resolved !== ":memory:")
+            mkdirSync(dirname(resolved), { recursive: true });
+        this.db = new DatabaseSync(resolved);
+        this.db.exec("PRAGMA busy_timeout = 5000");
+        this.db.exec("PRAGMA foreign_keys = ON");
+        if (resolved !== ":memory:")
+            this.db.exec("PRAGMA journal_mode = WAL");
+        this.applySchema();
+    }
+    close() {
+        this.db.close();
+    }
+    createJob(input, now = new Date()) {
+        const target = normalizeTarget(input.target);
+        validateJobInput({ ...input, target });
+        const timestamp = nowIso(now);
+        const nextRunAt = input.enabled === false ? undefined : computeNextRunAt(input.schedule, now)?.toISOString();
+        if (input.enabled !== false && !nextRunAt)
+            throw new Error("schedule has no future run");
+        const job = {
+            id: `cron_${randomUUID()}`,
+            name: (input.name ?? defaultName(input.prompt)).trim(),
+            description: input.description?.trim() || undefined,
+            enabled: input.enabled !== false,
+            target,
+            profile: input.profile,
+            prompt: input.prompt,
+            schedule: input.schedule,
+            scheduleUi: input.scheduleUi,
+            deleteAfterRun: input.deleteAfterRun === true,
+            state: { nextRunAt },
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        this.insertJob(job);
+        return this.getJob(job.id);
+    }
+    getJob(id) {
+        const row = this.db.prepare("SELECT * FROM pibo_cron_jobs WHERE id = ?").get(id);
+        return row ? jobFromRow(row) : undefined;
+    }
+    listJobs(input = {}) {
+        const clauses = [];
+        const values = [];
+        if (!input.includeDisabled)
+            clauses.push("enabled = 1");
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        return this.db.prepare(`SELECT * FROM pibo_cron_jobs ${where} ORDER BY updated_at DESC, id ASC`).all(...values).map(jobFromRow);
+    }
+    updateJob(id, patch, now = new Date()) {
+        const existing = this.getJob(id);
+        if (!existing)
+            return undefined;
+        const nextTarget = patch.target ? normalizeTarget(patch.target) : existing.target;
+        const next = {
+            ...existing,
+            ...patch,
+            name: patch.name !== undefined ? patch.name.trim() : existing.name,
+            description: patch.description !== undefined ? patch.description?.trim() || undefined : existing.description,
+            enabled: patch.enabled ?? existing.enabled,
+            target: nextTarget,
+            profile: patch.profile ?? existing.profile,
+            prompt: patch.prompt ?? existing.prompt,
+            schedule: patch.schedule ?? existing.schedule,
+            scheduleUi: patch.scheduleUi ?? existing.scheduleUi,
+            deleteAfterRun: patch.deleteAfterRun ?? existing.deleteAfterRun,
+            updatedAt: nowIso(now),
+        };
+        validateJobInput(next);
+        next.state = {
+            ...existing.state,
+            runningAt: existing.state.runningAt,
+            nextRunAt: next.enabled ? computeNextRunAt(next.schedule, now)?.toISOString() : undefined,
+        };
+        if (next.enabled && !next.state.nextRunAt && next.schedule.kind !== "at")
+            throw new Error("schedule has no future run");
+        this.writeJob(next);
+        return this.getJob(id);
+    }
+    removeJob(id) {
+        const result = this.db.prepare("DELETE FROM pibo_cron_jobs WHERE id = ?").run(id);
+        return Number(result.changes ?? 0) > 0;
+    }
+    listRuns(input = {}) {
+        const clauses = [];
+        const values = [];
+        if (input.jobId) {
+            clauses.push("job_id = ?");
+            values.push(input.jobId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        return this.db.prepare(`SELECT * FROM pibo_cron_runs ${where} ORDER BY created_at DESC LIMIT ?`).all(...values, Math.max(1, Math.min(input.limit ?? 100, 500))).map(runFromRow);
+    }
+    getRun(id) {
+        const row = this.db.prepare("SELECT * FROM pibo_cron_runs WHERE id = ?").get(id);
+        return row ? runFromRow(row) : undefined;
+    }
+    reserveDueRuns(limit, now = new Date()) {
+        const timestamp = nowIso(now);
+        const result = [];
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const rows = this.db.prepare(`
+				SELECT * FROM pibo_cron_jobs
+				WHERE enabled = 1
+				ORDER BY updated_at ASC
+			`).all();
+            for (const row of rows) {
+                if (result.length >= limit)
+                    break;
+                const job = jobFromRow(row);
+                if (job.state.runningAt)
+                    continue;
+                if (!job.state.nextRunAt || job.state.nextRunAt > timestamp)
+                    continue;
+                const run = this.createRunLocked(job, timestamp, "running");
+                const state = { ...job.state, runningAt: timestamp, lastRunAt: timestamp, lastRunId: run.id };
+                this.updateJobStateLocked(job.id, state, timestamp);
+                result.push({ job: { ...job, state, updatedAt: timestamp }, run });
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+        return result;
+    }
+    reserveManualRun(id, now = new Date()) {
+        const timestamp = nowIso(now);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const job = this.getJob(id);
+            if (!job) {
+                this.db.exec("COMMIT");
+                return undefined;
+            }
+            if (job.state.runningAt)
+                throw new Error("Job is already running");
+            const run = this.createRunLocked(job, timestamp, "running", "manual");
+            const state = { ...job.state, runningAt: timestamp, lastRunAt: timestamp, lastRunId: run.id };
+            this.updateJobStateLocked(job.id, state, timestamp);
+            this.db.exec("COMMIT");
+            return { job: { ...job, state, updatedAt: timestamp }, run };
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    completeRun(input, now = new Date()) {
+        const timestamp = nowIso(now);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const job = this.getJob(input.jobId);
+            if (!job) {
+                this.db.exec("COMMIT");
+                return;
+            }
+            const nextRunAt = job.enabled && job.schedule.kind !== "at" ? computeNextRunAt(job.schedule, now)?.toISOString() : undefined;
+            const enabled = job.schedule.kind === "at" && input.status === "ok" ? false : job.enabled;
+            const state = {
+                ...job.state,
+                runningAt: undefined,
+                nextRunAt: enabled ? nextRunAt : undefined,
+                lastRunAt: timestamp,
+                lastRunId: input.runId,
+                lastStatus: input.status === "error" ? "error" : input.status === "skipped" ? "skipped" : "ok",
+                lastError: input.error,
+                lastPiboSessionId: input.piboSessionId ?? job.state.lastPiboSessionId,
+                consecutiveErrors: input.status === "error" ? (job.state.consecutiveErrors ?? 0) + 1 : 0,
+            };
+            this.db.prepare(`
+				UPDATE pibo_cron_runs
+				SET status = ?, pibo_session_id = ?, reason = ?, error = ?, completed_at = ?, updated_at = ?
+				WHERE id = ?
+			`).run(input.status, input.piboSessionId ?? null, input.reason ?? null, input.error ?? null, timestamp, timestamp, input.runId);
+            this.db.prepare(`UPDATE pibo_cron_jobs SET enabled = ?, state_json = ?, updated_at = ? WHERE id = ?`).run(enabled ? 1 : 0, JSON.stringify(state), timestamp, job.id);
+            if (job.deleteAfterRun && job.schedule.kind === "at" && input.status === "ok") {
+                this.db.prepare("DELETE FROM pibo_cron_jobs WHERE id = ?").run(job.id);
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    recoverInterruptedRuns(cutoff = new Date(Date.now() - 5 * 60_000)) {
+        const cutoffIso = nowIso(cutoff);
+        const rows = this.db.prepare("SELECT * FROM pibo_cron_jobs WHERE json_extract(state_json, '$.runningAt') IS NOT NULL").all();
+        let recovered = 0;
+        for (const row of rows) {
+            const job = jobFromRow(row);
+            if (!job.state.runningAt || job.state.runningAt > cutoffIso)
+                continue;
+            if (job.state.lastRunId) {
+                this.completeRun({ jobId: job.id, runId: job.state.lastRunId, status: "error", error: "Cron run was interrupted by gateway restart", reason: "interrupted" });
+            }
+            else {
+                this.updateJobStateLocked(job.id, { ...job.state, runningAt: undefined }, nowIso());
+            }
+            recovered += 1;
+        }
+        return recovered;
+    }
+    status() {
+        const jobs = this.listJobs({ includeDisabled: false });
+        const running = jobs.filter((job) => job.state.runningAt).length;
+        const nextRunAt = jobs.map((job) => job.state.nextRunAt).filter((value) => Boolean(value)).sort()[0];
+        return { jobs: jobs.length, running, nextRunAt };
+    }
+    applySchema() {
+        this.createFreshSchema();
+    }
+    createFreshSchema() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS pibo_cron_jobs (
+				id TEXT PRIMARY KEY,
+				name TEXT NOT NULL,
+				description TEXT,
+				enabled INTEGER NOT NULL,
+				target_json TEXT NOT NULL,
+				profile TEXT NOT NULL,
+				prompt TEXT NOT NULL,
+				schedule_json TEXT NOT NULL,
+				schedule_ui_json TEXT,
+				delete_after_run INTEGER NOT NULL DEFAULT 0,
+				state_json TEXT NOT NULL,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_pibo_cron_jobs_enabled ON pibo_cron_jobs(enabled, updated_at DESC);
+
+			CREATE TABLE IF NOT EXISTS pibo_cron_runs (
+				id TEXT PRIMARY KEY,
+				job_id TEXT NOT NULL,
+				pibo_session_id TEXT,
+				status TEXT NOT NULL,
+				reason TEXT,
+				error TEXT,
+				started_at TEXT,
+				completed_at TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL
+			);
+			CREATE INDEX IF NOT EXISTS idx_pibo_cron_runs_job_created ON pibo_cron_runs(job_id, created_at DESC);
+		`);
+    }
+    insertJob(job) {
+        this.db.prepare(`
+			INSERT INTO pibo_cron_jobs (id, name, description, enabled, target_json, profile, prompt, schedule_json, schedule_ui_json, delete_after_run, state_json, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`).run(job.id, job.name, job.description ?? null, job.enabled ? 1 : 0, targetJson(job.target), job.profile, job.prompt, JSON.stringify(job.schedule), job.scheduleUi ? JSON.stringify(job.scheduleUi) : null, job.deleteAfterRun ? 1 : 0, JSON.stringify(job.state), job.createdAt, job.updatedAt);
+    }
+    writeJob(job) {
+        this.db.prepare(`
+			UPDATE pibo_cron_jobs
+			SET name = ?, description = ?, enabled = ?, target_json = ?, profile = ?, prompt = ?, schedule_json = ?, schedule_ui_json = ?, delete_after_run = ?, state_json = ?, updated_at = ?
+			WHERE id = ?
+		`).run(job.name, job.description ?? null, job.enabled ? 1 : 0, targetJson(job.target), job.profile, job.prompt, JSON.stringify(job.schedule), job.scheduleUi ? JSON.stringify(job.scheduleUi) : null, job.deleteAfterRun ? 1 : 0, JSON.stringify(job.state), job.updatedAt, job.id);
+    }
+    updateJobStateLocked(id, state, updatedAt) {
+        this.db.prepare("UPDATE pibo_cron_jobs SET state_json = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(state), updatedAt, id);
+    }
+    createRunLocked(job, timestamp, status, reason) {
+        const run = { id: `crun_${randomUUID()}`, jobId: job.id, status, reason, startedAt: timestamp, createdAt: timestamp, updatedAt: timestamp };
+        this.db.prepare(`
+			INSERT INTO pibo_cron_runs (id, job_id, pibo_session_id, status, reason, error, started_at, completed_at, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`).run(run.id, run.jobId, null, run.status, run.reason ?? null, null, run.startedAt ?? null, null, run.createdAt, run.updatedAt);
+        return run;
+    }
+}
+export function createDefaultPiboCronStore(options = {}) {
+    return new PiboCronStore(options);
+}

package/dist/cron/types.js

@@ -0,0 +1 @@
+export {};

package/dist/data/cli.js

@@ -0,0 +1,184 @@
+import { existsSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { piboHomePath } from "../core/pibo-home.js";
+import { PiboDataStore } from "./pibo-store.js";
+const INVENTORY_STORES = [
+    { name: "v2", file: "pibo.sqlite", tables: ["sessions", "rooms", "chat_messages", "event_log", "observations", "payloads", "session_navigation"] },
+    { name: "v2-shadow", file: "pibo-chat-v2.sqlite", tables: ["sessions", "rooms", "chat_messages", "event_log", "observations", "payloads", "session_navigation"] },
+    { name: "legacy-sessions", file: "pibo-sessions.sqlite", tables: ["pibo_sessions"] },
+    { name: "legacy-chat", file: "web-chat.sqlite", tables: ["chat_events", "web_chat_events", "web_chat_sessions", "pibo_rooms", "chat_session_reads"] },
+    { name: "reliability", file: "pibo-events.sqlite", tables: ["pibo_event_stream", "pibo_jobs", "pibo_runs"] },
+    { name: "auth", file: "auth.sqlite", tables: [] },
+];
+export async function runDataCli(argv) {
+    const args = argv.slice(2);
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        printDataHelp();
+        return;
+    }
+    if (args[0] === "inventory") {
+        const json = args.includes("--json");
+        const root = optionValue(args, "--root") ?? process.env.PIBO_HOME;
+        const inventory = collectInventory(root);
+        if (json)
+            console.log(JSON.stringify({ stores: inventory }, null, 2));
+        else
+            printInventory(inventory);
+        return;
+    }
+    if (args[0] === "migrate" && args[1] === "sessions-to-v2") {
+        const json = args.includes("--json");
+        const root = optionValue(args, "--root") ?? process.env.PIBO_HOME;
+        const from = optionValue(args, "--from") ?? dataPath(root, "pibo-sessions.sqlite");
+        const to = optionValue(args, "--to") ?? dataPath(root, "pibo.sqlite");
+        const report = migrateSessionsToV2({ from, to });
+        if (json)
+            console.log(JSON.stringify(report, null, 2));
+        else
+            printSessionMigrationReport(report);
+        return;
+    }
+    throw new Error(`Unknown pibo data command "${args[0]}". Run pibo data --help.`);
+}
+function collectInventory(root) {
+    return INVENTORY_STORES.map((store) => inventoryStore(store.name, store.file, store.tables, root));
+}
+function dataPath(root, file) {
+    return root ? resolve(root, file) : piboHomePath(file);
+}
+function hasTable(db, table) {
+    return Boolean(db.prepare("SELECT 1 AS found FROM sqlite_master WHERE type = 'table' AND name = ?").get(table));
+}
+function inventoryStore(name, file, expectedTables, root) {
+    const path = root ? resolve(root, file) : piboHomePath(file);
+    const exists = existsSync(path);
+    const result = {
+        name,
+        path,
+        exists,
+        bytes: exists ? statSync(path).size : 0,
+        walBytes: existsSync(`${path}-wal`) ? statSync(`${path}-wal`).size : 0,
+        tables: {},
+    };
+    if (!exists)
+        return result;
+    const db = new DatabaseSync(path, { readOnly: true });
+    try {
+        result.integrity = String(db.prepare("PRAGMA integrity_check").get()?.integrity_check ?? "unknown");
+        result.freelistPages = Number(db.prepare("PRAGMA freelist_count").get()?.freelist_count ?? 0);
+        result.pageCount = Number(db.prepare("PRAGMA page_count").get()?.page_count ?? 0);
+        result.pageSize = Number(db.prepare("PRAGMA page_size").get()?.page_size ?? 0);
+        const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name));
+        for (const table of expectedTables) {
+            if (!tables.has(table))
+                continue;
+            result.tables[table] = Number(db.prepare(`SELECT COUNT(*) AS count FROM ${quoteIdent(table)}`).get().count ?? 0);
+        }
+    }
+    finally {
+        db.close();
+    }
+    return result;
+}
+function migrateSessionsToV2(input) {
+    const report = { from: input.from, to: input.to, inputExists: existsSync(input.from), read: 0, inserted: 0, updated: 0, skipped: 0 };
+    if (!report.inputExists)
+        return report;
+    const source = new DatabaseSync(input.from, { readOnly: true });
+    const target = new PiboDataStore(input.to);
+    try {
+        if (!hasTable(source, "pibo_sessions"))
+            return report;
+        const rows = source.prepare("SELECT * FROM pibo_sessions ORDER BY created_at ASC").all();
+        report.read = rows.length;
+        for (const row of rows) {
+            const existing = target.db.prepare("SELECT updated_at FROM sessions WHERE id = ?").get(row.id);
+            const metadata = parseJsonObject(row.metadata_json);
+            const rootSessionId = row.parent_id ? (typeof metadata.rootSessionId === "string" ? metadata.rootSessionId : row.parent_id) : row.id;
+            if (!existing) {
+                const columns = [
+                    "id", "pi_session_id", "room_id", "root_session_id", "parent_id", "origin_id",
+                    "channel", "kind", "profile", "active_model_json", "workspace", "title", "status",
+                    "metadata_json", "created_at", "updated_at", "last_activity_at",
+                ];
+                target.db.prepare(`
+					INSERT INTO sessions (${columns.join(", ")})
+					VALUES (${columns.map(() => "?").join(", ")})
+				`).run(row.id, row.pi_session_id, typeof metadata.chatRoomId === "string" ? metadata.chatRoomId : null, rootSessionId, row.parent_id, row.origin_id, row.channel, row.kind, row.profile, row.active_model_json, row.workspace, row.title ?? "Untitled Session", "idle", JSON.stringify(metadata), row.created_at, row.updated_at, row.updated_at);
+                report.inserted++;
+            }
+            else if (row.updated_at > existing.updated_at) {
+                target.db.prepare(`
+					UPDATE sessions SET
+						pi_session_id = ?, root_session_id = ?, parent_id = ?, origin_id = ?,
+						channel = ?, kind = ?, profile = ?, active_model_json = ?, workspace = ?, title = ?,
+						metadata_json = ?, updated_at = ?, last_activity_at = MAX(last_activity_at, ?)
+					WHERE id = ?
+				`).run(row.pi_session_id, rootSessionId, row.parent_id, row.origin_id, row.channel, row.kind, row.profile, row.active_model_json, row.workspace, row.title ?? "Untitled Session", JSON.stringify(metadata), row.updated_at, row.updated_at, row.id);
+                report.updated++;
+            }
+            else {
+                report.skipped++;
+            }
+        }
+    }
+    finally {
+        source.close();
+        target.close();
+    }
+    return report;
+}
+function parseJsonObject(json) {
+    if (!json)
+        return {};
+    try {
+        const value = JSON.parse(json);
+        return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+    }
+    catch {
+        return {};
+    }
+}
+function printSessionMigrationReport(report) {
+    console.log(`from\t${report.from}`);
+    console.log(`to\t${report.to}`);
+    console.log(`inputExists\t${report.inputExists}`);
+    console.log(`read\t${report.read}`);
+    console.log(`inserted\t${report.inserted}`);
+    console.log(`updated\t${report.updated}`);
+    console.log(`skipped\t${report.skipped}`);
+}
+function quoteIdent(name) {
+    return `"${name.replaceAll('"', '""')}"`;
+}
+function optionValue(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return undefined;
+    return args[index + 1];
+}
+function printInventory(stores) {
+    console.log("store\texists\tbytes\twalBytes\tintegrity\ttables\tpath");
+    for (const store of stores) {
+        const tables = Object.entries(store.tables).map(([name, count]) => `${name}:${count}`).join(",") || "-";
+        console.log(`${store.name}\t${store.exists}\t${store.bytes}\t${store.walBytes}\t${store.integrity ?? "-"}\t${tables}\t${store.path}`);
+    }
+}
+function printDataHelp() {
+    console.log(`pibo data - inspect and maintain Pibo data stores
+
+Commands:
+  inventory           Read-only row counts, sizes, WAL sizes, and integrity checks; legacy-* rows are archived stores
+  migrate sessions-to-v2  Import an explicit legacy pibo-sessions.sqlite into pibo.sqlite idempotently
+
+Options:
+  --json              Print machine-readable JSON
+  --root DIR          Inspect a specific Pibo home directory instead of ~/.pibo
+  --to FILE           Target pibo.sqlite path for migration or repair
+
+Next:
+  pibo data inventory --json
+  pibo data migrate sessions-to-v2 --from /path/to/pibo-sessions.sqlite --json
+`);
+}

package/dist/data/event-log.js

@@ -0,0 +1,106 @@
+import { randomUUID } from "node:crypto";
+export class PiboEventLogStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    appendEvent(input) {
+        if (input.idempotencyKey) {
+            const existing = this.findByIdempotencyKey(input.idempotencyKey);
+            if (existing)
+                return existing;
+        }
+        const createdAt = input.createdAt ?? new Date().toISOString();
+        const eventId = input.eventId ?? `evt_${randomUUID()}`;
+        const result = this.db.prepare(`
+			INSERT OR IGNORE INTO event_log (
+				session_id,
+				session_sequence,
+				room_id,
+				topic,
+				type,
+				source,
+				actor_type,
+				actor_id,
+				turn_id,
+				event_id,
+				tool_call_id,
+				run_id,
+				workflow_run_id,
+				idempotency_key,
+				retention_class,
+				payload_ref,
+				preview_text,
+				attributes_json,
+				created_at,
+				indexed_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+		`).run(input.sessionId ?? null, input.sessionSequence ?? null, input.roomId ?? null, input.topic, input.type, input.source, input.actorType ?? null, input.actorId ?? null, input.turnId ?? null, eventId, input.toolCallId ?? null, input.runId ?? null, input.workflowRunId ?? null, input.idempotencyKey ?? null, input.retentionClass, input.payloadRef ?? null, input.previewText ?? null, JSON.stringify(input.attributes ?? {}), createdAt, input.indexedAt ?? null);
+        if (input.idempotencyKey) {
+            const existing = this.findByIdempotencyKey(input.idempotencyKey);
+            if (existing)
+                return existing;
+        }
+        const stored = this.findByStreamId(Number(result.lastInsertRowid));
+        if (!stored)
+            throw new Error(`Failed to append event log row \"${eventId}\"`);
+        return stored;
+    }
+    listEvents(input = {}) {
+        const clauses = [];
+        const values = [];
+        if (input.sessionId) {
+            clauses.push("session_id = ?");
+            values.push(input.sessionId);
+        }
+        if (input.roomId) {
+            clauses.push("room_id = ?");
+            values.push(input.roomId);
+        }
+        if (input.topic) {
+            clauses.push("topic = ?");
+            values.push(input.topic);
+        }
+        if (input.afterStreamId !== undefined) {
+            clauses.push("stream_id > ?");
+            values.push(input.afterStreamId);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        const limit = Math.max(1, Math.min(input.limit ?? 100, 1000));
+        const rows = this.db.prepare(`SELECT * FROM event_log ${where} ORDER BY stream_id ASC LIMIT ?`).all(...values, limit);
+        return rows.map(eventLogFromRow);
+    }
+    findByIdempotencyKey(idempotencyKey) {
+        const row = this.db.prepare("SELECT * FROM event_log WHERE idempotency_key = ? LIMIT 1").get(idempotencyKey);
+        return row ? eventLogFromRow(row) : undefined;
+    }
+    findByStreamId(streamId) {
+        const row = this.db.prepare("SELECT * FROM event_log WHERE stream_id = ?").get(streamId);
+        return row ? eventLogFromRow(row) : undefined;
+    }
+}
+function eventLogFromRow(row) {
+    return {
+        streamId: row.stream_id,
+        sessionId: row.session_id ?? undefined,
+        sessionSequence: row.session_sequence ?? undefined,
+        roomId: row.room_id ?? undefined,
+        topic: row.topic,
+        type: row.type,
+        source: row.source,
+        actorType: row.actor_type ?? undefined,
+        actorId: row.actor_id ?? undefined,
+        turnId: row.turn_id ?? undefined,
+        eventId: row.event_id ?? undefined,
+        toolCallId: row.tool_call_id ?? undefined,
+        runId: row.run_id ?? undefined,
+        workflowRunId: row.workflow_run_id ?? undefined,
+        idempotencyKey: row.idempotency_key ?? undefined,
+        retentionClass: row.retention_class,
+        payloadRef: row.payload_ref ?? undefined,
+        previewText: row.preview_text ?? undefined,
+        attributes: JSON.parse(row.attributes_json),
+        createdAt: row.created_at,
+        indexedAt: row.indexed_at ?? undefined,
+    };
+}