@mndrk/agx 2.0.0-next.8 → 2.0.0

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/state/threadSelection.test.ts

@@ -1,16 +1,16 @@
-import type { Thread } from "@/lib/storage";
+import type { Workspace } from "@/lib/storage";
 import {
-  clearLastThreadId,
-  loadLastThreadId,
-  persistLastThreadId,
-  resolveInitialThreadSelection,
+  clearLastWorkspaceId,
+  loadLastWorkspaceId,
+  persistLastWorkspaceId,
+  resolveInitialWorkspaceSelection,
 } from "./threadSelection";
 
-type ThreadStorage = Record<string, string>;
+type WorkspaceStorage = Record<string, string>;
 
-function withFakeLocalStorage<T>(callback: (storage: ThreadStorage) => T): T {
+function withFakeLocalStorage<T>(callback: (storage: WorkspaceStorage) => T): T {
   const originalWindow = globalThis.window;
-  const storage: ThreadStorage = {};
+  const storage: WorkspaceStorage = {};
   const fakeLocalStorage = {
     getItem(key: string) {
       return storage[key] ?? null;
@@ -31,7 +31,7 @@ function withFakeLocalStorage<T>(callback: (storage: ThreadStorage) => T): T {
   }
 }
 
-function createThread(id: string, updatedAt: number): Thread {
+function createWorkspace(id: string, updatedAt: number): Workspace {
   return {
     id,
     title: "",
@@ -41,39 +41,39 @@ function createThread(id: string, updatedAt: number): Thread {
   };
 }
 
-describe("threadSelection", () => {
-  test("persist/load/clear enjoy the last thread id lifecycle", () => {
+describe("workspaceSelection", () => {
+  test("persist/load/clear enjoy the last workspace id lifecycle", () => {
     withFakeLocalStorage(() => {
-      expect(loadLastThreadId()).toBeNull();
-      persistLastThreadId("thread-abc");
-      expect(loadLastThreadId()).toBe("thread-abc");
-      persistLastThreadId("thread-def");
-      expect(loadLastThreadId()).toBe("thread-def");
-      clearLastThreadId();
-      expect(loadLastThreadId()).toBeNull();
+      expect(loadLastWorkspaceId()).toBeNull();
+      persistLastWorkspaceId("workspace-abc");
+      expect(loadLastWorkspaceId()).toBe("workspace-abc");
+      persistLastWorkspaceId("workspace-def");
+      expect(loadLastWorkspaceId()).toBe("workspace-def");
+      clearLastWorkspaceId();
+      expect(loadLastWorkspaceId()).toBeNull();
     });
   });
 
-  test("resolveInitialThreadSelection restores saved thread when it exists", () => {
-    const threads = [createThread("thread-1", 2), createThread("thread-2", 1)];
-    const result = resolveInitialThreadSelection(threads, "thread-2");
-    expect(result.threadId).toBe("thread-2");
+  test("resolveInitialWorkspaceSelection restores saved workspace when it exists", () => {
+    const workspaces = [createWorkspace("workspace-1", 2), createWorkspace("workspace-2", 1)];
+    const result = resolveInitialWorkspaceSelection(workspaces, "workspace-2");
+    expect(result.workspaceId).toBe("workspace-2");
     expect(result.shouldClearSavedId).toBe(false);
     expect(result.restoredFromStorage).toBe(true);
   });
 
-  test("resolveInitialThreadSelection falls back and clears missing saved id", () => {
-    const threads = [createThread("thread-1", 2), createThread("thread-2", 1)];
-    const result = resolveInitialThreadSelection(threads, "missing");
-    expect(result.threadId).toBe("thread-1");
+  test("resolveInitialWorkspaceSelection falls back and clears missing saved id", () => {
+    const workspaces = [createWorkspace("workspace-1", 2), createWorkspace("workspace-2", 1)];
+    const result = resolveInitialWorkspaceSelection(workspaces, "missing");
+    expect(result.workspaceId).toBe("workspace-1");
     expect(result.shouldClearSavedId).toBe(true);
     expect(result.restoredFromStorage).toBe(false);
   });
 
-  test("resolveInitialThreadSelection defaults to first thread when no saved id exists", () => {
-    const threads = [createThread("thread-1", 2), createThread("thread-2", 1)];
-    const result = resolveInitialThreadSelection(threads, null);
-    expect(result.threadId).toBe("thread-1");
+  test("resolveInitialWorkspaceSelection defaults to first workspace when no saved id exists", () => {
+    const workspaces = [createWorkspace("workspace-1", 2), createWorkspace("workspace-2", 1)];
+    const result = resolveInitialWorkspaceSelection(workspaces, null);
+    expect(result.workspaceId).toBe("workspace-1");
     expect(result.shouldClearSavedId).toBe(false);
     expect(result.restoredFromStorage).toBe(false);
   });

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/state/threadSelection.ts

@@ -1,67 +1,67 @@
-import type { Thread } from "@/lib/storage";
+import type { Workspace } from "@/lib/storage";
 
-const THREAD_SELECTION_STORAGE_KEY = "agx-chat:last-thread";
+const WORKSPACE_SELECTION_STORAGE_KEY = "agx-chat:last-thread";
 
 function isStorageAvailable(): boolean {
   return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
 }
 
-export function loadLastThreadId(): string | null {
+export function loadLastWorkspaceId(): string | null {
   if (!isStorageAvailable()) {
     return null;
   }
 
   try {
-    return window.localStorage.getItem(THREAD_SELECTION_STORAGE_KEY);
+    return window.localStorage.getItem(WORKSPACE_SELECTION_STORAGE_KEY);
   } catch {
     return null;
   }
 }
 
-export function persistLastThreadId(threadId: string): void {
+export function persistLastWorkspaceId(workspaceId: string): void {
   if (!isStorageAvailable()) {
     return;
   }
 
   try {
-    window.localStorage.setItem(THREAD_SELECTION_STORAGE_KEY, threadId);
+    window.localStorage.setItem(WORKSPACE_SELECTION_STORAGE_KEY, workspaceId);
   } catch {
     // ignore storage failures (e.g., quota exceeded)
   }
 }
 
-export function clearLastThreadId(): void {
+export function clearLastWorkspaceId(): void {
   if (!isStorageAvailable()) {
     return;
   }
 
   try {
-    window.localStorage.removeItem(THREAD_SELECTION_STORAGE_KEY);
+    window.localStorage.removeItem(WORKSPACE_SELECTION_STORAGE_KEY);
   } catch {
     // ignore storage failures (e.g., quota exceeded)
   }
 }
 
-export type InitialThreadSelection = {
-  threadId: string | null;
+export type InitialWorkspaceSelection = {
+  workspaceId: string | null;
   shouldClearSavedId: boolean;
   restoredFromStorage: boolean;
 };
 
-export function resolveInitialThreadSelection(
-  threads: Thread[],
-  savedThreadId: string | null
-): InitialThreadSelection {
-  const fallbackThreadId = threads[0]?.id ?? null;
+export function resolveInitialWorkspaceSelection(
+  workspaces: Workspace[],
+  savedWorkspaceId: string | null
+): InitialWorkspaceSelection {
+  const fallbackWorkspaceId = workspaces[0]?.id ?? null;
 
-  if (!savedThreadId) {
-    return { threadId: fallbackThreadId, shouldClearSavedId: false, restoredFromStorage: false };
+  if (!savedWorkspaceId) {
+    return { workspaceId: fallbackWorkspaceId, shouldClearSavedId: false, restoredFromStorage: false };
   }
 
-  const savedThreadExists = threads.some((thread) => thread.id === savedThreadId);
-  if (savedThreadExists) {
-    return { threadId: savedThreadId, shouldClearSavedId: false, restoredFromStorage: true };
+  const savedWorkspaceExists = workspaces.some((workspace) => workspace.id === savedWorkspaceId);
+  if (savedWorkspaceExists) {
+    return { workspaceId: savedWorkspaceId, shouldClearSavedId: false, restoredFromStorage: true };
   }
 
-  return { threadId: fallbackThreadId, shouldClearSavedId: true, restoredFromStorage: false };
+  return { workspaceId: fallbackWorkspaceId, shouldClearSavedId: true, restoredFromStorage: false };
 }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/state/uiSettings.ts

@@ -1,12 +1,12 @@
 export const UI_SETTINGS_STORAGE_KEY = "agx-chat:uiSettings";
-const DEFAULT_THREAD_SIDEBAR_VISIBLE = false;
+const DEFAULT_WORKSPACE_SIDEBAR_VISIBLE = false;
 
 export interface UiSettings {
-  threadSidebarVisible: boolean;
+  workspaceSidebarVisible: boolean;
 }
 
 const DEFAULT_UI_SETTINGS: UiSettings = {
-  threadSidebarVisible: DEFAULT_THREAD_SIDEBAR_VISIBLE,
+  workspaceSidebarVisible: DEFAULT_WORKSPACE_SIDEBAR_VISIBLE,
 };
 
 function isStorageAvailable(): boolean {
@@ -27,10 +27,13 @@ function readUiSettings(): UiSettings {
     const parsed = JSON.parse(raw) as Partial<UiSettings>;
     return {
       ...DEFAULT_UI_SETTINGS,
-      threadSidebarVisible:
-        typeof parsed.threadSidebarVisible === "boolean"
-          ? parsed.threadSidebarVisible
-          : DEFAULT_THREAD_SIDEBAR_VISIBLE,
+      workspaceSidebarVisible:
+        typeof parsed.workspaceSidebarVisible === "boolean"
+          ? parsed.workspaceSidebarVisible
+          : // backwards compat: read old key
+            typeof (parsed as Record<string, unknown>).threadSidebarVisible === "boolean"
+            ? (parsed as Record<string, unknown>).threadSidebarVisible as boolean
+            : DEFAULT_WORKSPACE_SIDEBAR_VISIBLE,
     };
   } catch {
     return { ...DEFAULT_UI_SETTINGS };
@@ -49,14 +52,14 @@ function writeUiSettings(settings: UiSettings): void {
   }
 }
 
-export function loadThreadSidebarVisible(): boolean {
-  return readUiSettings().threadSidebarVisible;
+export function loadWorkspaceSidebarVisible(): boolean {
+  return readUiSettings().workspaceSidebarVisible;
 }
 
-export function persistThreadSidebarVisible(visible: boolean): void {
+export function persistWorkspaceSidebarVisible(visible: boolean): void {
   const nextSettings: UiSettings = {
     ...readUiSettings(),
-    threadSidebarVisible: visible,
+    workspaceSidebarVisible: visible,
   };
   writeUiSettings(nextSettings);
 }

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/_helpers.js

@@ -0,0 +1,68 @@
+/**
+ * Shared test helpers for projector tests.
+ * @jest-environment node
+ */
+
+'use strict';
+
+const Database = require('better-sqlite3');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+const SCHEMA_SQL = fs.readFileSync(
+  path.join(__dirname, '../../migrations/sqlite_schema.sql'),
+  'utf8'
+);
+
+function tmpDbPath() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'agx-proj-test-'));
+  return path.join(dir, 'test.db');
+}
+
+function makeDb(dbPath) {
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(SCHEMA_SQL);
+  return db;
+}
+
+function insertTask(db, { userId, title = 'Test Task' } = {}) {
+  const id = `task-${Math.random().toString(36).slice(2)}`;
+  db.prepare(`
+    INSERT INTO tasks (id, user_id, content, title, status)
+    VALUES (?, ?, ?, ?, 'queued')
+  `).run(id, userId, 'content', title);
+  return id;
+}
+
+function insertAuditEvent(db, { taskId, userId, action, payload = {} } = {}) {
+  const id = `evt-${Math.random().toString(36).slice(2)}`;
+  db.prepare(`
+    INSERT INTO task_audit_log (id, task_id, user_id, action, payload, signature)
+    VALUES (?, ?, ?, ?, ?, 'sig')
+  `).run(id, taskId, userId, action, JSON.stringify(payload));
+  return id;
+}
+
+/**
+ * Load projector module bound to a specific db instance (isolated module cache).
+ */
+function loadProjectorWithDb(db) {
+  jest.resetModules();
+  jest.mock('@/lib/sqlite-query-adapter', () => ({
+    getSQLiteDb: () => db,
+    SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
+    sqlExpr: (e) => ({ expr: e }),
+  }));
+  const cursors = require('@/lib/db/cursors');
+  const projector = require('@/lib/projectors/notificationProjector');
+  return { projector, cursors };
+}
+
+function countRows(db, table) {
+  return db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n;
+}
+
+module.exports = { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows };

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/crash.test.js

@@ -0,0 +1,139 @@
+/**
+ * @jest-environment node
+ *
+ * Crash/restart test: simulate mid-transaction kill by reloading the module
+ * mid-stream and verify cursor durability + DB consistency.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows } = require('./_helpers');
+
+describe('projector crash/restart test', () => {
+  let dbPath, db;
+
+  beforeEach(() => {
+    dbPath = tmpDbPath();
+    db = makeDb(dbPath);
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(path.dirname(dbPath), { recursive: true });
+  });
+
+  test('cursor is durable across simulated restart', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const userId = 'user-crash';
+    const taskId = insertTask(db, { userId });
+
+    // Insert 5 events
+    for (let i = 0; i < 5; i++) {
+      insertAuditEvent(db, { taskId, userId, action: 'complete' });
+    }
+
+    projector.runOnce();
+    const cursorAfterFirst = cursors.readCursor('notification_projector');
+    expect(cursorAfterFirst).toBeGreaterThan(0);
+    expect(countRows(db, 'notifications')).toBe(5);
+
+    // Simulate crash: reload module (in-memory debounce state is lost, cursor is from DB)
+    jest.resetModules();
+    jest.mock('@/lib/sqlite-query-adapter', () => ({
+      getSQLiteDb: () => db,
+      SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
+      sqlExpr: (e) => ({ expr: e }),
+    }));
+    const projector2 = require('@/lib/projectors/notificationProjector');
+    const cursors2 = require('@/lib/db/cursors');
+
+    // Cursor must be persisted from previous run
+    expect(cursors2.readCursor('notification_projector')).toBe(cursorAfterFirst);
+
+    // Insert 3 more events
+    for (let i = 0; i < 3; i++) {
+      insertAuditEvent(db, { taskId, userId, action: 'fail' });
+    }
+
+    projector2.runOnce();
+    // Only the 3 new events are processed; the 5 old ones are not re-delivered
+    expect(countRows(db, 'notifications')).toBe(8);
+  });
+
+  test('DB is consistent after simulated crash at cursor boundary', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const userId = 'user-boundary';
+    const taskIds = [
+      insertTask(db, { userId }),
+      insertTask(db, { userId }),
+    ];
+
+    // Insert exactly BATCH_SIZE (100) events across two tasks
+    for (let i = 0; i < 100; i++) {
+      insertAuditEvent(db, { taskId: taskIds[i % 2], userId, action: 'complete' });
+    }
+
+    projector.runOnce(); // processes 100
+    const cursor1 = cursors.readCursor('notification_projector');
+    const notifCount1 = countRows(db, 'notifications');
+    expect(notifCount1).toBe(100);
+
+    // Insert 50 more, then "crash" before processing
+    for (let i = 0; i < 50; i++) {
+      insertAuditEvent(db, { taskId: taskIds[i % 2], userId, action: 'fail' });
+    }
+
+    // Simulate crash: reload module without running
+    jest.resetModules();
+    jest.mock('@/lib/sqlite-query-adapter', () => ({
+      getSQLiteDb: () => db,
+      SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
+      sqlExpr: (e) => ({ expr: e }),
+    }));
+    const projector3 = require('@/lib/projectors/notificationProjector');
+    const cursors3 = require('@/lib/db/cursors');
+
+    // Cursor still at 100-event boundary
+    expect(cursors3.readCursor('notification_projector')).toBe(cursor1);
+
+    // Process the 50 new events
+    projector3.runOnce();
+    expect(countRows(db, 'notifications')).toBe(150);
+  });
+
+  test('outbox and notifications stay in sync after restart', () => {
+    const { projector } = loadProjectorWithDb(db);
+    const userId = 'user-sync';
+    const taskId = insertTask(db, { userId });
+
+    for (let i = 0; i < 20; i++) {
+      insertAuditEvent(db, { taskId, userId, action: i % 2 === 0 ? 'complete' : 'fail' });
+    }
+
+    projector.runOnce();
+
+    const notifCount = countRows(db, 'notifications');
+    const outboxCount = countRows(db, 'notification_outbox');
+
+    // Every notification must have exactly one outbox entry
+    expect(notifCount).toBe(outboxCount);
+    expect(notifCount).toBe(20);
+
+    // Simulate restart
+    jest.resetModules();
+    jest.mock('@/lib/sqlite-query-adapter', () => ({
+      getSQLiteDb: () => db,
+      SqlExpression: class SqlExpression { constructor(e) { this.expr = e; } },
+      sqlExpr: (e) => ({ expr: e }),
+    }));
+    const projector2 = require('@/lib/projectors/notificationProjector');
+    projector2.runOnce(); // no-op — no new events
+
+    // Counts unchanged after restart + no-op run
+    expect(countRows(db, 'notifications')).toBe(notifCount);
+    expect(countRows(db, 'notification_outbox')).toBe(outboxCount);
+  });
+});

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/tests/projector/duplicate.test.js

@@ -0,0 +1,111 @@
+/**
+ * @jest-environment node
+ *
+ * Duplicate-event test: replaying the same event_id must produce exactly one
+ * notification row (idempotency via UNIQUE(event_id, user_id, type)).
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { tmpDbPath, makeDb, insertTask, insertAuditEvent, loadProjectorWithDb, countRows } = require('./_helpers');
+
+describe('projector duplicate-event test', () => {
+  let dbPath, db;
+
+  beforeEach(() => {
+    dbPath = tmpDbPath();
+    db = makeDb(dbPath);
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    db.close();
+    fs.rmSync(path.dirname(dbPath), { recursive: true });
+  });
+
+  test('same event_id processed twice yields exactly one notification row', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const userId = 'user-dup';
+    const taskId = insertTask(db, { userId });
+
+    insertAuditEvent(db, { taskId, userId, action: 'complete' });
+
+    // First processing
+    projector.runOnce();
+    expect(countRows(db, 'notifications')).toBe(1);
+    expect(countRows(db, 'notification_outbox')).toBe(1);
+
+    // Reset cursor to force replay of same event
+    cursors.resetCursor('notification_projector');
+    projector.runOnce();
+
+    expect(countRows(db, 'notifications')).toBe(1); // still exactly one
+    expect(countRows(db, 'notification_outbox')).toBe(1);
+  });
+
+  test('same event replayed 10 times yields exactly one notification', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const userId = 'user-dup10';
+    const taskId = insertTask(db, { userId });
+
+    insertAuditEvent(db, { taskId, userId, action: 'fail' });
+
+    for (let i = 0; i < 10; i++) {
+      cursors.resetCursor('notification_projector');
+      projector.runOnce();
+    }
+
+    expect(countRows(db, 'notifications')).toBe(1);
+    expect(countRows(db, 'notification_outbox')).toBe(1);
+  });
+
+  test('different event types for same task produce separate notifications', () => {
+    const { projector } = loadProjectorWithDb(db);
+    const userId = 'user-types';
+    const taskId = insertTask(db, { userId });
+
+    // Each action produces a distinct (event_id, user_id, type) tuple
+    insertAuditEvent(db, { taskId, userId, action: 'dispatch' });
+    insertAuditEvent(db, { taskId, userId, action: 'execute' });
+    insertAuditEvent(db, { taskId, userId, action: 'complete' });
+
+    projector.runOnce();
+    expect(countRows(db, 'notifications')).toBe(3);
+  });
+
+  test('duplicate same-type events across different users create per-user rows', () => {
+    const { projector, cursors } = loadProjectorWithDb(db);
+    const taskId1 = insertTask(db, { userId: 'user-a' });
+    const taskId2 = insertTask(db, { userId: 'user-b' });
+
+    insertAuditEvent(db, { taskId: taskId1, userId: 'user-a', action: 'complete' });
+    insertAuditEvent(db, { taskId: taskId2, userId: 'user-b', action: 'complete' });
+
+    projector.runOnce();
+    expect(countRows(db, 'notifications')).toBe(2); // one per user
+
+    // Replay: still exactly 2
+    cursors.resetCursor('notification_projector');
+    projector.runOnce();
+    expect(countRows(db, 'notifications')).toBe(2);
+  });
+
+  test('notification fields are correctly populated on first insert', () => {
+    const { projector } = loadProjectorWithDb(db);
+    const userId = 'user-fields';
+    const taskId = insertTask(db, { userId, title: 'My Task' });
+
+    insertAuditEvent(db, { taskId, userId, action: 'complete' });
+    projector.runOnce();
+
+    const notif = db.prepare('SELECT * FROM notifications').get();
+    expect(notif.user_id).toBe(userId);
+    expect(notif.task_id).toBe(taskId);
+    expect(notif.type).toBe('task.completed');
+    expect(notif.tier).toBe('success');
+    expect(notif.title).toContain('My Task');
+    expect(notif.read_at).toBeNull();
+  });
+});