@pasko70/pibo 1.0.5 → 1.2.0

package/dist/web-annotations/index.js

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./attachments.js";
+export * from "./validation.js";
+export * from "./store.js";
+export * from "./tools.js";
+export * from "./cdp.js";
+export * from "./api.js";

package/dist/web-annotations/store.js

@@ -0,0 +1,407 @@
+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 { isWebAnnotationBindingState, isWebAnnotationStatus, isWebAnnotationTargetKind, } from "./types.js";
+import { normalizeWebAnnotationBindingInput, normalizeWebAnnotationBindingPatch, normalizeWebAnnotationCreateInput, normalizeWebAnnotationLimit, normalizeWebAnnotationPatchInput, normalizeWebAnnotationThreadMessageInput, WEB_ANNOTATION_LIMITS, } from "./validation.js";
+const BINDING_COLUMNS = [
+    "id",
+    "pibo_session_id",
+    "pibo_room_id",
+    "state",
+    "url",
+    "title",
+    "target_id",
+    "created_at",
+    "updated_at",
+    "last_injected_at",
+    "closed_at",
+    "error",
+    "metadata_json",
+];
+const ANNOTATION_COLUMNS = [
+    "id",
+    "pibo_session_id",
+    "pibo_room_id",
+    "binding_id",
+    "status",
+    "note",
+    "url",
+    "title",
+    "target_id",
+    "target_kind",
+    "viewport_json",
+    "target_json",
+    "screenshot_ref_json",
+    "thread_json",
+    "created_at",
+    "updated_at",
+    "resolved_at",
+    "resolved_by",
+    "summary",
+    "metadata_json",
+];
+function nowIso(now = new Date()) {
+    return now.toISOString();
+}
+function parseJson(json) {
+    return json ? JSON.parse(json) : undefined;
+}
+function stringifyJson(value) {
+    return value === undefined ? null : JSON.stringify(value);
+}
+function normalizeLimit(limit, defaultLimit, maxLimit) {
+    return normalizeWebAnnotationLimit(limit, defaultLimit, maxLimit);
+}
+function requireNonEmpty(value, field) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        throw new Error(`${field} is required`);
+    return trimmed;
+}
+function validateJsonObject(value, field) {
+    if (value === undefined)
+        return;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error(`${field} must be an object`);
+}
+function validateBindingInput(input) {
+    requireNonEmpty(input.piboSessionId, "piboSessionId");
+    requireNonEmpty(input.url, "url");
+    if (input.state !== undefined && !isWebAnnotationBindingState(input.state))
+        throw new Error(`Invalid binding state: ${input.state}`);
+    validateJsonObject(input.metadata, "metadata");
+}
+function validateBindingPatch(patch) {
+    if (patch.state !== undefined && !isWebAnnotationBindingState(patch.state))
+        throw new Error(`Invalid binding state: ${patch.state}`);
+    validateJsonObject(patch.metadata, "metadata");
+}
+function validateAnnotationInput(input) {
+    requireNonEmpty(input.piboSessionId, "piboSessionId");
+    requireNonEmpty(input.note, "note");
+    requireNonEmpty(input.url, "url");
+    if (input.status !== undefined && !isWebAnnotationStatus(input.status))
+        throw new Error(`Invalid annotation status: ${input.status}`);
+    if (!isWebAnnotationTargetKind(input.targetKind))
+        throw new Error(`Invalid annotation target kind: ${input.targetKind}`);
+    if (!input.viewport || typeof input.viewport.width !== "number" || typeof input.viewport.height !== "number") {
+        throw new Error("viewport width and height are required");
+    }
+    validateJsonObject(input.metadata, "metadata");
+}
+function validateAnnotationPatch(patch) {
+    if (patch.status !== undefined && !isWebAnnotationStatus(patch.status))
+        throw new Error(`Invalid annotation status: ${patch.status}`);
+    if (patch.summary !== undefined && patch.summary !== null && typeof patch.summary !== "string")
+        throw new Error("summary must be a string or null");
+    if (patch.resolvedBy !== undefined && patch.resolvedBy !== null && patch.resolvedBy !== "human" && patch.resolvedBy !== "agent") {
+        throw new Error("resolvedBy must be human, agent, or null");
+    }
+    validateJsonObject(patch.metadata, "metadata");
+}
+function bindingFromRow(row) {
+    return {
+        id: row.id,
+        piboSessionId: row.pibo_session_id,
+        piboRoomId: row.pibo_room_id ?? undefined,
+        state: row.state,
+        url: row.url,
+        title: row.title ?? undefined,
+        targetId: row.target_id ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at ?? undefined,
+        lastInjectedAt: row.last_injected_at ?? undefined,
+        closedAt: row.closed_at ?? undefined,
+        error: row.error ?? undefined,
+        metadata: parseJson(row.metadata_json),
+    };
+}
+function annotationFromRow(row) {
+    return {
+        id: row.id,
+        piboSessionId: row.pibo_session_id,
+        piboRoomId: row.pibo_room_id ?? undefined,
+        bindingId: row.binding_id ?? undefined,
+        status: row.status,
+        note: row.note,
+        url: row.url,
+        title: row.title ?? undefined,
+        targetId: row.target_id ?? undefined,
+        targetKind: row.target_kind,
+        viewport: JSON.parse(row.viewport_json),
+        target: parseJson(row.target_json),
+        screenshotRef: parseJson(row.screenshot_ref_json),
+        thread: parseJson(row.thread_json),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at ?? undefined,
+        resolvedAt: row.resolved_at ?? undefined,
+        resolvedBy: row.resolved_by ?? undefined,
+        summary: row.summary ?? undefined,
+        metadata: parseJson(row.metadata_json),
+    };
+}
+function quoteIdentifier(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+export class WebAnnotationStore {
+    db;
+    constructor(options = {}) {
+        const dbPath = options.path ?? piboHomePath("web-annotations.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();
+        this.applySchema();
+    }
+    close() {
+        this.db.close();
+    }
+    createBinding(input, now = new Date()) {
+        const normalized = normalizeWebAnnotationBindingInput(input);
+        validateBindingInput(normalized);
+        const timestamp = nowIso(now);
+        const binding = {
+            id: normalized.id ?? `wab_${randomUUID()}`,
+            piboSessionId: normalized.piboSessionId,
+            piboRoomId: normalized.piboRoomId,
+            state: normalized.state ?? "active",
+            url: normalized.url,
+            title: normalized.title,
+            targetId: normalized.targetId,
+            metadata: normalized.metadata,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        this.db.prepare(`
+			INSERT OR IGNORE INTO web_annotation_bindings (
+				id, pibo_session_id, pibo_room_id, state, url, title, target_id,
+				created_at, updated_at, last_injected_at, closed_at, error, metadata_json
+			) VALUES (${Array.from({ length: BINDING_COLUMNS.length }, () => "?").join(", ")})
+		`).run(binding.id, binding.piboSessionId, binding.piboRoomId ?? null, binding.state, binding.url, binding.title ?? null, binding.targetId ?? null, binding.createdAt, binding.updatedAt ?? null, null, null, null, stringifyJson(binding.metadata));
+        const existing = this.getBinding(binding.piboSessionId, binding.id);
+        if (!existing)
+            throw new Error("Failed to create web annotation binding");
+        return existing;
+    }
+    listBindings(input) {
+        const limit = normalizeLimit(input.limit, 100, 500);
+        return this.db.prepare(`
+			SELECT * FROM web_annotation_bindings
+			WHERE pibo_session_id = ? AND state != 'removed'
+			ORDER BY created_at DESC, id DESC
+			LIMIT ?
+		`).all(input.piboSessionId, limit).map(bindingFromRow);
+    }
+    getBinding(piboSessionId, id) {
+        const row = this.db.prepare(`
+			SELECT * FROM web_annotation_bindings
+			WHERE id = ? AND pibo_session_id = ?
+		`).get(id, piboSessionId);
+        return row ? bindingFromRow(row) : undefined;
+    }
+    getBindingById(id) {
+        const row = this.db.prepare(`
+			SELECT * FROM web_annotation_bindings
+			WHERE id = ? AND state != 'removed'
+		`).get(id);
+        return row ? bindingFromRow(row) : undefined;
+    }
+    patchBinding(piboSessionId, id, patch, now = new Date()) {
+        const normalized = normalizeWebAnnotationBindingPatch(patch);
+        validateBindingPatch(normalized);
+        const existing = this.getBinding(piboSessionId, id);
+        if (!existing)
+            return undefined;
+        const state = normalized.state ?? existing.state;
+        const timestamp = nowIso(now);
+        this.db.prepare(`
+			UPDATE web_annotation_bindings
+			SET state = ?, title = ?, target_id = ?, updated_at = ?, last_injected_at = ?, closed_at = ?, error = ?, metadata_json = ?
+			WHERE id = ? AND pibo_session_id = ?
+		`).run(state, normalized.title !== undefined ? normalized.title : existing.title ?? null, normalized.targetId !== undefined ? normalized.targetId : existing.targetId ?? null, timestamp, normalized.lastInjectedAt !== undefined ? normalized.lastInjectedAt : existing.lastInjectedAt ?? null, normalized.closedAt !== undefined ? normalized.closedAt : existing.closedAt ?? null, normalized.error !== undefined ? normalized.error : existing.error ?? null, normalized.metadata !== undefined ? stringifyJson(normalized.metadata) : stringifyJson(existing.metadata), id, piboSessionId);
+        return this.getBinding(piboSessionId, id);
+    }
+    removeBinding(piboSessionId, id, now = new Date()) {
+        const result = this.db.prepare(`
+			UPDATE web_annotation_bindings
+			SET state = 'removed', updated_at = ?
+			WHERE id = ? AND pibo_session_id = ?
+		`).run(nowIso(now), id, piboSessionId);
+        return Number(result.changes ?? 0) > 0;
+    }
+    createAnnotation(input, now = new Date()) {
+        const normalized = normalizeWebAnnotationCreateInput(input);
+        validateAnnotationInput(normalized);
+        const timestamp = nowIso(now);
+        const annotation = {
+            id: normalized.id ?? `ann_${randomUUID()}`,
+            piboSessionId: normalized.piboSessionId,
+            piboRoomId: normalized.piboRoomId,
+            bindingId: normalized.bindingId,
+            status: normalized.status ?? "open",
+            note: normalized.note,
+            url: normalized.url,
+            title: normalized.title,
+            targetId: normalized.targetId,
+            targetKind: normalized.targetKind,
+            viewport: normalized.viewport,
+            target: normalized.target,
+            screenshotRef: normalized.screenshotRef,
+            metadata: normalized.metadata,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+        };
+        this.db.prepare(`
+			INSERT OR IGNORE INTO web_annotations (
+				id, pibo_session_id, pibo_room_id, binding_id, status, note, url, title,
+				target_id, target_kind, viewport_json, target_json, screenshot_ref_json, thread_json,
+				created_at, updated_at, resolved_at, resolved_by, summary, metadata_json
+			) VALUES (${Array.from({ length: ANNOTATION_COLUMNS.length }, () => "?").join(", ")})
+		`).run(annotation.id, annotation.piboSessionId, annotation.piboRoomId ?? null, annotation.bindingId ?? null, annotation.status, annotation.note, annotation.url, annotation.title ?? null, annotation.targetId ?? null, annotation.targetKind, stringifyJson(annotation.viewport), stringifyJson(annotation.target), stringifyJson(annotation.screenshotRef), null, annotation.createdAt, annotation.updatedAt ?? null, null, null, null, stringifyJson(annotation.metadata));
+        const existing = this.getAnnotation(annotation.piboSessionId, annotation.id);
+        if (!existing)
+            throw new Error("Failed to create web annotation");
+        return existing;
+    }
+    listAnnotations(input = {}) {
+        const limit = normalizeLimit(input.limit, 100, 500);
+        const clauses = [];
+        const values = [];
+        if (input.piboSessionId !== undefined) {
+            clauses.push("pibo_session_id = ?");
+            values.push(input.piboSessionId);
+        }
+        if (input.status !== undefined) {
+            if (!isWebAnnotationStatus(input.status))
+                throw new Error(`Invalid annotation status: ${input.status}`);
+            clauses.push("status = ?");
+            values.push(input.status);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+        return this.db.prepare(`
+			SELECT * FROM web_annotations
+			${where}
+			ORDER BY created_at DESC, id DESC
+			LIMIT ?
+		`).all(...values, limit).map(annotationFromRow);
+    }
+    getAnnotation(piboSessionId, id) {
+        const row = this.db.prepare(`
+			SELECT * FROM web_annotations
+			WHERE id = ? AND pibo_session_id = ?
+		`).get(id, piboSessionId);
+        return row ? annotationFromRow(row) : undefined;
+    }
+    getAnnotationById(id) {
+        const row = this.db.prepare(`
+			SELECT * FROM web_annotations
+			WHERE id = ?
+		`).get(id);
+        return row ? annotationFromRow(row) : undefined;
+    }
+    patchAnnotation(piboSessionId, id, patch, now = new Date()) {
+        const normalized = normalizeWebAnnotationPatchInput(patch);
+        validateAnnotationPatch(normalized);
+        const existing = this.getAnnotation(piboSessionId, id);
+        if (!existing)
+            return undefined;
+        const timestamp = nowIso(now);
+        const status = normalized.status ?? existing.status;
+        const resolvedAt = status === "resolved" && !existing.resolvedAt ? timestamp : existing.resolvedAt ?? null;
+        this.db.prepare(`
+			UPDATE web_annotations
+			SET status = ?, updated_at = ?, resolved_at = ?, resolved_by = ?, summary = ?, metadata_json = ?
+			WHERE id = ? AND pibo_session_id = ?
+		`).run(status, timestamp, resolvedAt, normalized.resolvedBy !== undefined ? normalized.resolvedBy : existing.resolvedBy ?? null, normalized.summary !== undefined ? normalized.summary : existing.summary ?? null, normalized.metadata !== undefined ? stringifyJson(normalized.metadata) : stringifyJson(existing.metadata), id, piboSessionId);
+        return this.getAnnotation(piboSessionId, id);
+    }
+    acknowledgeAnnotation(piboSessionId, id, summary, now = new Date()) {
+        return this.patchAnnotation(piboSessionId, id, { status: "acknowledged", summary }, now);
+    }
+    resolveAnnotation(piboSessionId, id, summary, resolvedBy = "agent", now = new Date()) {
+        return this.patchAnnotation(piboSessionId, id, { status: "resolved", summary, resolvedBy }, now);
+    }
+    dismissAnnotation(piboSessionId, id, reason, now = new Date()) {
+        return this.patchAnnotation(piboSessionId, id, { status: "dismissed", summary: reason }, now);
+    }
+    addThreadMessage(input, now = new Date()) {
+        const normalized = normalizeWebAnnotationThreadMessageInput(input);
+        const existing = this.getAnnotation(normalized.piboSessionId, normalized.annotationId);
+        if (!existing)
+            return undefined;
+        const thread = existing.thread ?? [];
+        if (thread.length >= WEB_ANNOTATION_LIMITS.threadMessages)
+            throw new Error("annotation thread message limit reached");
+        const timestamp = nowIso(now);
+        const nextThread = [
+            ...thread,
+            { id: normalized.id ?? `wat_${randomUUID()}`, role: normalized.role, content: normalized.content, createdAt: timestamp },
+        ];
+        this.db.prepare(`
+			UPDATE web_annotations
+			SET thread_json = ?, updated_at = ?
+			WHERE id = ? AND pibo_session_id = ?
+		`).run(stringifyJson(nextThread), timestamp, normalized.annotationId, normalized.piboSessionId);
+        return this.getAnnotation(normalized.piboSessionId, normalized.annotationId);
+    }
+    applySchema() {
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS web_annotation_bindings (
+				id TEXT PRIMARY KEY,
+				pibo_session_id TEXT NOT NULL,
+				pibo_room_id TEXT,
+				state TEXT NOT NULL,
+				url TEXT NOT NULL,
+				title TEXT,
+				target_id TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT,
+				last_injected_at TEXT,
+				closed_at TEXT,
+				error TEXT,
+				metadata_json TEXT
+			);
+			CREATE INDEX IF NOT EXISTS idx_web_annotation_bindings_session
+				ON web_annotation_bindings(pibo_session_id, created_at DESC);
+			CREATE INDEX IF NOT EXISTS idx_web_annotation_bindings_target
+				ON web_annotation_bindings(target_id, state);
+
+			CREATE TABLE IF NOT EXISTS web_annotations (
+				id TEXT PRIMARY KEY,
+				pibo_session_id TEXT NOT NULL,
+				pibo_room_id TEXT,
+				binding_id TEXT,
+				status TEXT NOT NULL,
+				note TEXT NOT NULL,
+				url TEXT NOT NULL,
+				title TEXT,
+				target_id TEXT,
+				target_kind TEXT NOT NULL,
+				viewport_json TEXT NOT NULL,
+				target_json TEXT,
+				screenshot_ref_json TEXT,
+				thread_json TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT,
+				resolved_at TEXT,
+				resolved_by TEXT,
+				summary TEXT,
+				metadata_json TEXT
+			);
+			CREATE INDEX IF NOT EXISTS idx_web_annotations_session_status_created
+				ON web_annotations(pibo_session_id, status, created_at DESC);
+			CREATE INDEX IF NOT EXISTS idx_web_annotations_session_created
+				ON web_annotations(pibo_session_id, created_at DESC);
+		`);
+    }
+}
+export function createDefaultWebAnnotationStore() {
+    return new WebAnnotationStore();
+}