swarmroom 0.1.0

package/dist/daemon/__tests__/process-detector.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('node:child_process', () => ({
+    execSync: vi.fn(),
+}));
+import { execSync } from 'node:child_process';
+import { isProcessRunning, isClaudeCodeRunning, isOpenCodeRunning, isGeminiCliRunning, isAgentProcessRunning, AGENT_PROCESS_DETECTORS, } from '../process-detector.js';
+const mockedExecSync = vi.mocked(execSync);
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('isProcessRunning', () => {
+    it('returns true when pgrep succeeds (process found)', () => {
+        mockedExecSync.mockReturnValue(Buffer.from('12345'));
+        expect(isProcessRunning('claude')).toBe(true);
+        expect(mockedExecSync).toHaveBeenCalledWith('pgrep -f "claude"', {
+            stdio: ['pipe', 'pipe', 'ignore'],
+        });
+    });
+    it('returns false when pgrep throws (process not found)', () => {
+        mockedExecSync.mockImplementation(() => {
+            throw new Error('exit code 1');
+        });
+        expect(isProcessRunning('claude')).toBe(false);
+    });
+});
+describe('isClaudeCodeRunning', () => {
+    it('checks for "claude" process', () => {
+        mockedExecSync.mockReturnValue(Buffer.from('12345'));
+        const result = isClaudeCodeRunning();
+        expect(result).toBe(true);
+        expect(mockedExecSync).toHaveBeenCalledWith('pgrep -f "claude"', expect.any(Object));
+    });
+});
+describe('isOpenCodeRunning', () => {
+    it('checks for "opencode" process', () => {
+        mockedExecSync.mockReturnValue(Buffer.from('12345'));
+        const result = isOpenCodeRunning();
+        expect(result).toBe(true);
+        expect(mockedExecSync).toHaveBeenCalledWith('pgrep -f "opencode"', expect.any(Object));
+    });
+});
+describe('isGeminiCliRunning', () => {
+    it('checks for "gemini" process', () => {
+        mockedExecSync.mockReturnValue(Buffer.from('12345'));
+        const result = isGeminiCliRunning();
+        expect(result).toBe(true);
+        expect(mockedExecSync).toHaveBeenCalledWith('pgrep -f "gemini"', expect.any(Object));
+    });
+});
+describe('AGENT_PROCESS_DETECTORS', () => {
+    it('has entries for claude-code, opencode, and gemini-cli', () => {
+        expect(Object.keys(AGENT_PROCESS_DETECTORS)).toEqual(expect.arrayContaining(['claude-code', 'opencode', 'gemini-cli']));
+        expect(Object.keys(AGENT_PROCESS_DETECTORS)).toHaveLength(3);
+    });
+    it('maps to the correct detector functions', () => {
+        expect(AGENT_PROCESS_DETECTORS['claude-code']).toBe(isClaudeCodeRunning);
+        expect(AGENT_PROCESS_DETECTORS['opencode']).toBe(isOpenCodeRunning);
+        expect(AGENT_PROCESS_DETECTORS['gemini-cli']).toBe(isGeminiCliRunning);
+    });
+});
+describe('isAgentProcessRunning', () => {
+    it('returns false for unknown agent type', () => {
+        expect(isAgentProcessRunning('unknown-agent')).toBe(false);
+        expect(mockedExecSync).not.toHaveBeenCalled();
+    });
+    it('delegates to the correct detector for known agent type', () => {
+        mockedExecSync.mockReturnValue(Buffer.from('12345'));
+        expect(isAgentProcessRunning('claude-code')).toBe(true);
+        expect(mockedExecSync).toHaveBeenCalledWith('pgrep -f "claude"', expect.any(Object));
+    });
+    it('returns false when known agent process is not running', () => {
+        mockedExecSync.mockImplementation(() => {
+            throw new Error('exit code 1');
+        });
+        expect(isAgentProcessRunning('opencode')).toBe(false);
+    });
+});

package/dist/daemon/__tests__/watcher.test.d.ts

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

package/dist/daemon/__tests__/watcher.test.js

