swarmroom 0.1.0

package/dist/daemon/watcher.js

@@ -0,0 +1,225 @@
+import WebSocket from 'ws';
+import { spawn } from 'node:child_process';
+import { WS_RECONNECT_DELAY_MS, DAEMON_SPAWN_COOLDOWN_MS, } from '@swarmroom/shared';
+import { loadDaemonConfig } from './config.js';
+import { isAgentProcessRunning } from './process-detector.js';
+const MAX_RECONNECT_DELAY_MS = 30_000;
+export class DaemonWatcher {
+    hubUrl;
+    workdir;
+    verbose;
+    config;
+    ws = null;
+    reconnectTimer = null;
+    reconnectAttempts = 0;
+    intentionalDisconnect = false;
+    // Cooldown tracking: agentType -> timestamp of last spawn
+    spawnCooldowns = new Map();
+    constructor(options = {}) {
+        this.config = loadDaemonConfig();
+        this.hubUrl = options.hubUrl ?? this.config.hubUrl;
+        this.workdir = options.workdir ?? process.cwd();
+        this.verbose = options.verbose ?? false;
+    }
+    /** Start the daemon — connect to Hub WebSocket */
+    start() {
+        this.intentionalDisconnect = false;
+        this.log('Starting daemon watcher...');
+        this.log(`Hub URL: ${this.hubUrl}`);
+        this.log(`Working directory: ${this.workdir}`);
+        this.connectWebSocket();
+    }
+    /** Stop the daemon — disconnect and clean up */
+    stop() {
+        this.intentionalDisconnect = true;
+        this.clearReconnectTimer();
+        if (this.ws) {
+            this.ws.close(1000, 'daemon stopping');
+            this.ws = null;
+        }
+        this.log('Daemon watcher stopped.');
+    }
+    /** Reload config from disk */
+    reloadConfig() {
+        this.config = loadDaemonConfig();
+        this.log('Config reloaded.');
+    }
+    connectWebSocket() {
+        const wsUrl = this.hubUrl.replace(/^http/, 'ws') + '/ws';
+        this.log(`Connecting to ${wsUrl}...`);
+        this.ws = new WebSocket(wsUrl);
+        this.ws.on('open', () => {
+            this.reconnectAttempts = 0;
+            this.sendRegister();
+            this.log('Connected to Hub. Registered as daemon.');
+        });
+        this.ws.on('message', (data) => {
+            this.handleMessage(String(data));
+        });
+        this.ws.on('close', () => {
+            if (!this.intentionalDisconnect) {
+                this.scheduleReconnect();
+            }
+        });
+        this.ws.on('error', (err) => {
+            this.log(`WebSocket error: ${err.message}`);
+            // Error is followed by close event, which handles reconnection
+        });
+    }
+    sendRegister() {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const msg = {
+            type: 'register',
+            payload: { clientType: 'daemon' },
+            timestamp: new Date().toISOString(),
+        };
+        this.ws.send(JSON.stringify(msg));
+    }
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        switch (msg.type) {
+            case 'message_undelivered': {
+                const payload = msg.payload;
+                this.handleUndeliveredMessage(payload);
+                break;
+            }
+            case 'heartbeat': {
+                // Respond to server pings
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    const pong = {
+                        type: 'heartbeat',
+                        payload: { pong: true },
+                        timestamp: new Date().toISOString(),
+                    };
+                    this.ws.send(JSON.stringify(pong));
+                }
+                break;
+            }
+            case 'register':
+                this.log('Registration confirmed by hub.');
+                break;
+            default:
+                // Ignore other message types (agent_online, agent_offline, etc.)
+                break;
+        }
+    }
+    handleUndeliveredMessage(payload) {
+        const { recipientAgentId, recipientAgentName, message } = payload;
+        this.log(`Undelivered message for agent "${recipientAgentName}" (${recipientAgentId})`);
+        // Find which agent config matches this agent name
+        const agentType = this.findAgentType(recipientAgentName);
+        if (!agentType) {
+            this.log(`No config found for agent "${recipientAgentName}", ignoring.`);
+            return;
+        }
+        const agentConfig = this.config.agents[agentType];
+        if (!agentConfig) {
+            this.log(`No agent config for type "${agentType}", ignoring.`);
+            return;
+        }
+        // Check if headless wakeup is enabled
+        if (!agentConfig.headlessWakeup) {
+            this.log(`Headless wakeup disabled for "${agentType}", message stored in DB for later retrieval.`);
+            return;
+        }
+        // Check if the agent process is already running
+        if (isAgentProcessRunning(agentType)) {
+            this.log(`Agent "${agentType}" process is running but not connected. Message stored in DB.`);
+            return;
+        }
+        // Check cooldown
+        if (this.isOnCooldown(agentType)) {
+            this.log(`Agent "${agentType}" is on spawn cooldown, skipping.`);
+            return;
+        }
+        // Spawn headless process
+        this.spawnHeadless(agentType, agentConfig, message);
+    }
+    /**
+     * Find which agent type (config key) matches the given agent name.
+     * The agent name from the hub may be "claude-code", "opencode", "gemini-cli",
+     * or a custom name. We try exact match first, then partial matching.
+     */
+    findAgentType(agentName) {
+        const normalized = agentName.toLowerCase();
+        // Exact match against config keys
+        if (this.config.agents[normalized]) {
+            return normalized;
+        }
+        // Check if the agent name contains any known agent type
+        for (const key of Object.keys(this.config.agents)) {
+            if (normalized.includes(key) || key.includes(normalized)) {
+                return key;
+            }
+        }
+        return null;
+    }
+    isOnCooldown(agentType) {
+        const lastSpawn = this.spawnCooldowns.get(agentType);
+        if (!lastSpawn)
+            return false;
+        return Date.now() - lastSpawn < DAEMON_SPAWN_COOLDOWN_MS;
+    }
+    spawnHeadless(agentType, agentConfig, message) {
+        // Set cooldown immediately
+        this.spawnCooldowns.set(agentType, Date.now());
+        // Build the message content for the prompt
+        const messageContent = typeof message === 'object' && message !== null
+            ? message.content ?? JSON.stringify(message)
+            : String(message);
+        // Replace {message} template in args
+        const args = agentConfig.args.map((arg) => arg.replace('{message}', String(messageContent)));
+        const workdir = agentConfig.workdir ?? this.workdir;
+        this.log(`Spawning headless: ${agentConfig.command} ${args.join(' ')}`);
+        this.log(`  Working directory: ${workdir}`);
+        try {
+            const child = spawn(agentConfig.command, args, {
+                cwd: workdir,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                detached: false, // We want to track the child
+            });
+            child.stdout?.on('data', (data) => {
+                this.log(`[${agentType}:stdout] ${data.toString().trim()}`);
+            });
+            child.stderr?.on('data', (data) => {
+                this.log(`[${agentType}:stderr] ${data.toString().trim()}`);
+            });
+            child.on('exit', (code) => {
+                this.log(`[${agentType}] Process exited with code ${code}`);
+            });
+            child.on('error', (err) => {
+                this.log(`[${agentType}] Failed to spawn: ${err.message}`);
+            });
+        }
+        catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            this.log(`Failed to spawn ${agentType}: ${errMsg}`);
+        }
+    }
+    scheduleReconnect() {
+        this.clearReconnectTimer();
+        const delay = Math.min(WS_RECONNECT_DELAY_MS * Math.pow(2, this.reconnectAttempts), MAX_RECONNECT_DELAY_MS);
+        this.reconnectAttempts++;
+        this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.connectWebSocket();
+        }, delay);
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    log(message) {
+        const timestamp = new Date().toISOString();
+        console.log(`[daemon ${timestamp}] ${message}`);
+    }
+}

