@soleri/core 9.0.3 → 9.2.0

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

@@ -0,0 +1,276 @@
+/**
+ * Tests for chat-service-ops — cancellation, self-update, file handling,
+ * notifications, and browser sessions.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createChatServiceOps } from './chat-service-ops.js';
+import { createChatState } from './chat-state.js';
+import type { ChatState } from './chat-state.js';
+import type { OpDefinition } from '../../facades/types.js';
+
+// ─── 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,
+  })),
+}));
+
+vi.mock('../../chat/self-update.js', () => ({
+  SelfUpdateManager: vi.fn().mockImplementation(() => ({
+    loadContext: vi.fn().mockReturnValue(null),
+    clearContext: vi.fn(),
+    requestRestart: vi.fn().mockReturnValue({ scheduled: true }),
+  })),
+}));
+
+vi.mock('../../chat/file-handler.js', () => ({
+  detectFileIntent: vi.fn().mockReturnValue('vision'),
+  buildMultimodalContent: vi.fn().mockReturnValue({ type: 'image', data: 'abc' }),
+  cleanupTempFiles: vi.fn().mockReturnValue(3),
+}));
+
+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 }),
+  })),
+}));
+
+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 }),
+  })),
+}));
+
+// Needed via chat-state imports
+vi.mock('../../chat/chat-session.js', () => ({ ChatSessionManager: vi.fn() }));
+vi.mock('../../chat/auth-manager.js', () => ({ ChatAuthManager: vi.fn() }));
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function findOp(ops: OpDefinition[], name: string): OpDefinition {
+  const op = ops.find((o) => o.name === name);
+  if (!op) throw new Error(`Op not found: ${name}`);
+  return op;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe('chat-service-ops', () => {
+  let state: ChatState;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    state = createChatState();
+    ops = createChatServiceOps(state);
+  });
+
+  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',
+    ]);
+  });
+
+  // ─── Task Cancellation ─────────────────────────────────────────
+
+  describe('chat_cancel_create', () => {
+    it('creates cancellation signal', async () => {
+      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 });
+    });
+  });
+
+  describe('chat_cancel_stop', () => {
+    it('returns false when no cancellation manager', async () => {
+      const result = await findOp(ops, 'chat_cancel_stop').handler({ chatId: 'chat-1' });
+      expect(result).toEqual({ cancelled: false, reason: 'No cancellation manager initialized.' });
+    });
+
+    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>;
+      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: [] });
+    });
+
+    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>;
+      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[] };
+      expect(result.activeTasks).toBe(1);
+      expect(result.running).toHaveLength(1);
+    });
+  });
+
+  // ─── Self-Update ───────────────────────────────────────────────
+
+  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 });
+    });
+  });
+
+  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 });
+    });
+  });
+
+  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 });
+    });
+  });
+
+  // ─── File Handling ─────────────────────────────────────────────
+
+  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' });
+    });
+  });
+
+  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' });
+    });
+  });
+
+  // ─── Notifications ─────────────────────────────────────────────
+
+  describe('chat_notify_init', () => {
+    it('initializes notification engine', async () => {
+      expect(await findOp(ops, 'chat_notify_init').handler({})).toEqual({ initialized: true });
+    });
+  });
+
+  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.' });
+    });
+
+    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>;
+      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.' });
+    });
+  });
+
+  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.' });
+    });
+
+    it('polls after init', async () => {
+      await findOp(ops, 'chat_notify_init').handler({});
+      const result = (await findOp(ops, 'chat_notify_poll').handler({})) as Record<string, unknown>;
+      expect(result.polled).toBe(true);
+      expect(result.notified).toBe(2);
+    });
+  });
+
+  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 });
+    });
+
+    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>;
+      expect(result.initialized).toBe(true);
+    });
+  });
+
+  // ─── Browser Sessions ──────────────────────────────────────────
+
+  describe('chat_browser_init', () => {
+    it('initializes browser manager', async () => {
+      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>;
+      expect(result.chatId).toBe('chat-1');
+      expect(result.pid).toBe(1234);
+    });
+  });
+
+  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.' });
+    });
+
+    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>;
+      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: [] });
+    });
+
+    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>;
+      expect(result.initialized).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,374 @@
+/**
+ * Chat service ops — cancellation, self-update, file handling,
+ * notifications, and browser sessions.
+ * Split from chat-facade.ts for maintainability.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../../facades/types.js';
+import { TaskCancellationManager } from '../../chat/cancellation.js';
+import { SelfUpdateManager } from '../../chat/self-update.js';
+import { NotificationEngine } from '../../chat/notifications.js';
+import { BrowserSessionManager } from '../../chat/browser-session.js';
+import {
+  detectFileIntent,
+  buildMultimodalContent,
+  cleanupTempFiles,
+} from '../../chat/file-handler.js';
+import type { FileInfo } from '../../chat/file-handler.js';
+import type { ChatState } from './chat-state.js';
+
+export function createChatServiceOps(state: ChatState): OpDefinition[] {
+  return [
+    // ─── Task Cancellation Ops ─────────────────────────────────────
+
+    {
+      name: 'chat_cancel_create',
+      description:
+        'Create an AbortSignal for a chat task. If a task is already running for this chat, it is cancelled first. Returns signal status.',
+      auth: 'write',
+      schema: z.object({
+        chatId: z.string().describe('Chat/session ID.'),
+        description: z.string().optional().describe('Description of what is running.'),
+      }),
+      handler: async (params) => {
+        if (!state.cancellation) {
+          state.cancellation = new TaskCancellationManager();
+        }
+        const signal = state.cancellation.create(
+          params.chatId as string,
+          params.description as string | undefined,
+        );
+        return {
+          chatId: params.chatId,
+          created: true,
+          aborted: signal.aborted,
+          activeTasks: state.cancellation.size,
+        };
+      },
+    },
+
+    {
+      name: 'chat_cancel_stop',
+      description: 'Cancel the running task for a chat. Aborts the associated AbortController.',
+      auth: 'write',
+      schema: z.object({
+        chatId: z.string().describe('Chat/session ID to cancel.'),
+      }),
+      handler: async (params) => {
+        if (!state.cancellation) {
+          return { cancelled: false, reason: 'No cancellation manager initialized.' };
+        }
+        const info = state.cancellation.cancel(params.chatId as string);
+        if (!info) {
+          return { cancelled: false, reason: 'No running task for this chat.' };
+        }
+        return {
+          cancelled: true,
+          chatId: params.chatId,
+          description: info.description ?? null,
+          ranForMs: Date.now() - info.startedAt,
+          activeTasks: state.cancellation.size,
+        };
+      },
+    },
+
+    {
+      name: 'chat_cancel_status',
+      description: 'Get cancellation status — running tasks, per-chat info.',
+      auth: 'read',
+      schema: z.object({
+        chatId: z.string().optional().describe('Specific chat to check. Omit for all.'),
+      }),
+      handler: async (params) => {
+        if (!state.cancellation) {
+          return { activeTasks: 0, running: [] };
+        }
+        if (params.chatId) {
+          const info = state.cancellation.getInfo(params.chatId as string);
+          return {
+            chatId: params.chatId,
+            running: !!info,
+            description: info?.description ?? null,
+            startedAt: info?.startedAt ?? null,
+            ranForMs: info ? Date.now() - info.startedAt : null,
+          };
+        }
+        const running = state.cancellation.listRunning();
+        return {
+          activeTasks: state.cancellation.size,
+          running: running.map((id) => {
+            const info = state.cancellation!.getInfo(id);
+            return {
+              chatId: id,
+              description: info?.description ?? null,
+              startedAt: info?.startedAt ?? null,
+            };
+          }),
+        };
+      },
+    },
+
+    // ─── Self-Update Ops ───────────────────────────────────────────
+
+    {
+      name: 'chat_update_init',
+      description: 'Initialize self-update manager. Provide path for restart context persistence.',
+      auth: 'write',
+      schema: z.object({
+        contextPath: z.string().describe('Path for restart context JSON file.'),
+      }),
+      handler: async (params) => {
+        state.updater = new SelfUpdateManager(params.contextPath as string);
+        const pending = state.updater.loadContext();
+        return {
+          initialized: true,
+          hasPendingRestart: !!pending,
+          pendingContext: pending,
+        };
+      },
+    },
+
+    {
+      name: 'chat_update_request',
+      description: 'Request a restart. Saves context for post-restart confirmation.',
+      auth: 'write',
+      schema: z.object({
+        chatId: z.string().describe('Chat ID for post-restart confirmation.'),
+        reason: z
+          .enum(['self-update', 'rebuild', 'manual'])
+          .optional()
+          .describe('Restart reason. Default: manual.'),
+        commitSha: z.string().optional().describe('Git commit SHA if self-update.'),
+        contextPath: z.string().describe('Path for restart context.'),
+      }),
+      handler: async (params) => {
+        if (!state.updater) {
+          state.updater = new SelfUpdateManager(params.contextPath as string);
+        }
+        return state.updater.requestRestart(
+          params.chatId as string,
+          (params.reason as 'self-update' | 'rebuild' | 'manual') ?? 'manual',
+          params.commitSha as string | undefined,
+        );
+      },
+    },
+
+    {
+      name: 'chat_update_confirm',
+      description: 'Clear restart context after successful startup.',
+      auth: 'write',
+      schema: z.object({
+        contextPath: z.string().describe('Path for restart context.'),
+      }),
+      handler: async (params) => {
+        if (!state.updater) {
+          state.updater = new SelfUpdateManager(params.contextPath as string);
+        }
+        const context = state.updater.loadContext();
+        state.updater.clearContext();
+        return { confirmed: true, previousContext: context };
+      },
+    },
+
+    // ─── File Handling Ops ─────────────────────────────────────────
+
+    {
+      name: 'chat_file_detect_intent',
+      description: 'Detect user intent for a file — vision, text, or intake.',
+      auth: 'read',
+      schema: z.object({
+        filename: z.string().describe('Original filename.'),
+        mimeType: z.string().describe('MIME type.'),
+        userText: z.string().optional().describe('Accompanying user message text.'),
+      }),
+      handler: async (params) => {
+        const intent = detectFileIntent(
+          params.filename as string,
+          params.mimeType as string,
+          params.userText as string | undefined,
+        );
+        return { filename: params.filename, mimeType: params.mimeType, intent };
+      },
+    },
+
+    {
+      name: 'chat_file_build_content',
+      description: 'Build multimodal content from a file for the Anthropic API.',
+      auth: 'read',
+      schema: z.object({
+        filename: z.string().describe('Original filename.'),
+        mimeType: z.string().describe('MIME type.'),
+        dataBase64: z.string().describe('File content as base64.'),
+        intent: z.enum(['vision', 'text', 'intake']).describe('Detected intent.'),
+      }),
+      handler: async (params) => {
+        const file: FileInfo = {
+          name: params.filename as string,
+          mimeType: params.mimeType as string,
+          size: Buffer.byteLength(params.dataBase64 as string, 'base64'),
+          data: Buffer.from(params.dataBase64 as string, 'base64'),
+        };
+        return buildMultimodalContent(file, params.intent as 'vision' | 'text' | 'intake');
+      },
+    },
+
+    {
+      name: 'chat_file_cleanup',
+      description: 'Clean up temp files older than maxAgeMs.',
+      auth: 'write',
+      schema: z.object({
+        uploadDir: z.string().describe('Temp upload directory.'),
+        maxAgeMs: z.number().optional().describe('Max age in ms. Default: 1 hour.'),
+      }),
+      handler: async (params) => {
+        const removed = cleanupTempFiles(
+          params.uploadDir as string,
+          params.maxAgeMs as number | undefined,
+        );
+        return { removed, uploadDir: params.uploadDir };
+      },
+    },
+
+    // ─── Notification Ops ──────────────────────────────────────────
+
+    {
+      name: 'chat_notify_init',
+      description:
+        'Initialize the notification engine. Notifications are delivered via the provided callback pattern.',
+      auth: 'write',
+      schema: z.object({
+        intervalMs: z.number().optional().describe('Polling interval in ms. Default: 30 minutes.'),
+        defaultCooldownMs: z
+          .number()
+          .optional()
+          .describe('Default cooldown between notifications. Default: 4 hours.'),
+      }),
+      handler: async (params) => {
+        state.notifications = new NotificationEngine({
+          intervalMs: params.intervalMs as number | undefined,
+          defaultCooldownMs: params.defaultCooldownMs as number | undefined,
+          onNotify: async (checkId, message) => {
+            console.log(`[notification] ${checkId}: ${message}`);
+          },
+        });
+        return { initialized: true };
+      },
+    },
+
+    {
+      name: 'chat_notify_start',
+      description: 'Start the notification polling loop.',
+      auth: 'write',
+      handler: async () => {
+        if (!state.notifications) {
+          return { started: false, reason: 'Notification engine not initialized.' };
+        }
+        state.notifications.start();
+        return { started: true, ...state.notifications.stats() };
+      },
+    },
+
+    {
+      name: 'chat_notify_stop',
+      description: 'Stop the notification polling loop.',
+      auth: 'write',
+      handler: async () => {
+        if (!state.notifications) {
+          return { stopped: false, reason: 'Notification engine not initialized.' };
+        }
+        state.notifications.stop();
+        return { stopped: true, ...state.notifications.stats() };
+      },
+    },
+
+    {
+      name: 'chat_notify_poll',
+      description: 'Run all notification checks once (manual trigger).',
+      auth: 'write',
+      handler: async () => {
+        if (!state.notifications) {
+          return { polled: false, reason: 'Notification engine not initialized.' };
+        }
+        const notified = await state.notifications.poll();
+        return { polled: true, notified, ...state.notifications.stats() };
+      },
+    },
+
+    {
+      name: 'chat_notify_status',
+      description: 'Get notification engine status.',
+      auth: 'read',
+      handler: async () => {
+        if (!state.notifications) {
+          return { initialized: false, checks: 0, running: false, sent: 0, lastPollAt: null };
+        }
+        return { initialized: true, ...state.notifications.stats() };
+      },
+    },
+
+    // ─── Browser Session Ops ───────────────────────────────────────
+
+    {
+      name: 'chat_browser_init',
+      description: 'Initialize the browser session manager for per-chat Playwright isolation.',
+      auth: 'write',
+      schema: z.object({
+        maxSessions: z.number().optional().describe('Max concurrent sessions. Default: 3.'),
+        idleTimeoutMs: z.number().optional().describe('Idle timeout in ms. Default: 5 minutes.'),
+      }),
+      handler: async (params) => {
+        state.browser = new BrowserSessionManager({
+          maxSessions: params.maxSessions as number | undefined,
+          idleTimeoutMs: params.idleTimeoutMs as number | undefined,
+        });
+        return { initialized: true, maxSessions: params.maxSessions ?? 3 };
+      },
+    },
+
+    {
+      name: 'chat_browser_acquire',
+      description: 'Get or create a browser session for a chat. Spawns Playwright if needed.',
+      auth: 'write',
+      schema: z.object({
+        chatId: z.string().describe('Chat ID for isolation.'),
+      }),
+      handler: async (params) => {
+        if (!state.browser) {
+          state.browser = new BrowserSessionManager();
+        }
+        const session = state.browser.acquire(params.chatId as string);
+        return {
+          chatId: params.chatId,
+          pid: session.process.pid ?? null,
+          activeSessions: state.browser.size,
+        };
+      },
+    },
+
+    {
+      name: 'chat_browser_release',
+      description: 'Release a browser session for a chat.',
+      auth: 'write',
+      schema: z.object({
+        chatId: z.string().describe('Chat ID to release.'),
+      }),
+      handler: async (params) => {
+        if (!state.browser) return { released: false, reason: 'No browser manager.' };
+        const released = state.browser.release(params.chatId as string);
+        return { released, activeSessions: state.browser.size };
+      },
+    },
+
+    {
+      name: 'chat_browser_status',
+      description: 'Get browser session status — active sessions, per-chat info.',
+      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))));
+        return { initialized: true, activeSessions: state.browser.size, sessions };
+      },
+    },
+  ];
+}