@soleri/core 9.0.4 → 9.2.0

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

@@ -0,0 +1,197 @@
+/**
+ * Tests for chat-session-ops — session lifecycle management ops.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createChatSessionOps } from './chat-session-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 ─────────────────────────────────────────────
+
+const mockSession = {
+  id: 'sess-1',
+  messages: [{ role: 'user', content: 'hi', timestamp: 1000 }],
+  createdAt: 1000,
+  lastActiveAt: 2000,
+  meta: { key: 'val' },
+};
+
+const mockSessionManager = {
+  size: 1,
+  startReaper: vi.fn(),
+  getOrCreate: vi.fn().mockReturnValue(mockSession),
+  appendMessage: vi.fn(),
+  messageCount: vi.fn().mockReturnValue(2),
+  clear: vi.fn(),
+  delete: vi.fn(),
+  listAll: vi.fn().mockReturnValue(['sess-1', 'sess-2']),
+};
+
+vi.mock('../../chat/chat-session.js', () => ({
+  ChatSessionManager: vi.fn().mockImplementation(() => mockSessionManager),
+}));
+
+// ─── 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-session-ops', () => {
+  let state: ChatState;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    state = createChatState();
+    ops = createChatSessionOps(state);
+  });
+
+  it('exports 6 session ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'chat_session_init',
+      'chat_session_get',
+      'chat_session_append',
+      'chat_session_clear',
+      'chat_session_delete',
+      'chat_session_list',
+    ]);
+  });
+
+  describe('chat_session_init', () => {
+    it('initializes session manager and returns status', async () => {
+      const op = findOp(ops, 'chat_session_init');
+      const result = await op.handler({ storageDir: '/tmp/sessions' });
+      expect(result).toEqual({
+        initialized: true,
+        activeSessions: 1,
+        storageDir: '/tmp/sessions',
+      });
+      expect(mockSessionManager.startReaper).toHaveBeenCalled();
+    });
+
+    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',
+        ttlMs: 5000,
+        compactionThreshold: 50,
+        compactionKeep: 20,
+      });
+      expect(ChatSessionManager).toHaveBeenCalledWith({
+        storageDir: '/tmp/s',
+        ttlMs: 5000,
+        compactionThreshold: 50,
+        compactionKeep: 20,
+      });
+    });
+
+    it('has write auth level', () => {
+      const op = findOp(ops, 'chat_session_init');
+      expect(op.auth).toBe('write');
+    });
+  });
+
+  describe('chat_session_get', () => {
+    it('returns session info', async () => {
+      const op = findOp(ops, 'chat_session_get');
+      const result = await op.handler({ sessionId: 'sess-1', storageDir: '/tmp/s' });
+      expect(result).toEqual({
+        id: 'sess-1',
+        messageCount: 1,
+        createdAt: 1000,
+        lastActiveAt: 2000,
+        meta: { key: 'val' },
+      });
+      expect(mockSessionManager.getOrCreate).toHaveBeenCalledWith('sess-1');
+    });
+
+    it('has read auth level', () => {
+      const op = findOp(ops, 'chat_session_get');
+      expect(op.auth).toBe('read');
+    });
+  });
+
+  describe('chat_session_append', () => {
+    it('appends message and returns count', async () => {
+      const op = findOp(ops, 'chat_session_append');
+      const result = await op.handler({
+        sessionId: 'sess-1',
+        storageDir: '/tmp/s',
+        role: 'user',
+        content: 'hello',
+      });
+      expect(mockSessionManager.appendMessage).toHaveBeenCalledWith('sess-1', {
+        role: 'user',
+        content: 'hello',
+        timestamp: expect.any(Number),
+      });
+      expect(result).toEqual({
+        sessionId: 'sess-1',
+        messageCount: 2,
+      });
+    });
+
+    it('has write auth level', () => {
+      const op = findOp(ops, 'chat_session_append');
+      expect(op.auth).toBe('write');
+    });
+  });
+
+  describe('chat_session_clear', () => {
+    it('clears session messages', async () => {
+      const op = findOp(ops, 'chat_session_clear');
+      const result = await op.handler({ sessionId: 'sess-1', storageDir: '/tmp/s' });
+      expect(mockSessionManager.clear).toHaveBeenCalledWith('sess-1');
+      expect(result).toEqual({ cleared: true, sessionId: 'sess-1' });
+    });
+  });
+
+  describe('chat_session_delete', () => {
+    it('deletes session', async () => {
+      const op = findOp(ops, 'chat_session_delete');
+      const result = await op.handler({ sessionId: 'sess-1', storageDir: '/tmp/s' });
+      expect(mockSessionManager.delete).toHaveBeenCalledWith('sess-1');
+      expect(result).toEqual({ deleted: true, sessionId: 'sess-1' });
+    });
+  });
+
+  describe('chat_session_list', () => {
+    it('lists all sessions', async () => {
+      const op = findOp(ops, 'chat_session_list');
+      const result = await op.handler({ storageDir: '/tmp/s' });
+      expect(result).toEqual({
+        sessions: ['sess-1', 'sess-2'],
+        count: 2,
+        active: 1,
+      });
+    });
+
+    it('has read auth level', () => {
+      const op = findOp(ops, 'chat_session_list');
+      expect(op.auth).toBe('read');
+    });
+  });
+
+  describe('state sharing', () => {
+    it('reuses session manager across ops (lazy init once)', async () => {
+      const initOp = findOp(ops, 'chat_session_init');
+      const getOp = findOp(ops, 'chat_session_get');
+
+      await initOp.handler({ storageDir: '/tmp/s' });
+      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);
+    });
+  });
+});

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

@@ -0,0 +1,146 @@
+/**
+ * Chat session ops — session lifecycle management.
+ * Split from chat-facade.ts for maintainability.
+ */
+
+import { z } from 'zod';
+import type { OpDefinition } from '../../facades/types.js';
+import type { ChatSessionConfig } from '../../chat/types.js';
+import type { ChatState } from './chat-state.js';
+import { getOrCreateSessions } from './chat-state.js';
+
+export function createChatSessionOps(state: ChatState): OpDefinition[] {
+  return [
+    {
+      name: 'chat_session_init',
+      description:
+        'Initialize chat session management. Must be called before other session ops. Provide the storage directory path.',
+      auth: 'write',
+      schema: z.object({
+        storageDir: z.string().describe('Directory for session persistence.'),
+        ttlMs: z.number().optional().describe('Session TTL in ms. Default: 7200000 (2 hours).'),
+        compactionThreshold: z
+          .number()
+          .optional()
+          .describe('Messages before compaction. Default: 100.'),
+        compactionKeep: z
+          .number()
+          .optional()
+          .describe('Messages to keep after compaction. Default: 40.'),
+      }),
+      handler: async (params) => {
+        const config: ChatSessionConfig = {
+          storageDir: params.storageDir as string,
+          ttlMs: params.ttlMs as number | undefined,
+          compactionThreshold: params.compactionThreshold as number | undefined,
+          compactionKeep: params.compactionKeep as number | undefined,
+        };
+        const sessions = getOrCreateSessions(state, config);
+        return {
+          initialized: true,
+          activeSessions: sessions.size,
+          storageDir: config.storageDir,
+        };
+      },
+    },
+
+    {
+      name: 'chat_session_get',
+      description: 'Get or create a chat session by ID. Returns session with message history.',
+      auth: 'read',
+      schema: z.object({
+        sessionId: z.string().describe('Session/chat ID.'),
+        storageDir: z.string().describe('Storage directory (auto-initializes if needed).'),
+      }),
+      handler: async (params) => {
+        const sessions = getOrCreateSessions(state, {
+          storageDir: params.storageDir as string,
+        });
+        const session = sessions.getOrCreate(params.sessionId as string);
+        return {
+          id: session.id,
+          messageCount: session.messages.length,
+          createdAt: session.createdAt,
+          lastActiveAt: session.lastActiveAt,
+          meta: session.meta,
+        };
+      },
+    },
+
+    {
+      name: 'chat_session_append',
+      description: 'Append a message to a chat session.',
+      auth: 'write',
+      schema: z.object({
+        sessionId: z.string().describe('Session/chat ID.'),
+        storageDir: z.string().describe('Storage directory.'),
+        role: z.enum(['user', 'assistant', 'system', 'tool']).describe('Message role.'),
+        content: z.string().describe('Message content.'),
+      }),
+      handler: async (params) => {
+        const sessions = getOrCreateSessions(state, {
+          storageDir: params.storageDir as string,
+        });
+        sessions.appendMessage(params.sessionId as string, {
+          role: params.role as 'user' | 'assistant' | 'system' | 'tool',
+          content: params.content as string,
+          timestamp: Date.now(),
+        });
+        return {
+          sessionId: params.sessionId,
+          messageCount: sessions.messageCount(params.sessionId as string),
+        };
+      },
+    },
+
+    {
+      name: 'chat_session_clear',
+      description: 'Clear message history for a session (keeps session alive).',
+      auth: 'write',
+      schema: z.object({
+        sessionId: z.string().describe('Session/chat ID.'),
+        storageDir: z.string().describe('Storage directory.'),
+      }),
+      handler: async (params) => {
+        const sessions = getOrCreateSessions(state, {
+          storageDir: params.storageDir as string,
+        });
+        sessions.clear(params.sessionId as string);
+        return { cleared: true, sessionId: params.sessionId };
+      },
+    },
+
+    {
+      name: 'chat_session_delete',
+      description: 'Delete a session entirely (memory + disk).',
+      auth: 'write',
+      schema: z.object({
+        sessionId: z.string().describe('Session/chat ID.'),
+        storageDir: z.string().describe('Storage directory.'),
+      }),
+      handler: async (params) => {
+        const sessions = getOrCreateSessions(state, {
+          storageDir: params.storageDir as string,
+        });
+        sessions.delete(params.sessionId as string);
+        return { deleted: true, sessionId: params.sessionId };
+      },
+    },
+
+    {
+      name: 'chat_session_list',
+      description: 'List all session IDs (active + persisted).',
+      auth: 'read',
+      schema: z.object({
+        storageDir: z.string().describe('Storage directory.'),
+      }),
+      handler: async (params) => {
+        const sessions = getOrCreateSessions(state, {
+          storageDir: params.storageDir as string,
+        });
+        const ids = sessions.listAll();
+        return { sessions: ids, count: ids.length, active: sessions.size };
+      },
+    },
+  ];
+}

