swarmroom 0.1.0

package/bin/swarmroom.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/commands/agents.d.ts

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

package/dist/commands/agents.js

@@ -0,0 +1,71 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { DEFAULT_PORT } from '@swarmroom/shared';
+import { banner, table, error, info, 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 makeAgentsCommand() {
+    const cmd = new Command('agents')
+        .description('List all registered agents')
+        .option('--hub-url <url>', 'Hub URL (or discover via mDNS)')
+        .action(async (options) => {
+        banner('SwarmRoom Agents');
+        const hubUrl = await resolveHubUrl(options.hubUrl);
+        const spinner = ora(`Fetching agents from ${chalk.cyan(hubUrl)}...`).start();
+        try {
+            const response = await fetch(`${hubUrl}/api/agents`);
+            if (!response.ok) {
+                spinner.fail(`Hub returned HTTP ${response.status}`);
+                return;
+            }
+            const result = (await response.json());
+            const agents = result.data.agents;
+            spinner.stop();
+            if (agents.length === 0) {
+                console.log('');
+                info('No agents registered yet.');
+                console.log('');
+                console.log(chalk.gray('  Tip: Connect an agent using the SDK or configure one with ') +
+                    chalk.cyan('swarmroom setup'));
+                console.log('');
+                return;
+            }
+            console.log('');
+            info(`${agents.length} agent(s) registered`);
+            console.log('');
+            const headers = ['Name', 'Status', 'Teams', 'ID'];
+            const rows = agents.map((agent) => {
+                const name = agent.displayName ?? agent.name;
+                const status = statusIndicator(agent.status);
+                const teams = agent.agentCard?.teams?.join(', ') ?? chalk.gray('none');
+                const id = chalk.gray(agent.id.slice(0, 8) + '…');
+                return [name, status, teams, id];
+            });
+            table(headers, rows);
+            console.log('');
+        }
+        catch {
+            spinner.fail(`Cannot connect to Hub at ${chalk.cyan(hubUrl)}`);
+            console.log('');
+            error('Hub is offline or unreachable.');
+            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/commands/daemon.d.ts

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

package/dist/commands/daemon.js

@@ -0,0 +1,302 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { DaemonWatcher } from '../daemon/watcher.js';
+import { loadDaemonConfig, saveDaemonConfig, getDefaultConfig, } from '../daemon/config.js';
+import { banner, keyValue, info, success, error, warn, table, } from '../utils/display.js';
+const PID_FILE = join(homedir(), '.swarmroom', 'daemon.pid');
+function makeStartCommand() {
+    return new Command('start')
+        .description('Start the SwarmRoom daemon')
+        .option('--hub-url <url>', 'Override hub URL')
+        .option('--verbose', 'Enable verbose logging')
+        .option('--background', 'Run as detached background process')
+        .action(async (options) => {
+        banner('SwarmRoom Daemon');
+        const config = loadDaemonConfig();
+        const hubUrl = options.hubUrl ?? config.hubUrl;
+        if (options.background) {
+            const args = [process.argv[1], 'daemon', 'start', '--hub-url', hubUrl];
+            if (options.verbose) {
+                args.push('--verbose');
+            }
+            const child = spawn(process.argv[0], args, {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            const pid = child.pid;
+            if (pid) {
+                const pidDir = join(homedir(), '.swarmroom');
+                if (!existsSync(pidDir)) {
+                    const { mkdirSync } = await import('node:fs');
+                    mkdirSync(pidDir, { recursive: true });
+                }
+                writeFileSync(PID_FILE, String(pid), 'utf-8');
+                success(`Daemon started in background (PID: ${chalk.bold(String(pid))})`);
+                keyValue('Hub URL', chalk.cyan(hubUrl));
+                keyValue('PID file', chalk.gray(PID_FILE));
+            }
+            else {
+                error('Failed to start daemon process.');
+            }
+            return;
+        }
+        info(`Starting daemon in foreground...`);
+        keyValue('Hub URL', chalk.cyan(hubUrl));
+        console.log('');
+        const watcher = new DaemonWatcher({
+            hubUrl,
+            verbose: options.verbose ?? false,
+            workdir: process.cwd(),
+        });
+        watcher.start();
+        const shutdown = () => {
+            console.log('');
+            info('Shutting down daemon...');
+            watcher.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+}
+function makeStopCommand() {
+    return new Command('stop')
+        .description('Stop the SwarmRoom daemon')
+        .action(() => {
+        banner('SwarmRoom Daemon');
+        if (!existsSync(PID_FILE)) {
+            error('No daemon PID file found. Daemon may not be running.');
+            return;
+        }
+        const pidStr = readFileSync(PID_FILE, 'utf-8').trim();
+        const pid = parseInt(pidStr, 10);
+        if (isNaN(pid)) {
+            error(`Invalid PID in ${PID_FILE}: "${pidStr}"`);
+            unlinkSync(PID_FILE);
+            return;
+        }
+        try {
+            process.kill(pid, 'SIGTERM');
+            unlinkSync(PID_FILE);
+            success(`Daemon stopped (PID: ${chalk.bold(String(pid))})`);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ESRCH') {
+                warn('Daemon process not found (may have already stopped).');
+                unlinkSync(PID_FILE);
+            }
+            else {
+                error(`Failed to stop daemon (PID: ${pid}): ${err.message}`);
+            }
+        }
+    });
+}
+function makeStatusSubcommand() {
+    return new Command('status')
+        .description('Show daemon status')
+        .action(() => {
+        banner('SwarmRoom Daemon');
+        let daemonRunning = false;
+        let daemonPid = null;
+        if (existsSync(PID_FILE)) {
+            const pidStr = readFileSync(PID_FILE, 'utf-8').trim();
+            const pid = parseInt(pidStr, 10);
+            if (!isNaN(pid)) {
+                try {
+                    process.kill(pid, 0);
+                    daemonRunning = true;
+                    daemonPid = pid;
+                }
+                catch {
+                }
+            }
+        }
+        const config = loadDaemonConfig();
+        keyValue('Status', daemonRunning
+            ? chalk.green('● running')
+            : chalk.gray('● stopped'));
+        if (daemonPid !== null) {
+            keyValue('PID', chalk.white(String(daemonPid)));
+        }
+        keyValue('Hub URL', chalk.cyan(config.hubUrl));
+        console.log('');
+        const agentNames = Object.keys(config.agents);
+        if (agentNames.length > 0) {
+            info('Agent wakeup configuration:');
+            console.log('');
+            const headers = ['Agent', 'Headless Wakeup', 'Command'];
+            const rows = agentNames.map((name) => {
+                const agent = config.agents[name];
+                const wakeup = agent.headlessWakeup
+                    ? chalk.green('enabled')
+                    : chalk.gray('disabled');
+                const cmd = chalk.white(`${agent.command} ${agent.args.join(' ')}`);
+                return [name, wakeup, cmd];
+            });
+            table(headers, rows);
+        }
+        else {
+            info('No agents configured.');
+        }
+        console.log('');
+    });
+}
+function makeConfigSubcommand() {
+    return new Command('config')
+        .description('Configure the daemon')
+        .action(async () => {
+        banner('SwarmRoom Daemon');
+        let running = true;
+        while (running) {
+            const config = loadDaemonConfig();
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: 'Daemon configuration:',
+                    choices: [
+                        { name: 'Show current config', value: 'show' },
+                        { name: 'Toggle headless wakeup for an agent', value: 'toggle' },
+                        { name: 'Set hub URL', value: 'hub-url' },
+                        { name: 'Set workdir for an agent', value: 'workdir' },
+                        { name: 'Reset to defaults', value: 'reset' },
+                        { name: 'Exit', value: 'exit' },
+                    ],
+                },
+            ]);
+            switch (action) {
+                case 'show': {
+                    console.log('');
+                    keyValue('Hub URL', chalk.cyan(config.hubUrl));
+                    console.log('');
+                    const agentNames = Object.keys(config.agents);
+                    if (agentNames.length > 0) {
+                        const headers = ['Agent', 'Headless Wakeup', 'Command', 'Workdir'];
+                        const rows = agentNames.map((name) => {
+                            const agent = config.agents[name];
+                            const wakeup = agent.headlessWakeup
+                                ? chalk.green('enabled')
+                                : chalk.gray('disabled');
+                            const cmd = `${agent.command} ${agent.args.join(' ')}`;
+                            const workdir = agent.workdir ?? chalk.gray('(default)');
+                            return [name, wakeup, cmd, workdir];
+                        });
+                        table(headers, rows);
+                    }
+                    else {
+                        info('No agents configured.');
+                    }
+                    console.log('');
+                    break;
+                }
+                case 'toggle': {
+                    const agentNames = Object.keys(config.agents);
+                    if (agentNames.length === 0) {
+                        warn('No agents configured.');
+                        break;
+                    }
+                    const { agent } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'agent',
+                            message: 'Select agent to toggle:',
+                            choices: agentNames.map((name) => {
+                                const agentConf = config.agents[name];
+                                const status = agentConf.headlessWakeup
+                                    ? chalk.green('enabled')
+                                    : chalk.gray('disabled');
+                                return { name: `${name} (${status})`, value: name };
+                            }),
+                        },
+                    ]);
+                    const agentConfig = config.agents[agent];
+                    if (agentConfig) {
+                        agentConfig.headlessWakeup = !agentConfig.headlessWakeup;
+                        saveDaemonConfig(config);
+                        const newStatus = agentConfig.headlessWakeup ? 'enabled' : 'disabled';
+                        success(`Headless wakeup for ${chalk.bold(agent)} is now ${newStatus}.`);
+                    }
+                    break;
+                }
+                case 'hub-url': {
+                    const { url } = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'url',
+                            message: 'Enter new hub URL:',
+                            default: config.hubUrl,
+                        },
+                    ]);
+                    config.hubUrl = url;
+                    saveDaemonConfig(config);
+                    success(`Hub URL set to ${chalk.cyan(url)}`);
+                    break;
+                }
+                case 'workdir': {
+                    const agentNames = Object.keys(config.agents);
+                    if (agentNames.length === 0) {
+                        warn('No agents configured.');
+                        break;
+                    }
+                    const { agent } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'agent',
+                            message: 'Select agent:',
+                            choices: agentNames,
+                        },
+                    ]);
+                    const { dir } = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'dir',
+                            message: `Working directory for ${agent}:`,
+                            default: config.agents[agent]?.workdir ?? process.cwd(),
+                        },
+                    ]);
+                    const agentConfig = config.agents[agent];
+                    if (agentConfig) {
+                        agentConfig.workdir = dir;
+                        saveDaemonConfig(config);
+                        success(`Workdir for ${chalk.bold(agent)} set to ${chalk.cyan(dir)}`);
+                    }
+                    break;
+                }
+                case 'reset': {
+                    const { confirm } = await inquirer.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: 'Reset daemon config to defaults?',
+                            default: false,
+                        },
+                    ]);
+                    if (confirm) {
+                        saveDaemonConfig(getDefaultConfig());
+                        success('Config reset to defaults.');
+                    }
+                    break;
+                }
+                case 'exit':
+                    running = false;
+                    break;
+            }
+        }
+    });
+}
+export function makeDaemonCommand() {
+    const cmd = new Command('daemon')
+        .description('Manage the SwarmRoom daemon');
+    cmd.addCommand(makeStartCommand());
+    cmd.addCommand(makeStopCommand());
+    cmd.addCommand(makeStatusSubcommand());
+    cmd.addCommand(makeConfigSubcommand());
+    return cmd;
+}

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,165 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { DEFAULT_PORT } from '@swarmroom/shared';
+import { banner, successBox, info, warn, } from '../utils/display.js';
+import { detectAllAgents } from '../detectors/index.js';
+import { configureAgent } from '../configurators/index.js';
+async function tryMdnsDiscovery() {
+    try {
+        const { discoverHub } = await import('@swarmroom/sdk');
+        return await discoverHub(5000);
+    }
+    catch {
+        return null;
+    }
+}
+async function testHubConnection(hubUrl) {
+    try {
+        const response = await fetch(`${hubUrl}/health`);
+        if (!response.ok)
+            return null;
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+export function makeSetupCommand() {
+    const cmd = new Command('setup')
+        .description('Interactive setup wizard for SwarmRoom')
+        .option('--hub-url <url>', 'Hub URL (skip mDNS discovery)')
+        .option('--dry-run', 'Show what would be configured without writing files')
+        .option('--yes', 'Skip confirmations (non-interactive)')
+        .action(async (options) => {
+        banner('SwarmRoom Setup', 'Configure your AI agents to collaborate');
+        const dryRun = options.dryRun ?? false;
+        const nonInteractive = options.yes ?? false;
+        if (dryRun) {
+            warn('Dry run mode — no files will be written');
+            console.log('');
+        }
+        let hubUrl = options.hubUrl ?? null;
+        if (!hubUrl) {
+            const mdnsSpinner = ora('Searching for SwarmRoom Hub via mDNS...').start();
+            hubUrl = await tryMdnsDiscovery();
+            if (hubUrl) {
+                mdnsSpinner.succeed(`Found Hub at ${chalk.cyan(hubUrl)}`);
+            }
+            else {
+                mdnsSpinner.info('No Hub found via mDNS');
+                if (nonInteractive) {
+                    hubUrl = `http://localhost:${DEFAULT_PORT}`;
+                    info(`Using default Hub URL: ${chalk.cyan(hubUrl)}`);
+                }
+                else {
+                    const answers = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'hubUrl',
+                            message: 'Enter Hub URL:',
+                            default: `http://localhost:${DEFAULT_PORT}`,
+                        },
+                    ]);
+                    hubUrl = answers.hubUrl;
+                }
+            }
+        }
+        const connectionSpinner = ora(`Testing connection to ${chalk.cyan(hubUrl)}...`).start();
+        const health = await testHubConnection(hubUrl);
+        if (health) {
+            connectionSpinner.succeed(`Hub is ${chalk.green('online')} (v${health.version}, ${health.agentCount} agents)`);
+        }
+        else {
+            connectionSpinner.warn(`Hub at ${chalk.cyan(hubUrl)} is ${chalk.red('offline')}`);
+            warn('Setup will continue, but some features may not work until the Hub is running.');
+            console.log('');
+        }
+        const detectSpinner = ora('Detecting installed AI agents...').start();
+        const agents = await detectAllAgents();
+        const installedAgents = agents.filter((a) => a.installed);
+        if (installedAgents.length > 0) {
+            detectSpinner.succeed(`Found ${installedAgents.length} installed agent(s)`);
+        }
+        else {
+            detectSpinner.info('No agents auto-detected');
+        }
+        console.log('');
+        for (const agent of agents) {
+            const status = agent.installed ? chalk.green('installed') : chalk.gray('not found');
+            const config = agent.configExists ? chalk.cyan(`config: ${agent.configPath}`) : chalk.gray('no config');
+            console.log(`  ${agent.name}: ${status} | ${config}`);
+        }
+        console.log('');
+        let selectedAgents;
+        if (nonInteractive) {
+            selectedAgents = installedAgents.map((a) => a.name);
+            info(`Auto-selecting ${selectedAgents.length} installed agent(s)`);
+        }
+        else {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'agents',
+                    message: 'Select agents to configure:',
+                    choices: agents.map((a) => ({
+                        name: `${a.name}${a.installed ? chalk.green(' (installed)') : ''}${a.configExists ? chalk.cyan(' (config exists)') : ''}`,
+                        value: a.name,
+                        checked: a.installed,
+                    })),
+                },
+            ]);
+            selectedAgents = answers.agents;
+        }
+        if (selectedAgents.length === 0) {
+            info('No agents selected. You can run setup again later.');
+            return;
+        }
+        console.log('');
+        const agentMap = new Map();
+        for (const agent of agents) {
+            agentMap.set(agent.name, agent);
+        }
+        const configuredAgents = [];
+        const failedAgents = [];
+        for (const agentName of selectedAgents) {
+            const detection = agentMap.get(agentName);
+            if (!detection)
+                continue;
+            const configSpinner = ora(`Configuring ${chalk.bold(agentName)}...`).start();
+            const result = await configureAgent(agentName, hubUrl, detection.configPath, dryRun);
+            if (!result.success) {
+                configSpinner.fail(`${agentName}: ${chalk.red(result.error ?? 'unknown error')}`);
+                failedAgents.push(agentName);
+                continue;
+            }
+            if (dryRun) {
+                configSpinner.info(`${agentName}: ${chalk.yellow('dry run')} → ${chalk.dim(result.configPath)}`);
+            }
+            else {
+                const backupNote = result.backedUp ? ` (backup: ${chalk.dim(result.backupPath)})` : '';
+                configSpinner.succeed(`${agentName}: ${chalk.green('configured')} → ${chalk.dim(result.configPath)}${backupNote}`);
+            }
+            if (result.after) {
+                console.log(chalk.gray(result.after.split('\n').map((l) => `    ${l}`).join('\n')));
+            }
+            configuredAgents.push(agentName);
+        }
+        console.log('');
+        const summaryLines = [
+            `Hub: ${hubUrl}`,
+            `Agents configured: ${configuredAgents.length}`,
+            ...configuredAgents.map((a) => `  ${chalk.green('✔')} ${a}`),
+            ...failedAgents.map((a) => `  ${chalk.red('✘')} ${a}`),
+        ];
+        if (dryRun) {
+            summaryLines.push('', chalk.yellow('(dry run — no files were written)'));
+        }
+        successBox('Setup Complete', summaryLines);
+        if (!dryRun && configuredAgents.length > 0) {
+            info('Run ' + chalk.cyan('swarmroom status') + ' to verify your configuration.');
+        }
+    });
+    return cmd;
+}

package/dist/commands/start.d.ts

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