@mndrk/agx 2.0.0-next.8 → 2.0.0

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useNotifications.ts

@@ -0,0 +1,115 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export interface Notification {
+  id: string;
+  user_id: string;
+  task_id: string | null;
+  event_id: string | null;
+  type: string;
+  tier: string | null;
+  title: string;
+  body: string | null;
+  created_at: string;
+  read_at: string | null;
+}
+
+interface UseNotificationsOptions {
+  pollInterval?: number;
+  limit?: number;
+}
+
+export function useNotifications({ pollInterval = 15000, limit = 20 }: UseNotificationsOptions = {}) {
+  const [notifications, setNotifications] = useState<Notification[]>([]);
+  const [unreadCount, setUnreadCount] = useState(0);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [nextCursor, setNextCursor] = useState<string | null>(null);
+  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const fetchUnreadCount = useCallback(async () => {
+    try {
+      const res = await fetch("/api/notifications/unread-count");
+      if (!res.ok) return;
+      const data = await res.json();
+      setUnreadCount(data.count ?? 0);
+    } catch {
+      // swallow — badge will be stale
+    }
+  }, []);
+
+  const fetchNotifications = useCallback(async (replace = true) => {
+    try {
+      if (replace) setLoading(true);
+      const url = replace
+        ? `/api/notifications?limit=${limit}`
+        : `/api/notifications?limit=${limit}&cursor=${nextCursor}`;
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const data = await res.json();
+      const items: Notification[] = data.notifications ?? [];
+      if (replace) {
+        setNotifications(items);
+      } else {
+        setNotifications((prev) => [...prev, ...items]);
+      }
+      setNextCursor(data.next_cursor ?? null);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load notifications");
+    } finally {
+      if (replace) setLoading(false);
+    }
+  }, [limit, nextCursor]);
+
+  const refresh = useCallback(async () => {
+    await Promise.all([fetchNotifications(true), fetchUnreadCount()]);
+  }, [fetchNotifications, fetchUnreadCount]);
+
+  const loadMore = useCallback(async () => {
+    if (!nextCursor) return;
+    await fetchNotifications(false);
+  }, [nextCursor, fetchNotifications]);
+
+  const markAsRead = useCallback(async (id: string) => {
+    // Optimistic update
+    setNotifications((prev) =>
+      prev.map((n) => (n.id === id ? { ...n, read_at: new Date().toISOString() } : n))
+    );
+    setUnreadCount((c) => Math.max(0, c - 1));
+
+    try {
+      const res = await fetch(`/api/notifications/${id}/read`, { method: "PATCH" });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    } catch {
+      // Roll back on failure
+      await refresh();
+    }
+  }, [refresh]);
+
+  // Initial fetch + polling
+  useEffect(() => {
+    void refresh();
+
+    timerRef.current = setInterval(() => {
+      void refresh();
+    }, pollInterval);
+
+    return () => {
+      if (timerRef.current) clearInterval(timerRef.current);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [pollInterval]);
+
+  return {
+    notifications,
+    unreadCount,
+    loading,
+    error,
+    hasMore: nextCursor !== null,
+    refresh,
+    loadMore,
+    markAsRead,
+  };
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useThreadState.ts

@@ -1,30 +1,30 @@
 import { useCallback, useEffect, useRef, useState } from "react";
-import { threadService } from "@/services/threadService";
-import type { SaveThreadInput, Thread } from "@/lib/storage";
+import { workspaceService } from "@/services/threadService";
+import type { SaveWorkspaceInput, Workspace } from "@/lib/storage";
 import type { GroupMessage } from "@/lib/types";
 import {
-  clearLastThreadId,
-  loadLastThreadId,
-  persistLastThreadId,
-  resolveInitialThreadSelection,
+  clearLastWorkspaceId,
+  loadLastWorkspaceId,
+  persistLastWorkspaceId,
+  resolveInitialWorkspaceSelection,
 } from "@/state/threadSelection";
 
-const sortByUpdatedAt = (threads: Thread[]) =>
-  [...threads].sort((a, b) => b.updatedAt - a.updatedAt);
+const sortAlphabetically = (workspaces: Workspace[]) =>
+  [...workspaces].sort((a, b) => (a.title || "").localeCompare(b.title || ""));
 
-export function useThreadState() {
+export function useWorkspaceState() {
   const isMounted = useRef(true);
-  const [threads, setThreads] = useState<Thread[]>([]);
-  const [activeThreadId, setActiveThreadId] = useState<string | null>(null);
+  const [workspaces, setWorkspaces] = useState<Workspace[]>([]);
+  const [activeWorkspaceId, setActiveWorkspaceId] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(true);
-  const [isRestoringActiveThread, setIsRestoringActiveThread] = useState(true);
+  const [isRestoringActiveWorkspace, setIsRestoringActiveWorkspace] = useState(true);
   const [isCreating, setIsCreating] = useState(false);
-  const [deletingThreadId, setDeletingThreadId] = useState<string | null>(null);
-  const [renamingThreadId, setRenamingThreadId] = useState<string | null>(null);
-  const hasHydratedActiveThreadRef = useRef(false);
+  const [deletingWorkspaceId, setDeletingWorkspaceId] = useState<string | null>(null);
+  const [renamingWorkspaceId, setRenamingWorkspaceId] = useState<string | null>(null);
+  const hasHydratedActiveWorkspaceRef = useRef(false);
 
-  const selectThread = useCallback((threadId: string) => {
-    setActiveThreadId(threadId);
+  const selectWorkspace = useCallback((workspaceId: string) => {
+    setActiveWorkspaceId(workspaceId);
   }, []);
 
   useEffect(() => {
@@ -39,31 +39,31 @@ export function useThreadState() {
 
     (async () => {
       try {
-        const fetched = await threadService.listThreads();
+        const fetched = await workspaceService.listWorkspaces();
         if (cancelled || !isMounted.current) return;
-        setThreads(fetched);
-        const savedThreadId = loadLastThreadId();
-        const { threadId: initialThreadId, shouldClearSavedId, restoredFromStorage } =
-          resolveInitialThreadSelection(fetched, savedThreadId);
+        setWorkspaces(sortAlphabetically(fetched));
+        const savedWorkspaceId = loadLastWorkspaceId();
+        const { workspaceId: initialWorkspaceId, shouldClearSavedId, restoredFromStorage } =
+          resolveInitialWorkspaceSelection(fetched, savedWorkspaceId);
         if (shouldClearSavedId) {
-          clearLastThreadId();
+          clearLastWorkspaceId();
         }
-        if (!hasHydratedActiveThreadRef.current) {
-          hasHydratedActiveThreadRef.current = true;
+        if (!hasHydratedActiveWorkspaceRef.current) {
+          hasHydratedActiveWorkspaceRef.current = true;
         }
-        if (restoredFromStorage && initialThreadId) {
-          selectThread(initialThreadId);
-        } else if (initialThreadId) {
-          setActiveThreadId((prev) => prev ?? initialThreadId);
+        if (restoredFromStorage && initialWorkspaceId) {
+          selectWorkspace(initialWorkspaceId);
+        } else if (initialWorkspaceId) {
+          setActiveWorkspaceId((prev) => prev ?? initialWorkspaceId);
         } else {
-          setActiveThreadId(null);
+          setActiveWorkspaceId(null);
         }
       } catch (error) {
-        console.error("Failed to load threads", error);
+        console.error("Failed to load workspaces", error);
       } finally {
         if (isMounted.current) {
           setIsLoading(false);
-          setIsRestoringActiveThread(false);
+          setIsRestoringActiveWorkspace(false);
         }
       }
     })();
@@ -71,31 +71,31 @@ export function useThreadState() {
     return () => {
       cancelled = true;
     };
-  }, [selectThread]);
+  }, [selectWorkspace]);
 
   useEffect(() => {
-    if (!hasHydratedActiveThreadRef.current) {
+    if (!hasHydratedActiveWorkspaceRef.current) {
       return;
     }
 
-    if (activeThreadId) {
-      persistLastThreadId(activeThreadId);
+    if (activeWorkspaceId) {
+      persistLastWorkspaceId(activeWorkspaceId);
     } else {
-      clearLastThreadId();
+      clearLastWorkspaceId();
     }
-  }, [activeThreadId]);
+  }, [activeWorkspaceId]);
 
-  const createThread = useCallback(
-    async (input?: Partial<Pick<SaveThreadInput, "id" | "title" | "messages" | "metadata">>) => {
+  const createWorkspace = useCallback(
+    async (input?: Partial<Pick<SaveWorkspaceInput, "id" | "title" | "messages" | "metadata">>) => {
       setIsCreating(true);
       try {
-        const thread = await threadService.createThread(input);
-        if (!isMounted.current) return thread;
-        setThreads((prev) => sortByUpdatedAt([...prev.filter((item) => item.id !== thread.id), thread]));
-        setActiveThreadId(thread.id);
-        return thread;
+        const workspace = await workspaceService.createWorkspace(input);
+        if (!isMounted.current) return workspace;
+        setWorkspaces((prev) => sortAlphabetically([...prev.filter((item) => item.id !== workspace.id), workspace]));
+        setActiveWorkspaceId(workspace.id);
+        return workspace;
       } catch (error) {
-        console.error("Failed to create thread", error);
+        console.error("Failed to create workspace", error);
         throw error;
       } finally {
         if (isMounted.current) {
@@ -104,83 +104,83 @@ export function useThreadState() {
       }
     }, []);
 
-  const deleteThread = useCallback(async (threadId: string) => {
-    if (!threadId) return;
-    setDeletingThreadId(threadId);
+  const deleteWorkspace = useCallback(async (workspaceId: string) => {
+    if (!workspaceId) return;
+    setDeletingWorkspaceId(workspaceId);
     try {
-      await threadService.deleteThread(threadId);
+      await workspaceService.deleteWorkspace(workspaceId);
       if (!isMounted.current) return;
-      let nextThreads: Thread[] = [];
-      setThreads((prev) => {
-        nextThreads = sortByUpdatedAt(prev.filter((thread) => thread.id !== threadId));
-        return nextThreads;
+      let nextWorkspaces: Workspace[] = [];
+      setWorkspaces((prev) => {
+        nextWorkspaces = sortAlphabetically(prev.filter((workspace) => workspace.id !== workspaceId));
+        return nextWorkspaces;
       });
-      setActiveThreadId((current) =>
-        current === threadId ? nextThreads[0]?.id ?? null : current
+      setActiveWorkspaceId((current) =>
+        current === workspaceId ? nextWorkspaces[0]?.id ?? null : current
       );
     } catch (error) {
-      console.error("Failed to delete thread", error);
+      console.error("Failed to delete workspace", error);
       throw error;
     } finally {
       if (isMounted.current) {
-        setDeletingThreadId(null);
+        setDeletingWorkspaceId(null);
       }
     }
   }, []);
 
-  const renameThread = useCallback(async (threadId: string, title: string) => {
-    const id = threadId.trim();
+  const renameWorkspace = useCallback(async (workspaceId: string, title: string) => {
+    const id = workspaceId.trim();
     const nextTitle = title.trim();
     if (!id || !nextTitle) return;
 
-    setRenamingThreadId(id);
+    setRenamingWorkspaceId(id);
     try {
-      const updated = await threadService.renameThread(id, nextTitle);
+      const updated = await workspaceService.renameWorkspace(id, nextTitle);
       if (!updated || !isMounted.current) return;
-      setThreads((prev) =>
-        sortByUpdatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+      setWorkspaces((prev) =>
+        sortAlphabetically(prev.map((workspace) => (workspace.id === updated.id ? updated : workspace)))
       );
     } catch (error) {
-      console.error("Failed to rename thread", error);
+      console.error("Failed to rename workspace", error);
       throw error;
     } finally {
       if (isMounted.current) {
-        setRenamingThreadId((current) => (current === id ? null : current));
+        setRenamingWorkspaceId((current) => (current === id ? null : current));
       }
     }
   }, []);
 
-  const updateThreadMessages = useCallback(
-    async (threadId: string, messages: GroupMessage[]) => {
-      if (!threadId) return;
+  const updateWorkspaceMessages = useCallback(
+    async (workspaceId: string, messages: GroupMessage[]) => {
+      if (!workspaceId) return;
       try {
-        const updated = await threadService.saveThreadMessages(threadId, messages);
+        const updated = await workspaceService.saveWorkspaceMessages(workspaceId, messages);
         if (!updated || !isMounted.current) return;
-        setThreads((prev) =>
-          sortByUpdatedAt(prev.map((thread) => (thread.id === updated.id ? updated : thread)))
+        setWorkspaces((prev) =>
+          sortAlphabetically(prev.map((workspace) => (workspace.id === updated.id ? updated : workspace)))
         );
       } catch (error) {
-        console.error("Failed to update thread messages", error);
+        console.error("Failed to update workspace messages", error);
       }
     },
     []
   );
 
-  const isDeletingActiveThread = activeThreadId !== null && deletingThreadId === activeThreadId;
+  const isDeletingActiveWorkspace = activeWorkspaceId !== null && deletingWorkspaceId === activeWorkspaceId;
 
   return {
-    threads,
-    activeThreadId,
-    selectThread,
-    createThread,
-    deleteThread,
+    workspaces,
+    activeWorkspaceId,
+    selectWorkspace,
+    createWorkspace,
+    deleteWorkspace,
     isLoading,
-    isRestoringActiveThread,
+    isRestoringActiveWorkspace,
     isCreating,
-    deletingThreadId,
-    renamingThreadId,
-    isDeletingActiveThread,
-    updateThreadMessages,
-    renameThread,
+    deletingWorkspaceId,
+    renamingWorkspaceId,
+    isDeletingActiveWorkspace,
+    updateWorkspaceMessages,
+    renameWorkspace,
   };
 }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/cli-runner.ts

@@ -25,8 +25,13 @@ type StreamParser = {
   flush: () => void;
 };
 
+const AGX_ACK_RE = /\[agx:(?:spawn|exit:\d+)\]\n?/g;
+
 const createRawParser = (onDelta: (chunk: string) => void): StreamParser => ({
-  push: onDelta,
+  push: (chunk: string) => {
+    const cleaned = chunk.replace(AGX_ACK_RE, "");
+    if (cleaned) onDelta(cleaned);
+  },
   flush: () => {},
 });
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/db/cursors.js

@@ -0,0 +1,75 @@
+/**
+ * lib/db/cursors.js
+ *
+ * Durable per-consumer cursor helpers for event-stream projectors.
+ * Cursors are stored in the projector_cursors table keyed by consumer_id.
+ * The cursor value is the rowid (integer) of the last processed event.
+ */
+
+'use strict';
+
+const { getSQLiteDb } = require('../sqlite-query-adapter');
+
+/**
+ * Read the current cursor position for a consumer.
+ * Returns 0 if the consumer has no recorded position (process from beginning).
+ *
+ * @param {string} consumerId - Unique consumer identifier (e.g. 'notification_projector')
+ * @returns {number} Last processed rowid, or 0
+ */
+function readCursor(consumerId) {
+  const db = getSQLiteDb();
+  const row = db.prepare(
+    'SELECT last_event_id FROM projector_cursors WHERE consumer_id = ?'
+  ).get(consumerId);
+  if (!row) return 0;
+  const pos = parseInt(row.last_event_id, 10);
+  return Number.isFinite(pos) ? pos : 0;
+}
+
+/**
+ * Advance the cursor to a new position within an existing transaction.
+ * The caller is responsible for wrapping this in a transaction so the cursor
+ * update and the projection writes are committed atomically.
+ *
+ * @param {import('better-sqlite3').Database} db - SQLite connection (same one used in txn)
+ * @param {string} consumerId
+ * @param {number} newRowid - rowid of the last event that was successfully processed
+ */
+function advanceCursorInTxn(db, consumerId, newRowid) {
+  db.prepare(`
+    INSERT INTO projector_cursors (consumer_id, last_event_id, updated_at)
+    VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    ON CONFLICT(consumer_id) DO UPDATE SET
+      last_event_id = excluded.last_event_id,
+      updated_at    = excluded.updated_at
+  `).run(consumerId, String(newRowid));
+}
+
+/**
+ * Reset a consumer's cursor back to 0 (triggers full replay on next run).
+ * Useful for testing and forced replay.
+ *
+ * @param {string} consumerId
+ */
+function resetCursor(consumerId) {
+  const db = getSQLiteDb();
+  db.prepare(`
+    INSERT INTO projector_cursors (consumer_id, last_event_id, updated_at)
+    VALUES (?, '0', strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    ON CONFLICT(consumer_id) DO UPDATE SET
+      last_event_id = '0',
+      updated_at    = excluded.updated_at
+  `).run(consumerId);
+}
+
+/**
+ * List all known consumers and their cursor positions.
+ * @returns {Array<{consumer_id: string, last_event_id: string, updated_at: string}>}
+ */
+function listCursors() {
+  const db = getSQLiteDb();
+  return db.prepare('SELECT * FROM projector_cursors ORDER BY consumer_id').all();
+}
+
+module.exports = { readCursor, advanceCursorInTxn, resetCursor, listCursors };

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/db/notifications.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * lib/db/notifications.js
+ *
+ * Query helpers for the notifications read-model table.
+ */
+
+const { getSQLiteDb } = require('../sqlite-query-adapter');
+
+const DEFAULT_UNREAD_CAP = 500;
+
+/**
+ * Return up to `cap` unread notifications for a user, newest first.
+ *
+ * @param {string} userId
+ * @param {number} [cap=500]
+ * @returns {Array<{id, task_id, event_id, type, tier, title, body, created_at}>}
+ */
+function getUnreadSummary(userId, cap = DEFAULT_UNREAD_CAP) {
+  const db = getSQLiteDb();
+  return db.prepare(`
+    SELECT id, task_id, event_id, type, tier, title, body, created_at
+    FROM notifications
+    WHERE user_id = ? AND read_at IS NULL
+    ORDER BY created_at DESC
+    LIMIT ?
+  `).all(userId, cap);
+}
+
+/**
+ * Count unread notifications for a user.
+ *
+ * @param {string} userId
+ * @returns {number}
+ */
+function countUnread(userId) {
+  const db = getSQLiteDb();
+  return db.prepare(
+    'SELECT COUNT(*) AS n FROM notifications WHERE user_id = ? AND read_at IS NULL'
+  ).get(userId)?.n ?? 0;
+}
+
+/**
+ * Delete notifications older than minDays (read) or maxDays (any).
+ * Returns the total number of rows deleted.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.minDays=60] - prune read notifications older than this
+ * @param {number} [opts.maxDays=90] - prune all notifications older than this
+ * @returns {{ deleted: number }}
+ */
+function pruneOldNotifications({ minDays = 60, maxDays = 90 } = {}) {
+  const db = getSQLiteDb();
+
+  const r1 = db.prepare(`
+    DELETE FROM notifications
+    WHERE created_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-${minDays} days')
+      AND read_at IS NOT NULL
+  `).run();
+
+  const r2 = db.prepare(`
+    DELETE FROM notifications
+    WHERE created_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', '-${maxDays} days')
+  `).run();
+
+  return { deleted: r1.changes + r2.changes };
+}
+
+module.exports = { getUnreadSummary, countUnread, pruneOldNotifications };

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/lib/db/preferences.js

@@ -0,0 +1,110 @@
+/**
+ * lib/db/preferences.js
+ *
+ * Notification preference helpers.
+ *
+ * Preference resolution order (highest priority first):
+ *  1. Task-level: tasks.stage_decisions → { notifications: { [type]: bool } }
+ *  2. User-level: user_settings.notification_prefs → { [type]: bool }  (if table exists)
+ *  3. Global default: true (notify for everything)
+ *
+ * Schema convention for task-level prefs (stored in tasks.stage_decisions JSON):
+ *   { "notifications": { "task.completed": true, "task.failed": false } }
+ *
+ * Schema convention for user-level prefs (stored in user_settings.notification_prefs JSON):
+ *   { "task.completed": true, "task.failed": false }
+ */
+
+'use strict';
+
+const { getSQLiteDb } = require('../sqlite-query-adapter');
+
+/**
+ * Read task-level notification preferences for a specific notification type.
+ * Returns null if no task-level override exists for this type.
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} taskId
+ * @param {string} notificationType - e.g. 'task.completed'
+ * @returns {boolean|null} explicit preference, or null if not set at task level
+ */
+function getTaskLevelPref(db, taskId, notificationType) {
+  const row = db.prepare(
+    "SELECT json_extract(stage_decisions, '$.notifications') AS notif_prefs FROM tasks WHERE id = ?"
+  ).get(taskId);
+
+  if (!row || !row.notif_prefs) return null;
+
+  try {
+    const prefs = typeof row.notif_prefs === 'string'
+      ? JSON.parse(row.notif_prefs)
+      : row.notif_prefs;
+    if (prefs && typeof prefs[notificationType] === 'boolean') {
+      return prefs[notificationType];
+    }
+  } catch {
+    // Malformed JSON — treat as no preference
+  }
+  return null;
+}
+
+/**
+ * Read user-level notification preferences for a specific notification type.
+ * Returns null if no user-level preference exists for this type.
+ *
+ * Reads from user_settings.notification_prefs (JSON column).
+ * Gracefully handles missing table (returns null).
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} userId
+ * @param {string} notificationType - e.g. 'task.completed'
+ * @returns {boolean|null} explicit preference, or null if not set
+ */
+function getUserLevelPref(db, userId, notificationType) {
+  try {
+    const row = db.prepare(
+      "SELECT json_extract(notification_prefs, '$.' || ?) AS pref FROM user_settings WHERE user_id = ?"
+    ).get(notificationType, userId);
+
+    if (row && typeof row.pref === 'integer') {
+      // SQLite stores JSON booleans as integers (0/1)
+      return row.pref !== 0;
+    }
+    if (row && typeof row.pref === 'string') {
+      if (row.pref === 'true') return true;
+      if (row.pref === 'false') return false;
+    }
+  } catch {
+    // user_settings table may not exist yet — return null (default)
+  }
+  return null;
+}
+
+/**
+ * Determine whether a notification should be emitted for a given task + type.
+ *
+ * Resolution order:
+ *  1. Task-level preference (tasks.stage_decisions.notifications[type])
+ *  2. User-level preference (user_settings.notification_prefs[type])
+ *  3. Global default → true
+ *
+ * @param {import('better-sqlite3').Database} db
+ * @param {string} taskId
+ * @param {string} userId
+ * @param {string} notificationType - e.g. 'task.completed'
+ * @returns {boolean}
+ */
+function shouldNotify(db, taskId, userId, notificationType) {
+  // 1. Task-level override
+  const taskPref = getTaskLevelPref(db, taskId, notificationType);
+  if (taskPref !== null) return taskPref;
+
+  // 2. User-level default
+  const userPref = getUserLevelPref(db, userId, notificationType);
+  if (userPref !== null) return userPref;
+
+  // 3. Global default — notify
+  return true;
+}
+
+module.exports = { shouldNotify, getTaskLevelPref, getUserLevelPref };