@@ -0,0 +1,305 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockOn = vi.fn();
+const mockSend = vi.fn();
+const mockClose = vi.fn();
+vi.mock('ws', () => {
+    const MockWebSocket = vi.fn().mockImplementation(function () {
+        this.on = mockOn;
+        this.send = mockSend;
+        this.close = mockClose;
+        this.readyState = 1;
+    });
+    MockWebSocket.OPEN = 1;
+    return { default: MockWebSocket };
+});
+const mockLoadDaemonConfig = vi.fn();
+vi.mock('../config.js', () => ({
+    loadDaemonConfig: (...args) => mockLoadDaemonConfig(...args),
+}));
+const mockIsAgentProcessRunning = vi.fn();
+vi.mock('../process-detector.js', () => ({
+    isAgentProcessRunning: (...args) => mockIsAgentProcessRunning(...args),
+}));
+const mockSpawn = vi.fn();
+vi.mock('node:child_process', () => ({
+    spawn: (...args) => mockSpawn(...args),
+}));
+import WebSocket from 'ws';
+import { DaemonWatcher } from '../watcher.js';
+function makeDefaultConfig(overrides = {}) {
+    return {
+        hubUrl: 'http://localhost:3000',
+        agents: {
+            'claude-code': {
+                headlessWakeup: false,
+                command: 'claude',
+                args: ['-p', '{message}', '--dangerously-skip-permissions'],
+            },
+            'opencode': {
+                headlessWakeup: false,
+                command: 'opencode',
+                args: ['run', '{message}'],
+            },
+            'gemini-cli': {
+                headlessWakeup: false,
+                command: 'gemini',
+                args: ['-p', '{message}'],
+            },
+        },
+        ...overrides,
+    };
+}
+function getEventHandler(eventName) {
+    for (const call of mockOn.mock.calls) {
+        if (call[0] === eventName) {
+            return call[1];
+        }
+    }
+    return undefined;
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    mockLoadDaemonConfig.mockReturnValue(makeDefaultConfig());
+    mockSpawn.mockReturnValue({
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+    });
+});
+describe('DaemonWatcher constructor', () => {
+    it('uses config hubUrl when no override provided', () => {
+        mockLoadDaemonConfig.mockReturnValue(makeDefaultConfig({ hubUrl: 'http://myhost:4000' }));
+        const watcher = new DaemonWatcher();
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        watcher.start();
+        expect(WebSocket).toHaveBeenCalledWith('ws://myhost:4000/ws');
+    });
+    it('uses provided hubUrl over config hubUrl', () => {
+        const watcher = new DaemonWatcher({ hubUrl: 'http://custom:5000' });
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        watcher.start();
+        expect(WebSocket).toHaveBeenCalledWith('ws://custom:5000/ws');
+    });
+});
+describe('DaemonWatcher.start', () => {
+    it('creates WebSocket with ws:// URL derived from http:// hubUrl', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const watcher = new DaemonWatcher();
+        watcher.start();
+        expect(WebSocket).toHaveBeenCalledWith('ws://localhost:3000/ws');
+    });
+    it('registers event handlers on the WebSocket', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const watcher = new DaemonWatcher();
+        watcher.start();
+        const registeredEvents = mockOn.mock.calls.map((c) => c[0]);
+        expect(registeredEvents).toContain('open');
+        expect(registeredEvents).toContain('message');
+        expect(registeredEvents).toContain('close');
+        expect(registeredEvents).toContain('error');
+    });
+});
+describe('DaemonWatcher message handling', () => {
+    function startWatcher(configOverrides = {}) {
+        mockLoadDaemonConfig.mockReturnValue(makeDefaultConfig(configOverrides));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const watcher = new DaemonWatcher();
+        watcher.start();
+        return watcher;
+    }
+    function sendMessage(msg) {
+        const handler = getEventHandler('message');
+        expect(handler).toBeDefined();
+        handler(JSON.stringify(msg));
+    }
+    function makeUndeliveredMsg(agentName, content = 'hello') {
+        return {
+            type: 'message_undelivered',
+            payload: {
+                recipientAgentId: 'agent-123',
+                recipientAgentName: agentName,
+                message: { content },
+            },
+            timestamp: new Date().toISOString(),
+        };
+    }
+    it('does NOT spawn when headless wakeup is disabled', () => {
+        startWatcher();
+        sendMessage(makeUndeliveredMsg('claude-code'));
+        expect(mockSpawn).not.toHaveBeenCalled();
+    });
+    it('does NOT spawn when agent process is already running', () => {
+        startWatcher({
+            agents: {
+                'claude-code': {
+                    headlessWakeup: true,
+                    command: 'claude',
+                    args: ['-p', '{message}'],
+                },
+            },
+        });
+        mockIsAgentProcessRunning.mockReturnValue(true);
+        sendMessage(makeUndeliveredMsg('claude-code'));
+        expect(mockSpawn).not.toHaveBeenCalled();
+    });
+    it('does NOT spawn when on cooldown', () => {
+        startWatcher({
+            agents: {
+                'claude-code': {
+                    headlessWakeup: true,
+                    command: 'claude',
+                    args: ['-p', '{message}'],
+                },
+            },
+        });
+        mockIsAgentProcessRunning.mockReturnValue(false);
+        sendMessage(makeUndeliveredMsg('claude-code'));
+        expect(mockSpawn).toHaveBeenCalledTimes(1);
+        mockSpawn.mockClear();
+        sendMessage(makeUndeliveredMsg('claude-code'));
+        expect(mockSpawn).not.toHaveBeenCalled();
+    });
+    it('DOES spawn when headless enabled, process not running, no cooldown', () => {
+        startWatcher({
+            agents: {
+                'opencode': {
+                    headlessWakeup: true,
+                    command: 'opencode',
+                    args: ['run', '{message}'],
+                },
+            },
+        });
+        mockIsAgentProcessRunning.mockReturnValue(false);
+        sendMessage(makeUndeliveredMsg('opencode'));
+        expect(mockSpawn).toHaveBeenCalledTimes(1);
+        expect(mockSpawn).toHaveBeenCalledWith('opencode', ['run', 'hello'], expect.objectContaining({
+            cwd: expect.any(String),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }));
+    });
+    it('spawns with correct workdir from agent config', () => {
+        startWatcher({
+            agents: {
+                'gemini-cli': {
+                    headlessWakeup: true,
+                    command: 'gemini',
+                    args: ['-p', '{message}'],
+                    workdir: '/my/project',
+                },
+            },
+        });
+        mockIsAgentProcessRunning.mockReturnValue(false);
+        sendMessage(makeUndeliveredMsg('gemini-cli'));
+        expect(mockSpawn).toHaveBeenCalledWith('gemini', ['-p', 'hello'], expect.objectContaining({ cwd: '/my/project' }));
+    });
+    it('replaces {message} template in args with message content', () => {
+        startWatcher({
+            agents: {
+                'claude-code': {
+                    headlessWakeup: true,
+                    command: 'claude',
+                    args: ['-p', '{message}', '--flag'],
+                },
+            },
+        });
+        mockIsAgentProcessRunning.mockReturnValue(false);
+        sendMessage(makeUndeliveredMsg('claude-code', 'fix the bug'));
+        expect(mockSpawn).toHaveBeenCalledWith('claude', ['-p', 'fix the bug', '--flag'], expect.any(Object));
+    });
+    it('ignores unknown agent names', () => {
+        startWatcher({
+            agents: {
+                'claude-code': {
+                    headlessWakeup: true,
+                    command: 'claude',
+                    args: ['-p', '{message}'],
+                },
+            },
+        });
+        sendMessage(makeUndeliveredMsg('totally-unknown'));
+        expect(mockSpawn).not.toHaveBeenCalled();
+    });
+});
+describe('DaemonWatcher heartbeat', () => {
+    it('responds with pong when receiving heartbeat', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const watcher = new DaemonWatcher();
+        watcher.start();
+        const handler = getEventHandler('message');
+        expect(handler).toBeDefined();
+        handler(JSON.stringify({
+            type: 'heartbeat',
+            payload: {},
+            timestamp: new Date().toISOString(),
+        }));
+        expect(mockSend).toHaveBeenCalledWith(expect.stringContaining('"pong":true'));
+    });
+});
+describe('DaemonWatcher.stop', () => {
+    it('closes the WebSocket', () => {
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        const watcher = new DaemonWatcher();
+        watcher.start();
+        watcher.stop();
+        expect(mockClose).toHaveBeenCalledWith(1000, 'daemon stopping');
+    });
+});
+describe('DaemonWatcher.findAgentType (via message handling)', () => {
+    function startWithAllHeadless() {
+        mockLoadDaemonConfig.mockReturnValue(makeDefaultConfig({
+            agents: {
+                'claude-code': { headlessWakeup: true, command: 'claude', args: ['-p', '{message}'] },
+                'opencode': { headlessWakeup: true, command: 'opencode', args: ['run', '{message}'] },
+                'gemini-cli': { headlessWakeup: true, command: 'gemini', args: ['-p', '{message}'] },
+            },
+        }));
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        mockIsAgentProcessRunning.mockReturnValue(false);
+        const watcher = new DaemonWatcher();
+        watcher.start();
+        return watcher;
+    }
+    it('matches exact agent name', () => {
+        startWithAllHeadless();
+        const handler = getEventHandler('message');
+        handler(JSON.stringify({
+            type: 'message_undelivered',
+            payload: {
+                recipientAgentId: 'id-1',
+                recipientAgentName: 'claude-code',
+                message: { content: 'test' },
+            },
+            timestamp: new Date().toISOString(),
+        }));
+        expect(mockSpawn).toHaveBeenCalledWith('claude', expect.any(Array), expect.any(Object));
+    });
+    it('matches partial agent name containing config key', () => {
+        startWithAllHeadless();
+        const handler = getEventHandler('message');
+        handler(JSON.stringify({
+            type: 'message_undelivered',
+            payload: {
+                recipientAgentId: 'id-2',
+                recipientAgentName: 'my-claude-code-agent',
+                message: { content: 'test' },
+            },
+            timestamp: new Date().toISOString(),
+        }));
+        expect(mockSpawn).toHaveBeenCalledWith('claude', expect.any(Array), expect.any(Object));
+    });
+    it('returns null for completely unmatched agent name', () => {
+        startWithAllHeadless();
+        const handler = getEventHandler('message');
+        handler(JSON.stringify({
+            type: 'message_undelivered',
+            payload: {
+                recipientAgentId: 'id-3',
+                recipientAgentName: 'cursor-agent',
+                message: { content: 'test' },
+            },
+            timestamp: new Date().toISOString(),
+        }));
+        expect(mockSpawn).not.toHaveBeenCalled();
+    });
+});

