@soleri/core 9.2.0 → 9.3.0

package/src/runtime/facades/chat-service-ops.test.ts

@@ -9,24 +9,59 @@ import { createChatState } from './chat-state.js';
 import type { ChatState } from './chat-state.js';
 import type { OpDefinition } from '../../facades/types.js';
 
+// ─── Mock instances ─────────────────────────────────────────────────
+
+const mockCancellation = {
+  create: vi.fn().mockReturnValue({ aborted: false }),
+  cancel: vi.fn().mockReturnValue({ description: 'test', startedAt: 1000 }),
+  getInfo: vi.fn().mockReturnValue({ description: 'test', startedAt: 1000 }),
+  listRunning: vi.fn().mockReturnValue(['chat-1']),
+  size: 1,
+};
+
+const mockSelfUpdate = {
+  loadContext: vi.fn().mockReturnValue(null),
+  clearContext: vi.fn(),
+  requestRestart: vi.fn().mockReturnValue({ scheduled: true }),
+};
+
+const mockNotification = {
+  start: vi.fn(),
+  stop: vi.fn(),
+  poll: vi.fn().mockResolvedValue(2),
+  stats: vi.fn().mockReturnValue({ checks: 3, running: true, sent: 5, lastPollAt: 1000 }),
+};
+
+const mockBrowserSession = {
+  process: { pid: 1234 },
+};
+
+const mockBrowser = {
+  acquire: vi.fn().mockReturnValue(mockBrowserSession),
+  release: vi.fn().mockReturnValue(true),
+  size: 1,
+  listSessions: vi.fn().mockReturnValue(['c1']),
+  getInfo: vi.fn().mockReturnValue({ startedAt: 1000 }),
+};
+
 // ─── Mock chat modules ─────────────────────────────────────────────
 
 vi.mock('../../chat/cancellation.js', () => ({
-  TaskCancellationManager: vi.fn().mockImplementation(() => ({
-    create: vi.fn().mockReturnValue({ aborted: false }),
-    cancel: vi.fn().mockReturnValue({ description: 'test', startedAt: 1000 }),
-    getInfo: vi.fn().mockReturnValue({ description: 'test', startedAt: 1000 }),
-    listRunning: vi.fn().mockReturnValue(['chat-1']),
-    size: 1,
-  })),
+  TaskCancellationManager: class {
+    create = mockCancellation.create;
+    cancel = mockCancellation.cancel;
+    getInfo = mockCancellation.getInfo;
+    listRunning = mockCancellation.listRunning;
+    size = mockCancellation.size;
+  },
 }));
 
 vi.mock('../../chat/self-update.js', () => ({
-  SelfUpdateManager: vi.fn().mockImplementation(() => ({
-    loadContext: vi.fn().mockReturnValue(null),
-    clearContext: vi.fn(),
-    requestRestart: vi.fn().mockReturnValue({ scheduled: true }),
-  })),
+  SelfUpdateManager: class {
+    loadContext = mockSelfUpdate.loadContext;
+    clearContext = mockSelfUpdate.clearContext;
+    requestRestart = mockSelfUpdate.requestRestart;
+  },
 }));
 
 vi.mock('../../chat/file-handler.js', () => ({
@@ -36,31 +71,35 @@ vi.mock('../../chat/file-handler.js', () => ({
 }));
 
 vi.mock('../../chat/notifications.js', () => ({
-  NotificationEngine: vi.fn().mockImplementation(() => ({
-    start: vi.fn(),
-    stop: vi.fn(),
-    poll: vi.fn().mockResolvedValue(2),
-    stats: vi.fn().mockReturnValue({ checks: 3, running: true, sent: 5, lastPollAt: 1000 }),
-  })),
+  NotificationEngine: class {
+    start = mockNotification.start;
+    stop = mockNotification.stop;
+    poll = mockNotification.poll;
+    stats = mockNotification.stats;
+  },
 }));
 
-const mockBrowserSession = {
-  process: { pid: 1234 },
-};
-
 vi.mock('../../chat/browser-session.js', () => ({
-  BrowserSessionManager: vi.fn().mockImplementation(() => ({
-    acquire: vi.fn().mockReturnValue(mockBrowserSession),
-    release: vi.fn().mockReturnValue(true),
-    size: 1,
-    listSessions: vi.fn().mockReturnValue(['c1']),
-    getInfo: vi.fn().mockReturnValue({ startedAt: 1000 }),
-  })),
+  BrowserSessionManager: class {
+    acquire = mockBrowser.acquire;
+    release = mockBrowser.release;
+    size = mockBrowser.size;
+    listSessions = mockBrowser.listSessions;
+    getInfo = mockBrowser.getInfo;
+  },
 }));
 
 // Needed via chat-state imports
-vi.mock('../../chat/chat-session.js', () => ({ ChatSessionManager: vi.fn() }));
-vi.mock('../../chat/auth-manager.js', () => ({ ChatAuthManager: vi.fn() }));
+vi.mock('../../chat/chat-session.js', () => ({
+  ChatSessionManager: class {
+    _stub = true;
+  },
+}));
+vi.mock('../../chat/auth-manager.js', () => ({
+  ChatAuthManager: class {
+    _stub = true;
+  },
+}));
 
 // ─── Helpers ────────────────────────────────────────────────────────
 
@@ -85,12 +124,24 @@ describe('chat-service-ops', () => {
   it('exports 18 service ops', () => {
     const names = ops.map((o) => o.name);
     expect(names).toEqual([
-      'chat_cancel_create', 'chat_cancel_stop', 'chat_cancel_status',
-      'chat_update_init', 'chat_update_request', 'chat_update_confirm',
-      'chat_file_detect_intent', 'chat_file_build_content', 'chat_file_cleanup',
-      'chat_notify_init', 'chat_notify_start', 'chat_notify_stop',
-      'chat_notify_poll', 'chat_notify_status',
-      'chat_browser_init', 'chat_browser_acquire', 'chat_browser_release', 'chat_browser_status',
+      'chat_cancel_create',
+      'chat_cancel_stop',
+      'chat_cancel_status',
+      'chat_update_init',
+      'chat_update_request',
+      'chat_update_confirm',
+      'chat_file_detect_intent',
+      'chat_file_build_content',
+      'chat_file_cleanup',
+      'chat_notify_init',
+      'chat_notify_start',
+      'chat_notify_stop',
+      'chat_notify_poll',
+      'chat_notify_status',
+      'chat_browser_init',
+      'chat_browser_acquire',
+      'chat_browser_release',
+      'chat_browser_status',
     ]);
   });
 
@@ -98,7 +149,10 @@ describe('chat-service-ops', () => {
 
   describe('chat_cancel_create', () => {
     it('creates cancellation signal', async () => {
-      const result = await findOp(ops, 'chat_cancel_create').handler({ chatId: 'chat-1', description: 'processing' });
+      const result = await findOp(ops, 'chat_cancel_create').handler({
+        chatId: 'chat-1',
+        description: 'processing',
+      });
       expect(result).toEqual({ chatId: 'chat-1', created: true, aborted: false, activeTasks: 1 });
     });
   });
@@ -111,25 +165,35 @@ describe('chat-service-ops', () => {
 
     it('cancels task after create', async () => {
       await findOp(ops, 'chat_cancel_create').handler({ chatId: 'chat-1' });
-      const result = (await findOp(ops, 'chat_cancel_stop').handler({ chatId: 'chat-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_cancel_stop').handler({
+        chatId: 'chat-1',
+      })) as Record<string, unknown>;
       expect(result.cancelled).toBe(true);
     });
   });
 
   describe('chat_cancel_status', () => {
     it('returns empty when no manager', async () => {
-      expect(await findOp(ops, 'chat_cancel_status').handler({})).toEqual({ activeTasks: 0, running: [] });
+      expect(await findOp(ops, 'chat_cancel_status').handler({})).toEqual({
+        activeTasks: 0,
+        running: [],
+      });
     });
 
     it('returns per-chat status', async () => {
       await findOp(ops, 'chat_cancel_create').handler({ chatId: 'chat-1' });
-      const result = (await findOp(ops, 'chat_cancel_status').handler({ chatId: 'chat-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_cancel_status').handler({
+        chatId: 'chat-1',
+      })) as Record<string, unknown>;
       expect(result.running).toBe(true);
     });
 
     it('returns all running tasks when no chatId', async () => {
       await findOp(ops, 'chat_cancel_create').handler({ chatId: 'chat-1' });
-      const result = (await findOp(ops, 'chat_cancel_status').handler({})) as { activeTasks: number; running: unknown[] };
+      const result = (await findOp(ops, 'chat_cancel_status').handler({})) as {
+        activeTasks: number;
+        running: unknown[];
+      };
       expect(result.activeTasks).toBe(1);
       expect(result.running).toHaveLength(1);
     });
@@ -139,23 +203,29 @@ describe('chat-service-ops', () => {
 
   describe('chat_update_init', () => {
     it('initializes updater', async () => {
-      expect(await findOp(ops, 'chat_update_init').handler({ contextPath: '/tmp/ctx.json' }))
-        .toEqual({ initialized: true, hasPendingRestart: false, pendingContext: null });
+      expect(
+        await findOp(ops, 'chat_update_init').handler({ contextPath: '/tmp/ctx.json' }),
+      ).toEqual({ initialized: true, hasPendingRestart: false, pendingContext: null });
     });
   });
 
   describe('chat_update_request', () => {
     it('requests restart', async () => {
-      expect(await findOp(ops, 'chat_update_request').handler({
-        chatId: 'chat-1', reason: 'self-update', contextPath: '/tmp/ctx.json',
-      })).toEqual({ scheduled: true });
+      expect(
+        await findOp(ops, 'chat_update_request').handler({
+          chatId: 'chat-1',
+          reason: 'self-update',
+          contextPath: '/tmp/ctx.json',
+        }),
+      ).toEqual({ scheduled: true });
     });
   });
 
   describe('chat_update_confirm', () => {
     it('confirms and clears context', async () => {
-      expect(await findOp(ops, 'chat_update_confirm').handler({ contextPath: '/tmp/ctx.json' }))
-        .toEqual({ confirmed: true, previousContext: null });
+      expect(
+        await findOp(ops, 'chat_update_confirm').handler({ contextPath: '/tmp/ctx.json' }),
+      ).toEqual({ confirmed: true, previousContext: null });
     });
   });
 
@@ -163,16 +233,20 @@ describe('chat-service-ops', () => {
 
   describe('chat_file_detect_intent', () => {
     it('detects file intent', async () => {
-      expect(await findOp(ops, 'chat_file_detect_intent').handler({
-        filename: 'photo.jpg', mimeType: 'image/jpeg',
-      })).toEqual({ filename: 'photo.jpg', mimeType: 'image/jpeg', intent: 'vision' });
+      expect(
+        await findOp(ops, 'chat_file_detect_intent').handler({
+          filename: 'photo.jpg',
+          mimeType: 'image/jpeg',
+        }),
+      ).toEqual({ filename: 'photo.jpg', mimeType: 'image/jpeg', intent: 'vision' });
     });
   });
 
   describe('chat_file_cleanup', () => {
     it('cleans up temp files', async () => {
-      expect(await findOp(ops, 'chat_file_cleanup').handler({ uploadDir: '/tmp/uploads' }))
-        .toEqual({ removed: 3, uploadDir: '/tmp/uploads' });
+      expect(await findOp(ops, 'chat_file_cleanup').handler({ uploadDir: '/tmp/uploads' })).toEqual(
+        { removed: 3, uploadDir: '/tmp/uploads' },
+      );
     });
   });
 
@@ -186,28 +260,37 @@ describe('chat-service-ops', () => {
 
   describe('chat_notify_start', () => {
     it('returns error when not initialized', async () => {
-      expect(await findOp(ops, 'chat_notify_start').handler({}))
-        .toEqual({ started: false, reason: 'Notification engine not initialized.' });
+      expect(await findOp(ops, 'chat_notify_start').handler({})).toEqual({
+        started: false,
+        reason: 'Notification engine not initialized.',
+      });
     });
 
     it('starts after init', async () => {
       await findOp(ops, 'chat_notify_init').handler({});
-      const result = (await findOp(ops, 'chat_notify_start').handler({})) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_notify_start').handler({})) as Record<
+        string,
+        unknown
+      >;
       expect(result.started).toBe(true);
     });
   });
 
   describe('chat_notify_stop', () => {
     it('returns error when not initialized', async () => {
-      expect(await findOp(ops, 'chat_notify_stop').handler({}))
-        .toEqual({ stopped: false, reason: 'Notification engine not initialized.' });
+      expect(await findOp(ops, 'chat_notify_stop').handler({})).toEqual({
+        stopped: false,
+        reason: 'Notification engine not initialized.',
+      });
     });
   });
 
   describe('chat_notify_poll', () => {
     it('returns error when not initialized', async () => {
-      expect(await findOp(ops, 'chat_notify_poll').handler({}))
-        .toEqual({ polled: false, reason: 'Notification engine not initialized.' });
+      expect(await findOp(ops, 'chat_notify_poll').handler({})).toEqual({
+        polled: false,
+        reason: 'Notification engine not initialized.',
+      });
     });
 
     it('polls after init', async () => {
@@ -220,13 +303,21 @@ describe('chat-service-ops', () => {
 
   describe('chat_notify_status', () => {
     it('returns uninitialized status', async () => {
-      expect(await findOp(ops, 'chat_notify_status').handler({}))
-        .toEqual({ initialized: false, checks: 0, running: false, sent: 0, lastPollAt: null });
+      expect(await findOp(ops, 'chat_notify_status').handler({})).toEqual({
+        initialized: false,
+        checks: 0,
+        running: false,
+        sent: 0,
+        lastPollAt: null,
+      });
     });
 
     it('returns stats after init', async () => {
       await findOp(ops, 'chat_notify_init').handler({});
-      const result = (await findOp(ops, 'chat_notify_status').handler({})) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_notify_status').handler({})) as Record<
+        string,
+        unknown
+      >;
       expect(result.initialized).toBe(true);
     });
   });
@@ -235,14 +326,18 @@ describe('chat-service-ops', () => {
 
   describe('chat_browser_init', () => {
     it('initializes browser manager', async () => {
-      expect(await findOp(ops, 'chat_browser_init').handler({ maxSessions: 5 }))
-        .toEqual({ initialized: true, maxSessions: 5 });
+      expect(await findOp(ops, 'chat_browser_init').handler({ maxSessions: 5 })).toEqual({
+        initialized: true,
+        maxSessions: 5,
+      });
     });
   });
 
   describe('chat_browser_acquire', () => {
     it('acquires browser session', async () => {
-      const result = (await findOp(ops, 'chat_browser_acquire').handler({ chatId: 'chat-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_browser_acquire').handler({
+        chatId: 'chat-1',
+      })) as Record<string, unknown>;
       expect(result.chatId).toBe('chat-1');
       expect(result.pid).toBe(1234);
     });
@@ -250,26 +345,36 @@ describe('chat-service-ops', () => {
 
   describe('chat_browser_release', () => {
     it('returns false when no browser manager', async () => {
-      expect(await findOp(ops, 'chat_browser_release').handler({ chatId: 'chat-1' }))
-        .toEqual({ released: false, reason: 'No browser manager.' });
+      expect(await findOp(ops, 'chat_browser_release').handler({ chatId: 'chat-1' })).toEqual({
+        released: false,
+        reason: 'No browser manager.',
+      });
     });
 
     it('releases after init', async () => {
       await findOp(ops, 'chat_browser_init').handler({});
-      const result = (await findOp(ops, 'chat_browser_release').handler({ chatId: 'chat-1' })) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_browser_release').handler({
+        chatId: 'chat-1',
+      })) as Record<string, unknown>;
       expect(result.released).toBe(true);
     });
   });
 
   describe('chat_browser_status', () => {
     it('returns uninitialized status', async () => {
-      expect(await findOp(ops, 'chat_browser_status').handler({}))
-        .toEqual({ initialized: false, activeSessions: 0, sessions: [] });
+      expect(await findOp(ops, 'chat_browser_status').handler({})).toEqual({
+        initialized: false,
+        activeSessions: 0,
+        sessions: [],
+      });
     });
 
     it('returns status after init', async () => {
       await findOp(ops, 'chat_browser_init').handler({});
-      const result = (await findOp(ops, 'chat_browser_status').handler({})) as Record<string, unknown>;
+      const result = (await findOp(ops, 'chat_browser_status').handler({})) as Record<
+        string,
+        unknown
+      >;
       expect(result.initialized).toBe(true);
     });
   });

package/src/runtime/facades/chat-service-ops.ts

@@ -366,7 +366,9 @@ export function createChatServiceOps(state: ChatState): OpDefinition[] {
       auth: 'read',
       handler: async () => {
         if (!state.browser) return { initialized: false, activeSessions: 0, sessions: [] };
-        const sessions = state.browser.listSessions().map((id) => (Object.assign({chatId:id}, state.browser! .getInfo(id))));
+        const sessions = state.browser
+          .listSessions()
+          .map((id) => Object.assign({ chatId: id }, state.browser!.getInfo(id)));
         return { initialized: true, activeSessions: state.browser.size, sessions };
       },
     },

package/src/runtime/facades/chat-session-ops.test.ts

@@ -29,8 +29,22 @@ const mockSessionManager = {
   listAll: vi.fn().mockReturnValue(['sess-1', 'sess-2']),
 };
 
+const mockConstructorCalls: unknown[][] = [];
+
 vi.mock('../../chat/chat-session.js', () => ({
-  ChatSessionManager: vi.fn().mockImplementation(() => mockSessionManager),
+  ChatSessionManager: class {
+    size = mockSessionManager.size;
+    startReaper = mockSessionManager.startReaper;
+    getOrCreate = mockSessionManager.getOrCreate;
+    appendMessage = mockSessionManager.appendMessage;
+    messageCount = mockSessionManager.messageCount;
+    clear = mockSessionManager.clear;
+    delete = mockSessionManager.delete;
+    listAll = mockSessionManager.listAll;
+    constructor(...args: unknown[]) {
+      mockConstructorCalls.push(args);
+    }
+  },
 }));
 
 // ─── Helpers ────────────────────────────────────────────────────────
@@ -49,6 +63,7 @@ describe('chat-session-ops', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    mockConstructorCalls.length = 0;
     state = createChatState();
     ops = createChatSessionOps(state);
   });
@@ -78,7 +93,6 @@ describe('chat-session-ops', () => {
     });
 
     it('passes optional config params', async () => {
-      const { ChatSessionManager } = await import('../../chat/chat-session.js');
       const op = findOp(ops, 'chat_session_init');
       await op.handler({
         storageDir: '/tmp/s',
@@ -86,12 +100,14 @@ describe('chat-session-ops', () => {
         compactionThreshold: 50,
         compactionKeep: 20,
       });
-      expect(ChatSessionManager).toHaveBeenCalledWith({
-        storageDir: '/tmp/s',
-        ttlMs: 5000,
-        compactionThreshold: 50,
-        compactionKeep: 20,
-      });
+      expect(mockConstructorCalls[0]).toEqual([
+        {
+          storageDir: '/tmp/s',
+          ttlMs: 5000,
+          compactionThreshold: 50,
+          compactionKeep: 20,
+        },
+      ]);
     });
 
     it('has write auth level', () => {
@@ -190,8 +206,7 @@ describe('chat-session-ops', () => {
       await getOp.handler({ sessionId: 'x', storageDir: '/tmp/s' });
 
       // ChatSessionManager should be constructed only once
-      const { ChatSessionManager } = await import('../../chat/chat-session.js');
-      expect(ChatSessionManager).toHaveBeenCalledTimes(1);
+      expect(mockConstructorCalls).toHaveLength(1);
     });
   });
 });