@rookdaemon/agora 0.2.8 → 0.2.9

package/dist/cli.js

@@ -1,1208 +1,1234 @@
 #!/usr/bin/env node
-import { parseArgs } from 'node:util';
-import { existsSync, mkdirSync } from 'node:fs';
-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';
-import { RelayClient } from './relay/client.js';
-import { PeerDiscoveryService } from './discovery/peer-discovery.js';
-import { getDefaultBootstrapRelay } from './discovery/bootstrap.js';
-import { resolveBroadcastName } from './utils.js';
-import { ReputationStore } from './reputation/store.js';
-import { createVerification } from './reputation/verification.js';
-import { createCommit, createReveal, verifyReveal } from './reputation/commit-reveal.js';
-import { computeTrustScore } from './reputation/scoring.js';
-/**
- * Get the config file path from CLI options, environment, or default.
- */
-function getConfigPath(options) {
-    if (options.config) {
-        return resolve(options.config);
-    }
-    if (process.env.AGORA_CONFIG) {
-        return resolve(process.env.AGORA_CONFIG);
+import {
+  PeerDiscoveryService,
+  RelayClient,
+  RelayServer,
+  ReputationStore,
+  computeTrustScore,
+  createCommit,
+  createEnvelope,
+  createReveal,
+  createVerification,
+  decodeInboundEnvelope,
+  getDefaultBootstrapRelay,
+  initPeerConfig,
+  loadPeerConfig,
+  resolveBroadcastName,
+  savePeerConfig,
+  sendToPeer,
+  sendViaRelay,
+  verifyEnvelope,
+  verifyReveal
+} from "./chunk-JUOGKXFN.js";
+
+// src/cli.ts
+import { parseArgs } from "util";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { homedir } from "os";
+
+// src/peer/server.ts
+import { EventEmitter } from "events";
+import { WebSocketServer, WebSocket } from "ws";
+var PeerServer = class extends EventEmitter {
+  wss = null;
+  peers = /* @__PURE__ */ new Map();
+  identity;
+  announcePayload;
+  constructor(identity, announcePayload) {
+    super();
+    this.identity = identity;
+    this.announcePayload = announcePayload;
+  }
+  /**
+   * Start the WebSocket server
+   */
+  start(port) {
+    return new Promise((resolve2, reject) => {
+      try {
+        this.wss = new WebSocketServer({ port });
+        this.wss.on("error", (error) => {
+          this.emit("error", error);
+          reject(error);
+        });
+        this.wss.on("listening", () => {
+          resolve2();
+        });
+        this.wss.on("connection", (socket) => {
+          this.handleConnection(socket);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop the WebSocket server
+   */
+  async stop() {
+    return new Promise((resolve2, reject) => {
+      if (!this.wss) {
+        resolve2();
+        return;
+      }
+      for (const peer of this.peers.values()) {
+        peer.socket.close();
+      }
+      this.peers.clear();
+      this.wss.close((err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.wss = null;
+          resolve2();
+        }
+      });
+    });
+  }
+  /**
+   * Get all connected peers
+   */
+  getPeers() {
+    return new Map(this.peers);
+  }
+  /**
+   * Send a message to a specific peer
+   */
+  send(publicKey, envelope) {
+    const peer = this.peers.get(publicKey);
+    if (!peer || peer.socket.readyState !== WebSocket.OPEN) {
+      return false;
     }
-    return resolve(homedir(), '.config', 'agora', 'config.json');
+    try {
+      peer.socket.send(JSON.stringify(envelope));
+      return true;
+    } catch (error) {
+      this.emit("error", error);
+      return false;
+    }
+  }
+  /**
+   * Broadcast a message to all connected peers
+   */
+  broadcast(envelope) {
+    for (const [publicKey, peer] of this.peers) {
+      if (peer.socket.readyState === WebSocket.OPEN) {
+        this.send(publicKey, envelope);
+      }
+    }
+  }
+  /**
+   * Handle incoming connection
+   */
+  handleConnection(socket) {
+    let peerPublicKey = null;
+    const announceEnvelope = createEnvelope(
+      "announce",
+      this.identity.publicKey,
+      this.identity.privateKey,
+      this.announcePayload
+    );
+    socket.send(JSON.stringify(announceEnvelope));
+    socket.on("message", (data) => {
+      try {
+        const envelope = JSON.parse(data.toString());
+        const verification = verifyEnvelope(envelope);
+        if (!verification.valid) {
+          return;
+        }
+        if (!peerPublicKey) {
+          if (envelope.type === "announce") {
+            peerPublicKey = envelope.sender;
+            const payload = envelope.payload;
+            const peer = {
+              publicKey: peerPublicKey,
+              socket,
+              announced: true,
+              metadata: payload.metadata
+            };
+            this.peers.set(peerPublicKey, peer);
+            this.emit("peer-connected", peerPublicKey, peer);
+          }
+          return;
+        }
+        if (envelope.sender !== peerPublicKey) {
+          return;
+        }
+        this.emit("message-received", envelope, peerPublicKey);
+      } catch {
+      }
+    });
+    socket.on("close", () => {
+      if (peerPublicKey) {
+        this.peers.delete(peerPublicKey);
+        this.emit("peer-disconnected", peerPublicKey);
+      }
+    });
+    socket.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+};
+
+// src/cli.ts
+function getConfigPath(options) {
+  if (options.config) {
+    return resolve(options.config);
+  }
+  if (process.env.AGORA_CONFIG) {
+    return resolve(process.env.AGORA_CONFIG);
+  }
+  return resolve(homedir(), ".config", "agora", "config.json");
 }
-/**
- * Ensure the config directory exists.
- */
 function ensureConfigDir(configPath) {
-    const dir = dirname(configPath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
+  const dir = dirname(configPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
 }
-/**
- * Output data as JSON or pretty format.
- */
 function output(data, pretty) {
-    if (pretty) {
-        // Pretty output for humans
-        if (typeof data === 'object' && data !== null) {
-            for (const [key, value] of Object.entries(data)) {
-                if (Array.isArray(value)) {
-                    console.log(`${key}:`);
-                    for (const item of value) {
-                        if (typeof item === 'object' && item !== null) {
-                            const entries = Object.entries(item);
-                            console.log(`  - ${entries.map(([k, v]) => `${k}: ${v}`).join(', ')}`);
-                        }
-                        else {
-                            console.log(`  - ${item}`);
-                        }
-                    }
-                }
-                else if (typeof value === 'object' && value !== null) {
-                    console.log(`${key}:`);
-                    for (const [k, v] of Object.entries(value)) {
-                        console.log(`  ${k}: ${v}`);
-                    }
-                }
-                else {
-                    console.log(`${key}: ${value}`);
-                }
+  if (pretty) {
+    if (typeof data === "object" && data !== null) {
+      for (const [key, value] of Object.entries(data)) {
+        if (Array.isArray(value)) {
+          console.log(`${key}:`);
+          for (const item of value) {
+            if (typeof item === "object" && item !== null) {
+              const entries = Object.entries(item);
+              console.log(`  - ${entries.map(([k, v]) => `${k}: ${v}`).join(", ")}`);
+            } else {
+              console.log(`  - ${item}`);
             }
+          }
+        } else if (typeof value === "object" && value !== null) {
+          console.log(`${key}:`);
+          for (const [k, v] of Object.entries(value)) {
+            console.log(`  ${k}: ${v}`);
+          }
+        } else {
+          console.log(`${key}: ${value}`);
         }
-        else {
-            console.log(data);
-        }
-    }
-    else {
-        // JSON output for programmatic use
-        console.log(JSON.stringify(data, null, 2));
+      }
+    } else {
+      console.log(data);
     }
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
 }
-/**
- * Handle the `agora init` command.
- */
 function handleInit(options) {
-    const configPath = getConfigPath(options);
-    ensureConfigDir(configPath);
-    if (existsSync(configPath)) {
-        const config = loadPeerConfig(configPath);
-        output({
-            status: 'already_initialized',
-            publicKey: config.identity.publicKey,
-            configPath
-        }, options.pretty || false);
-        process.exit(0);
-    }
-    const config = initPeerConfig(configPath);
+  const configPath = getConfigPath(options);
+  ensureConfigDir(configPath);
+  if (existsSync(configPath)) {
+    const config2 = loadPeerConfig(configPath);
     output({
-        status: 'initialized',
-        publicKey: config.identity.publicKey,
-        configPath
+      status: "already_initialized",
+      publicKey: config2.identity.publicKey,
+      configPath
     }, options.pretty || false);
+    process.exit(0);
+  }
+  const config = initPeerConfig(configPath);
+  output({
+    status: "initialized",
+    publicKey: config.identity.publicKey,
+    configPath
+  }, options.pretty || false);
 }
-/**
- * Handle the `agora whoami` command.
- */
 function handleWhoami(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);
-    output({
-        publicKey: config.identity.publicKey,
-        configPath
-    }, options.pretty || false);
+  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);
+  output({
+    publicKey: config.identity.publicKey,
+    configPath
+  }, options.pretty || false);
 }
-/**
- * Handle the `agora peers add` command.
- */
 function handlePeersAdd(args, options) {
-    if (args.length < 1) {
-        console.error('Error: Missing peer name. Usage: agora peers add <name> --pubkey <pubkey> [--url <url> --token <token>]');
-        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 url = options.url;
-    const token = options.token;
-    const pubkey = options.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);
-    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] = {
-        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);
-    const outputData = {
-        status: 'added',
-        name,
-        publicKey: pubkey
-    };
-    if (url) {
-        outputData.url = url;
-    }
-    output(outputData, options.pretty || false);
+  if (args.length < 1) {
+    console.error("Error: Missing peer name. Usage: agora peers add <name> --pubkey <pubkey> [--url <url> --token <token>]");
+    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 url = options.url;
+  const token = options.token;
+  const pubkey = options.pubkey;
+  if (!pubkey) {
+    console.error("Error: Missing required --pubkey option.");
+    process.exit(1);
+  }
+  if (url && !token || !url && token) {
+    console.error("Error: Both --url and --token must be provided together.");
+    process.exit(1);
+  }
+  const config = loadPeerConfig(configPath);
+  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);
+  }
+  config.peers[name] = {
+    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);
+  const outputData = {
+    status: "added",
+    name,
+    publicKey: pubkey
+  };
+  if (url) {
+    outputData.url = url;
+  }
+  output(outputData, options.pretty || false);
 }
-/**
- * Handle the `agora peers list` command.
- */
 function handlePeersList(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 peers = Object.entries(config.peers).map(([key, peer]) => ({
-        name: peer.name || key,
-        url: peer.url,
-        publicKey: peer.publicKey,
-    }));
-    output({ peers }, options.pretty || false);
+  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 peers = Object.entries(config.peers).map(([key, peer]) => ({
+    name: peer.name || key,
+    url: peer.url,
+    publicKey: peer.publicKey
+  }));
+  output({ peers }, options.pretty || false);
 }
-/**
- * Handle the `agora peers remove` command.
- */
 function handlePeersRemove(args, options) {
-    if (args.length < 1) {
-        console.error('Error: Missing peer name. Usage: agora peers remove <name>');
-        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);
-    }
-    delete config.peers[name];
-    savePeerConfig(configPath, config);
-    output({
-        status: 'removed',
-        name
-    }, options.pretty || false);
+  if (args.length < 1) {
+    console.error("Error: Missing peer name. Usage: agora peers remove <name>");
+    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);
+  }
+  delete config.peers[name];
+  savePeerConfig(configPath, config);
+  output({
+    status: "removed",
+    name
+  }, options.pretty || false);
 }
-/**
- * Handle the `agora peers discover` command.
- */
 async function handlePeersDiscover(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);
-    // Determine relay configuration
-    let relayUrl;
-    let relayPublicKey;
-    if (options.relay) {
-        // Use custom relay from command line
-        relayUrl = options.relay;
-        relayPublicKey = options['relay-pubkey'];
-    }
-    else if (config.relay) {
-        // Use relay from config
-        relayUrl = typeof config.relay === 'string' ? config.relay : config.relay.url;
-        // TODO: Add relayPublicKey to config schema in future
-        relayPublicKey = undefined;
-    }
-    else {
-        // Use default bootstrap relay
-        const bootstrap = getDefaultBootstrapRelay();
-        relayUrl = bootstrap.relayUrl;
-        relayPublicKey = bootstrap.relayPublicKey;
-    }
-    // Parse filters
-    const filters = {};
-    if (options['active-within']) {
-        const ms = parseInt(options['active-within'], 10);
-        if (isNaN(ms) || ms <= 0) {
-            console.error('Error: --active-within must be a positive number (milliseconds)');
-            process.exit(1);
-        }
-        filters.activeWithin = ms;
-    }
-    if (options.limit) {
-        const limit = parseInt(options.limit, 10);
-        if (isNaN(limit) || limit <= 0) {
-            console.error('Error: --limit must be a positive number');
-            process.exit(1);
-        }
-        filters.limit = limit;
-    }
-    // Resolve broadcast name
-    const broadcastName = resolveBroadcastName(config, undefined);
-    // Connect to relay
-    const relayClient = new RelayClient({
-        relayUrl,
-        publicKey: config.identity.publicKey,
-        privateKey: config.identity.privateKey,
-        name: broadcastName,
+  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);
+  let relayUrl;
+  let relayPublicKey;
+  if (options.relay) {
+    relayUrl = options.relay;
+    relayPublicKey = options["relay-pubkey"];
+  } else if (config.relay) {
+    relayUrl = typeof config.relay === "string" ? config.relay : config.relay.url;
+    relayPublicKey = void 0;
+  } else {
+    const bootstrap = getDefaultBootstrapRelay();
+    relayUrl = bootstrap.relayUrl;
+    relayPublicKey = bootstrap.relayPublicKey;
+  }
+  const filters = {};
+  if (options["active-within"]) {
+    const ms = parseInt(options["active-within"], 10);
+    if (isNaN(ms) || ms <= 0) {
+      console.error("Error: --active-within must be a positive number (milliseconds)");
+      process.exit(1);
+    }
+    filters.activeWithin = ms;
+  }
+  if (options.limit) {
+    const limit = parseInt(options.limit, 10);
+    if (isNaN(limit) || limit <= 0) {
+      console.error("Error: --limit must be a positive number");
+      process.exit(1);
+    }
+    filters.limit = limit;
+  }
+  const broadcastName = resolveBroadcastName(config, void 0);
+  const relayClient = new RelayClient({
+    relayUrl,
+    publicKey: config.identity.publicKey,
+    privateKey: config.identity.privateKey,
+    name: broadcastName
+  });
+  try {
+    await relayClient.connect();
+    const discoveryService = new PeerDiscoveryService({
+      publicKey: config.identity.publicKey,
+      privateKey: config.identity.privateKey,
+      relayClient,
+      relayPublicKey
     });
-    try {
-        // Connect
-        await relayClient.connect();
-        // Create discovery service
-        const discoveryService = new PeerDiscoveryService({
-            publicKey: config.identity.publicKey,
-            privateKey: config.identity.privateKey,
-            relayClient,
-            relayPublicKey,
-        });
-        // Discover peers
-        const peerList = await discoveryService.discoverViaRelay(Object.keys(filters).length > 0 ? filters : undefined);
-        if (!peerList) {
-            output({
-                status: 'no_response',
-                message: 'No response from relay',
-            }, options.pretty || false);
-            process.exit(1);
-        }
-        // Save to config if requested
-        if (options.save) {
-            let savedCount = 0;
-            for (const peer of peerList.peers) {
-                // Only save if not already in config
-                const existing = Object.values(config.peers).find(p => p.publicKey === peer.publicKey);
-                if (!existing) {
-                    const peerName = peer.metadata?.name || `peer-${peer.publicKey.substring(0, 8)}`;
-                    config.peers[peerName] = {
-                        publicKey: peer.publicKey,
-                        name: peerName,
-                    };
-                    savedCount++;
-                }
-            }
-            if (savedCount > 0) {
-                savePeerConfig(configPath, config);
-            }
-            output({
-                status: 'discovered',
-                totalPeers: peerList.totalPeers,
-                peersReturned: peerList.peers.length,
-                peersSaved: savedCount,
-                relayPublicKey: peerList.relayPublicKey,
-                peers: peerList.peers.map(p => ({
-                    publicKey: p.publicKey,
-                    name: p.metadata?.name,
-                    version: p.metadata?.version,
-                    lastSeen: p.lastSeen,
-                })),
-            }, options.pretty || false);
+    const peerList = await discoveryService.discoverViaRelay(Object.keys(filters).length > 0 ? filters : void 0);
+    if (!peerList) {
+      output({
+        status: "no_response",
+        message: "No response from relay"
+      }, options.pretty || false);
+      process.exit(1);
+    }
+    if (options.save) {
+      let savedCount = 0;
+      for (const peer of peerList.peers) {
+        const existing = Object.values(config.peers).find((p) => p.publicKey === peer.publicKey);
+        if (!existing) {
+          const peerName = peer.metadata?.name || `peer-${peer.publicKey.substring(0, 8)}`;
+          config.peers[peerName] = {
+            publicKey: peer.publicKey,
+            name: peerName
+          };
+          savedCount++;
         }
-        else {
-            output({
-                status: 'discovered',
-                totalPeers: peerList.totalPeers,
-                peersReturned: peerList.peers.length,
-                relayPublicKey: peerList.relayPublicKey,
-                peers: peerList.peers.map(p => ({
-                    publicKey: p.publicKey,
-                    name: p.metadata?.name,
-                    version: p.metadata?.version,
-                    lastSeen: p.lastSeen,
-                })),
-            }, options.pretty || false);
-        }
-    }
-    catch (e) {
-        console.error('Error discovering peers:', e instanceof Error ? e.message : String(e));
-        process.exit(1);
-    }
-    finally {
-        relayClient.disconnect();
-    }
+      }
+      if (savedCount > 0) {
+        savePeerConfig(configPath, config);
+      }
+      output({
+        status: "discovered",
+        totalPeers: peerList.totalPeers,
+        peersReturned: peerList.peers.length,
+        peersSaved: savedCount,
+        relayPublicKey: peerList.relayPublicKey,
+        peers: peerList.peers.map((p) => ({
+          publicKey: p.publicKey,
+          name: p.metadata?.name,
+          version: p.metadata?.version,
+          lastSeen: p.lastSeen
+        }))
+      }, options.pretty || false);
+    } else {
+      output({
+        status: "discovered",
+        totalPeers: peerList.totalPeers,
+        peersReturned: peerList.peers.length,
+        relayPublicKey: peerList.relayPublicKey,
+        peers: peerList.peers.map((p) => ({
+          publicKey: p.publicKey,
+          name: p.metadata?.name,
+          version: p.metadata?.version,
+          lastSeen: p.lastSeen
+        }))
+      }, options.pretty || false);
+    }
+  } catch (e) {
+    console.error("Error discovering peers:", e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  } finally {
+    relayClient.disconnect();
+  }
 }
-/**
- * Handle the `agora send` command.
- */
 async function handleSend(args, options) {
-    if (args.length < 1) {
-        console.error('Error: Missing peer name. Usage: agora send <name> <message> OR agora send <name> --type <type> --payload <json>');
-        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];
-    let messageType;
-    let messagePayload;
-    if (options.type && options.payload) {
-        // Typed message - validate it's a valid MessageType
-        const validTypes = ['announce', 'discover', 'request', 'response', 'publish', 'subscribe', 'verify', 'ack', 'error'];
-        if (!validTypes.includes(options.type)) {
-            console.error(`Error: Invalid message type '${options.type}'. Valid types: ${validTypes.join(', ')}`);
-            process.exit(1);
-        }
-        messageType = options.type;
-        try {
-            messagePayload = JSON.parse(options.payload);
-        }
-        catch {
-            console.error('Error: Invalid JSON payload.');
-            process.exit(1);
-        }
-    }
-    else {
-        // Text message - use 'publish' type with text payload
-        if (args.length < 2) {
-            console.error('Error: Missing message text. Usage: agora send <name> <message>');
-            process.exit(1);
-        }
-        messageType = 'publish';
-        messagePayload = { text: args.slice(1).join(' ') };
-    }
-    // Determine transport method: HTTP or relay
-    const hasHttpTransport = peer.url && peer.token;
-    const hasRelay = config.relay;
-    // Send the message
+  if (args.length < 1) {
+    console.error("Error: Missing peer name. Usage: agora send <name> <message> OR agora send <name> --type <type> --payload <json>");
+    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];
+  let messageType;
+  let messagePayload;
+  if (options.type && options.payload) {
+    const validTypes = ["announce", "discover", "request", "response", "publish", "subscribe", "verify", "ack", "error"];
+    if (!validTypes.includes(options.type)) {
+      console.error(`Error: Invalid message type '${options.type}'. Valid types: ${validTypes.join(", ")}`);
+      process.exit(1);
+    }
+    messageType = options.type;
     try {
-        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 && config.relay) {
-            // Use relay transport
-            // Extract URL from relay (string or object)
-            const relayUrl = typeof config.relay === 'string' ? config.relay : config.relay.url;
-            const relayConfig = {
-                identity: config.identity,
-                relayUrl,
-            };
-            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 {
-            // Neither HTTP nor relay available
-            console.error(`Error: Peer '${name}' unreachable. No HTTP endpoint and no relay configured.`);
-            process.exit(1);
-        }
-    }
-    catch (e) {
-        console.error('Error sending message:', e instanceof Error ? e.message : String(e));
-        process.exit(1);
-    }
-}
-/**
- * Handle the `agora decode` command.
- */
-function handleDecode(args, options) {
-    if (args.length < 1) {
-        console.error('Error: Missing message. Usage: agora decode <message>');
-        process.exit(1);
-    }
-    const configPath = getConfigPath(options);
-    if (!existsSync(configPath)) {
-        console.error('Error: Config file not found. Run `agora init` first.');
+      messagePayload = JSON.parse(options.payload);
+    } catch {
+      console.error("Error: Invalid JSON payload.");
+      process.exit(1);
+    }
+  } else {
+    if (args.length < 2) {
+      console.error("Error: Missing message text. Usage: agora send <name> <message>");
+      process.exit(1);
+    }
+    messageType = "publish";
+    messagePayload = { text: args.slice(1).join(" ") };
+  }
+  const hasHttpTransport = peer.url && peer.token;
+  const hasRelay = config.relay;
+  try {
+    if (hasHttpTransport) {
+      const transportConfig = {
+        identity: config.identity,
+        peers: /* @__PURE__ */ 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);
-    }
-    const config = loadPeerConfig(configPath);
-    const peers = new Map();
-    for (const [, val] of Object.entries(config.peers)) {
-        // 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);
-    if (result.ok) {
+      }
+    } else if (hasRelay && config.relay) {
+      const relayUrl = typeof config.relay === "string" ? config.relay : config.relay.url;
+      const relayConfig = {
+        identity: config.identity,
+        relayUrl
+      };
+      const result = await sendViaRelay(
+        relayConfig,
+        peer.publicKey,
+        messageType,
+        messagePayload
+      );
+      if (result.ok) {
         output({
-            status: 'verified',
-            sender: result.envelope.sender,
-            type: result.envelope.type,
-            payload: result.envelope.payload,
-            id: result.envelope.id,
-            timestamp: result.envelope.timestamp,
-            inReplyTo: result.envelope.inReplyTo || null,
+          status: "sent",
+          peer: name,
+          type: messageType,
+          transport: "relay"
         }, options.pretty || false);
-    }
-    else {
+      } else {
         output({
-            status: 'failed',
-            reason: result.reason,
+          status: "failed",
+          peer: name,
+          type: messageType,
+          transport: "relay",
+          error: result.error
         }, options.pretty || false);
         process.exit(1);
+      }
+    } else {
+      console.error(`Error: Peer '${name}' unreachable. No HTTP endpoint and no relay configured.`);
+      process.exit(1);
     }
+  } catch (e) {
+    console.error("Error sending message:", e instanceof Error ? e.message : String(e));
+    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;
+function handleDecode(args, options) {
+  if (args.length < 1) {
+    console.error("Error: Missing message. Usage: agora decode <message>");
+    process.exit(1);
+  }
+  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 peers = /* @__PURE__ */ new Map();
+  for (const [, val] of Object.entries(config.peers)) {
+    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);
+  if (result.ok) {
+    output({
+      status: "verified",
+      sender: result.envelope.sender,
+      type: result.envelope.type,
+      payload: result.envelope.payload,
+      id: result.envelope.id,
+      timestamp: result.envelope.timestamp,
+      inReplyTo: result.envelope.inReplyTo || null
+    }, options.pretty || false);
+  } else {
     output({
-        identity: config.identity.publicKey,
-        configPath,
-        relay: config.relay || 'not configured',
-        peerCount,
-        peers: Object.keys(config.peers),
+      status: "failed",
+      reason: result.reason
     }, options.pretty || false);
+    process.exit(1);
+  }
+}
+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 && config.relay) {
-                // Use relay transport
-                // Extract URL from relay (string or object)
-                const relayUrl = typeof config.relay === 'string' ? config.relay : config.relay.url;
-                const relayConfig = {
-                    identity: config.identity,
-                    relayUrl,
-                };
-                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',
-                });
-            }
+  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);
+  }
+  const announcePayload = {
+    capabilities: [],
+    metadata: {
+      name: options.name || "agora-node",
+      version: options.version || "0.1.0"
+    }
+  };
+  const results = [];
+  for (const [name, peer] of Object.entries(config.peers)) {
+    const hasHttpTransport = peer.url && peer.token;
+    const hasRelay = config.relay;
+    try {
+      if (hasHttpTransport) {
+        const peers = /* @__PURE__ */ 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
+          });
         }
-        catch (e) {
-            results.push({
-                peer: name,
-                status: 'error',
-                error: e instanceof Error ? e.message : String(e),
-            });
+      } else if (hasRelay && config.relay) {
+        const relayUrl = typeof config.relay === "string" ? config.relay : config.relay.url;
+        const relayConfig = {
+          identity: config.identity,
+          relayUrl
+        };
+        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);
+  }
+  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(),
+  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);
+  }
+  const checksParam = options.checks || "ping";
+  const requestedChecks = checksParam.split(",").map((c) => c.trim());
+  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: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (requestedChecks.includes("ping")) {
+    const startTime = Date.now();
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 1e4);
+      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) {
+        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)
+      };
+    }
+  }
+  if (requestedChecks.includes("workspace")) {
+    result.checks.workspace = {
+      ok: false,
+      implemented: false,
+      error: "Workspace check requires peer diagnostic protocol support"
     };
-    // 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);
+  }
+  if (requestedChecks.includes("tools")) {
+    result.checks.tools = {
+      ok: false,
+      implemented: false,
+      error: "Tools check requires peer diagnostic protocol support"
+    };
+  }
+  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);
-    }
-    // Resolve server name using priority: CLI --name, config.relay.name, config.identity.name, default
-    const serverName = resolveBroadcastName(config, 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));
+  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);
+  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 = resolveBroadcastName(config, options.name) || "agora-server";
+  const announcePayload = {
+    capabilities: [],
+    metadata: {
+      name: serverName,
+      version: "0.1.0"
+    }
+  };
+  const server = new PeerServer(config.identity, announcePayload);
+  server.on("peer-connected", (publicKey, peer) => {
+    const peerName = peer.metadata?.name || publicKey.substring(0, 16);
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Peer connected: ${peerName} (${publicKey})`);
+  });
+  server.on("peer-disconnected", (publicKey) => {
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Peer disconnected: ${publicKey}`);
+  });
+  server.on("message-received", (envelope, fromPublicKey) => {
+    console.log(`[${(/* @__PURE__ */ 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(`[${(/* @__PURE__ */ new Date()).toISOString()}] Error:`, error.message);
+  });
+  try {
+    await server.start(port);
+    console.log(`[${(/* @__PURE__ */ 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");
+    process.on("SIGINT", async () => {
+      console.log(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] Shutting down server...`);
+      await server.stop();
+      console.log("Server stopped");
+      process.exit(0);
     });
-    server.on('error', (error) => {
-        console.error(`[${new Date().toISOString()}] Error:`, error.message);
+    process.on("SIGTERM", async () => {
+      console.log(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] Shutting down server...`);
+      await server.stop();
+      console.log("Server stopped");
+      process.exit(0);
     });
-    // 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);
-    }
+  } 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);
-    }
+  const port = parseInt(options.port || "9474", 10);
+  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 server = new RelayServer();
+  server.on("agent-registered", (publicKey) => {
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Agent registered: ${publicKey}`);
+  });
+  server.on("agent-disconnected", (publicKey) => {
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Agent disconnected: ${publicKey}`);
+  });
+  server.on("message-relayed", (from, to, envelope) => {
+    console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Message relayed: ${from.substring(0, 16)}... \u2192 ${to.substring(0, 16)}... (type: ${envelope.type})`);
+  });
+  server.on("error", (error) => {
+    console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Error:`, error.message);
+  });
+  try {
+    await server.start(port);
+    console.log(`[${(/* @__PURE__ */ 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");
+    const shutdown = async () => {
+      console.log(`
+[${(/* @__PURE__ */ new Date()).toISOString()}] Shutting down relay...`);
+      await server.stop();
+      console.log("Relay stopped");
+      process.exit(0);
+    };
+    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);
+  }
 }
-/**
- * Get the reputation store file path.
- */
 function getReputationStorePath() {
-    return resolve(homedir(), '.local', 'share', 'agora', 'reputation.jsonl');
+  return resolve(homedir(), ".local", "share", "agora", "reputation.jsonl");
 }
-/**
- * Handle the `agora reputation verify` command.
- * Creates a verification record for another agent's output.
- */
 async function handleReputationVerify(args, options) {
-    if (!options.target || !options.domain || !options.verdict) {
-        console.error('Error: Missing required options');
-        console.error('Usage: agora reputation verify --target <id> --domain <domain> --verdict <correct|incorrect|disputed> --confidence <0-1> [--evidence <url>]');
-        process.exit(1);
-    }
-    // Validate verdict
-    if (!['correct', 'incorrect', 'disputed'].includes(options.verdict)) {
-        console.error('Error: verdict must be one of: correct, incorrect, disputed');
-        process.exit(1);
-    }
-    // Parse confidence
-    const confidence = options.confidence ? parseFloat(options.confidence) : 1.0;
-    if (isNaN(confidence) || confidence < 0 || confidence > 1) {
-        console.error('Error: confidence must be a number between 0 and 1');
-        process.exit(1);
-    }
-    // Load config
-    const configPath = getConfigPath(options);
-    if (!existsSync(configPath)) {
-        console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
-        process.exit(1);
-    }
-    const config = loadPeerConfig(configPath);
-    // Create verification
-    const verification = createVerification(config.identity.publicKey, config.identity.privateKey, options.target, options.domain, options.verdict, confidence, Date.now(), options.evidence);
-    // Save to reputation store
-    const storePath = getReputationStorePath();
-    const store = new ReputationStore(storePath);
-    await store.addVerification(verification);
-    output({
-        status: 'verification_created',
-        id: verification.id,
-        verifier: verification.verifier,
-        target: verification.target,
-        domain: verification.domain,
-        verdict: verification.verdict,
-        confidence: verification.confidence,
-        timestamp: verification.timestamp,
-    }, options.pretty || false);
+  if (!options.target || !options.domain || !options.verdict) {
+    console.error("Error: Missing required options");
+    console.error("Usage: agora reputation verify --target <id> --domain <domain> --verdict <correct|incorrect|disputed> --confidence <0-1> [--evidence <url>]");
+    process.exit(1);
+  }
+  if (!["correct", "incorrect", "disputed"].includes(options.verdict)) {
+    console.error("Error: verdict must be one of: correct, incorrect, disputed");
+    process.exit(1);
+  }
+  const confidence = options.confidence ? parseFloat(options.confidence) : 1;
+  if (isNaN(confidence) || confidence < 0 || confidence > 1) {
+    console.error("Error: confidence must be a number between 0 and 1");
+    process.exit(1);
+  }
+  const configPath = getConfigPath(options);
+  if (!existsSync(configPath)) {
+    console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
+    process.exit(1);
+  }
+  const config = loadPeerConfig(configPath);
+  const verification = createVerification(
+    config.identity.publicKey,
+    config.identity.privateKey,
+    options.target,
+    options.domain,
+    options.verdict,
+    confidence,
+    Date.now(),
+    options.evidence
+  );
+  const storePath = getReputationStorePath();
+  const store = new ReputationStore(storePath);
+  await store.addVerification(verification);
+  output({
+    status: "verification_created",
+    id: verification.id,
+    verifier: verification.verifier,
+    target: verification.target,
+    domain: verification.domain,
+    verdict: verification.verdict,
+    confidence: verification.confidence,
+    timestamp: verification.timestamp
+  }, options.pretty || false);
 }
-/**
- * Handle the `agora reputation commit` command.
- * Creates a commitment to a prediction before outcome is known.
- */
 async function handleReputationCommit(args, options) {
-    if (!options.domain || !options.prediction) {
-        console.error('Error: Missing required options');
-        console.error('Usage: agora reputation commit --domain <domain> --prediction <text> [--expiry <milliseconds>]');
-        console.error('Example: agora reputation commit --domain weather_forecast --prediction "It will rain tomorrow" --expiry 86400000');
-        process.exit(1);
-    }
-    // Parse expiry (default 24 hours)
-    const expiryMs = options.expiry ? parseInt(options.expiry, 10) : 86400000;
-    if (isNaN(expiryMs) || expiryMs <= 0) {
-        console.error('Error: expiry must be a positive number (milliseconds)');
-        process.exit(1);
-    }
-    // Load config
-    const configPath = getConfigPath(options);
-    if (!existsSync(configPath)) {
-        console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
-        process.exit(1);
-    }
-    const config = loadPeerConfig(configPath);
-    // Create commit
-    const commit = createCommit(config.identity.publicKey, config.identity.privateKey, options.domain, options.prediction, Date.now(), expiryMs);
-    // Save to reputation store
-    const storePath = getReputationStorePath();
-    const store = new ReputationStore(storePath);
-    await store.addCommit(commit);
-    output({
-        status: 'commitment_created',
-        id: commit.id,
-        agent: commit.agent,
-        domain: commit.domain,
-        commitment: commit.commitment,
-        timestamp: commit.timestamp,
-        expiry: commit.expiry,
-        note: 'Store this ID to reveal the prediction after expiry',
-    }, options.pretty || false);
+  if (!options.domain || !options.prediction) {
+    console.error("Error: Missing required options");
+    console.error("Usage: agora reputation commit --domain <domain> --prediction <text> [--expiry <milliseconds>]");
+    console.error('Example: agora reputation commit --domain weather_forecast --prediction "It will rain tomorrow" --expiry 86400000');
+    process.exit(1);
+  }
+  const expiryMs = options.expiry ? parseInt(options.expiry, 10) : 864e5;
+  if (isNaN(expiryMs) || expiryMs <= 0) {
+    console.error("Error: expiry must be a positive number (milliseconds)");
+    process.exit(1);
+  }
+  const configPath = getConfigPath(options);
+  if (!existsSync(configPath)) {
+    console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
+    process.exit(1);
+  }
+  const config = loadPeerConfig(configPath);
+  const commit = createCommit(
+    config.identity.publicKey,
+    config.identity.privateKey,
+    options.domain,
+    options.prediction,
+    Date.now(),
+    expiryMs
+  );
+  const storePath = getReputationStorePath();
+  const store = new ReputationStore(storePath);
+  await store.addCommit(commit);
+  output({
+    status: "commitment_created",
+    id: commit.id,
+    agent: commit.agent,
+    domain: commit.domain,
+    commitment: commit.commitment,
+    timestamp: commit.timestamp,
+    expiry: commit.expiry,
+    note: "Store this ID to reveal the prediction after expiry"
+  }, options.pretty || false);
 }
-/**
- * Handle the `agora reputation reveal` command.
- * Reveals a prediction and outcome after commitment expiry.
- */
 async function handleReputationReveal(args, options) {
-    if (!options['commit-id'] || !options.prediction || !options.outcome) {
-        console.error('Error: Missing required options');
-        console.error('Usage: agora reputation reveal --commit-id <id> --prediction <text> --outcome <text> [--evidence <url>]');
-        process.exit(1);
-    }
-    // Load config
-    const configPath = getConfigPath(options);
-    if (!existsSync(configPath)) {
-        console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
-        process.exit(1);
-    }
-    const config = loadPeerConfig(configPath);
-    // Load commit from store
-    const storePath = getReputationStorePath();
-    const store = new ReputationStore(storePath);
-    const commit = await store.getCommit(options['commit-id']);
-    if (!commit) {
-        console.error(`Error: Commitment ${options['commit-id']} not found in local store`);
-        process.exit(1);
-    }
-    // Create reveal
-    const reveal = createReveal(config.identity.publicKey, config.identity.privateKey, options['commit-id'], options.prediction, options.outcome, Date.now(), options.evidence);
-    // Verify the reveal against the commit
-    const verification = verifyReveal(commit, reveal);
-    if (!verification.valid) {
-        console.error(`Error: Reveal verification failed: ${verification.reason}`);
-        process.exit(1);
-    }
-    // Save to reputation store
-    await store.addReveal(reveal);
-    output({
-        status: 'prediction_revealed',
-        id: reveal.id,
-        agent: reveal.agent,
-        commitmentId: reveal.commitmentId,
-        prediction: reveal.prediction,
-        outcome: reveal.outcome,
-        timestamp: reveal.timestamp,
-        verified: true,
-    }, options.pretty || false);
+  if (!options["commit-id"] || !options.prediction || !options.outcome) {
+    console.error("Error: Missing required options");
+    console.error("Usage: agora reputation reveal --commit-id <id> --prediction <text> --outcome <text> [--evidence <url>]");
+    process.exit(1);
+  }
+  const configPath = getConfigPath(options);
+  if (!existsSync(configPath)) {
+    console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
+    process.exit(1);
+  }
+  const config = loadPeerConfig(configPath);
+  const storePath = getReputationStorePath();
+  const store = new ReputationStore(storePath);
+  const commit = await store.getCommit(options["commit-id"]);
+  if (!commit) {
+    console.error(`Error: Commitment ${options["commit-id"]} not found in local store`);
+    process.exit(1);
+  }
+  const reveal = createReveal(
+    config.identity.publicKey,
+    config.identity.privateKey,
+    options["commit-id"],
+    options.prediction,
+    options.outcome,
+    Date.now(),
+    options.evidence
+  );
+  const verification = verifyReveal(commit, reveal);
+  if (!verification.valid) {
+    console.error(`Error: Reveal verification failed: ${verification.reason}`);
+    process.exit(1);
+  }
+  await store.addReveal(reveal);
+  output({
+    status: "prediction_revealed",
+    id: reveal.id,
+    agent: reveal.agent,
+    commitmentId: reveal.commitmentId,
+    prediction: reveal.prediction,
+    outcome: reveal.outcome,
+    timestamp: reveal.timestamp,
+    verified: true
+  }, options.pretty || false);
 }
-/**
- * Handle the `agora reputation query` command.
- * Queries reputation score for an agent in a domain.
- */
 async function handleReputationQuery(args, options) {
-    if (!options.domain) {
-        console.error('Error: Missing required option: --domain');
-        console.error('Usage: agora reputation query --domain <domain> [--agent <pubkey>]');
-        console.error('If --agent is omitted, shows reputation for current agent');
-        process.exit(1);
-    }
-    // Load config
-    const configPath = getConfigPath(options);
-    if (!existsSync(configPath)) {
-        console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
-        process.exit(1);
-    }
-    const config = loadPeerConfig(configPath);
-    const agent = options.agent || config.identity.publicKey;
-    // Load reputation store
-    const storePath = getReputationStorePath();
-    const store = new ReputationStore(storePath);
-    const verifications = await store.getVerificationsByDomain(options.domain);
-    // Filter verifications for this agent
-    const agentVerifications = verifications.filter(v => v.target === agent);
-    // Compute trust score
-    const score = computeTrustScore(agent, options.domain, agentVerifications, Date.now());
-    output({
-        agent: score.agent,
-        domain: score.domain,
-        score: score.score,
-        verificationCount: score.verificationCount,
-        lastVerified: score.lastVerified,
-        lastVerifiedDate: score.lastVerified > 0 ? new Date(score.lastVerified).toISOString() : 'never',
-        topVerifiers: score.topVerifiers,
-    }, options.pretty || false);
+  if (!options.domain) {
+    console.error("Error: Missing required option: --domain");
+    console.error("Usage: agora reputation query --domain <domain> [--agent <pubkey>]");
+    console.error("If --agent is omitted, shows reputation for current agent");
+    process.exit(1);
+  }
+  const configPath = getConfigPath(options);
+  if (!existsSync(configPath)) {
+    console.error(`Error: Config file not found at ${configPath}. Run 'agora init' first.`);
+    process.exit(1);
+  }
+  const config = loadPeerConfig(configPath);
+  const agent = options.agent || config.identity.publicKey;
+  const storePath = getReputationStorePath();
+  const store = new ReputationStore(storePath);
+  const verifications = await store.getVerificationsByDomain(options.domain);
+  const agentVerifications = verifications.filter((v) => v.target === agent);
+  const score = computeTrustScore(agent, options.domain, agentVerifications, Date.now());
+  output({
+    agent: score.agent,
+    domain: score.domain,
+    score: score.score,
+    verificationCount: score.verificationCount,
+    lastVerified: score.lastVerified,
+    lastVerifiedDate: score.lastVerified > 0 ? new Date(score.lastVerified).toISOString() : "never",
+    topVerifiers: score.topVerifiers
+  }, options.pretty || false);
 }
-/**
- * Parse CLI arguments and route to appropriate handler.
- */
 async function main() {
-    const args = process.argv.slice(2);
-    if (args.length === 0) {
-        console.error('Usage: agora <command> [options]');
-        console.error('Commands: init, whoami, status, peers, announce, send, decode, serve, diagnose, relay, reputation');
-        console.error('  peers subcommands: add, list, remove, discover');
-        console.error('  reputation subcommands: verify, commit, reveal, query');
-        process.exit(1);
-    }
-    // Parse global options
-    const parsed = parseArgs({
-        args,
-        options: {
-            config: { type: 'string' },
-            pretty: { type: 'boolean' },
-            url: { type: 'string' },
-            token: { type: 'string' },
-            pubkey: { type: 'string' },
-            type: { type: 'string' },
-            payload: { type: 'string' },
-            name: { type: 'string' },
-            version: { type: 'string' },
-            port: { type: 'string' },
-            checks: { type: 'string' },
-            relay: { type: 'string' },
-            'relay-pubkey': { type: 'string' },
-            limit: { type: 'string' },
-            'active-within': { type: 'string' },
-            save: { type: 'boolean' },
-            // Reputation options
-            target: { type: 'string' },
-            domain: { type: 'string' },
-            verdict: { type: 'string' },
-            confidence: { type: 'string' },
-            evidence: { type: 'string' },
-            prediction: { type: 'string' },
-            expiry: { type: 'string' },
-            'commit-id': { type: 'string' },
-            outcome: { type: 'string' },
-            agent: { type: 'string' },
-        },
-        strict: false,
-        allowPositionals: true,
-    });
-    const command = parsed.positionals[0];
-    const subcommand = parsed.positionals[1];
-    const remainingArgs = parsed.positionals.slice(2);
-    const options = {
-        config: typeof parsed.values.config === 'string' ? parsed.values.config : undefined,
-        pretty: typeof parsed.values.pretty === 'boolean' ? parsed.values.pretty : undefined,
-        type: typeof parsed.values.type === 'string' ? parsed.values.type : undefined,
-        payload: typeof parsed.values.payload === 'string' ? parsed.values.payload : undefined,
-        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,
-        relay: typeof parsed.values.relay === 'string' ? parsed.values.relay : undefined,
-        'relay-pubkey': typeof parsed.values['relay-pubkey'] === 'string' ? parsed.values['relay-pubkey'] : undefined,
-        limit: typeof parsed.values.limit === 'string' ? parsed.values.limit : undefined,
-        'active-within': typeof parsed.values['active-within'] === 'string' ? parsed.values['active-within'] : undefined,
-        save: typeof parsed.values.save === 'boolean' ? parsed.values.save : undefined,
-        // Reputation options
-        target: typeof parsed.values.target === 'string' ? parsed.values.target : undefined,
-        domain: typeof parsed.values.domain === 'string' ? parsed.values.domain : undefined,
-        verdict: typeof parsed.values.verdict === 'string' ? parsed.values.verdict : undefined,
-        confidence: typeof parsed.values.confidence === 'string' ? parsed.values.confidence : undefined,
-        evidence: typeof parsed.values.evidence === 'string' ? parsed.values.evidence : undefined,
-        prediction: typeof parsed.values.prediction === 'string' ? parsed.values.prediction : undefined,
-        expiry: typeof parsed.values.expiry === 'string' ? parsed.values.expiry : undefined,
-        'commit-id': typeof parsed.values['commit-id'] === 'string' ? parsed.values['commit-id'] : undefined,
-        outcome: typeof parsed.values.outcome === 'string' ? parsed.values.outcome : undefined,
-        agent: typeof parsed.values.agent === 'string' ? parsed.values.agent : undefined,
-    };
-    try {
-        switch (command) {
-            case 'init':
-                handleInit(options);
-                break;
-            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':
-                        handlePeersRemove(remainingArgs, options);
-                        break;
-                    case 'discover':
-                        await handlePeersDiscover(options);
-                        break;
-                    default:
-                        console.error('Error: Unknown peers subcommand. Use: add, list, remove, discover');
-                        process.exit(1);
-                }
-                break;
-            case 'send':
-                await handleSend([subcommand, ...remainingArgs], options);
-                break;
-            case 'decode':
-                handleDecode([subcommand, ...remainingArgs].filter(Boolean), options);
-                break;
-            case 'serve':
-                await handleServe(options);
-                break;
-            case 'relay':
-                await handleRelay(options);
-                break;
-            case 'reputation':
-                switch (subcommand) {
-                    case 'verify':
-                        await handleReputationVerify(remainingArgs, options);
-                        break;
-                    case 'commit':
-                        await handleReputationCommit(remainingArgs, options);
-                        break;
-                    case 'reveal':
-                        await handleReputationReveal(remainingArgs, options);
-                        break;
-                    case 'query':
-                        await handleReputationQuery(remainingArgs, options);
-                        break;
-                    default:
-                        console.error('Error: Unknown reputation subcommand. Use: verify, commit, reveal, query');
-                        process.exit(1);
-                }
-                break;
-            default:
-                console.error(`Error: Unknown command '${command}'. Use: init, whoami, status, peers, announce, send, decode, serve, diagnose, relay, reputation`);
-                process.exit(1);
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("Usage: agora <command> [options]");
+    console.error("Commands: init, whoami, status, peers, announce, send, decode, serve, diagnose, relay, reputation");
+    console.error("  peers subcommands: add, list, remove, discover");
+    console.error("  reputation subcommands: verify, commit, reveal, query");
+    process.exit(1);
+  }
+  const parsed = parseArgs({
+    args,
+    options: {
+      config: { type: "string" },
+      pretty: { type: "boolean" },
+      url: { type: "string" },
+      token: { type: "string" },
+      pubkey: { type: "string" },
+      type: { type: "string" },
+      payload: { type: "string" },
+      name: { type: "string" },
+      version: { type: "string" },
+      port: { type: "string" },
+      checks: { type: "string" },
+      relay: { type: "string" },
+      "relay-pubkey": { type: "string" },
+      limit: { type: "string" },
+      "active-within": { type: "string" },
+      save: { type: "boolean" },
+      // Reputation options
+      target: { type: "string" },
+      domain: { type: "string" },
+      verdict: { type: "string" },
+      confidence: { type: "string" },
+      evidence: { type: "string" },
+      prediction: { type: "string" },
+      expiry: { type: "string" },
+      "commit-id": { type: "string" },
+      outcome: { type: "string" },
+      agent: { type: "string" }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  const command = parsed.positionals[0];
+  const subcommand = parsed.positionals[1];
+  const remainingArgs = parsed.positionals.slice(2);
+  const options = {
+    config: typeof parsed.values.config === "string" ? parsed.values.config : void 0,
+    pretty: typeof parsed.values.pretty === "boolean" ? parsed.values.pretty : void 0,
+    type: typeof parsed.values.type === "string" ? parsed.values.type : void 0,
+    payload: typeof parsed.values.payload === "string" ? parsed.values.payload : void 0,
+    url: typeof parsed.values.url === "string" ? parsed.values.url : void 0,
+    token: typeof parsed.values.token === "string" ? parsed.values.token : void 0,
+    pubkey: typeof parsed.values.pubkey === "string" ? parsed.values.pubkey : void 0,
+    name: typeof parsed.values.name === "string" ? parsed.values.name : void 0,
+    version: typeof parsed.values.version === "string" ? parsed.values.version : void 0,
+    port: typeof parsed.values.port === "string" ? parsed.values.port : void 0,
+    checks: typeof parsed.values.checks === "string" ? parsed.values.checks : void 0,
+    relay: typeof parsed.values.relay === "string" ? parsed.values.relay : void 0,
+    "relay-pubkey": typeof parsed.values["relay-pubkey"] === "string" ? parsed.values["relay-pubkey"] : void 0,
+    limit: typeof parsed.values.limit === "string" ? parsed.values.limit : void 0,
+    "active-within": typeof parsed.values["active-within"] === "string" ? parsed.values["active-within"] : void 0,
+    save: typeof parsed.values.save === "boolean" ? parsed.values.save : void 0,
+    // Reputation options
+    target: typeof parsed.values.target === "string" ? parsed.values.target : void 0,
+    domain: typeof parsed.values.domain === "string" ? parsed.values.domain : void 0,
+    verdict: typeof parsed.values.verdict === "string" ? parsed.values.verdict : void 0,
+    confidence: typeof parsed.values.confidence === "string" ? parsed.values.confidence : void 0,
+    evidence: typeof parsed.values.evidence === "string" ? parsed.values.evidence : void 0,
+    prediction: typeof parsed.values.prediction === "string" ? parsed.values.prediction : void 0,
+    expiry: typeof parsed.values.expiry === "string" ? parsed.values.expiry : void 0,
+    "commit-id": typeof parsed.values["commit-id"] === "string" ? parsed.values["commit-id"] : void 0,
+    outcome: typeof parsed.values.outcome === "string" ? parsed.values.outcome : void 0,
+    agent: typeof parsed.values.agent === "string" ? parsed.values.agent : void 0
+  };
+  try {
+    switch (command) {
+      case "init":
+        handleInit(options);
+        break;
+      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 void 0:
+            handlePeersList(options);
+            break;
+          case "remove":
+            handlePeersRemove(remainingArgs, options);
+            break;
+          case "discover":
+            await handlePeersDiscover(options);
+            break;
+          default:
+            console.error("Error: Unknown peers subcommand. Use: add, list, remove, discover");
+            process.exit(1);
         }
-    }
-    catch (e) {
-        console.error('Error:', e instanceof Error ? e.message : String(e));
+        break;
+      case "send":
+        await handleSend([subcommand, ...remainingArgs], options);
+        break;
+      case "decode":
+        handleDecode([subcommand, ...remainingArgs].filter(Boolean), options);
+        break;
+      case "serve":
+        await handleServe(options);
+        break;
+      case "relay":
+        await handleRelay(options);
+        break;
+      case "reputation":
+        switch (subcommand) {
+          case "verify":
+            await handleReputationVerify(remainingArgs, options);
+            break;
+          case "commit":
+            await handleReputationCommit(remainingArgs, options);
+            break;
+          case "reveal":
+            await handleReputationReveal(remainingArgs, options);
+            break;
+          case "query":
+            await handleReputationQuery(remainingArgs, options);
+            break;
+          default:
+            console.error("Error: Unknown reputation subcommand. Use: verify, commit, reveal, query");
+            process.exit(1);
+        }
+        break;
+      default:
+        console.error(`Error: Unknown command '${command}'. Use: init, whoami, status, peers, announce, send, decode, serve, diagnose, relay, reputation`);
         process.exit(1);
     }
+  } catch (e) {
+    console.error("Error:", e instanceof Error ? e.message : String(e));
+    process.exit(1);
+  }
 }
 main().catch((e) => {
-    console.error('Fatal error:', e instanceof Error ? e.message : String(e));
-    process.exit(1);
+  console.error("Fatal error:", e instanceof Error ? e.message : String(e));
+  process.exit(1);
 });
 //# sourceMappingURL=cli.js.map