package/dist/daemon/config.d.ts

@@ -0,0 +1,26 @@
+import { type DaemonConfig } from '@swarmroom/shared';
+/**
+ * Returns the path to the daemon config file.
+ */
+export declare function getConfigPath(): string;
+/**
+ * Returns the default daemon configuration.
+ * All agents have headlessWakeup disabled by default.
+ */
+export declare function getDefaultConfig(): DaemonConfig;
+/**
+ * Load daemon config from ~/.swarmroom/daemon.json.
+ * Returns default config if file doesn't exist.
+ * Validates with Zod schema and merges with defaults for missing fields.
+ */
+export declare function loadDaemonConfig(): DaemonConfig;
+/**
+ * Save daemon config to ~/.swarmroom/daemon.json.
+ * Creates the ~/.swarmroom/ directory if it doesn't exist.
+ */
+export declare function saveDaemonConfig(config: DaemonConfig): void;
+/**
+ * Ensure the config file exists. If not, write defaults.
+ * Returns the loaded (or newly created) config.
+ */
+export declare function ensureConfig(): DaemonConfig;

package/dist/daemon/config.js

@@ -0,0 +1,89 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { DaemonConfigSchema } from '@swarmroom/shared';
+const CONFIG_DIR = join(homedir(), '.swarmroom');
+const CONFIG_PATH = join(CONFIG_DIR, 'daemon.json');
+/**
+ * Returns the path to the daemon config file.
+ */
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+/**
+ * Returns the default daemon configuration.
+ * All agents have headlessWakeup disabled by default.
+ */
+export function getDefaultConfig() {
+    return {
+        hubUrl: 'http://localhost:3000',
+        agents: {
+            'claude-code': {
+                headlessWakeup: false,
+                command: 'claude',
+                args: ['-p', '{message}', '--dangerously-skip-permissions'],
+            },
+            'opencode': {
+                headlessWakeup: false,
+                command: 'opencode',
+                args: ['run', '{message}'],
+            },
+            'gemini-cli': {
+                headlessWakeup: false,
+                command: 'gemini',
+                args: ['-p', '{message}'],
+            },
+        },
+    };
+}
+/**
+ * Load daemon config from ~/.swarmroom/daemon.json.
+ * Returns default config if file doesn't exist.
+ * Validates with Zod schema and merges with defaults for missing fields.
+ */
+export function loadDaemonConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return getDefaultConfig();
+    }
+    try {
+        const raw = readFileSync(CONFIG_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        // Merge with defaults: user config overrides defaults
+        const defaults = getDefaultConfig();
+        const merged = {
+            ...defaults,
+            ...parsed,
+            agents: {
+                ...defaults.agents,
+                ...(parsed.agents ?? {}),
+            },
+        };
+        return DaemonConfigSchema.parse(merged);
+    }
+    catch (error) {
+        console.warn(`[daemon] Failed to load config from ${CONFIG_PATH}, using defaults:`, error);
+        return getDefaultConfig();
+    }
+}
+/**
+ * Save daemon config to ~/.swarmroom/daemon.json.
+ * Creates the ~/.swarmroom/ directory if it doesn't exist.
+ */
+export function saveDaemonConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Ensure the config file exists. If not, write defaults.
+ * Returns the loaded (or newly created) config.
+ */
+export function ensureConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        const config = getDefaultConfig();
+        saveDaemonConfig(config);
+        return config;
+    }
+    return loadDaemonConfig();
+}

