claude-code-swarm 0.3.2 → 0.3.4

package/references/openhive/src/__tests__/bridge/manager.test.ts

@@ -1,419 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, afterEach, vi } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { initDatabase, closeDatabase } from '../../db/index.js';
-import * as bridgeDAL from '../../db/dal/bridge.js';
-import { encryptCredentials } from '../../bridge/credentials.js';
-import { BridgeManager } from '../../bridge/manager.js';
-import type { BridgeAdapter, InboundMessage, AdapterConfig, PlatformDestination, OutboundMessage } from '../../bridge/types.js';
-
-// Mock broadcastToChannel
-vi.mock('../../realtime/index.js', () => ({
-  broadcastToChannel: vi.fn(),
-}));
-
-const TEST_DB_PATH = path.join(process.cwd(), 'test-manager.db');
-const ENCRYPTION_KEY = 'test-manager-encryption-key';
-
-function createTestAgent(db: ReturnType<typeof import('better-sqlite3')>, name: string): string {
-  const id = `agent_${name}`;
-  db.prepare(`
-    INSERT OR IGNORE INTO agents (id, name, account_type) VALUES (?, ?, 'human')
-  `).run(id, name);
-  return id;
-}
-
-/**
- * Create a mock adapter that yields messages from a controllable queue.
- */
-function createMockAdapter(): BridgeAdapter & {
-  pushMessage: (msg: InboundMessage) => void;
-  sentMessages: Array<{ destination: PlatformDestination; message: OutboundMessage }>;
-  closeStream: () => void;
-  connectCalls: number;
-  disconnectCalls: number;
-  lastConfig: AdapterConfig | null;
-} {
-  let messageResolve: ((value: IteratorResult<InboundMessage>) => void) | null = null;
-  const messageQueue: InboundMessage[] = [];
-  let streamClosed = false;
-  const sentMessages: Array<{ destination: PlatformDestination; message: OutboundMessage }> = [];
-  let connectCalls = 0;
-  let disconnectCalls = 0;
-  let lastConfig: AdapterConfig | null = null;
-
-  const adapter: BridgeAdapter & {
-    pushMessage: (msg: InboundMessage) => void;
-    sentMessages: typeof sentMessages;
-    closeStream: () => void;
-    connectCalls: number;
-    disconnectCalls: number;
-    lastConfig: AdapterConfig | null;
-  } = {
-    platform: 'slack',
-    sentMessages,
-
-    get connectCalls() { return connectCalls; },
-    get disconnectCalls() { return disconnectCalls; },
-    get lastConfig() { return lastConfig; },
-
-    async connect(config: AdapterConfig) {
-      connectCalls++;
-      lastConfig = config;
-    },
-
-    messages(): AsyncIterable<InboundMessage> {
-      return {
-        [Symbol.asyncIterator]() {
-          return {
-            next(): Promise<IteratorResult<InboundMessage>> {
-              if (streamClosed) {
-                return Promise.resolve({ done: true, value: undefined });
-              }
-              if (messageQueue.length > 0) {
-                return Promise.resolve({ done: false, value: messageQueue.shift()! });
-              }
-              return new Promise((resolve) => {
-                messageResolve = resolve;
-              });
-            },
-          };
-        },
-      };
-    },
-
-    async send(destination: PlatformDestination, message: OutboundMessage) {
-      sentMessages.push({ destination, message });
-    },
-
-    async disconnect() {
-      disconnectCalls++;
-      streamClosed = true;
-      if (messageResolve) {
-        messageResolve({ done: true, value: undefined });
-        messageResolve = null;
-      }
-    },
-
-    pushMessage(msg: InboundMessage) {
-      if (messageResolve) {
-        messageResolve({ done: false, value: msg });
-        messageResolve = null;
-      } else {
-        messageQueue.push(msg);
-      }
-    },
-
-    closeStream() {
-      streamClosed = true;
-      if (messageResolve) {
-        messageResolve({ done: true, value: undefined });
-        messageResolve = null;
-      }
-    },
-  };
-
-  return adapter;
-}
-
-describe('BridgeManager', () => {
-  let db: ReturnType<typeof import('better-sqlite3')>;
-  let testAgentId: string;
-  let manager: BridgeManager;
-  let mockAdapter: ReturnType<typeof createMockAdapter>;
-
-  beforeAll(() => {
-    if (fs.existsSync(TEST_DB_PATH)) fs.unlinkSync(TEST_DB_PATH);
-    db = initDatabase(TEST_DB_PATH);
-    testAgentId = createTestAgent(db, 'manager-test-owner');
-  });
-
-  afterEach(async () => {
-    if (manager) {
-      await manager.stopAll();
-    }
-  });
-
-  afterAll(() => {
-    closeDatabase();
-    if (fs.existsSync(TEST_DB_PATH)) fs.unlinkSync(TEST_DB_PATH);
-  });
-
-  function createManager(): BridgeManager {
-    manager = new BridgeManager({
-      maxBridges: 5,
-      credentialEncryptionKey: ENCRYPTION_KEY,
-    });
-    mockAdapter = createMockAdapter();
-    manager.registerAdapter('slack', () => mockAdapter);
-    return manager;
-  }
-
-  function createTestBridge(name: string, status: 'active' | 'inactive' = 'inactive'): string {
-    const encrypted = encryptCredentials({ bot_token: 'xoxb-test' }, ENCRYPTION_KEY);
-    const bridge = bridgeDAL.createBridge({
-      name,
-      platform: 'slack',
-      transport_mode: 'outbound',
-      credentials_encrypted: encrypted,
-      owner_agent_id: testAgentId,
-    });
-    if (status === 'active') {
-      bridgeDAL.updateBridge(bridge.id, { status: 'active' });
-    }
-    return bridge.id;
-  }
-
-  // ── Adapter registration ──
-
-  it('registers adapter factories', () => {
-    const mgr = createManager();
-    expect(() => mgr.registerAdapter('discord', () => createMockAdapter())).not.toThrow();
-  });
-
-  // ── Starting bridges ──
-
-  it('starts a bridge successfully', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('start-test');
-
-    await mgr.startBridge(bridgeId);
-
-    expect(mgr.runningCount).toBe(1);
-    const status = mgr.getBridgeStatus(bridgeId);
-    expect(status).not.toBeNull();
-    expect(status!.status).toBe('connected');
-    expect(mockAdapter.connectCalls).toBe(1);
-  });
-
-  it('decrypts credentials and passes them to adapter', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('cred-test');
-
-    await mgr.startBridge(bridgeId);
-
-    expect(mockAdapter.lastConfig).not.toBeNull();
-    expect(mockAdapter.lastConfig!.credentials.bot_token).toBe('xoxb-test');
-  });
-
-  it('throws when starting an already-running bridge', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('dupe-test');
-
-    await mgr.startBridge(bridgeId);
-    await expect(mgr.startBridge(bridgeId)).rejects.toThrow('already running');
-  });
-
-  it('throws when bridge not found', async () => {
-    const mgr = createManager();
-    await expect(mgr.startBridge('nonexistent')).rejects.toThrow('not found');
-  });
-
-  it('throws when no adapter registered for platform', async () => {
-    manager = new BridgeManager({
-      maxBridges: 5,
-      credentialEncryptionKey: ENCRYPTION_KEY,
-    });
-    // Don't register any adapters
-
-    const encrypted = encryptCredentials({ token: 'test' }, ENCRYPTION_KEY);
-    const bridge = bridgeDAL.createBridge({
-      name: 'no-adapter-test',
-      platform: 'discord',
-      transport_mode: 'outbound',
-      credentials_encrypted: encrypted,
-      owner_agent_id: testAgentId,
-    });
-
-    await expect(manager.startBridge(bridge.id)).rejects.toThrow('No adapter registered');
-  });
-
-  it('enforces max bridges limit', async () => {
-    manager = new BridgeManager({
-      maxBridges: 1,
-      credentialEncryptionKey: ENCRYPTION_KEY,
-    });
-    manager.registerAdapter('slack', () => createMockAdapter());
-
-    const id1 = createTestBridge('limit-1');
-    const id2 = createTestBridge('limit-2');
-
-    await manager.startBridge(id1);
-    await expect(manager.startBridge(id2)).rejects.toThrow('Maximum bridge limit');
-  });
-
-  it('throws when encryption key not configured', async () => {
-    manager = new BridgeManager({ maxBridges: 5 });
-    manager.registerAdapter('slack', () => createMockAdapter());
-    const bridgeId = createTestBridge('no-key-test');
-
-    await expect(manager.startBridge(bridgeId)).rejects.toThrow('encryption key not configured');
-  });
-
-  // ── Stopping bridges ──
-
-  it('stops a running bridge', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('stop-test');
-
-    await mgr.startBridge(bridgeId);
-    expect(mgr.runningCount).toBe(1);
-
-    await mgr.stopBridge(bridgeId);
-    expect(mgr.runningCount).toBe(0);
-    expect(mockAdapter.disconnectCalls).toBe(1);
-
-    // Check DB status was updated
-    const config = bridgeDAL.getBridge(bridgeId);
-    expect(config!.status).toBe('inactive');
-  });
-
-  it('stopAll stops all bridges', async () => {
-    const mgr = createManager();
-    const id1 = createTestBridge('stopall-1');
-    const id2 = createTestBridge('stopall-2');
-
-    // Need separate adapters for each
-    let adapterCount = 0;
-    manager.registerAdapter('slack', () => {
-      adapterCount++;
-      return createMockAdapter();
-    });
-
-    await mgr.startBridge(id1);
-    await mgr.startBridge(id2);
-    expect(mgr.runningCount).toBe(2);
-
-    await mgr.stopAll();
-    expect(mgr.runningCount).toBe(0);
-  });
-
-  it('stopBridge is safe to call on non-running bridge', async () => {
-    const mgr = createManager();
-    await expect(mgr.stopBridge('nonexistent')).resolves.toBeUndefined();
-  });
-
-  // ── Status ──
-
-  it('returns status for running bridge', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('status-test');
-
-    await mgr.startBridge(bridgeId);
-    const status = mgr.getBridgeStatus(bridgeId);
-
-    expect(status).not.toBeNull();
-    expect(status!.name).toBe('status-test');
-    expect(status!.platform).toBe('slack');
-    expect(status!.status).toBe('connected');
-  });
-
-  it('returns disconnected status for non-running bridge', () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('status-stopped');
-    const status = mgr.getBridgeStatus(bridgeId);
-
-    expect(status).not.toBeNull();
-    expect(status!.status).toBe('disconnected');
-  });
-
-  it('returns null for non-existent bridge', () => {
-    const mgr = createManager();
-    expect(mgr.getBridgeStatus('nonexistent')).toBeNull();
-  });
-
-  // ── Outbound relay ──
-
-  it('relays hive events to connected bridges', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('outbound-relay');
-
-    bridgeDAL.addChannelMapping(bridgeId, {
-      platform_channel_id: 'C_RELAY',
-      hive_name: 'general',
-      direction: 'bidirectional',
-    });
-
-    // Re-register adapter so it gets the mappings
-    mockAdapter = createMockAdapter();
-    mgr.registerAdapter('slack', () => mockAdapter);
-
-    await mgr.startBridge(bridgeId);
-
-    mgr.notifyHiveEvent({
-      type: 'new_post',
-      postId: 'post_relay_1',
-      authorId: testAgentId,
-      authorName: 'Test User',
-      hiveName: 'general',
-      title: 'Relayed Post',
-      content: 'This should be relayed',
-    });
-
-    // Give the async send a moment
-    await new Promise(r => setTimeout(r, 50));
-
-    expect(mockAdapter.sentMessages.length).toBe(1);
-    expect(mockAdapter.sentMessages[0].destination.platformChannelId).toBe('C_RELAY');
-    expect(mockAdapter.sentMessages[0].message.text).toContain('Relayed Post');
-  });
-
-  it('skips outbound relay for disconnected bridges', async () => {
-    const mgr = createManager();
-
-    // Don't start any bridge, just call notifyHiveEvent
-    mgr.notifyHiveEvent({
-      type: 'new_post',
-      postId: 'post_skip',
-      authorId: testAgentId,
-      authorName: 'Test',
-      hiveName: 'general',
-      content: 'Should not relay',
-    });
-
-    // No error thrown, no messages sent
-  });
-
-  // ── Mapping reload ──
-
-  it('reloads channel mappings for running bridge', async () => {
-    const mgr = createManager();
-    const bridgeId = createTestBridge('reload-mappings');
-
-    await mgr.startBridge(bridgeId);
-
-    // Initially no mappings
-    let status = mgr.getBridgeStatus(bridgeId);
-    expect(status!.channelCount).toBe(0);
-
-    // Add a mapping
-    bridgeDAL.addChannelMapping(bridgeId, {
-      platform_channel_id: 'C_NEW',
-      hive_name: 'general',
-    });
-
-    // Reload
-    mgr.reloadMappings(bridgeId);
-
-    status = mgr.getBridgeStatus(bridgeId);
-    expect(status!.channelCount).toBe(1);
-  });
-
-  // ── startAll ──
-
-  it('starts all active bridges on startup', async () => {
-    const mgr = createManager();
-    const activeId = createTestBridge('startall-active', 'active');
-    createTestBridge('startall-inactive', 'inactive');
-
-    // Need separate adapters
-    mgr.registerAdapter('slack', () => createMockAdapter());
-
-    await mgr.startAll();
-
-    // Only the active bridge should start
-    expect(mgr.runningCount).toBe(1);
-    const status = mgr.getBridgeStatus(activeId);
-    expect(status!.status).toBe('connected');
-  });
-});

