@datafrog-io/n2n-nexus 0.1.7 → 0.2.0

package/build/storage/store.js

@@ -0,0 +1,146 @@
+/**
+ * Meeting Store Entry Point
+ *
+ * Provides a unified interface that automatically selects between:
+ * - SQLite backend (preferred, for concurrent access safety)
+ * - JSON backend (fallback, for environments without native module support)
+ */
+// Lazy-loaded store implementation
+let storeType = null;
+let SqliteStore = null;
+let JsonStore = null;
+/**
+ * Detect and initialize the appropriate store
+ */
+async function getStore() {
+    if (storeType === "sqlite" && SqliteStore) {
+        return { type: "sqlite", store: SqliteStore };
+    }
+    if (storeType === "json" && JsonStore) {
+        return { type: "json", store: JsonStore };
+    }
+    // Try SQLite first
+    try {
+        // Dynamic import to avoid bundling issues
+        const sqliteModule = await import("./sqlite-meeting.js");
+        SqliteStore = sqliteModule.SqliteMeetingStore;
+        SqliteStore.init();
+        storeType = "sqlite";
+        console.error("[Nexus MeetingStore] Using SQLite backend");
+        return { type: "sqlite", store: SqliteStore };
+    }
+    catch (e) {
+        console.error("[Nexus MeetingStore] SQLite unavailable:", e.message);
+        console.error("[Nexus MeetingStore] Falling back to JSON backend");
+        console.warn("[Nexus MeetingStore] ⚠️ JSON mode is single-process only. For multi-IDE environments, install better-sqlite3.");
+        // Fall back to JSON
+        const jsonModule = await import("./meetings.js");
+        JsonStore = jsonModule.MeetingStore;
+        storeType = "json";
+        return { type: "json", store: JsonStore };
+    }
+}
+/**
+ * Unified Meeting Store Interface
+ */
+export const UnifiedMeetingStore = {
+    /**
+     * Start a new meeting
+     */
+    async startMeeting(topic, initiator) {
+        const { store } = await getStore();
+        return store.startMeeting(topic, initiator);
+    },
+    /**
+     * Get a meeting by ID
+     */
+    async getMeeting(id) {
+        const { store } = await getStore();
+        return store.getMeeting(id);
+    },
+    /**
+     * Add a message to a meeting
+     */
+    async addMessage(meetingId, message) {
+        const { store } = await getStore();
+        return store.addMessage(meetingId, message);
+    },
+    /**
+     * End a meeting
+     */
+    async endMeeting(meetingId, summary, callerId) {
+        const { store } = await getStore();
+        return store.endMeeting(meetingId, summary, callerId);
+    },
+    /**
+     * Archive a meeting
+     */
+    async archiveMeeting(meetingId, callerId) {
+        const { store } = await getStore();
+        return store.archiveMeeting(meetingId, callerId);
+    },
+    /**
+     * Reopen a meeting
+     */
+    async reopenMeeting(meetingId, callerId) {
+        const { store } = await getStore();
+        return store.reopenMeeting(meetingId, callerId);
+    },
+    /**
+     * List meetings
+     */
+    async listMeetings(status) {
+        const { store } = await getStore();
+        return store.listMeetings(status);
+    },
+    /**
+     * Get the current active meeting
+     */
+    async getActiveMeeting() {
+        const { store } = await getStore();
+        return store.getActiveMeeting();
+    },
+    /**
+     * Get recent messages
+     */
+    async getRecentMessages(count, meetingId) {
+        const { store } = await getStore();
+        return store.getRecentMessages(count || 10, meetingId);
+    },
+    /**
+     * Get the current backend type
+     */
+    async getBackendType() {
+        const { type } = await getStore();
+        return type;
+    },
+    /**
+     * Get meeting state (SQLite only, returns empty for JSON)
+     */
+    async getState() {
+        const { type, store } = await getStore();
+        if (type === "sqlite") {
+            const sqliteStore = store;
+            const activeMeetings = JSON.parse(sqliteStore.getState("active_meetings") || "[]");
+            const defaultMeetingId = sqliteStore.getState("default_meeting") || null;
+            return { activeMeetings, defaultMeetingId };
+        }
+        else {
+            // JSON backend
+            const jsonStore = store;
+            const state = await jsonStore.getState();
+            return state;
+        }
+    },
+    /**
+     * Get storage info for status display
+     * @returns storage_mode and is_degraded flag
+     */
+    async getStorageInfo() {
+        const { type } = await getStore();
+        return {
+            storage_mode: type,
+            is_degraded: type === "json" // JSON mode is considered degraded
+        };
+    }
+};

package/build/storage/tasks.js