package/dist/daemon/process-detector.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Check if a process matching the given name/pattern is currently running.
+ * Uses `pgrep -f` on Linux/macOS or `tasklist` on Windows.
+ */
+export declare function isProcessRunning(processPattern: string): boolean;
+/** Check if any Claude Code process is running */
+export declare function isClaudeCodeRunning(): boolean;
+/** Check if any OpenCode process is running */
+export declare function isOpenCodeRunning(): boolean;
+/** Check if any Gemini CLI process is running */
+export declare function isGeminiCliRunning(): boolean;
+/**
+ * Map of agent type names to their process detection functions.
+ * Agent type names match the keys used in DaemonConfig.agents.
+ */
+export declare const AGENT_PROCESS_DETECTORS: Record<string, () => boolean>;
+/**
+ * Check if the agent of the given type has a running process.
+ * Returns false for unknown agent types.
+ */
+export declare function isAgentProcessRunning(agentType: string): boolean;

package/dist/daemon/process-detector.js

@@ -0,0 +1,59 @@
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+/**
+ * Check if a process matching the given name/pattern is currently running.
+ * Uses `pgrep -f` on Linux/macOS or `tasklist` on Windows.
+ */
+export function isProcessRunning(processPattern) {
+    const os = platform();
+    try {
+        if (os === 'win32') {
+            const output = execSync(`tasklist /FI "IMAGENAME eq ${processPattern}*"`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            return !output.includes('No tasks are running');
+        }
+        else {
+            // Linux / macOS — pgrep -f matches full command line
+            execSync(`pgrep -f "${processPattern}"`, {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            return true; // pgrep exits 0 = found
+        }
+    }
+    catch {
+        return false; // pgrep exits 1 = not found, or command failed
+    }
+}
+/** Check if any Claude Code process is running */
+export function isClaudeCodeRunning() {
+    return isProcessRunning('claude');
+}
+/** Check if any OpenCode process is running */
+export function isOpenCodeRunning() {
+    return isProcessRunning('opencode');
+}
+/** Check if any Gemini CLI process is running */
+export function isGeminiCliRunning() {
+    return isProcessRunning('gemini');
+}
+/**
+ * Map of agent type names to their process detection functions.
+ * Agent type names match the keys used in DaemonConfig.agents.
+ */
+export const AGENT_PROCESS_DETECTORS = {
+    'claude-code': isClaudeCodeRunning,
+    'opencode': isOpenCodeRunning,
+    'gemini-cli': isGeminiCliRunning,
+};
+/**
+ * Check if the agent of the given type has a running process.
+ * Returns false for unknown agent types.
+ */
+export function isAgentProcessRunning(agentType) {
+    const detector = AGENT_PROCESS_DETECTORS[agentType];
+    if (!detector)
+        return false;
+    return detector();
+}

package/dist/daemon/watcher.d.ts

@@ -0,0 +1,38 @@
+export interface DaemonWatcherOptions {
+    hubUrl?: string;
+    workdir?: string;
+    verbose?: boolean;
+}
+export declare class DaemonWatcher {
+    private readonly hubUrl;
+    private readonly workdir;
+    private readonly verbose;
+    private config;
+    private ws;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private intentionalDisconnect;
+    private spawnCooldowns;
+    constructor(options?: DaemonWatcherOptions);
+    /** Start the daemon — connect to Hub WebSocket */
+    start(): void;
+    /** Stop the daemon — disconnect and clean up */
+    stop(): void;
+    /** Reload config from disk */
+    reloadConfig(): void;
+    private connectWebSocket;
+    private sendRegister;
+    private handleMessage;
+    private handleUndeliveredMessage;
+    /**
+     * 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.
+     */
+    private findAgentType;
+    private isOnCooldown;
+    private spawnHeadless;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private log;
+}