@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/__tests__/sessions.test.ts

@@ -1,322 +0,0 @@
-/**
- * Tests for Multi-Session Manager
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { Database } from '../compat/sqlite';
-import { SessionManager } from '../sessions/manager';
-import type { SessionEvent } from '../sessions/types';
-
-describe('SessionManager', () => {
-  let db: Database;
-  let manager: SessionManager;
-
-  beforeEach(() => {
-    db = new Database(':memory:');
-    db.exec('PRAGMA journal_mode=WAL');
-    db.exec('PRAGMA foreign_keys=ON');
-    SessionManager.resetInstance();
-    manager = new SessionManager(db);
-  });
-
-  afterEach(() => {
-    db.close();
-    SessionManager.resetInstance();
-  });
-
-  describe('create', () => {
-    it('should create a new session with defaults', () => {
-      const session = manager.create({ name: 'Test Session' });
-      expect(session.id).toBeTruthy();
-      expect(session.name).toBe('Test Session');
-      expect(session.status).toBe('active');
-      expect(session.mode).toBe('plan');
-      expect(session.tokenCount).toBe(0);
-      expect(session.costUSD).toBe(0);
-    });
-
-    it('should create a session with custom options', () => {
-      const session = manager.create({
-        name: 'Deploy Session',
-        mode: 'deploy',
-        model: 'claude-sonnet',
-        cwd: '/tmp/project',
-      });
-      expect(session.mode).toBe('deploy');
-      expect(session.model).toBe('claude-sonnet');
-      expect(session.cwd).toBe('/tmp/project');
-    });
-
-    it('should emit a created event', () => {
-      const events: SessionEvent[] = [];
-      manager.onEvent(e => events.push(e));
-      manager.create({ name: 'Test' });
-      expect(events).toHaveLength(1);
-      expect(events[0].type).toBe('created');
-    });
-  });
-
-  describe('list', () => {
-    it('should list all sessions', () => {
-      manager.create({ name: 'Session 1' });
-      manager.create({ name: 'Session 2' });
-      const sessions = manager.list();
-      expect(sessions).toHaveLength(2);
-    });
-
-    it('should filter by status', () => {
-      const _s1 = manager.create({ name: 'Active' });
-      const s2 = manager.create({ name: 'Completed' });
-      manager.complete(s2.id);
-
-      const active = manager.list('active');
-      expect(active).toHaveLength(1);
-      expect(active[0].name).toBe('Active');
-
-      const completed = manager.list('completed');
-      expect(completed).toHaveLength(1);
-      expect(completed[0].name).toBe('Completed');
-    });
-  });
-
-  describe('get', () => {
-    it('should return a session by ID', () => {
-      const created = manager.create({ name: 'Lookup Test' });
-      const fetched = manager.get(created.id);
-      expect(fetched).not.toBeNull();
-      expect(fetched!.name).toBe('Lookup Test');
-    });
-
-    it('should return null for non-existent session', () => {
-      expect(manager.get('nonexistent')).toBeNull();
-    });
-  });
-
-  describe('switchTo', () => {
-    it('should switch active session', () => {
-      const s1 = manager.create({ name: 'Session 1' });
-      const s2 = manager.create({ name: 'Session 2' });
-      manager.switchTo(s1.id);
-      expect(manager.getActiveSessionId()).toBe(s1.id);
-
-      manager.switchTo(s2.id);
-      expect(manager.getActiveSessionId()).toBe(s2.id);
-
-      // s1 should be suspended
-      const s1Updated = manager.get(s1.id);
-      expect(s1Updated!.status).toBe('suspended');
-    });
-
-    it('should return null for non-existent session', () => {
-      expect(manager.switchTo('nonexistent')).toBeNull();
-    });
-  });
-
-  describe('suspend and resume', () => {
-    it('should suspend an active session', () => {
-      const session = manager.create({ name: 'Test' });
-      manager.switchTo(session.id);
-      manager.suspend(session.id);
-
-      const updated = manager.get(session.id);
-      expect(updated!.status).toBe('suspended');
-      expect(manager.getActiveSessionId()).toBeNull();
-    });
-
-    it('should resume a suspended session', () => {
-      const session = manager.create({ name: 'Test' });
-      manager.suspend(session.id);
-      manager.resume(session.id);
-
-      const updated = manager.get(session.id);
-      expect(updated!.status).toBe('active');
-      expect(manager.getActiveSessionId()).toBe(session.id);
-    });
-
-    it('should not resume a completed session', () => {
-      const session = manager.create({ name: 'Test' });
-      manager.complete(session.id);
-      const result = manager.resume(session.id);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('complete', () => {
-    it('should mark session as completed', () => {
-      const session = manager.create({ name: 'Test' });
-      manager.switchTo(session.id);
-      manager.complete(session.id);
-
-      const updated = manager.get(session.id);
-      expect(updated!.status).toBe('completed');
-      expect(manager.getActiveSessionId()).toBeNull();
-    });
-  });
-
-  describe('destroy', () => {
-    it('should remove session from database', () => {
-      const session = manager.create({ name: 'Test' });
-      manager.destroy(session.id);
-      expect(manager.get(session.id)).toBeNull();
-    });
-  });
-
-  describe('updateSession', () => {
-    it('should update session fields', () => {
-      const session = manager.create({ name: 'Test' });
-      manager.updateSession(session.id, {
-        tokenCount: 5000,
-        costUSD: 0.05,
-        mode: 'build',
-      });
-
-      const updated = manager.get(session.id);
-      expect(updated!.tokenCount).toBe(5000);
-      expect(updated!.costUSD).toBe(0.05);
-      expect(updated!.mode).toBe('build');
-    });
-  });
-
-  describe('file conflict detection', () => {
-    it('should detect when two sessions edit the same file', () => {
-      const s1 = manager.create({ name: 'Session 1' });
-      const s2 = manager.create({ name: 'Session 2' });
-
-      manager.recordFileEdit(s1.id, '/src/index.ts');
-      const conflicts = manager.recordFileEdit(s2.id, '/src/index.ts');
-
-      expect(conflicts).toContain(s1.id);
-    });
-
-    it('should not detect conflicts for the same session', () => {
-      const s1 = manager.create({ name: 'Session 1' });
-
-      manager.recordFileEdit(s1.id, '/src/index.ts');
-      const conflicts = manager.recordFileEdit(s1.id, '/src/index.ts');
-
-      expect(conflicts).toHaveLength(0);
-    });
-
-    it('should emit file_conflict event', () => {
-      const events: SessionEvent[] = [];
-      manager.onEvent(e => events.push(e));
-
-      const s1 = manager.create({ name: 'S1' });
-      const s2 = manager.create({ name: 'S2' });
-
-      manager.recordFileEdit(s1.id, '/src/index.ts');
-      manager.recordFileEdit(s2.id, '/src/index.ts');
-
-      const conflictEvents = events.filter(e => e.type === 'file_conflict');
-      expect(conflictEvents).toHaveLength(1);
-    });
-  });
-
-  describe('event listeners', () => {
-    it('should support removing listeners', () => {
-      const events: SessionEvent[] = [];
-      const unsub = manager.onEvent(e => events.push(e));
-
-      manager.create({ name: 'Before' });
-      expect(events).toHaveLength(1);
-
-      unsub();
-      manager.create({ name: 'After' });
-      expect(events).toHaveLength(1); // No new events after unsubscribe
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // PERF-2a: Debounced SQLite write batching
-  // -------------------------------------------------------------------------
-  describe('PERF-2a: debounced SQLite flush (saveConversationAndStats)', () => {
-    let fastManager: SessionManager;
-
-    beforeEach(() => {
-      // flushDebounceMs=0 triggers immediate flush for deterministic tests
-      fastManager = new SessionManager(db, { flushDebounceMs: 0 });
-    });
-
-    it('saveConversationAndStats flushes immediately when flushDebounceMs=0', () => {
-      const session = fastManager.create({ name: 'Flush Test' });
-      const msgs = [{ role: 'user' as const, content: 'hello' }];
-      fastManager.saveConversationAndStats(session.id, msgs, { tokenCount: 10 });
-
-      const loaded = fastManager.loadConversation(session.id);
-      expect(loaded).toHaveLength(1);
-      expect(loaded[0].content).toBe('hello');
-    });
-
-    it('multiple saveConversationAndStats calls merge stats before flush', () => {
-      const session = fastManager.create({ name: 'Merge Test' });
-      const msgs = [{ role: 'user' as const, content: 'first' }];
-      // First call (with debounce=0, flushes immediately per-call)
-      fastManager.saveConversationAndStats(session.id, msgs, { tokenCount: 5 });
-      const loaded = fastManager.loadConversation(session.id);
-      expect(loaded[0].content).toBe('first');
-    });
-
-    it('flushAll() persists pending writes when called explicitly', () => {
-      // Use a high debounce so writes are pending
-      const deferredManager = new SessionManager(db, { flushDebounceMs: 60_000 });
-      const session = deferredManager.create({ name: 'Deferred' });
-      const msgs = [{ role: 'assistant' as const, content: 'deferred write' }];
-      deferredManager.saveConversationAndStats(session.id, msgs, {});
-
-      // Without flushAll, nothing is written yet
-      // (flushDebounceMs=0 manager can't verify this without timing, but we can
-      // verify flushAll itself writes correctly)
-      deferredManager.flushAll();
-
-      const loaded = deferredManager.loadConversation(session.id);
-      expect(loaded[0].content).toBe('deferred write');
-    });
-
-    it('flushAll() is a no-op when nothing is pending', () => {
-      // Should not throw
-      expect(() => fastManager.flushAll()).not.toThrow();
-    });
-
-    it('constructor accepts flushDebounceMs option', () => {
-      const m = new SessionManager(db, { flushDebounceMs: 1000 });
-      expect(m).toBeInstanceOf(SessionManager);
-    });
-  });
-});
-
-// ===========================================================================
-// M2: Session rename
-// ===========================================================================
-
-describe('SessionManager.rename (M2)', () => {
-  let renameDb: Database;
-  let renameManager: SessionManager;
-
-  beforeEach(() => {
-    renameDb = new Database(':memory:');
-    renameDb.exec('PRAGMA journal_mode=WAL');
-    renameDb.exec('PRAGMA foreign_keys=ON');
-    SessionManager.resetInstance();
-    renameManager = new SessionManager(renameDb);
-  });
-
-  afterEach(() => {
-    renameDb.close();
-    SessionManager.resetInstance();
-  });
-
-  it('rename updates the session name', () => {
-    const session = renameManager.create({ name: 'chat-2026-01-01T10:00' });
-    renameManager.rename(session.id, 'deploy-staging-app');
-    const updated = renameManager.get(session.id);
-    expect(updated?.name).toBe('deploy-staging-app');
-  });
-
-  it('rename is a no-op for non-existent session (no throw)', () => {
-    expect(() => renameManager.rename('non-existent-id', 'new-name')).not.toThrow();
-  });
-
-  it('rename accepts empty string', () => {
-    const session = renameManager.create({ name: 'original' });
-    expect(() => renameManager.rename(session.id, '')).not.toThrow();
-  });
-});

package/src/__tests__/sharing.test.ts

@@ -1,340 +0,0 @@
-/**
- * Tests for Session Sharing
- */
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import {
-  shareSession,
-  getSharedSession,
-  listShares,
-  deleteShare,
-  getShareUrl,
-  cleanupExpiredShares,
-  _deps,
-  type SharedSession,
-} from '../sharing/sync';
-import { generateShareViewer } from '../sharing/viewer';
-
-// ---------------------------------------------------------------------------
-// Mock data
-// ---------------------------------------------------------------------------
-
-const mockSession = {
-  id: 'test-session-id',
-  name: 'Test Session',
-  mode: 'build',
-  model: 'claude-sonnet',
-  status: 'active',
-  costUSD: 0.05,
-  tokenCount: 5000,
-  createdAt: new Date().toISOString(),
-  updatedAt: new Date().toISOString(),
-};
-
-const mockMessages = [
-  { role: 'user' as const, content: 'Hello' },
-  { role: 'assistant' as const, content: 'Hi there!' },
-];
-
-// ---------------------------------------------------------------------------
-// Inject test dependencies (no module-level mocks — avoids cross-file leaks)
-// ---------------------------------------------------------------------------
-
-/** Minimal in-memory DB that mimics the SQLite API used by sharing/sync.ts */
-function makeInMemoryDb() {
-  const rows = new Map<string, any>();
-
-  return {
-    run(sql: string, params: any[]) {
-      if (/INSERT INTO shares/.test(sql)) {
-        const [id, session_id, name, messages, model, mode, cost_usd, token_count, is_live, write_token, created_at, expires_at] = params;
-        rows.set(id, { id, session_id, name, messages, model, mode, cost_usd, token_count, is_live, write_token, created_at, expires_at });
-        return { changes: 1 };
-      } else if (/UPDATE shares SET messages/.test(sql)) {
-        const [messages, id] = params;
-        const row = rows.get(id);
-        if (row) { row.messages = messages; return { changes: 1 }; }
-        return { changes: 0 };
-      } else if (/DELETE FROM shares WHERE expires_at/.test(sql)) {
-        const [now] = params;
-        let count = 0;
-        for (const [id, row] of rows) {
-          if (row.expires_at <= now) { rows.delete(id); count++; }
-        }
-        return { changes: count };
-      } else if (/DELETE FROM shares WHERE id/.test(sql)) {
-        const [id] = params;
-        const existed = rows.has(id);
-        rows.delete(id);
-        return { changes: existed ? 1 : 0 };
-      }
-      return { changes: 0 };
-    },
-    query(sql: string) {
-      return {
-        get(...params: any[]) {
-          if (/WHERE id = \? AND expires_at/.test(sql)) {
-            const [id, now] = params;
-            const row = rows.get(id);
-            return row && row.expires_at > now ? row : undefined;
-          }
-          return undefined;
-        },
-        all(..._params: any[]) {
-          // listShares uses DELETE first then SELECT with ORDER BY (no WHERE params)
-          return [...rows.values()];
-        },
-      };
-    },
-  };
-}
-
-beforeEach(() => {
-  const db = makeInMemoryDb();
-  _deps.getDb = () => db;
-  _deps.getConversation = (id: string) =>
-    id === 'test-session-id' ? { messages: mockMessages } : null;
-  _deps.getSessionManager = () => ({
-    get: (id: string) => (id === 'test-session-id' ? mockSession : null),
-  });
-});
-
-afterEach(() => {
-  _deps.getDb = undefined;
-  _deps.getConversation = undefined;
-  _deps.getSessionManager = undefined;
-});
-
-// ---------------------------------------------------------------------------
-// shareSession
-// ---------------------------------------------------------------------------
-
-describe('shareSession', () => {
-  test('creates a share for a valid session', () => {
-    const shared = shareSession('test-session-id');
-    expect(shared).not.toBeNull();
-    expect(shared!.id).toBeTruthy();
-    expect(shared!.sessionId).toBe('test-session-id');
-    expect(shared!.name).toBe('Test Session');
-    expect(shared!.messages).toEqual(mockMessages);
-    expect(shared!.model).toBe('claude-sonnet');
-    expect(shared!.mode).toBe('build');
-    expect(shared!.costUSD).toBe(0.05);
-    expect(shared!.tokenCount).toBe(5000);
-    expect(shared!.isLive).toBe(false);
-    expect(shared!.expiresAt).toBeTruthy();
-    expect(shared!.writeToken).toBeTruthy();
-  });
-
-  test('returns null for non-existent session', () => {
-    const shared = shareSession('nonexistent-id');
-    expect(shared).toBeNull();
-  });
-
-  test('respects isLive option', () => {
-    const shared = shareSession('test-session-id', { isLive: true });
-    expect(shared).not.toBeNull();
-    expect(shared!.isLive).toBe(true);
-  });
-
-  test('respects custom ttlDays', () => {
-    const shared = shareSession('test-session-id', { ttlDays: 7 });
-    expect(shared).not.toBeNull();
-    const expiresAt = new Date(shared!.expiresAt);
-    const now = new Date();
-    const diffDays = (expiresAt.getTime() - now.getTime()) / (1000 * 60 * 60 * 24);
-    // Should expire in approximately 7 days (allow some tolerance for execution time)
-    expect(diffDays).toBeGreaterThan(6.9);
-    expect(diffDays).toBeLessThan(7.1);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getSharedSession
-// ---------------------------------------------------------------------------
-
-describe('getSharedSession', () => {
-  test('returns the shared session without writeToken', () => {
-    const created = shareSession('test-session-id');
-    expect(created).not.toBeNull();
-
-    const retrieved = getSharedSession(created!.id);
-    expect(retrieved).not.toBeNull();
-    expect(retrieved!.id).toBe(created!.id);
-    expect(retrieved!.sessionId).toBe('test-session-id');
-    expect(retrieved!.name).toBe('Test Session');
-    // The writeToken should NOT be present in the public view
-    expect(retrieved!.writeToken).toBeUndefined();
-  });
-
-  test('returns null for non-existent share', () => {
-    const result = getSharedSession('does-not-exist');
-    expect(result).toBeNull();
-  });
-
-  test('returns null for expired shares', () => {
-    // Create a share with a very short TTL, then manipulate its expiry
-    const created = shareSession('test-session-id', { ttlDays: 0 });
-    expect(created).not.toBeNull();
-
-    // The share was created with ttlDays: 0, which means it expires immediately
-    // Access the internal store to verify expiry behavior
-    // Since ttlDays is 0, expiry = now + 0 days = now, which is already expired
-    const result = getSharedSession(created!.id);
-    expect(result).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// listShares
-// ---------------------------------------------------------------------------
-
-describe('listShares', () => {
-  test('returns an array of shares', () => {
-    const shares = listShares();
-    expect(Array.isArray(shares)).toBe(true);
-  });
-
-  test('filters out expired shares', () => {
-    // Create a valid share
-    const valid = shareSession('test-session-id', { ttlDays: 30 });
-    expect(valid).not.toBeNull();
-
-    // Create a share that expires immediately
-    const expired = shareSession('test-session-id', { ttlDays: 0 });
-    expect(expired).not.toBeNull();
-
-    const shares = listShares();
-    const ids = shares.map(s => s.id);
-
-    // The valid share should be in the list
-    expect(ids).toContain(valid!.id);
-    // The expired share should NOT be in the list
-    expect(ids).not.toContain(expired!.id);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// deleteShare
-// ---------------------------------------------------------------------------
-
-describe('deleteShare', () => {
-  test('removes a share and returns true', () => {
-    const created = shareSession('test-session-id');
-    expect(created).not.toBeNull();
-
-    const deleted = deleteShare(created!.id);
-    expect(deleted).toBe(true);
-
-    // Verify it is gone
-    const result = getSharedSession(created!.id);
-    expect(result).toBeNull();
-  });
-
-  test('returns false for non-existent share', () => {
-    expect(deleteShare('nonexistent')).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// cleanupExpiredShares
-// ---------------------------------------------------------------------------
-
-describe('cleanupExpiredShares', () => {
-  test('removes expired shares and returns count', () => {
-    // Create an immediately-expiring share
-    shareSession('test-session-id', { ttlDays: 0 });
-
-    const cleaned = cleanupExpiredShares();
-    expect(typeof cleaned).toBe('number');
-    expect(cleaned).toBeGreaterThanOrEqual(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getShareUrl
-// ---------------------------------------------------------------------------
-
-describe('getShareUrl', () => {
-  test('generates URL with default base', () => {
-    const url = getShareUrl('abc123');
-    expect(url).toBe('http://localhost:6001/nimbus/share/abc123');
-  });
-
-  test('generates URL with custom base', () => {
-    const url = getShareUrl('abc123', 'https://astron.dev');
-    expect(url).toBe('https://astron.dev/nimbus/share/abc123');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// generateShareViewer
-// ---------------------------------------------------------------------------
-
-describe('generateShareViewer', () => {
-  const mockSharedSession: SharedSession = {
-    id: 'test-share-id',
-    sessionId: 'session-123',
-    name: 'Test Session',
-    messages: [
-      { role: 'user', content: 'Hello' },
-      { role: 'assistant', content: 'Hi there! How can I help?' },
-      { role: 'user', content: 'Deploy my app' },
-      { role: 'assistant', content: 'I will help you deploy your application.' },
-    ],
-    model: 'claude-sonnet',
-    mode: 'build',
-    costUSD: 0.0042,
-    tokenCount: 1500,
-    createdAt: new Date().toISOString(),
-    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
-    isLive: false,
-  };
-
-  test('generates valid HTML', () => {
-    const html = generateShareViewer(mockSharedSession);
-    expect(html).toContain('<!DOCTYPE html>');
-    expect(html).toContain('Nimbus');
-    expect(html).toContain('Test Session');
-    expect(html).toContain('claude-sonnet');
-    expect(html).toContain('build');
-  });
-
-  test('escapes HTML entities', () => {
-    const session: SharedSession = {
-      ...mockSharedSession,
-      messages: [
-        { role: 'user', content: '<script>alert("xss")</script>' },
-        { role: 'assistant', content: 'Safe response & "quotes"' },
-      ],
-    };
-    const html = generateShareViewer(session);
-    expect(html).not.toContain('<script>alert');
-    expect(html).toContain('&lt;script&gt;');
-    expect(html).toContain('&amp;');
-    expect(html).toContain('&quot;quotes&quot;');
-  });
-
-  test('shows LIVE badge when isLive=true', () => {
-    const liveSession = { ...mockSharedSession, isLive: true };
-    const html = generateShareViewer(liveSession);
-    expect(html).toContain('LIVE');
-  });
-
-  test('does not show LIVE badge when isLive=false', () => {
-    const html = generateShareViewer(mockSharedSession);
-    expect(html).not.toContain('LIVE');
-  });
-
-  test('includes expiry information', () => {
-    const html = generateShareViewer(mockSharedSession);
-    expect(html).toContain('Expires');
-  });
-
-  test('includes all user and assistant messages', () => {
-    const html = generateShareViewer(mockSharedSession);
-    expect(html).toContain('Hello');
-    expect(html).toContain('Hi there! How can I help?');
-    expect(html).toContain('Deploy my app');
-    expect(html).toContain('I will help you deploy your application.');
-  });
-});