package/dist/detectors/__tests__/detectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/detectors/__tests__/detectors.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+vi.mock('node:child_process', () => ({
+    execSync: vi.fn(),
+}));
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    copyFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { ClaudeCodeDetector } from '../claude-code.js';
+import { OpenCodeDetector } from '../opencode.js';
+import { GeminiCliDetector } from '../gemini-cli.js';
+import { detectAllAgents } from '../index.js';
+const mockedExecSync = vi.mocked(execSync);
+const mockedExistsSync = vi.mocked(existsSync);
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('ClaudeCodeDetector', () => {
+    const detector = new ClaudeCodeDetector();
+    it('detects when claude is installed and config exists in cwd', async () => {
+        mockedExecSync.mockReturnValue(Buffer.from('/usr/bin/claude'));
+        mockedExistsSync.mockReturnValueOnce(true);
+        const result = await detector.detect();
+        expect(result.installed).toBe(true);
+        expect(result.configExists).toBe(true);
+        expect(result.configPath).toBe(join(process.cwd(), '.mcp.json'));
+        expect(result.name).toBe('Claude Code');
+        expect(mockedExecSync).toHaveBeenCalledWith('which claude', { stdio: 'ignore' });
+    });
+    it('detects when claude is not installed and no config exists', async () => {
+        mockedExecSync.mockImplementation(() => {
+            throw new Error('not found');
+        });
+        mockedExistsSync.mockReturnValue(false);
+        const result = await detector.detect();
+        expect(result.installed).toBe(false);
+        expect(result.configExists).toBe(false);
+        expect(result.configPath).toBe(join(process.cwd(), '.mcp.json'));
+        expect(result.name).toBe('Claude Code');
+    });
+    it('finds config in home directory when not in cwd', async () => {
+        mockedExecSync.mockReturnValue(Buffer.from('/usr/bin/claude'));
+        mockedExistsSync.mockReturnValueOnce(false).mockReturnValueOnce(true);
+        const result = await detector.detect();
+        expect(result.installed).toBe(true);
+        expect(result.configExists).toBe(true);
+        expect(result.configPath).toBe(join(homedir(), '.mcp.json'));
+    });
+});
+describe('OpenCodeDetector', () => {
+    const detector = new OpenCodeDetector();
+    it('detects when opencode is installed and config exists', async () => {
+        mockedExecSync.mockReturnValue(Buffer.from('/usr/bin/opencode'));
+        mockedExistsSync.mockReturnValue(true);
+        const result = await detector.detect();
+        expect(result.installed).toBe(true);
+        expect(result.configExists).toBe(true);
+        expect(result.configPath).toBe(join(process.cwd(), 'opencode.json'));
+        expect(result.name).toBe('OpenCode');
+    });
+    it('detects when opencode is not installed', async () => {
+        mockedExecSync.mockImplementation(() => {
+            throw new Error('not found');
+        });
+        mockedExistsSync.mockReturnValue(false);
+        const result = await detector.detect();
+        expect(result.installed).toBe(false);
+        expect(result.configExists).toBe(false);
+    });
+});
+describe('GeminiCliDetector', () => {
+    const detector = new GeminiCliDetector();
+    it('detects when gemini is installed and config exists', async () => {
+        mockedExecSync.mockReturnValue(Buffer.from('/usr/bin/gemini'));
+        mockedExistsSync.mockReturnValue(true);
+        const result = await detector.detect();
+        expect(result.installed).toBe(true);
+        expect(result.configExists).toBe(true);
+        expect(result.configPath).toBe(join(homedir(), '.gemini', 'settings.json'));
+        expect(result.name).toBe('Gemini CLI');
+    });
+});
+describe('detectAllAgents', () => {
+    it('returns results for all 3 agents', async () => {
+        mockedExecSync.mockReturnValue(Buffer.from('/usr/bin/agent'));
+        mockedExistsSync.mockReturnValue(true);
+        const results = await detectAllAgents();
+        expect(results).toHaveLength(3);
+        const names = results.map((r) => r.name);
+        expect(names).toContain('Claude Code');
+        expect(names).toContain('OpenCode');
+        expect(names).toContain('Gemini CLI');
+        results.forEach((r) => {
+            expect(r.installed).toBe(true);
+            expect(r.configExists).toBe(true);
+        });
+    });
+});