package/src/runtime/facades/chat-state.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared chat state and lazy initializers.
+ * Used by chat-session-ops.ts and chat-transport-ops.ts.
+ */
+
+import { ChatSessionManager } from '../../chat/chat-session.js';
+import { ChatAuthManager } from '../../chat/auth-manager.js';
+import { TaskCancellationManager } from '../../chat/cancellation.js';
+import { SelfUpdateManager } from '../../chat/self-update.js';
+import { NotificationEngine } from '../../chat/notifications.js';
+import { MessageQueue } from '../../chat/queue.js';
+import { BrowserSessionManager } from '../../chat/browser-session.js';
+import { McpToolBridge } from '../../chat/mcp-bridge.js';
+import type { ChatSessionConfig, ChatAuthConfig } from '../../chat/types.js';
+
+/**
+ * Chat transport state — lazily initialized on first use.
+ * Config comes from runtime flags or op params.
+ */
+export interface ChatState {
+  sessions: ChatSessionManager | null;
+  auth: ChatAuthManager | null;
+  bridge: McpToolBridge | null;
+  cancellation: TaskCancellationManager | null;
+  updater: SelfUpdateManager | null;
+  notifications: NotificationEngine | null;
+  queue: MessageQueue | null;
+  browser: BrowserSessionManager | null;
+}
+
+export function createChatState(): ChatState {
+  return {
+    sessions: null,
+    auth: null,
+    bridge: null,
+    cancellation: null,
+    updater: null,
+    notifications: null,
+    queue: null,
+    browser: null,
+  };
+}
+
+export function getOrCreateSessions(
+  state: ChatState,
+  config: ChatSessionConfig,
+): ChatSessionManager {
+  if (!state.sessions) {
+    state.sessions = new ChatSessionManager(config);
+    state.sessions.startReaper();
+  }
+  return state.sessions;
+}
+
+export function getOrCreateAuth(state: ChatState, config: ChatAuthConfig): ChatAuthManager {
+  if (!state.auth) {
+    state.auth = new ChatAuthManager(config);
+  }
+  return state.auth;
+}

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

