claude-code-swarm 0.0.1 → 0.3.3

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

@@ -0,0 +1,305 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import * as path from 'path';
+import { initDatabase, closeDatabase } from '../../db/index.js';
+import * as agentsDAL from '../../db/dal/agents.js';
+import * as hivesDAL from '../../db/dal/hives.js';
+import { SwarmManager, SwarmHostingError } from '../../swarm/manager.js';
+import * as dal from '../../swarm/dal.js';
+import type { SwarmHostingConfig } from '../../swarm/types.js';
+import { testRoot, testDbPath, cleanTestRoot } from '../helpers/test-dirs.js';
+
+const TEST_ROOT = testRoot('swarm-manager');
+const TEST_DB_PATH = testDbPath(TEST_ROOT, 'swarm-manager-test.db');
+const TEST_DATA_DIR = path.join(TEST_ROOT, 'swarm-manager-data');
+const FIXTURES_DIR = path.resolve(__dirname, 'fixtures');
+const SLEEP_SCRIPT = path.join(FIXTURES_DIR, 'sleep-server.js');
+
+function createTestConfig(overrides?: Partial<SwarmHostingConfig>): SwarmHostingConfig {
+  return {
+    enabled: true,
+    default_provider: 'local',
+    openswarm_command: `node ${SLEEP_SCRIPT}`,
+    data_dir: TEST_DATA_DIR,
+    port_range: [19100, 19110],
+    max_swarms: 3,
+    health_check_interval: 60000, // long interval so it doesn't interfere with tests
+    max_health_failures: 3,
+    auto_restart: false,
+    max_restart_attempts: 3,
+    ...overrides,
+  };
+}
+
+describe('SwarmManager', () => {
+  let agentId: string;
+  let agentApiKey: string;
+  let hiveAgentId: string;
+
+  beforeAll(async () => {
+    initDatabase(TEST_DB_PATH);
+
+    const agentResult = await agentsDAL.createAgent({
+      name: 'manager-test-agent',
+      description: 'Agent for manager tests',
+    });
+    agentId = agentResult.agent.id;
+    agentApiKey = agentResult.apiKey;
+
+    // Create a second agent for ownership tests
+    const hiveAgentResult = await agentsDAL.createAgent({
+      name: 'hive-owner-agent',
+      description: 'Agent that owns a hive',
+    });
+    hiveAgentId = hiveAgentResult.agent.id;
+
+    // Create a test hive
+    hivesDAL.createHive({
+      name: 'test-hive',
+      description: 'A test hive for swarm manager tests',
+      owner_id: hiveAgentId,
+    });
+  });
+
+  afterAll(() => {
+    closeDatabase();
+    cleanTestRoot(TEST_ROOT);
+  });
+
+  describe('spawn error paths', () => {
+    it('should reject when max_swarms is reached', async () => {
+      const config = createTestConfig({ max_swarms: 0 });
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        await expect(
+          manager.spawn(agentId, { name: 'too-many' })
+        ).rejects.toThrow(SwarmHostingError);
+
+        await expect(
+          manager.spawn(agentId, { name: 'too-many' })
+        ).rejects.toThrow(/Maximum of 0/);
+      } finally {
+        await manager.shutdown();
+      }
+    });
+
+    it('should reject for unsupported provider', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        await expect(
+          manager.spawn(agentId, { name: 'bad-provider', provider: 'fly' })
+        ).rejects.toThrow(/not configured/);
+      } finally {
+        await manager.shutdown();
+      }
+    });
+
+    it('should reject when hive does not exist', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        await expect(
+          manager.spawn(agentId, { name: 'bad-hive', hive: 'nonexistent-hive' })
+        ).rejects.toThrow(/not found/i);
+      } finally {
+        await manager.shutdown();
+      }
+    });
+  });
+
+  describe('spawn with local provider', () => {
+    it('should spawn a swarm and create DB record', async () => {
+      // Use a process that stays alive but won't have health endpoint
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        // The spawn will partially succeed: process starts but health check will timeout
+        // since our dummy process doesn't serve HTTP
+        const hosted = await manager.spawn(agentId, {
+          name: 'test-spawn-swarm',
+          adapter: 'macro-agent',
+        });
+
+        expect(hosted).toBeDefined();
+        expect(hosted.id).toMatch(/^hswarm_/);
+        expect(hosted.provider).toBe('local');
+        expect(hosted.spawned_by).toBe(agentId);
+        // State will be unhealthy since our test process doesn't serve health
+        expect(['running', 'unhealthy']).toContain(hosted.state);
+        expect(hosted.assigned_port).toBeGreaterThanOrEqual(19100);
+        expect(hosted.assigned_port).toBeLessThanOrEqual(19110);
+      } finally {
+        await manager.shutdown();
+      }
+    }, 35000);
+
+    it('should allocate sequential ports', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        const hosted1 = await manager.spawn(agentId, { name: 'port-test-1' });
+        const hosted2 = await manager.spawn(agentId, { name: 'port-test-2' });
+
+        expect(hosted1.assigned_port).not.toBe(hosted2.assigned_port);
+        expect(hosted1.assigned_port).toBeGreaterThanOrEqual(19100);
+        expect(hosted2.assigned_port).toBeGreaterThanOrEqual(19100);
+      } finally {
+        await manager.shutdown();
+      }
+    }, 65000);
+
+    it('should use default adapter when none specified', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        const hosted = await manager.spawn(agentId, { name: 'default-adapter-test' });
+
+        expect(hosted.config).toBeDefined();
+        expect(hosted.config!.adapter).toBe('macro-agent');
+      } finally {
+        await manager.shutdown();
+      }
+    }, 35000);
+  });
+
+  describe('stop', () => {
+    it('should reject for non-existent hosted swarm', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        await expect(
+          manager.stop('hswarm_nonexistent', agentId)
+        ).rejects.toThrow(/not found/i);
+      } finally {
+        await manager.shutdown();
+      }
+    });
+
+    it('should reject when caller is not the owner', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        const hosted = await manager.spawn(agentId, { name: 'ownership-test' });
+
+        // Try to stop with a different agent
+        await expect(
+          manager.stop(hosted.id, hiveAgentId)
+        ).rejects.toThrow(/not spawn/i);
+      } finally {
+        await manager.shutdown();
+      }
+    }, 35000);
+
+    it('should stop a hosted swarm and update state', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        const hosted = await manager.spawn(agentId, { name: 'stop-test' });
+        const stopped = await manager.stop(hosted.id, agentId);
+
+        expect(stopped.state).toBe('stopped');
+      } finally {
+        await manager.shutdown();
+      }
+    }, 40000);
+  });
+
+  describe('getLogs', () => {
+    it('should reject for non-existent hosted swarm', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        await expect(
+          manager.getLogs('hswarm_nonexistent', agentId)
+        ).rejects.toThrow(/not found/i);
+      } finally {
+        await manager.shutdown();
+      }
+    });
+
+    it('should reject when caller is not the owner', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        const hosted = await manager.spawn(agentId, { name: 'logs-owner-test' });
+
+        await expect(
+          manager.getLogs(hosted.id, hiveAgentId)
+        ).rejects.toThrow(/not spawn/i);
+      } finally {
+        await manager.shutdown();
+      }
+    }, 35000);
+  });
+
+  describe('restart', () => {
+    it('should reject for non-existent hosted swarm', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      try {
+        await expect(
+          manager.restart('hswarm_nonexistent', agentId)
+        ).rejects.toThrow(/not found/i);
+      } finally {
+        await manager.shutdown();
+      }
+    });
+  });
+
+  describe('health monitor', () => {
+    it('should start and stop the health monitor without error', async () => {
+      const config = createTestConfig({ health_check_interval: 100000 });
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      // Should not throw
+      manager.startHealthMonitor();
+      manager.stopHealthMonitor();
+
+      await manager.shutdown();
+    });
+
+    it('should not start duplicate monitors', () => {
+      const config = createTestConfig({ health_check_interval: 100000 });
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      manager.startHealthMonitor();
+      manager.startHealthMonitor(); // Should be a no-op
+
+      manager.stopHealthMonitor();
+    });
+  });
+
+  describe('shutdown', () => {
+    it('should stop health monitor and all processes on shutdown', async () => {
+      const config = createTestConfig();
+      const manager = new SwarmManager(config, 'http://localhost:3000');
+
+      manager.startHealthMonitor();
+
+      // Shutdown should not throw
+      await manager.shutdown();
+    });
+  });
+});
+
+describe('SwarmHostingError', () => {
+  it('should have code and message', () => {
+    const error = new SwarmHostingError('NOT_FOUND', 'Hosted swarm not found');
+    expect(error.code).toBe('NOT_FOUND');
+    expect(error.message).toBe('Hosted swarm not found');
+    expect(error.name).toBe('SwarmHostingError');
+    expect(error instanceof Error).toBe(true);
+  });
+});