package/references/openhive/src/__tests__/bridge/mentions.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractMentions } from '../../bridge/mentions.js';
-
-describe('Bridge Mention Extraction', () => {
-  it('extracts @mentions from text', () => {
-    const result = extractMentions('@infra-swarm check worker-3');
-    expect(result).toEqual(['infra-swarm']);
-  });
-
-  it('extracts multiple mentions', () => {
-    const result = extractMentions('@infra-swarm @research-bot please investigate');
-    expect(result).toContain('infra-swarm');
-    expect(result).toContain('research-bot');
-    expect(result).toHaveLength(2);
-  });
-
-  it('handles mentions mid-sentence', () => {
-    const result = extractMentions('hey @infra-swarm can you check this?');
-    expect(result).toEqual(['infra-swarm']);
-  });
-
-  it('handles underscores in names', () => {
-    const result = extractMentions('@my_swarm do something');
-    expect(result).toEqual(['my_swarm']);
-  });
-
-  it('normalizes to lowercase', () => {
-    const result = extractMentions('@InfraSwarm check this');
-    expect(result).toEqual(['infraswarm']);
-  });
-
-  it('deduplicates text mentions', () => {
-    const result = extractMentions('@swarm do this @swarm and that');
-    expect(result).toEqual(['swarm']);
-  });
-
-  it('merges with adapter-provided mentions', () => {
-    const result = extractMentions(
-      'check worker-3',
-      ['infra-swarm'],
-    );
-    expect(result).toEqual(['infra-swarm']);
-  });
-
-  it('deduplicates text mentions with adapter mentions', () => {
-    const result = extractMentions(
-      '@infra-swarm check worker-3',
-      ['infra-swarm'],
-    );
-    expect(result).toEqual(['infra-swarm']);
-  });
-
-  it('combines text and adapter mentions', () => {
-    const result = extractMentions(
-      '@research-bot look into this',
-      ['infra-swarm'],
-    );
-    expect(result).toContain('infra-swarm');
-    expect(result).toContain('research-bot');
-    expect(result).toHaveLength(2);
-  });
-
-  it('returns empty array for no mentions', () => {
-    const result = extractMentions('just a regular message');
-    expect(result).toEqual([]);
-  });
-
-  it('does not match email addresses as mentions', () => {
-    const result = extractMentions('send to user@example.com');
-    // user@example.com should not be extracted — @ is not at a word boundary start
-    expect(result).toEqual([]);
-  });
-
-  it('handles empty text', () => {
-    const result = extractMentions('');
-    expect(result).toEqual([]);
-  });
-
-  it('handles mention at start of text', () => {
-    const result = extractMentions('@swarm-alpha hello');
-    expect(result).toEqual(['swarm-alpha']);
-  });
-});