@@ -0,0 +1,269 @@
+/**
+ * Tests for chat-transport-ops — chunking, auth, bridge, compression, voice, queue.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createChatTransportOps } from './chat-transport-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/response-chunker.js', () => ({
+  chunkResponse: vi.fn().mockReturnValue(['chunk1', 'chunk2']),
+}));
+
+const mockAuthManager = {
+  enabled: true,
+  authenticatedCount: 1,
+  isAuthenticated: vi.fn().mockReturnValue(true),
+  isLockedOut: vi.fn().mockReturnValue(false),
+  authenticate: vi.fn().mockReturnValue(true),
+  revoke: vi.fn(),
+  listAuthenticated: vi.fn().mockReturnValue([{ userId: 'u1', authenticatedAt: 1000 }]),
+};
+
+vi.mock('../../chat/auth-manager.js', () => ({
+  ChatAuthManager: vi.fn().mockImplementation(() => mockAuthManager),
+}));
+
+const mockBridge = {
+  size: 1,
+  register: vi.fn(),
+  listTools: vi.fn().mockReturnValue([{ name: 'tool1' }]),
+  execute: vi.fn().mockResolvedValue({ output: 'result' }),
+};
+
+vi.mock('../../chat/mcp-bridge.js', () => ({
+  McpToolBridge: vi.fn().mockImplementation(() => mockBridge),
+}));
+
+vi.mock('../../chat/output-compressor.js', () => ({
+  createOutputCompressor: vi.fn().mockReturnValue(
+    (_name: string, output: string, _max?: number) => output.slice(0, 10),
+  ),
+}));
+
+vi.mock('../../chat/voice.js', () => ({
+  transcribeAudio: vi.fn().mockResolvedValue({ text: 'hello world', language: 'en' }),
+  synthesizeSpeech: vi.fn().mockResolvedValue({
+    success: true,
+    audio: Buffer.from('audio-data'),
+  }),
+}));
+
+const mockQueue = {
+  inboxCount: vi.fn().mockReturnValue(2),
+  outboxCount: vi.fn().mockReturnValue(1),
+  readInbox: vi.fn().mockReturnValue([{ id: 'm1', text: 'hi' }]),
+  formatInbox: vi.fn().mockReturnValue('formatted'),
+  sendResponse: vi.fn().mockReturnValue({ id: 'r1' }),
+  drainOutbox: vi.fn().mockReturnValue([{ id: 'r1' }]),
+};
+
+vi.mock('../../chat/queue.js', () => ({
+  MessageQueue: vi.fn().mockImplementation(() => mockQueue),
+}));
+
+// Needed via chat-state imports
+vi.mock('../../chat/chat-session.js', () => ({
+  ChatSessionManager: 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-transport-ops', () => {
+  let state: ChatState;
+  let ops: OpDefinition[];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    state = createChatState();
+    ops = createChatTransportOps(state);
+  });
+
+  it('exports 17 transport ops', () => {
+    const names = ops.map((o) => o.name);
+    expect(names).toEqual([
+      'chat_chunk_response',
+      'chat_auth_init', 'chat_auth_check', 'chat_auth_authenticate',
+      'chat_auth_revoke', 'chat_auth_status',
+      'chat_bridge_init', 'chat_bridge_register', 'chat_bridge_list', 'chat_bridge_execute',
+      'chat_compress_output',
+      'chat_voice_transcribe', 'chat_voice_synthesize',
+      'chat_queue_init', 'chat_queue_inbox', 'chat_queue_reply', 'chat_queue_drain',
+    ]);
+  });
+
+  // ─── Chunking ──────────────────────────────────────────────────
+
+  describe('chat_chunk_response', () => {
+    it('chunks text and returns result', async () => {
+      const op = findOp(ops, 'chat_chunk_response');
+      const result = (await op.handler({ text: 'hello world' })) as { chunks: string[]; count: number };
+      expect(result.chunks).toEqual(['chunk1', 'chunk2']);
+      expect(result.count).toBe(2);
+    });
+
+    it('has read auth level', () => {
+      expect(findOp(ops, 'chat_chunk_response').auth).toBe('read');
+    });
+  });
+
+  // ─── Authentication ────────────────────────────────────────────
+
+  describe('chat_auth_init', () => {
+    it('initializes and returns status', async () => {
+      const result = await findOp(ops, 'chat_auth_init').handler({ storagePath: '/tmp/auth.json' });
+      expect(result).toEqual({ initialized: true, enabled: true, authenticatedCount: 1 });
+    });
+  });
+
+  describe('chat_auth_check', () => {
+    it('checks authentication status', async () => {
+      const result = await findOp(ops, 'chat_auth_check').handler({ userId: 'u1', storagePath: '/tmp/auth.json' });
+      expect(result).toEqual({ userId: 'u1', authenticated: true, lockedOut: false });
+    });
+  });
+
+  describe('chat_auth_authenticate', () => {
+    it('authenticates user with passphrase', async () => {
+      const result = await findOp(ops, 'chat_auth_authenticate').handler({
+        userId: 'u1', passphrase: 'secret', storagePath: '/tmp/auth.json',
+      });
+      expect(result).toEqual({ userId: 'u1', success: true, lockedOut: false });
+      expect(mockAuthManager.authenticate).toHaveBeenCalledWith('u1', 'secret');
+    });
+  });
+
+  describe('chat_auth_revoke', () => {
+    it('revokes authentication', async () => {
+      const result = await findOp(ops, 'chat_auth_revoke').handler({ userId: 'u1', storagePath: '/tmp/auth.json' });
+      expect(result).toEqual({ revoked: true, userId: 'u1' });
+    });
+  });
+
+  describe('chat_auth_status', () => {
+    it('returns auth status', async () => {
+      const result = await findOp(ops, 'chat_auth_status').handler({ storagePath: '/tmp/auth.json' });
+      expect(result).toEqual({
+        enabled: true, authenticatedCount: 1,
+        authenticatedUsers: [{ userId: 'u1', authenticatedAt: 1000 }],
+      });
+    });
+  });
+
+  // ─── MCP Bridge ────────────────────────────────────────────────
+
+  describe('chat_bridge_init', () => {
+    it('initializes bridge', async () => {
+      const result = await findOp(ops, 'chat_bridge_init').handler({});
+      expect(result).toEqual({ initialized: true, toolCount: 0 });
+    });
+  });
+
+  describe('chat_bridge_register', () => {
+    it('registers a tool', async () => {
+      const result = await findOp(ops, 'chat_bridge_register').handler({
+        name: 'my-tool', description: 'A tool', inputSchema: { type: 'object' },
+      });
+      expect(result).toEqual({ registered: true, name: 'my-tool', totalTools: 1 });
+    });
+  });
+
+  describe('chat_bridge_list', () => {
+    it('returns empty when bridge not initialized', async () => {
+      expect(await findOp(ops, 'chat_bridge_list').handler({})).toEqual({ tools: [], count: 0 });
+    });
+
+    it('returns tools after init', async () => {
+      await findOp(ops, 'chat_bridge_init').handler({});
+      expect(await findOp(ops, 'chat_bridge_list').handler({})).toEqual({ tools: [{ name: 'tool1' }], count: 1 });
+    });
+  });
+
+  describe('chat_bridge_execute', () => {
+    it('returns error when not initialized', async () => {
+      expect(await findOp(ops, 'chat_bridge_execute').handler({ name: 'tool1' }))
+        .toEqual({ output: 'Bridge not initialized', isError: true });
+    });
+
+    it('executes tool after init', async () => {
+      await findOp(ops, 'chat_bridge_init').handler({});
+      expect(await findOp(ops, 'chat_bridge_execute').handler({ name: 'tool1', input: { a: 1 } }))
+        .toEqual({ output: 'result' });
+    });
+  });
+
+  describe('chat_compress_output', () => {
+    it('compresses output', async () => {
+      const result = (await findOp(ops, 'chat_compress_output').handler({
+        toolName: 'test', output: 'long output text here',
+      })) as { compressed: string; originalLength: number; compressedLength: number };
+      expect(result.originalLength).toBe(21);
+      expect(result.compressedLength).toBe(10);
+    });
+  });
+
+  // ─── Voice ─────────────────────────────────────────────────────
+
+  describe('chat_voice_transcribe', () => {
+    it('transcribes audio', async () => {
+      const result = await findOp(ops, 'chat_voice_transcribe').handler({
+        audioBase64: Buffer.from('test').toString('base64'), openaiApiKey: 'key-123',
+      });
+      expect(result).toEqual({ text: 'hello world', language: 'en' });
+    });
+  });
+
+  describe('chat_voice_synthesize', () => {
+    it('synthesizes speech', async () => {
+      const result = (await findOp(ops, 'chat_voice_synthesize').handler({
+        text: 'hello', openaiApiKey: 'key-123',
+      })) as Record<string, unknown>;
+      expect(result.success).toBe(true);
+      expect(result.audioBase64).toBeDefined();
+    });
+  });
+
+  // ─── Queue ─────────────────────────────────────────────────────
+
+  describe('chat_queue_init', () => {
+    it('initializes queue', async () => {
+      expect(await findOp(ops, 'chat_queue_init').handler({ queueDir: '/tmp/queue' }))
+        .toEqual({ initialized: true, inbox: 2, outbox: 1 });
+    });
+  });
+
+  describe('chat_queue_inbox', () => {
+    it('reads inbox', async () => {
+      const result = (await findOp(ops, 'chat_queue_inbox').handler({ queueDir: '/tmp/queue' })) as Record<string, unknown>;
+      expect(result.count).toBe(1);
+      expect(result.formatted).toBe('formatted');
+    });
+  });
+
+  describe('chat_queue_reply', () => {
+    it('sends reply', async () => {
+      expect(await findOp(ops, 'chat_queue_reply').handler({
+        messageId: 'm1', chatId: 'chat-1', text: 'response', queueDir: '/tmp/queue',
+      })).toEqual({ sent: true, response: { id: 'r1' } });
+    });
+  });
+
+  describe('chat_queue_drain', () => {
+    it('drains outbox', async () => {
+      expect(await findOp(ops, 'chat_queue_drain').handler({ queueDir: '/tmp/queue' }))
+        .toEqual({ responses: [{ id: 'r1' }], count: 1 });
+    });
+  });
+});