swarmroom 0.1.0

package/dist/commands/start.js

@@ -0,0 +1,134 @@
+import { Command } from 'commander';
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import chalk from 'chalk';
+import { DaemonWatcher } from '../daemon/watcher.js';
+import { banner, keyValue, info, error } from '../utils/display.js';
+const HUB_STARTUP_DELAY_MS = 2000;
+function resolveServerEntry() {
+    const require = createRequire(import.meta.url);
+    return require.resolve('@swarmroom/server/dist/index.js');
+}
+function prefixLines(prefix, data) {
+    const text = data.toString().trim();
+    if (!text)
+        return;
+    for (const line of text.split('\n')) {
+        console.log(`${prefix} ${line}`);
+    }
+}
+function startHubProcess(port) {
+    const serverEntry = resolveServerEntry();
+    if (!existsSync(serverEntry)) {
+        error(`Server entry not found at: ${serverEntry}`);
+        error('Make sure the server is built: npm run build -w packages/server');
+        process.exit(1);
+    }
+    const hubProcess = spawn('node', [serverEntry], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, PORT: String(port) },
+    });
+    const hubPrefix = chalk.blue('[hub]');
+    const hubErrPrefix = chalk.red('[hub]');
+    hubProcess.stdout?.on('data', (data) => {
+        prefixLines(hubPrefix, data);
+    });
+    hubProcess.stderr?.on('data', (data) => {
+        prefixLines(hubErrPrefix, data);
+    });
+    hubProcess.on('exit', (code) => {
+        if (code !== null && code !== 0) {
+            error(`Hub process exited with code ${code}`);
+        }
+    });
+    hubProcess.on('error', (err) => {
+        error(`Failed to start hub: ${err.message}`);
+    });
+    return hubProcess;
+}
+export function makeStartCommand() {
+    const cmd = new Command('start')
+        .description('Start SwarmRoom (hub + daemon)')
+        .option('--hub-only', 'Start only the hub server')
+        .option('--daemon-only', 'Start only the daemon watcher')
+        .option('--hub-url <url>', 'Hub URL for daemon connection')
+        .option('--port <port>', 'Server port (default: 3000)', '3000')
+        .option('--verbose', 'Enable verbose logging')
+        .action(async (options) => {
+        const port = parseInt(options.port, 10);
+        const verbose = options.verbose ?? false;
+        if (options.hubOnly && options.daemonOnly) {
+            error('Cannot use --hub-only and --daemon-only together.');
+            process.exit(1);
+        }
+        if (options.hubOnly) {
+            banner('SwarmRoom Hub');
+            info('Starting hub server only...');
+            keyValue('Port', chalk.cyan(String(port)));
+            console.log('');
+            const hubProcess = startHubProcess(port);
+            const shutdown = () => {
+                console.log('');
+                info('Shutting down hub...');
+                hubProcess.kill('SIGTERM');
+                process.exit(0);
+            };
+            process.on('SIGINT', shutdown);
+            process.on('SIGTERM', shutdown);
+            return;
+        }
+        if (options.daemonOnly) {
+            const hubUrl = options.hubUrl ?? `http://localhost:${port}`;
+            banner('SwarmRoom Daemon');
+            info('Starting daemon watcher only...');
+            keyValue('Hub URL', chalk.cyan(hubUrl));
+            console.log('');
+            const watcher = new DaemonWatcher({
+                hubUrl,
+                workdir: process.cwd(),
+                verbose,
+            });
+            watcher.start();
+            const shutdown = () => {
+                console.log('');
+                info('Shutting down daemon...');
+                watcher.stop();
+                process.exit(0);
+            };
+            process.on('SIGINT', shutdown);
+            process.on('SIGTERM', shutdown);
+            return;
+        }
+        const hubUrl = options.hubUrl ?? `http://localhost:${port}`;
+        banner('SwarmRoom', 'Hub + Daemon');
+        info('Starting hub server and daemon watcher...');
+        keyValue('Port', chalk.cyan(String(port)));
+        keyValue('Hub URL', chalk.cyan(hubUrl));
+        if (verbose) {
+            keyValue('Verbose', chalk.yellow('enabled'));
+        }
+        console.log('');
+        const hubProcess = startHubProcess(port);
+        const watcher = new DaemonWatcher({
+            hubUrl,
+            workdir: process.cwd(),
+            verbose,
+        });
+        const daemonTimer = setTimeout(() => {
+            info('Starting daemon watcher...');
+            watcher.start();
+        }, HUB_STARTUP_DELAY_MS);
+        const shutdown = () => {
+            console.log('');
+            info('Shutting down SwarmRoom...');
+            clearTimeout(daemonTimer);
+            watcher.stop();
+            hubProcess.kill('SIGTERM');
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+    return cmd;
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function makeStatusCommand(): Command;

package/dist/commands/status.js

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { DEFAULT_PORT } from '@swarmroom/shared';
+import { banner, keyValue, error, formatUptime, statusIndicator, } from '../utils/display.js';
+async function resolveHubUrl(providedUrl) {
+    if (providedUrl)
+        return providedUrl;
+    try {
+        const { discoverHub } = await import('@swarmroom/sdk');
+        const discovered = await discoverHub(3000);
+        if (discovered)
+            return discovered;
+    }
+    catch {
+    }
+    return `http://localhost:${DEFAULT_PORT}`;
+}
+export function makeStatusCommand() {
+    const cmd = new Command('status')
+        .description('Show SwarmRoom Hub status')
+        .option('--hub-url <url>', 'Hub URL (or discover via mDNS)')
+        .action(async (options) => {
+        banner('SwarmRoom Status');
+        const hubUrl = await resolveHubUrl(options.hubUrl);
+        const spinner = ora(`Connecting to ${chalk.cyan(hubUrl)}...`).start();
+        try {
+            const response = await fetch(`${hubUrl}/health`);
+            if (!response.ok) {
+                spinner.fail(`Hub returned HTTP ${response.status}`);
+                return;
+            }
+            const health = (await response.json());
+            spinner.stop();
+            console.log('');
+            keyValue('Hub URL', chalk.cyan(hubUrl));
+            keyValue('Status', statusIndicator(health.status === 'ok' ? 'online' : 'offline'));
+            keyValue('Version', chalk.white(health.version));
+            keyValue('Uptime', chalk.white(formatUptime(health.uptime)));
+            keyValue('Agents', chalk.white(String(health.agentCount)));
+            console.log('');
+        }
+        catch {
+            spinner.fail(`Cannot connect to Hub at ${chalk.cyan(hubUrl)}`);
+            console.log('');
+            error('Hub is offline or unreachable.');
+            console.log('');
+            keyValue('Hub URL', chalk.cyan(hubUrl));
+            keyValue('Status', statusIndicator('offline'));
+            console.log('');
+            console.log(chalk.gray('  Tip: Start the hub with ') +
+                chalk.cyan('npm run dev -w packages/server') +
+                chalk.gray(' or check the URL.'));
+            console.log('');
+        }
+    });
+    return cmd;
+}

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

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

package/dist/configurators/__tests__/configurators.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ClaudeCodeConfigurator } from '../claude-code.js';
+import { OpenCodeConfigurator } from '../opencode.js';
+import { GeminiCliConfigurator } from '../gemini-cli.js';
+import { configureAgent } from '../index.js';
+let tempDir;
+afterEach(() => {
+    if (tempDir) {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+});
+function createTempDir() {
+    tempDir = mkdtempSync(join(tmpdir(), 'swarmroom-test-'));
+    return tempDir;
+}
+describe('ClaudeCodeConfigurator', () => {
+    const configurator = new ClaudeCodeConfigurator();
+    const hubUrl = 'http://localhost:3000';
+    it('writes correct JSON to new config file', async () => {
+        const dir = createTempDir();
+        const configPath = join(dir, '.mcp.json');
+        const result = await configurator.configure(hubUrl, configPath, false);
+        expect(result.success).toBe(true);
+        expect(result.backedUp).toBe(false);
+        const written = JSON.parse(readFileSync(configPath, 'utf-8'));
+        expect(written.mcpServers.swarmroom).toEqual({
+            type: 'http',
+            url: 'http://localhost:3000/mcp',
+        });
+    });
+    it('merges with existing config and creates backup', async () => {
+        const dir = createTempDir();
+        const configPath = join(dir, '.mcp.json');
+        const existingConfig = {
+            mcpServers: {
+                other: { type: 'stdio', command: 'some-tool' },
+            },
+        };
+        writeFileSync(configPath, JSON.stringify(existingConfig, null, 2), 'utf-8');
+        const result = await configurator.configure(hubUrl, configPath, false);
+        expect(result.success).toBe(true);
+        expect(result.backedUp).toBe(true);
+        expect(result.backupPath).toBe(configPath + '.bak');
+        expect(existsSync(configPath + '.bak')).toBe(true);
+        const merged = JSON.parse(readFileSync(configPath, 'utf-8'));
+        expect(merged.mcpServers.other).toEqual({ type: 'stdio', command: 'some-tool' });
+        expect(merged.mcpServers.swarmroom).toEqual({
+            type: 'http',
+            url: 'http://localhost:3000/mcp',
+        });
+    });
+    it('does not write files in dry-run mode', async () => {
+        const dir = createTempDir();
+        const configPath = join(dir, '.mcp.json');
+        const result = await configurator.configure(hubUrl, configPath, true);
+        expect(result.success).toBe(true);
+        expect(result.backedUp).toBe(false);
+        expect(result.before).toBe('{}');
+        expect(result.after).toContain('swarmroom');
+        expect(existsSync(configPath)).toBe(false);
+    });
+});
+describe('OpenCodeConfigurator', () => {
+    const configurator = new OpenCodeConfigurator();
+    const hubUrl = 'http://localhost:3000';
+    it('writes config with mcp key (not mcpServers)', async () => {
+        const dir = createTempDir();
+        const configPath = join(dir, 'opencode.json');
+        const result = await configurator.configure(hubUrl, configPath, false);
+        expect(result.success).toBe(true);
+        const written = JSON.parse(readFileSync(configPath, 'utf-8'));
+        expect(written.mcp.swarmroom).toEqual({
+            type: 'remote',
+            url: 'http://localhost:3000/mcp',
+        });
+        expect(written.mcpServers).toBeUndefined();
+    });
+});
+describe('GeminiCliConfigurator', () => {
+    const configurator = new GeminiCliConfigurator();
+    const hubUrl = 'http://localhost:3000';
+    it('creates parent directories and writes httpUrl format', async () => {
+        const dir = createTempDir();
+        const configPath = join(dir, '.gemini', 'settings.json');
+        const result = await configurator.configure(hubUrl, configPath, false);
+        expect(result.success).toBe(true);
+        const written = JSON.parse(readFileSync(configPath, 'utf-8'));
+        expect(written.mcpServers.swarmroom).toEqual({
+            httpUrl: 'http://localhost:3000/mcp',
+        });
+    });
+});
+describe('configureAgent', () => {
+    it('returns error for unknown agent name', async () => {
+        const result = await configureAgent('Unknown Agent', 'http://localhost:3000', '/tmp/fake', false);
+        expect(result.success).toBe(false);
+        expect(result.error).toContain('No configurator found');
+    });
+});

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

@@ -0,0 +1,5 @@
+import type { AgentConfigurator, ConfiguratorResult } from './index.js';
+export declare class ClaudeCodeConfigurator implements AgentConfigurator {
+    readonly name = "Claude Code";
+    configure(hubUrl: string, configPath: string, dryRun: boolean): Promise<ConfiguratorResult>;
+}

package/dist/configurators/claude-code.js

@@ -0,0 +1,60 @@
+import { readFileSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
+export class ClaudeCodeConfigurator {
+    name = 'Claude Code';
+    async configure(hubUrl, configPath, dryRun) {
+        try {
+            let existing = {};
+            let before = '{}';
+            if (existsSync(configPath)) {
+                const raw = readFileSync(configPath, 'utf-8');
+                before = raw;
+                existing = JSON.parse(raw);
+            }
+            const mcpServers = (existing.mcpServers ?? {});
+            const merged = {
+                ...existing,
+                mcpServers: {
+                    ...mcpServers,
+                    swarmroom: {
+                        type: 'http',
+                        url: `${hubUrl}/mcp`,
+                    },
+                },
+            };
+            const after = JSON.stringify(merged, null, 2) + '\n';
+            if (dryRun) {
+                return {
+                    success: true,
+                    configPath,
+                    backedUp: false,
+                    before,
+                    after,
+                };
+            }
+            let backedUp = false;
+            let backupPath;
+            if (existsSync(configPath)) {
+                backupPath = configPath + '.bak';
+                copyFileSync(configPath, backupPath);
+                backedUp = true;
+            }
+            writeFileSync(configPath, after, 'utf-8');
+            return {
+                success: true,
+                configPath,
+                backedUp,
+                backupPath,
+                before,
+                after,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                configPath,
+                backedUp: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { AgentConfigurator, ConfiguratorResult } from './index.js';
+export declare class GeminiCliConfigurator implements AgentConfigurator {
+    readonly name = "Gemini CLI";
+    configure(hubUrl: string, configPath: string, dryRun: boolean): Promise<ConfiguratorResult>;
+}

package/dist/configurators/gemini-cli.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync, copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class GeminiCliConfigurator {
+    name = 'Gemini CLI';
+    async configure(hubUrl, configPath, dryRun) {
+        try {
+            let existing = {};
+            let before = '{}';
+            if (existsSync(configPath)) {
+                const raw = readFileSync(configPath, 'utf-8');
+                before = raw;
+                existing = JSON.parse(raw);
+            }
+            const mcpServers = (existing.mcpServers ?? {});
+            const merged = {
+                ...existing,
+                mcpServers: {
+                    ...mcpServers,
+                    swarmroom: {
+                        httpUrl: `${hubUrl}/mcp`,
+                    },
+                },
+            };
+            const after = JSON.stringify(merged, null, 2) + '\n';
+            if (dryRun) {
+                return {
+                    success: true,
+                    configPath,
+                    backedUp: false,
+                    before,
+                    after,
+                };
+            }
+            mkdirSync(dirname(configPath), { recursive: true });
+            let backedUp = false;
+            let backupPath;
+            if (existsSync(configPath)) {
+                backupPath = configPath + '.bak';
+                copyFileSync(configPath, backupPath);
+                backedUp = true;
+            }
+            writeFileSync(configPath, after, 'utf-8');
+            return {
+                success: true,
+                configPath,
+                backedUp,
+                backupPath,
+                before,
+                after,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                configPath,
+                backedUp: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}

package/dist/configurators/index.d.ts

@@ -0,0 +1,18 @@
+import { ClaudeCodeConfigurator } from './claude-code.js';
+import { OpenCodeConfigurator } from './opencode.js';
+import { GeminiCliConfigurator } from './gemini-cli.js';
+export interface ConfiguratorResult {
+    success: boolean;
+    configPath: string;
+    backedUp: boolean;
+    backupPath?: string;
+    error?: string;
+    before?: string;
+    after?: string;
+}
+export interface AgentConfigurator {
+    name: string;
+    configure(hubUrl: string, configPath: string, dryRun: boolean): Promise<ConfiguratorResult>;
+}
+export declare function configureAgent(agentName: string, hubUrl: string, configPath: string, dryRun: boolean): Promise<ConfiguratorResult>;
+export { ClaudeCodeConfigurator, OpenCodeConfigurator, GeminiCliConfigurator };

package/dist/configurators/index.js

@@ -0,0 +1,21 @@
+import { ClaudeCodeConfigurator } from './claude-code.js';
+import { OpenCodeConfigurator } from './opencode.js';
+import { GeminiCliConfigurator } from './gemini-cli.js';
+const configurators = {
+    'Claude Code': new ClaudeCodeConfigurator(),
+    'OpenCode': new OpenCodeConfigurator(),
+    'Gemini CLI': new GeminiCliConfigurator(),
+};
+export async function configureAgent(agentName, hubUrl, configPath, dryRun) {
+    const configurator = configurators[agentName];
+    if (!configurator) {
+        return {
+            success: false,
+            configPath,
+            backedUp: false,
+            error: `No configurator found for agent: ${agentName}`,
+        };
+    }
+    return configurator.configure(hubUrl, configPath, dryRun);
+}
+export { ClaudeCodeConfigurator, OpenCodeConfigurator, GeminiCliConfigurator };

package/dist/configurators/opencode.d.ts

@@ -0,0 +1,5 @@
+import type { AgentConfigurator, ConfiguratorResult } from './index.js';
+export declare class OpenCodeConfigurator implements AgentConfigurator {
+    readonly name = "OpenCode";
+    configure(hubUrl: string, configPath: string, dryRun: boolean): Promise<ConfiguratorResult>;
+}

package/dist/configurators/opencode.js

@@ -0,0 +1,60 @@
+import { readFileSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
+export class OpenCodeConfigurator {
+    name = 'OpenCode';
+    async configure(hubUrl, configPath, dryRun) {
+        try {
+            let existing = {};
+            let before = '{}';
+            if (existsSync(configPath)) {
+                const raw = readFileSync(configPath, 'utf-8');
+                before = raw;
+                existing = JSON.parse(raw);
+            }
+            const mcp = (existing.mcp ?? {});
+            const merged = {
+                ...existing,
+                mcp: {
+                    ...mcp,
+                    swarmroom: {
+                        type: 'remote',
+                        url: `${hubUrl}/mcp`,
+                    },
+                },
+            };
+            const after = JSON.stringify(merged, null, 2) + '\n';
+            if (dryRun) {
+                return {
+                    success: true,
+                    configPath,
+                    backedUp: false,
+                    before,
+                    after,
+                };
+            }
+            let backedUp = false;
+            let backupPath;
+            if (existsSync(configPath)) {
+                backupPath = configPath + '.bak';
+                copyFileSync(configPath, backupPath);
+                backedUp = true;
+            }
+            writeFileSync(configPath, after, 'utf-8');
+            return {
+                success: true,
+                configPath,
+                backedUp,
+                backupPath,
+                before,
+                after,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                configPath,
+                backedUp: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}

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

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

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

@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { getDefaultConfig, loadDaemonConfig, saveDaemonConfig, ensureConfig, getConfigPath, } from '../config.js';
+const mockedExistsSync = vi.mocked(existsSync);
+const mockedReadFileSync = vi.mocked(readFileSync);
+const mockedWriteFileSync = vi.mocked(writeFileSync);
+const mockedMkdirSync = vi.mocked(mkdirSync);
+const CONFIG_DIR = join(homedir(), '.swarmroom');
+const CONFIG_PATH = join(CONFIG_DIR, 'daemon.json');
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('getConfigPath', () => {
+    it('returns the correct path under ~/.swarmroom/', () => {
+        const path = getConfigPath();
+        expect(path).toBe(CONFIG_PATH);
+    });
+});
+describe('getDefaultConfig', () => {
+    it('returns config with hubUrl and three agents', () => {
+        const config = getDefaultConfig();
+        expect(config.hubUrl).toBe('http://localhost:3000');
+        expect(Object.keys(config.agents)).toHaveLength(3);
+        expect(config.agents).toHaveProperty('claude-code');
+        expect(config.agents).toHaveProperty('opencode');
+        expect(config.agents).toHaveProperty('gemini-cli');
+    });
+    it('has all agents with headlessWakeup disabled by default', () => {
+        const config = getDefaultConfig();
+        for (const agent of Object.values(config.agents)) {
+            expect(agent.headlessWakeup).toBe(false);
+        }
+    });
+    it('has correct command for each agent', () => {
+        const config = getDefaultConfig();
+        expect(config.agents['claude-code'].command).toBe('claude');
+        expect(config.agents['opencode'].command).toBe('opencode');
+        expect(config.agents['gemini-cli'].command).toBe('gemini');
+    });
+});
+describe('loadDaemonConfig', () => {
+    it('returns defaults when config file does not exist', () => {
+        mockedExistsSync.mockReturnValue(false);
+        const config = loadDaemonConfig();
+        expect(config).toEqual(getDefaultConfig());
+        expect(mockedReadFileSync).not.toHaveBeenCalled();
+    });
+    it('parses valid config from file and merges with defaults', () => {
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(JSON.stringify({
+            hubUrl: 'http://myhost:4000',
+            agents: {
+                'claude-code': {
+                    headlessWakeup: true,
+                    command: 'claude',
+                    args: ['-p', '{message}'],
+                },
+            },
+        }));
+        const config = loadDaemonConfig();
+        expect(config.hubUrl).toBe('http://myhost:4000');
+        expect(config.agents['claude-code'].headlessWakeup).toBe(true);
+        expect(config.agents['opencode']).toBeDefined();
+        expect(config.agents['gemini-cli']).toBeDefined();
+    });
+    it('handles invalid JSON gracefully and returns defaults', () => {
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue('not valid json {{{');
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const config = loadDaemonConfig();
+        expect(config).toEqual(getDefaultConfig());
+        warnSpy.mockRestore();
+    });
+});
+describe('saveDaemonConfig', () => {
+    it('writes JSON to the correct path', () => {
+        mockedExistsSync.mockReturnValue(true);
+        const config = getDefaultConfig();
+        saveDaemonConfig(config);
+        expect(mockedWriteFileSync).toHaveBeenCalledWith(CONFIG_PATH, expect.stringContaining('"hubUrl"'), 'utf-8');
+    });
+    it('creates directory if it does not exist', () => {
+        mockedExistsSync.mockReturnValue(false);
+        saveDaemonConfig(getDefaultConfig());
+        expect(mockedMkdirSync).toHaveBeenCalledWith(CONFIG_DIR, { recursive: true });
+        expect(mockedWriteFileSync).toHaveBeenCalled();
+    });
+    it('does not create directory if it already exists', () => {
+        mockedExistsSync.mockReturnValue(true);
+        saveDaemonConfig(getDefaultConfig());
+        expect(mockedMkdirSync).not.toHaveBeenCalled();
+    });
+});
+describe('ensureConfig', () => {
+    it('creates file with defaults when config does not exist', () => {
+        mockedExistsSync.mockReturnValue(false);
+        const config = ensureConfig();
+        expect(config).toEqual(getDefaultConfig());
+        expect(mockedWriteFileSync).toHaveBeenCalled();
+    });
+    it('loads existing config when file exists', () => {
+        mockedExistsSync.mockReturnValue(true);
+        mockedReadFileSync.mockReturnValue(JSON.stringify({
+            hubUrl: 'http://custom:5000',
+            agents: {
+                'claude-code': {
+                    headlessWakeup: true,
+                    command: 'claude',
+                    args: ['-p', '{message}'],
+                },
+            },
+        }));
+        const config = ensureConfig();
+        expect(config.hubUrl).toBe('http://custom:5000');
+        expect(mockedWriteFileSync).not.toHaveBeenCalled();
+    });
+});

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

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