package/dist/detectors/claude-code.d.ts

@@ -0,0 +1,7 @@
+import type { AgentDetector, DetectionResult } from './index.js';
+export declare class ClaudeCodeDetector implements AgentDetector {
+    readonly name = "Claude Code";
+    detect(): Promise<DetectionResult>;
+    private checkInstalled;
+    private findConfig;
+}

package/dist/detectors/claude-code.js

@@ -0,0 +1,39 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export class ClaudeCodeDetector {
+    name = 'Claude Code';
+    async detect() {
+        const installed = this.checkInstalled();
+        const { configExists, configPath } = this.findConfig();
+        return {
+            installed,
+            configExists,
+            configPath,
+            name: this.name,
+        };
+    }
+    checkInstalled() {
+        try {
+            execSync('which claude', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    findConfig() {
+        // Check cwd first, then home directory
+        const cwdPath = join(process.cwd(), '.mcp.json');
+        if (existsSync(cwdPath)) {
+            return { configExists: true, configPath: cwdPath };
+        }
+        const homePath = join(homedir(), '.mcp.json');
+        if (existsSync(homePath)) {
+            return { configExists: true, configPath: homePath };
+        }
+        // Default to cwd path even if not found
+        return { configExists: false, configPath: cwdPath };
+    }
+}

package/dist/detectors/gemini-cli.d.ts

@@ -0,0 +1,6 @@
+import type { AgentDetector, DetectionResult } from './index.js';
+export declare class GeminiCliDetector implements AgentDetector {
+    readonly name = "Gemini CLI";
+    detect(): Promise<DetectionResult>;
+    private checkInstalled;
+}

package/dist/detectors/gemini-cli.js

@@ -0,0 +1,27 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+export class GeminiCliDetector {
+    name = 'Gemini CLI';
+    async detect() {
+        const installed = this.checkInstalled();
+        const configPath = join(homedir(), '.gemini', 'settings.json');
+        const configExists = existsSync(configPath);
+        return {
+            installed,
+            configExists,
+            configPath,
+            name: this.name,
+        };
+    }
+    checkInstalled() {
+        try {
+            execSync('which gemini', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/detectors/index.d.ts

@@ -0,0 +1,15 @@
+import { ClaudeCodeDetector } from './claude-code.js';
+import { OpenCodeDetector } from './opencode.js';
+import { GeminiCliDetector } from './gemini-cli.js';
+export interface DetectionResult {
+    installed: boolean;
+    configExists: boolean;
+    configPath: string;
+    name: string;
+}
+export interface AgentDetector {
+    name: string;
+    detect(): Promise<DetectionResult>;
+}
+export declare function detectAllAgents(): Promise<DetectionResult[]>;
+export { ClaudeCodeDetector, OpenCodeDetector, GeminiCliDetector };

package/dist/detectors/index.js

@@ -0,0 +1,12 @@
+import { ClaudeCodeDetector } from './claude-code.js';
+import { OpenCodeDetector } from './opencode.js';
+import { GeminiCliDetector } from './gemini-cli.js';
+const allDetectors = [
+    new ClaudeCodeDetector(),
+    new OpenCodeDetector(),
+    new GeminiCliDetector(),
+];
+export async function detectAllAgents() {
+    return Promise.all(allDetectors.map((d) => d.detect()));
+}
+export { ClaudeCodeDetector, OpenCodeDetector, GeminiCliDetector };

package/dist/detectors/opencode.d.ts

@@ -0,0 +1,6 @@
+import type { AgentDetector, DetectionResult } from './index.js';
+export declare class OpenCodeDetector implements AgentDetector {
+    readonly name = "OpenCode";
+    detect(): Promise<DetectionResult>;
+    private checkInstalled;
+}

package/dist/detectors/opencode.js

@@ -0,0 +1,26 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export class OpenCodeDetector {
+    name = 'OpenCode';
+    async detect() {
+        const installed = this.checkInstalled();
+        const configPath = join(process.cwd(), 'opencode.json');
+        const configExists = existsSync(configPath);
+        return {
+            installed,
+            configExists,
+            configPath,
+            name: this.name,
+        };
+    }
+    checkInstalled() {
+        try {
+            execSync('which opencode', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,17 @@
+import { Command } from 'commander';
+import { makeSetupCommand } from './commands/setup.js';
+import { makeStatusCommand } from './commands/status.js';
+import { makeAgentsCommand } from './commands/agents.js';
+import { makeDaemonCommand } from './commands/daemon.js';
+import { makeStartCommand } from './commands/start.js';
+const program = new Command();
+program
+    .name('swarmroom')
+    .description('SwarmRoom CLI — orchestrate AI agents on your local network')
+    .version('0.1.0');
+program.addCommand(makeSetupCommand());
+program.addCommand(makeStatusCommand());
+program.addCommand(makeAgentsCommand());
+program.addCommand(makeDaemonCommand());
+program.addCommand(makeStartCommand());
+program.parse();

package/dist/utils/display.d.ts

@@ -0,0 +1,10 @@
+export declare function banner(title: string, message?: string): void;
+export declare function successBox(title: string, lines: string[]): void;
+export declare function table(headers: string[], rows: string[][]): void;
+export declare function statusIndicator(status: string): string;
+export declare function formatUptime(seconds: number): string;
+export declare function keyValue(key: string, value: string): void;
+export declare function error(message: string): void;
+export declare function warn(message: string): void;
+export declare function info(message: string): void;
+export declare function success(message: string): void;

package/dist/utils/display.js

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+export function banner(title, message) {
+    const line = '─'.repeat(Math.max(title.length, message?.length ?? 0) + 4);
+    console.log('');
+    console.log(chalk.cyan(`  ╭${line}╮`));
+    console.log(chalk.cyan(`  │  ${chalk.bold.white(title.padEnd(line.length - 4))}  │`));
+    if (message) {
+        console.log(chalk.cyan(`  │  ${chalk.gray(message.padEnd(line.length - 4))}  │`));
+    }
+    console.log(chalk.cyan(`  ╰${line}╯`));
+    console.log('');
+}
+export function successBox(title, lines) {
+    const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
+    const width = maxLen + 4;
+    const border = '─'.repeat(width);
+    console.log('');
+    console.log(chalk.green(`  ╭${border}╮`));
+    console.log(chalk.green(`  │  ${chalk.bold.white(title.padEnd(width - 4))}  │`));
+    console.log(chalk.green(`  │${' '.repeat(width)}│`));
+    for (const line of lines) {
+        console.log(chalk.green(`  │  ${line.padEnd(width - 4)}  │`));
+    }
+    console.log(chalk.green(`  ╰${border}╯`));
+    console.log('');
+}
+export function table(headers, rows) {
+    const colWidths = headers.map((h, i) => {
+        const maxRow = rows.reduce((max, row) => Math.max(max, (row[i] ?? '').length), 0);
+        return Math.max(h.length, maxRow);
+    });
+    const headerLine = headers.map((h, i) => chalk.bold.white(h.padEnd(colWidths[i]))).join('  ');
+    const separator = colWidths.map((w) => '─'.repeat(w)).join('──');
+    console.log(`  ${headerLine}`);
+    console.log(chalk.gray(`  ${separator}`));
+    for (const row of rows) {
+        const line = row.map((cell, i) => cell.padEnd(colWidths[i])).join('  ');
+        console.log(`  ${line}`);
+    }
+}
+export function statusIndicator(status) {
+    switch (status) {
+        case 'online':
+            return chalk.green('●') + ' ' + chalk.green('online');
+        case 'busy':
+            return chalk.yellow('●') + ' ' + chalk.yellow('busy');
+        case 'idle':
+            return chalk.blue('●') + ' ' + chalk.blue('idle');
+        case 'offline':
+            return chalk.gray('●') + ' ' + chalk.gray('offline');
+        default:
+            return chalk.gray('●') + ' ' + chalk.gray(status);
+    }
+}
+export function formatUptime(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+    const hours = Math.floor(seconds / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    return `${hours}h ${mins}m`;
+}
+export function keyValue(key, value) {
+    console.log(`  ${chalk.gray(key + ':')} ${value}`);
+}
+export function error(message) {
+    console.error(chalk.red(`  ✖ ${message}`));
+}
+export function warn(message) {
+    console.log(chalk.yellow(`  ⚠ ${message}`));
+}
+export function info(message) {
+    console.log(chalk.blue(`  ℹ ${message}`));
+}
+export function success(message) {
+    console.log(chalk.green(`  ✔ ${message}`));
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "swarmroom",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "LAN-based agent discovery and communication hub for AI coding agents",
+  "keywords": ["swarm", "agent", "mcp", "ai", "multi-agent", "lan", "discovery"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visual-z/swarm.git",
+    "directory": "packages/cli"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "swarmroom": "./bin/swarmroom.js"
+  },
+  "files": ["dist", "bin", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@swarmroom/sdk": "^0.1.0",
+    "@swarmroom/server": "^0.1.0",
+    "@swarmroom/shared": "^0.1.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "inquirer": "^13.2.2",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "vitest": "^4.0.18"
+  }
+}