package/references/openhive/src/__tests__/swarm/routes.test.ts

@@ -0,0 +1,396 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import Fastify, { FastifyInstance } from 'fastify';
+import * as path from 'path';
+import { initDatabase, closeDatabase } from '../../db/index.js';
+import * as agentsDAL from '../../db/dal/agents.js';
+import * as hivesDAL from '../../db/dal/hives.js';
+import { swarmHostingRoutes } from '../../api/routes/swarm-hosting.js';
+import { SwarmManager } from '../../swarm/manager.js';
+import * as dal from '../../swarm/dal.js';
+import { ConfigSchema, type Config } from '../../config.js';
+import type { SwarmHostingConfig } from '../../swarm/types.js';
+import { testRoot, testDbPath, cleanTestRoot } from '../helpers/test-dirs.js';
+
+const TEST_ROOT = testRoot('swarm-routes');
+const TEST_DB_PATH = testDbPath(TEST_ROOT, 'swarm-routes-test.db');
+const TEST_DATA_DIR = path.join(TEST_ROOT, 'swarm-routes-data');
+const FIXTURES_DIR = path.resolve(__dirname, 'fixtures');
+const SLEEP_SCRIPT = path.join(FIXTURES_DIR, 'sleep-server.js');
+
+function createTestConfig(): Config {
+  return ConfigSchema.parse({
+    database: TEST_DB_PATH,
+    instance: { name: 'Test OpenHive', description: 'Test instance' },
+    admin: { createOnStartup: false },
+    auth: { mode: 'local' },
+    rateLimit: { enabled: false },
+    swarmHosting: {
+      enabled: true,
+      default_provider: 'local',
+      openswarm_command: `node ${SLEEP_SCRIPT}`,
+      data_dir: TEST_DATA_DIR,
+      port_range: [19200, 19210],
+      max_swarms: 5,
+      health_check_interval: 100000,
+      max_health_failures: 3,
+    },
+  });
+}
+
+// Auth middleware that reads Bearer token
+function createAuthPreHandler(agents: Map<string, { id: string; name: string }>) {
+  return async function authMiddleware(request: any, reply: any) {
+    const auth = request.headers.authorization;
+    if (!auth || !auth.startsWith('Bearer ')) {
+      return reply.status(401).send({ error: 'Unauthorized' });
+    }
+    const token = auth.slice(7);
+    const agent = agents.get(token);
+    if (!agent) {
+      return reply.status(401).send({ error: 'Invalid token' });
+    }
+    request.agent = agent;
+  };
+}
+
+describe('Swarm Hosting API Routes', () => {
+  let app: FastifyInstance;
+  let config: Config;
+  let swarmManager: SwarmManager;
+  let testAgent: { id: string; apiKey: string; name: string };
+  let otherAgent: { id: string; apiKey: string; name: string };
+  const agentsByKey = new Map<string, { id: string; name: string }>();
+
+  beforeAll(async () => {
+    cleanTestRoot(TEST_ROOT);
+    initDatabase(TEST_DB_PATH);
+    config = createTestConfig();
+
+    // Create test agents
+    const agentResult = await agentsDAL.createAgent({
+      name: 'route-test-agent',
+      description: 'Agent for route tests',
+    });
+    testAgent = { id: agentResult.agent.id, apiKey: agentResult.apiKey, name: 'route-test-agent' };
+    agentsByKey.set(agentResult.apiKey, { id: agentResult.agent.id, name: 'route-test-agent' });
+
+    const otherResult = await agentsDAL.createAgent({
+      name: 'other-route-agent',
+      description: 'Another agent for ownership tests',
+    });
+    otherAgent = { id: otherResult.agent.id, apiKey: otherResult.apiKey, name: 'other-route-agent' };
+    agentsByKey.set(otherResult.apiKey, { id: otherResult.agent.id, name: 'other-route-agent' });
+
+    // Create test hive
+    hivesDAL.createHive({
+      name: 'route-test-hive',
+      description: 'Test hive for route tests',
+      owner_id: testAgent.id,
+    });
+
+    // Initialize SwarmManager
+    swarmManager = new SwarmManager(
+      config.swarmHosting as unknown as SwarmHostingConfig,
+      'http://localhost:3000'
+    );
+
+    // Create Fastify app with auth middleware that maps API keys to agents
+    app = Fastify({ logger: false });
+
+    // Decorate request with agent
+    app.decorateRequest('agent', null);
+
+    // Add auth hook for all routes
+    app.addHook('preHandler', async (request: any, reply: any) => {
+      const auth = request.headers.authorization;
+      if (auth && auth.startsWith('Bearer ')) {
+        const token = auth.slice(7);
+        const agent = agentsByKey.get(token);
+        if (agent) {
+          request.agent = agent;
+        }
+      }
+    });
+
+    // Attach swarm manager to the fastify instance
+    (app as any).swarmManager = swarmManager;
+
+    await app.register(
+      async (api) => {
+        await api.register(swarmHostingRoutes, { config });
+      },
+      { prefix: '/api/v1' }
+    );
+  });
+
+  afterAll(async () => {
+    await swarmManager.shutdown();
+    await app.close();
+    closeDatabase();
+    cleanTestRoot(TEST_ROOT);
+  });
+
+  describe('GET /api/v1/map/hosted', () => {
+    it('should return empty list initially', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/api/v1/map/hosted',
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.data).toBeDefined();
+      expect(Array.isArray(body.data)).toBe(true);
+      expect(body.total).toBeDefined();
+    });
+
+    it('should require authentication', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/api/v1/map/hosted',
+      });
+
+      expect(response.statusCode).toBe(401);
+    });
+  });
+
+  describe('POST /api/v1/map/hosted/spawn', () => {
+    it('should spawn a swarm and return its details', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: {
+          name: 'api-spawned-swarm',
+          adapter: 'macro-agent',
+        },
+      });
+
+      expect(response.statusCode).toBe(201);
+      const body = JSON.parse(response.body);
+      expect(body.id).toMatch(/^hswarm_/);
+      expect(body.provider).toBe('local');
+      expect(body.assigned_port).toBeGreaterThanOrEqual(19200);
+      expect(body.created_at).toBeDefined();
+    }, 35000);
+
+    it('should reject invalid request body', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: {
+          name: '', // empty string fails min(1) validation
+        },
+      });
+
+      expect(response.statusCode).toBe(422);
+      const body = JSON.parse(response.body);
+      expect(body.error).toBe('VALIDATION_ERROR');
+    });
+
+    it('should reject name exceeding max length', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: {
+          name: 'x'.repeat(101),
+        },
+      });
+
+      expect(response.statusCode).toBe(422);
+    });
+  });
+
+  describe('GET /api/v1/map/hosted/:id', () => {
+    it('should return details of a hosted swarm', async () => {
+      // Create one first
+      const spawnRes = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: { name: 'detail-test-swarm' },
+      });
+      const spawned = JSON.parse(spawnRes.body);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: `/api/v1/map/hosted/${spawned.id}`,
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.id).toBe(spawned.id);
+      expect(body.provider).toBe('local');
+      expect(body.spawned_by).toBe(testAgent.id);
+    }, 35000);
+
+    it('should return 404 for non-existent ID', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/api/v1/map/hosted/hswarm_nonexistent',
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(404);
+    });
+  });
+
+  describe('POST /api/v1/map/hosted/:id/stop', () => {
+    it('should stop a hosted swarm', async () => {
+      const spawnRes = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: { name: 'stop-route-test' },
+      });
+      const spawned = JSON.parse(spawnRes.body);
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/v1/map/hosted/${spawned.id}/stop`,
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.state).toBe('stopped');
+    }, 40000);
+
+    it('should return 404 for non-existent swarm', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/hswarm_nonexistent/stop',
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(404);
+    });
+
+    it('should return 403 when not the owner', async () => {
+      const spawnRes = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: { name: 'ownership-stop-test' },
+      });
+      const spawned = JSON.parse(spawnRes.body);
+
+      const response = await app.inject({
+        method: 'POST',
+        url: `/api/v1/map/hosted/${spawned.id}/stop`,
+        headers: { authorization: `Bearer ${otherAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(403);
+    }, 35000);
+  });
+
+  describe('GET /api/v1/map/hosted/:id/logs', () => {
+    it('should return logs as text/plain', async () => {
+      const spawnRes = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: { name: 'logs-route-test' },
+      });
+      const spawned = JSON.parse(spawnRes.body);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: `/api/v1/map/hosted/${spawned.id}/logs`,
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(response.headers['content-type']).toContain('text/plain');
+    }, 35000);
+
+    it('should accept lines query param', async () => {
+      const spawnRes = await app.inject({
+        method: 'POST',
+        url: '/api/v1/map/hosted/spawn',
+        headers: {
+          authorization: `Bearer ${testAgent.apiKey}`,
+          'content-type': 'application/json',
+        },
+        payload: { name: 'logs-lines-route-test' },
+      });
+      const spawned = JSON.parse(spawnRes.body);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: `/api/v1/map/hosted/${spawned.id}/logs?lines=10`,
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+    }, 35000);
+  });
+
+  describe('GET /api/v1/map/hosted with filters', () => {
+    it('should filter by mine=true', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/api/v1/map/hosted?mine=true',
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      body.data.forEach((h: any) => {
+        expect(h.spawned_by).toBe(testAgent.id);
+      });
+    });
+
+    it('should filter by state', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/api/v1/map/hosted?state=stopped',
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      body.data.forEach((h: any) => {
+        expect(h.state).toBe('stopped');
+      });
+    });
+
+    it('should respect limit parameter', async () => {
+      const response = await app.inject({
+        method: 'GET',
+        url: '/api/v1/map/hosted?limit=2',
+        headers: { authorization: `Bearer ${testAgent.apiKey}` },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.data.length).toBeLessThanOrEqual(2);
+    });
+  });
+});