@rookdaemon/agora 0.1.2 → 0.1.5

package/dist/cli.js

@@ -5,6 +5,9 @@ import { dirname, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { loadPeerConfig, savePeerConfig, initPeerConfig } from './transport/peer-config.js';
 import { sendToPeer, decodeInboundEnvelope } from './transport/http.js';
+import { sendViaRelay } from './transport/relay.js';
+import { PeerServer } from './peer/server.js';
+import { RelayServer } from './relay/server.js';
 /**
  * Get the config file path from CLI options, environment, or default.
  */
@@ -108,7 +111,7 @@ function handleWhoami(options) {
  */
 function handlePeersAdd(args, options) {
     if (args.length < 1) {
-        console.error('Error: Missing peer name. Usage: agora peers add <name> --url <url> --token <token> --pubkey <pubkey>');
+        console.error('Error: Missing peer name. Usage: agora peers add <name> --pubkey <pubkey> [--url <url> --token <token>]');
         process.exit(1);
     }
     const name = args[0];
@@ -120,25 +123,42 @@ function handlePeersAdd(args, options) {
     const url = options.url;
     const token = options.token;
     const pubkey = options.pubkey;
-    if (!url || !token || !pubkey) {
-        console.error('Error: Missing required options. Usage: agora peers add <name> --url <url> --token <token> --pubkey <pubkey>');
+    if (!pubkey) {
+        console.error('Error: Missing required --pubkey option.');
         process.exit(1);
     }
+    // Validate that if one of url/token is provided, both must be
+    if ((url && !token) || (!url && token)) {
+        console.error('Error: Both --url and --token must be provided together.');
+        process.exit(1);
+    }
+    // Check if we have HTTP transport or relay
     const config = loadPeerConfig(configPath);
-    // Add the peer (name is optional but set for clarity)
+    const hasHttpConfig = url && token;
+    const hasRelay = config.relay;
+    if (!hasHttpConfig && !hasRelay) {
+        console.error('Error: Either (--url and --token) must be provided, or relay must be configured in config file.');
+        process.exit(1);
+    }
+    // Add the peer
     config.peers[name] = {
-        url,
-        token,
         publicKey: pubkey,
         name, // Set name to match the key for consistency
     };
+    if (url && token) {
+        config.peers[name].url = url;
+        config.peers[name].token = token;
+    }
     savePeerConfig(configPath, config);
-    output({
+    const outputData = {
         status: 'added',
         name,
-        url,
         publicKey: pubkey
-    }, options.pretty || false);
+    };
+    if (url) {
+        outputData.url = url;
+    }
+    output(outputData, options.pretty || false);
 }
 /**
  * Handle the `agora peers list` command.
@@ -230,34 +250,74 @@ async function handleSend(args, options) {
         messageType = 'publish';
         messagePayload = { text: args.slice(1).join(' ') };
     }
-    // Create transport config
-    const transportConfig = {
-        identity: config.identity,
-        peers: new Map([[peer.publicKey, {
-                    url: peer.url,
-                    token: peer.token,
-                    publicKey: peer.publicKey,
-                }]]),
-    };
+    // Determine transport method: HTTP or relay
+    const hasHttpTransport = peer.url && peer.token;
+    const hasRelay = config.relay;
     // Send the message
     try {
-        const result = await sendToPeer(transportConfig, peer.publicKey, messageType, messagePayload);
-        if (result.ok) {
-            output({
-                status: 'sent',
-                peer: name,
-                type: messageType,
-                httpStatus: result.status
-            }, options.pretty || false);
+        if (hasHttpTransport) {
+            // Use HTTP transport (existing behavior)
+            // Non-null assertion: we know url and token are strings here
+            const transportConfig = {
+                identity: config.identity,
+                peers: new Map([[peer.publicKey, {
+                            url: peer.url,
+                            token: peer.token,
+                            publicKey: peer.publicKey,
+                        }]]),
+            };
+            const result = await sendToPeer(transportConfig, peer.publicKey, messageType, messagePayload);
+            if (result.ok) {
+                output({
+                    status: 'sent',
+                    peer: name,
+                    type: messageType,
+                    transport: 'http',
+                    httpStatus: result.status
+                }, options.pretty || false);
+            }
+            else {
+                output({
+                    status: 'failed',
+                    peer: name,
+                    type: messageType,
+                    transport: 'http',
+                    httpStatus: result.status,
+                    error: result.error
+                }, options.pretty || false);
+                process.exit(1);
+            }
+        }
+        else if (hasRelay) {
+            // Use relay transport
+            // Non-null assertion: we know relay is a string here
+            const relayConfig = {
+                identity: config.identity,
+                relayUrl: config.relay,
+            };
+            const result = await sendViaRelay(relayConfig, peer.publicKey, messageType, messagePayload);
+            if (result.ok) {
+                output({
+                    status: 'sent',
+                    peer: name,
+                    type: messageType,
+                    transport: 'relay'
+                }, options.pretty || false);
+            }
+            else {
+                output({
+                    status: 'failed',
+                    peer: name,
+                    type: messageType,
+                    transport: 'relay',
+                    error: result.error
+                }, options.pretty || false);
+                process.exit(1);
+            }
         }
         else {
-            output({
-                status: 'failed',
-                peer: name,
-                type: messageType,
-                httpStatus: result.status,
-                error: result.error
-            }, options.pretty || false);
+            // Neither HTTP nor relay available
+            console.error(`Error: Peer '${name}' unreachable. No HTTP endpoint and no relay configured.`);
             process.exit(1);
         }
     }
@@ -282,7 +342,14 @@ function handleDecode(args, options) {
     const config = loadPeerConfig(configPath);
     const peers = new Map();
     for (const [, val] of Object.entries(config.peers)) {
-        peers.set(val.publicKey, val);
+        // Only add peers with HTTP config to the map for decoding
+        if (val.url && val.token) {
+            peers.set(val.publicKey, {
+                url: val.url,
+                token: val.token,
+                publicKey: val.publicKey,
+            });
+        }
     }
     const message = args.join(' ');
     const result = decodeInboundEnvelope(message, peers);
@@ -305,6 +372,359 @@ function handleDecode(args, options) {
         process.exit(1);
     }
 }
+/**
+ * Handle the `agora status` command.
+ */
+function handleStatus(options) {
+    const configPath = getConfigPath(options);
+    if (!existsSync(configPath)) {
+        console.error('Error: Config file not found. Run `agora init` first.');
+        process.exit(1);
+    }
+    const config = loadPeerConfig(configPath);
+    const peerCount = Object.keys(config.peers).length;
+    output({
+        identity: config.identity.publicKey,
+        configPath,
+        relay: config.relay || 'not configured',
+        peerCount,
+        peers: Object.keys(config.peers),
+    }, options.pretty || false);
+}
+/**
+ * Handle the `agora announce` command.
+ * Broadcasts an announce message to all configured peers.
+ */
+async function handleAnnounce(options) {
+    const configPath = getConfigPath(options);
+    if (!existsSync(configPath)) {
+        console.error('Error: Config file not found. Run `agora init` first.');
+        process.exit(1);
+    }
+    const config = loadPeerConfig(configPath);
+    const peerCount = Object.keys(config.peers).length;
+    if (peerCount === 0) {
+        console.error('Error: No peers configured. Use `agora peers add` to add peers first.');
+        process.exit(1);
+    }
+    // Create announce payload
+    const announcePayload = {
+        capabilities: [],
+        metadata: {
+            name: options.name || 'agora-node',
+            version: options.version || '0.1.0',
+        },
+    };
+    // Send announce to all peers
+    const results = [];
+    for (const [name, peer] of Object.entries(config.peers)) {
+        const hasHttpTransport = peer.url && peer.token;
+        const hasRelay = config.relay;
+        try {
+            if (hasHttpTransport) {
+                // Use HTTP transport
+                const peers = new Map();
+                peers.set(peer.publicKey, {
+                    url: peer.url,
+                    token: peer.token,
+                    publicKey: peer.publicKey,
+                });
+                const transportConfig = {
+                    identity: config.identity,
+                    peers,
+                };
+                const result = await sendToPeer(transportConfig, peer.publicKey, 'announce', announcePayload);
+                if (result.ok) {
+                    results.push({
+                        peer: name,
+                        status: 'sent',
+                        transport: 'http',
+                        httpStatus: result.status,
+                    });
+                }
+                else {
+                    results.push({
+                        peer: name,
+                        status: 'failed',
+                        transport: 'http',
+                        httpStatus: result.status,
+                        error: result.error,
+                    });
+                }
+            }
+            else if (hasRelay) {
+                // Use relay transport
+                const relayConfig = {
+                    identity: config.identity,
+                    relayUrl: config.relay,
+                };
+                const result = await sendViaRelay(relayConfig, peer.publicKey, 'announce', announcePayload);
+                if (result.ok) {
+                    results.push({
+                        peer: name,
+                        status: 'sent',
+                        transport: 'relay',
+                    });
+                }
+                else {
+                    results.push({
+                        peer: name,
+                        status: 'failed',
+                        transport: 'relay',
+                        error: result.error,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    peer: name,
+                    status: 'unreachable',
+                    error: 'No HTTP endpoint and no relay configured',
+                });
+            }
+        }
+        catch (e) {
+            results.push({
+                peer: name,
+                status: 'error',
+                error: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    output({ results }, options.pretty || false);
+}
+/**
+ * Handle the `agora diagnose` command.
+ * Run diagnostic checks on a peer (ping, workspace, tools).
+ */
+async function handleDiagnose(args, options) {
+    if (args.length < 1) {
+        console.error('Error: Missing peer name. Usage: agora diagnose <name> [--checks <comma-separated-list>]');
+        process.exit(1);
+    }
+    const name = args[0];
+    const configPath = getConfigPath(options);
+    if (!existsSync(configPath)) {
+        console.error('Error: Config file not found. Run `agora init` first.');
+        process.exit(1);
+    }
+    const config = loadPeerConfig(configPath);
+    if (!config.peers[name]) {
+        console.error(`Error: Peer '${name}' not found.`);
+        process.exit(1);
+    }
+    const peer = config.peers[name];
+    if (!peer.url) {
+        console.error(`Error: Peer '${name}' has no URL configured. Cannot diagnose.`);
+        process.exit(1);
+    }
+    // Parse checks parameter
+    const checksParam = options.checks || 'ping';
+    const requestedChecks = checksParam.split(',').map(c => c.trim());
+    // Validate check types
+    const validChecks = ['ping', 'workspace', 'tools'];
+    for (const check of requestedChecks) {
+        if (!validChecks.includes(check)) {
+            console.error(`Error: Invalid check type '${check}'. Valid checks: ${validChecks.join(', ')}`);
+            process.exit(1);
+        }
+    }
+    const result = {
+        peer: name,
+        status: 'unknown',
+        checks: {},
+        timestamp: new Date().toISOString(),
+    };
+    // Run ping check
+    if (requestedChecks.includes('ping')) {
+        const startTime = Date.now();
+        try {
+            // Add timeout to prevent hanging on unreachable peers
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 10000);
+            const response = await fetch(peer.url, {
+                method: 'GET',
+                headers: peer.token ? { 'Authorization': `Bearer ${peer.token}` } : {},
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            const latency = Date.now() - startTime;
+            if (response.ok || response.status === 404 || response.status === 405) {
+                // 404 or 405 means the endpoint exists but GET isn't supported - that's OK for a ping
+                result.checks.ping = { ok: true, latency_ms: latency };
+            }
+            else {
+                result.checks.ping = { ok: false, latency_ms: latency, error: `HTTP ${response.status}` };
+            }
+        }
+        catch (err) {
+            const latency = Date.now() - startTime;
+            result.checks.ping = {
+                ok: false,
+                latency_ms: latency,
+                error: err instanceof Error ? err.message : String(err)
+            };
+        }
+    }
+    // Run workspace check
+    if (requestedChecks.includes('workspace')) {
+        // This is a placeholder - actual implementation would depend on peer's diagnostic protocol
+        result.checks.workspace = {
+            ok: false,
+            implemented: false,
+            error: 'Workspace check requires peer diagnostic protocol support'
+        };
+    }
+    // Run tools check
+    if (requestedChecks.includes('tools')) {
+        // This is a placeholder - actual implementation would depend on peer's diagnostic protocol
+        result.checks.tools = {
+            ok: false,
+            implemented: false,
+            error: 'Tools check requires peer diagnostic protocol support'
+        };
+    }
+    // Determine overall status - only consider implemented checks
+    const implementedChecks = Object.values(result.checks).filter(check => check.implemented !== false);
+    if (implementedChecks.length === 0) {
+        result.status = 'unknown';
+    }
+    else {
+        const allOk = implementedChecks.every(check => check.ok);
+        const anyOk = implementedChecks.some(check => check.ok);
+        result.status = allOk ? 'healthy' : anyOk ? 'degraded' : 'unhealthy';
+    }
+    output(result, options.pretty || false);
+}
+/**
+ * Handle the `agora serve` command.
+ * Starts a persistent WebSocket server for incoming peer connections.
+ */
+async function handleServe(options) {
+    const configPath = getConfigPath(options);
+    if (!existsSync(configPath)) {
+        console.error('Error: Config file not found. Run `agora init` first.');
+        process.exit(1);
+    }
+    const config = loadPeerConfig(configPath);
+    const port = parseInt(options.port || '9473', 10);
+    // Validate port
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(`Error: Invalid port number '${options.port}'. Port must be between 1 and 65535.`);
+        process.exit(1);
+    }
+    const serverName = options.name || 'agora-server';
+    // Create announce payload
+    const announcePayload = {
+        capabilities: [],
+        metadata: {
+            name: serverName,
+            version: '0.1.0',
+        },
+    };
+    // Create and configure PeerServer
+    const server = new PeerServer(config.identity, announcePayload);
+    // Setup event listeners
+    server.on('peer-connected', (publicKey, peer) => {
+        const peerName = peer.metadata?.name || publicKey.substring(0, 16);
+        console.log(`[${new Date().toISOString()}] Peer connected: ${peerName} (${publicKey})`);
+    });
+    server.on('peer-disconnected', (publicKey) => {
+        console.log(`[${new Date().toISOString()}] Peer disconnected: ${publicKey}`);
+    });
+    server.on('message-received', (envelope, fromPublicKey) => {
+        console.log(`[${new Date().toISOString()}] Message from ${fromPublicKey}:`);
+        console.log(JSON.stringify({
+            id: envelope.id,
+            type: envelope.type,
+            sender: envelope.sender,
+            timestamp: envelope.timestamp,
+            payload: envelope.payload,
+        }, null, 2));
+    });
+    server.on('error', (error) => {
+        console.error(`[${new Date().toISOString()}] Error:`, error.message);
+    });
+    // Start the server
+    try {
+        await server.start(port);
+        console.log(`[${new Date().toISOString()}] Agora server started`);
+        console.log(`  Name: ${serverName}`);
+        console.log(`  Public Key: ${config.identity.publicKey}`);
+        console.log(`  WebSocket Port: ${port}`);
+        console.log(`  Listening for peer connections...`);
+        console.log('');
+        console.log('Press Ctrl+C to stop the server');
+        // Keep the process alive
+        process.on('SIGINT', async () => {
+            console.log(`\n[${new Date().toISOString()}] Shutting down server...`);
+            await server.stop();
+            console.log('Server stopped');
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            console.log(`\n[${new Date().toISOString()}] Shutting down server...`);
+            await server.stop();
+            console.log('Server stopped');
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.error('Failed to start server:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
+/**
+ * Handle the `agora relay` command.
+ * Starts a WebSocket relay server for routing messages between agents.
+ */
+async function handleRelay(options) {
+    const port = parseInt(options.port || '9474', 10);
+    // Validate port
+    if (isNaN(port) || port < 1 || port > 65535) {
+        console.error(`Error: Invalid port number '${options.port}'. Port must be between 1 and 65535.`);
+        process.exit(1);
+    }
+    // Create and configure RelayServer
+    const server = new RelayServer();
+    // Setup event listeners
+    server.on('agent-registered', (publicKey) => {
+        console.log(`[${new Date().toISOString()}] Agent registered: ${publicKey}`);
+    });
+    server.on('agent-disconnected', (publicKey) => {
+        console.log(`[${new Date().toISOString()}] Agent disconnected: ${publicKey}`);
+    });
+    server.on('message-relayed', (from, to, envelope) => {
+        console.log(`[${new Date().toISOString()}] Message relayed: ${from.substring(0, 16)}... → ${to.substring(0, 16)}... (type: ${envelope.type})`);
+    });
+    server.on('error', (error) => {
+        console.error(`[${new Date().toISOString()}] Error:`, error.message);
+    });
+    // Start the server
+    try {
+        await server.start(port);
+        console.log(`[${new Date().toISOString()}] Agora relay server started`);
+        console.log(`  WebSocket Port: ${port}`);
+        console.log(`  Connected agents: 0`);
+        console.log(`  Listening for agent connections...`);
+        console.log('');
+        console.log('Press Ctrl+C to stop the relay');
+        // Shared shutdown handler
+        const shutdown = async () => {
+            console.log(`\n[${new Date().toISOString()}] Shutting down relay...`);
+            await server.stop();
+            console.log('Relay stopped');
+            process.exit(0);
+        };
+        // Keep the process alive
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (error) {
+        console.error('Failed to start relay:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}
 /**
  * Parse CLI arguments and route to appropriate handler.
  */
@@ -312,7 +732,7 @@ async function main() {
     const args = process.argv.slice(2);
     if (args.length === 0) {
         console.error('Usage: agora <command> [options]');
-        console.error('Commands: init, whoami, peers, send');
+        console.error('Commands: init, whoami, status, peers, announce, send, decode, serve, diagnose, relay');
         process.exit(1);
     }
     // Parse global options
@@ -326,6 +746,10 @@ async function main() {
             pubkey: { type: 'string' },
             type: { type: 'string' },
             payload: { type: 'string' },
+            name: { type: 'string' },
+            version: { type: 'string' },
+            port: { type: 'string' },
+            checks: { type: 'string' },
         },
         strict: false,
         allowPositionals: true,
@@ -341,6 +765,10 @@ async function main() {
         url: typeof parsed.values.url === 'string' ? parsed.values.url : undefined,
         token: typeof parsed.values.token === 'string' ? parsed.values.token : undefined,
         pubkey: typeof parsed.values.pubkey === 'string' ? parsed.values.pubkey : undefined,
+        name: typeof parsed.values.name === 'string' ? parsed.values.name : undefined,
+        version: typeof parsed.values.version === 'string' ? parsed.values.version : undefined,
+        port: typeof parsed.values.port === 'string' ? parsed.values.port : undefined,
+        checks: typeof parsed.values.checks === 'string' ? parsed.values.checks : undefined,
     };
     try {
         switch (command) {
@@ -350,12 +778,23 @@ async function main() {
             case 'whoami':
                 handleWhoami(options);
                 break;
+            case 'status':
+                handleStatus(options);
+                break;
+            case 'announce':
+                await handleAnnounce(options);
+                break;
+            case 'diagnose':
+                await handleDiagnose([subcommand, ...remainingArgs].filter(Boolean), options);
+                break;
             case 'peers':
                 switch (subcommand) {
                     case 'add':
                         handlePeersAdd(remainingArgs, options);
                         break;
                     case 'list':
+                    case undefined:
+                        // Allow 'agora peers' to work like 'agora peers list'
                         handlePeersList(options);
                         break;
                     case 'remove':
@@ -372,8 +811,14 @@ async function main() {
             case 'decode':
                 handleDecode([subcommand, ...remainingArgs].filter(Boolean), options);
                 break;
+            case 'serve':
+                await handleServe(options);
+                break;
+            case 'relay':
+                await handleRelay(options);
+                break;
             default:
-                console.error(`Error: Unknown command '${command}'. Use: init, whoami, peers, send, decode`);
+                console.error(`Error: Unknown command '${command}'. Use: init, whoami, status, peers, announce, send, decode, serve, diagnose, relay`);
                 process.exit(1);
         }
     }