package/references/openhive/src/__tests__/bridge/outbound.test.ts

@@ -1,209 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { initDatabase, closeDatabase } from '../../db/index.js';
-import * as bridgeDAL from '../../db/dal/bridge.js';
-import { processOutboundEvent, type HiveEvent } from '../../bridge/outbound.js';
-import type { BridgeConfig, ChannelMapping } from '../../bridge/types.js';
-
-const TEST_DB_PATH = path.join(process.cwd(), 'test-outbound.db');
-
-function createTestAgent(db: ReturnType<typeof import('better-sqlite3')>, name: string): string {
-  const id = `agent_${name}`;
-  db.prepare(`
-    INSERT OR IGNORE INTO agents (id, name, account_type) VALUES (?, ?, 'human')
-  `).run(id, name);
-  return id;
-}
-
-describe('Outbound Pipeline', () => {
-  let db: ReturnType<typeof import('better-sqlite3')>;
-  let testAgentId: string;
-  let proxyAgentId: string;
-  let bridgeConfig: BridgeConfig;
-  let mappings: ChannelMapping[];
-
-  beforeAll(() => {
-    if (fs.existsSync(TEST_DB_PATH)) fs.unlinkSync(TEST_DB_PATH);
-    db = initDatabase(TEST_DB_PATH);
-    testAgentId = createTestAgent(db, 'outbound-test-owner');
-    proxyAgentId = createTestAgent(db, 'proxy-slack-user');
-
-    // Create a bridge
-    bridgeConfig = bridgeDAL.createBridge({
-      name: 'outbound-test-slack',
-      platform: 'slack',
-      transport_mode: 'outbound',
-      credentials_encrypted: 'encrypted',
-      owner_agent_id: testAgentId,
-    });
-
-    // Create channel mappings
-    const bidir = bridgeDAL.addChannelMapping(bridgeConfig.id, {
-      platform_channel_id: 'C_BIDIR',
-      platform_channel_name: '#general',
-      hive_name: 'general',
-      direction: 'bidirectional',
-    });
-
-    const inboundOnly = bridgeDAL.addChannelMapping(bridgeConfig.id, {
-      platform_channel_id: 'C_INONLY',
-      hive_name: 'general',
-      direction: 'inbound',
-    });
-
-    const outboundOnly = bridgeDAL.addChannelMapping(bridgeConfig.id, {
-      platform_channel_id: 'C_OUTONLY',
-      hive_name: 'general',
-      direction: 'outbound',
-    });
-
-    mappings = [bidir, inboundOnly, outboundOnly];
-
-    // Register the proxy agent
-    bridgeDAL.createProxyAgent({
-      bridge_id: bridgeConfig.id,
-      platform_user_id: 'U_PROXY',
-      agent_id: proxyAgentId,
-      platform_display_name: 'Slack User',
-    });
-  });
-
-  afterAll(() => {
-    closeDatabase();
-    if (fs.existsSync(TEST_DB_PATH)) fs.unlinkSync(TEST_DB_PATH);
-  });
-
-  function makeEvent(overrides: Partial<HiveEvent> = {}): HiveEvent {
-    return {
-      type: 'new_post',
-      postId: 'post_123',
-      authorId: testAgentId,
-      authorName: 'Test Agent',
-      hiveName: 'general',
-      title: 'Test Post',
-      content: 'Test content from OpenHive',
-      ...overrides,
-    };
-  }
-
-  // ── Echo prevention ──
-
-  it('skips events from proxy agents (echo prevention)', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      authorId: proxyAgentId,
-    }));
-    expect(actions).toHaveLength(0);
-  });
-
-  // ── Direction filtering ──
-
-  it('skips inbound-only channel mappings', () => {
-    // Only bidirectional and outbound mappings should produce actions
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent());
-    const channelIds = actions.map(a => a.destination.platformChannelId);
-    expect(channelIds).not.toContain('C_INONLY');
-  });
-
-  it('includes bidirectional channel mappings', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent());
-    const channelIds = actions.map(a => a.destination.platformChannelId);
-    expect(channelIds).toContain('C_BIDIR');
-  });
-
-  it('includes outbound-only channel mappings', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent());
-    const channelIds = actions.map(a => a.destination.platformChannelId);
-    expect(channelIds).toContain('C_OUTONLY');
-  });
-
-  // ── Post formatting ──
-
-  it('formats a post with title and content', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      title: 'My Title',
-      content: 'My Content',
-    }));
-    expect(actions.length).toBeGreaterThan(0);
-    const msg = actions[0].message;
-    expect(msg.text).toContain('**Test Agent**');
-    expect(msg.text).toContain('*My Title*');
-    expect(msg.text).toContain('My Content');
-  });
-
-  it('formats a post where title equals content', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      title: 'Same text',
-      content: 'Same text',
-    }));
-    expect(actions.length).toBeGreaterThan(0);
-    const msg = actions[0].message;
-    expect(msg.text).toBe('**Test Agent**: Same text');
-  });
-
-  // ── Comment formatting ──
-
-  it('formats a comment event', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      type: 'new_comment',
-      commentId: 'comment_456',
-      content: 'A comment',
-    }));
-    expect(actions.length).toBeGreaterThan(0);
-    const msg = actions[0].message;
-    expect(msg.text).toBe('**Test Agent**: A comment');
-  });
-
-  // ── Thread context ──
-
-  it('includes thread context for comments when mapping exists', () => {
-    // Look up the actual hive ID from seed data
-    const hive = db.prepare("SELECT id FROM hives WHERE name = 'general'").get() as { id: string };
-
-    // Create a post that has a message mapping
-    db.prepare(`
-      INSERT OR IGNORE INTO posts (id, hive_id, author_id, title) VALUES ('post_thread_test', ?, ?, 'Thread Test')
-    `).run(hive.id, testAgentId);
-
-    bridgeDAL.recordMessageMapping({
-      bridge_id: bridgeConfig.id,
-      platform_message_id: 'slack_msg_parent',
-      platform_channel_id: 'C_BIDIR',
-      post_id: 'post_thread_test',
-    });
-
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      type: 'new_comment',
-      postId: 'post_thread_test',
-      commentId: 'comment_789',
-      content: 'Threaded reply',
-    }));
-
-    const bidirAction = actions.find(a => a.destination.platformChannelId === 'C_BIDIR');
-    expect(bidirAction).toBeDefined();
-    expect(bidirAction!.destination.threadId).toBe('slack_msg_parent');
-  });
-
-  it('sends without thread context when no mapping exists', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      type: 'new_comment',
-      postId: 'post_no_mapping',
-      commentId: 'comment_no_map',
-      content: 'No thread context',
-    }));
-
-    expect(actions.length).toBeGreaterThan(0);
-    for (const action of actions) {
-      expect(action.destination.threadId).toBeUndefined();
-    }
-  });
-
-  // ── Non-matching hive ──
-
-  it('returns no actions for unmapped hives', () => {
-    const actions = processOutboundEvent(bridgeConfig, mappings, makeEvent({
-      hiveName: 'some-other-hive',
-    }));
-    expect(actions).toHaveLength(0);
-  });
-});