@@ -0,0 +1,204 @@
+/**
+ * TaskService - Phase 2: Async Task Management
+ *
+ * Manages long-running operations with progress tracking,
+ * meeting traceability, and MCP-compatible status reporting.
+ */
+import { getDatabase } from "./sqlite.js";
+// Generate unique task ID
+function generateTaskId() {
+    const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `task_${timestamp}_${random}`;
+}
+/**
+ * Initialize the tasks table (run migrations)
+ */
+export function initTasksTable() {
+    const db = getDatabase();
+    const TASKS_SCHEMA = `
+    CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        status TEXT NOT NULL CHECK(status IN ('pending', 'running', 'completed', 'failed', 'cancelled')) DEFAULT 'pending',
+        progress REAL DEFAULT 0.0 CHECK(progress >= 0.0 AND progress <= 1.0),
+        source_meeting_id TEXT,
+        metadata TEXT,
+        result_uri TEXT,
+        error_message TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        ttl INTEGER,
+        FOREIGN KEY (source_meeting_id) REFERENCES meetings(id) ON DELETE SET NULL
+    );
+    
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_meeting ON tasks(source_meeting_id);
+    `;
+    db.exec(TASKS_SCHEMA);
+    // Add trigger for auto-updating updated_at (separate exec to handle IF NOT EXISTS)
+    try {
+        db.exec(`
+            CREATE TRIGGER IF NOT EXISTS tasks_updated_at
+            AFTER UPDATE ON tasks
+            FOR EACH ROW
+            BEGIN
+                UPDATE tasks SET updated_at = datetime('now') WHERE id = OLD.id;
+            END;
+        `);
+    }
+    catch {
+        // Trigger may already exist in older SQLite versions without IF NOT EXISTS support
+    }
+    console.error("[Nexus] Tasks table initialized");
+}
+/**
+ * Create a new task
+ */
+export function createTask(input = {}) {
+    const db = getDatabase();
+    const id = input.id || generateTaskId();
+    const now = new Date().toISOString();
+    const stmt = db.prepare(`
+        INSERT INTO tasks (id, status, progress, source_meeting_id, metadata, created_at, updated_at, ttl)
+        VALUES (?, 'pending', 0.0, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, input.source_meeting_id || null, input.metadata ? JSON.stringify(input.metadata) : null, now, now, input.ttl || null);
+    return getTask(id);
+}
+/**
+ * Get a task by ID
+ */
+export function getTask(id) {
+    const db = getDatabase();
+    const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        status: row.status,
+        progress: row.progress,
+        source_meeting_id: row.source_meeting_id || null,
+        metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        result_uri: row.result_uri || null,
+        error_message: row.error_message || null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ttl: row.ttl || null
+    };
+}
+/**
+ * Update task status and progress
+ */
+export function updateTask(id, update) {
+    const db = getDatabase();
+    const now = new Date().toISOString();
+    const sets = ["updated_at = ?"];
+    const values = [now];
+    if (update.status !== undefined) {
+        sets.push("status = ?");
+        values.push(update.status);
+    }
+    if (update.progress !== undefined) {
+        sets.push("progress = ?");
+        values.push(Math.max(0, Math.min(1, update.progress)));
+    }
+    if (update.result_uri !== undefined) {
+        sets.push("result_uri = ?");
+        values.push(update.result_uri);
+    }
+    if (update.error_message !== undefined) {
+        sets.push("error_message = ?");
+        values.push(update.error_message);
+    }
+    if (update.metadata !== undefined) {
+        sets.push("metadata = ?");
+        values.push(JSON.stringify(update.metadata));
+    }
+    values.push(id);
+    const sql = `UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`;
+    db.prepare(sql).run(...values);
+    return getTask(id);
+}
+/**
+ * List tasks with optional status filter
+ */
+export function listTasks(status, limit = 50) {
+    const db = getDatabase();
+    let sql = "SELECT * FROM tasks";
+    const params = [];
+    if (status) {
+        sql += " WHERE status = ?";
+        params.push(status);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit);
+    const rows = db.prepare(sql).all(...params);
+    return rows.map(row => ({
+        id: row.id,
+        status: row.status,
+        progress: row.progress,
+        source_meeting_id: row.source_meeting_id || null,
+        metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        result_uri: row.result_uri || null,
+        error_message: row.error_message || null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ttl: row.ttl || null
+    }));
+}
+/**
+ * Get tasks by meeting ID
+ */
+export function getTasksByMeeting(meetingId) {
+    const db = getDatabase();
+    const rows = db.prepare(`
+        SELECT * FROM tasks WHERE source_meeting_id = ? ORDER BY created_at DESC
+    `).all(meetingId);
+    return rows.map(row => ({
+        id: row.id,
+        status: row.status,
+        progress: row.progress,
+        source_meeting_id: row.source_meeting_id || null,
+        metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        result_uri: row.result_uri || null,
+        error_message: row.error_message || null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ttl: row.ttl || null
+    }));
+}
+/**
+ * Cancel a pending or running task
+ */
+export function cancelTask(id) {
+    const task = getTask(id);
+    if (!task)
+        return false;
+    if (task.status !== "pending" && task.status !== "running")
+        return false;
+    updateTask(id, { status: "cancelled" });
+    return true;
+}
+/**
+ * Delete completed/failed/cancelled tasks older than specified age
+ */
+export function cleanupTasks(maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
+    const db = getDatabase();
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const result = db.prepare(`
+        DELETE FROM tasks 
+        WHERE status IN ('completed', 'failed', 'cancelled') 
+        AND updated_at < ?
+    `).run(cutoff);
+    return result.changes;
+}
+/**
+ * Get active (pending/running) task count
+ */
+export function getActiveTaskCount() {
+    const db = getDatabase();
+    const row = db.prepare(`
+        SELECT COUNT(*) as count FROM tasks WHERE status IN ('pending', 'running')
+    `).get();
+    return row.count;
+}