@highway1/cli 0.1.49 → 0.1.52

package/src/commands/join.ts

@@ -1,26 +1,37 @@
 import { Command } from 'commander';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
+  createMessageRouter,
   importKeyPair,
   createAgentCard,
   signAgentCard,
-  createDHTOperations,
-  createMessageRouter,
   sign,
   verify,
   extractPublicKey,
 } from '@highway1/core';
-import { getIdentity, getAgentCard, getBootstrapPeers } from '../config.js';
+import { getIdentity, getAgentCard } from '../config.js';
 import { success, error, spinner, printHeader, info } from '../ui.js';
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 
+// Default relay URLs (CVP-0011)
+const DEFAULT_RELAY_URLS = [
+  'ws://relay.highway1.net:8080',
+];
+
+function getRelayUrls(options: any): string[] {
+  if (options.relay) return [options.relay];
+  const envRelays = process.env.HW1_RELAY_URLS;
+  if (envRelays) return envRelays.split(',').map((u: string) => u.trim());
+  return DEFAULT_RELAY_URLS;
+}
+
 export function registerJoinCommand(program: Command): void {
   program
     .command('join')
-    .description('Join the Clawiverse network')
-    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
-    .option('--relay', 'Run as a relay server and advertise relay capability')
+    .description('Join the Clawiverse network via relay')
+    .option('--relay <url>', 'Relay WebSocket URL (e.g. ws://localhost:8080)')
     .option('--save-dir <path>', 'Directory to save received file attachments', './downloads')
     .action(async (options) => {
       try {
@@ -34,236 +45,47 @@ export function registerJoinCommand(program: Command): void {
           process.exit(1);
         }
 
-        const spin = spinner('Starting libp2p node...');
+        const spin = spinner('Connecting to relay...');
 
         const keyPair = importKeyPair({
           publicKey: identity.publicKey,
           privateKey: identity.privateKey,
         });
 
-        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
-        const bootstrapPeerIds = bootstrapPeers
-          .map((addr: string) => addr.split('/p2p/')[1])
-          .filter((peerId: string | undefined): peerId is string => Boolean(peerId));
-
-        const node = await createNode({
-          keyPair,
-          bootstrapPeers,
-          enableDHT: true,
-          reserveRelaySlot: true,
-          enableRelay: options.relay ?? false,
-        });
-
-        await node.start();
-
-        spin.succeed('Node started successfully!');
-
-        info(`Peer ID: ${node.getPeerId()}`);
-        info(`DID: ${identity.did}`);
-        info(`Listening on: ${node.getMultiaddrs().join(', ')}`);
-
-        // Wait for bootstrap peer connection before publishing to DHT
-        const connectSpin = spinner('Connecting to bootstrap peers...');
-
-        // Phase 1: wait for peer:connect (up to 10s)
-        let connected = false;
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 10000);
-          node.libp2p.addEventListener('peer:connect', () => {
-            connected = true;
-            clearTimeout(timeout);
-            resolve();
-          }, { once: true });
-        });
-
-        // If discovery has not connected us yet, proactively dial bootstrap peers once.
-        if (!connected && bootstrapPeers.length > 0) {
-          info('No peer discovered yet, dialing bootstrap peers...');
-          for (const bootstrapAddr of bootstrapPeers) {
-            try {
-              await node.libp2p.dial(bootstrapAddr);
-              connected = true;
-              break;
-            } catch {
-              // try next bootstrap peer
-            }
-          }
-        }
-
-        // Phase 2: wait for relay reservation using event + polling (more reliable across libp2p versions)
-        const countRelayAddrs = () => node.getMultiaddrs().filter(a => a.includes('/p2p-circuit')).length;
-        const initialRelayCount = countRelayAddrs();
-
-        info(`Initial relay addresses: ${initialRelayCount}`);
-        info('Waiting for relay reservation...');
-
-        let reservationSucceeded = false;
-        if (initialRelayCount === 0) {
-          await new Promise<void>((resolve) => {
-            const RELAY_WAIT_MS = 30000;
-            const POLL_MS = 500;
-            let settled = false;
-
-            const finish = () => {
-              if (settled) return;
-              settled = true;
-              clearTimeout(timeout);
-              clearInterval(pollTimer);
-              (node.libp2p as any).removeEventListener('relay:reservation', onReservation);
-              (node.libp2p as any).removeEventListener('self:peer:update', onPeerUpdate);
-              resolve();
-            };
-
-            const onReservation = () => {
-              reservationSucceeded = true;
-              info('✓ Relay reservation successful!');
-              setTimeout(finish, 300);
-            };
-
-            const onPeerUpdate = () => {
-              if (countRelayAddrs() > 0) {
-                reservationSucceeded = true;
-                info('✓ Relay address detected from peer update');
-                finish();
-              }
-            };
-
-            const pollTimer = setInterval(() => {
-              if (countRelayAddrs() > 0) {
-                reservationSucceeded = true;
-                info('✓ Relay address detected');
-                finish();
-              }
-            }, POLL_MS);
-
-            const timeout = setTimeout(() => {
-              if (!reservationSucceeded) {
-                info(`Relay reservation timeout after ${RELAY_WAIT_MS / 1000}s.`);
-                info(`Connected peers: ${node.libp2p.getPeers().map(p => p.toString()).join(', ')}`);
-              }
-              finish();
-            }, RELAY_WAIT_MS);
-
-            // Event names vary by libp2p internals; keep as any to avoid typing mismatch.
-            (node.libp2p as any).addEventListener('relay:reservation', onReservation);
-            (node.libp2p as any).addEventListener('self:peer:update', onPeerUpdate);
-          });
-        } else {
-          reservationSucceeded = true;
-          info('✓ Relay address already present');
-        }
-
-        if (!reservationSucceeded) {
-          info('⚠ Relay reservation did not complete, continuing with fallback relay addresses');
-        }
-
-        connectSpin.succeed('Connected to network!');
-
-        // Publish Agent Card with peerId and multiaddrs so others can dial us
-        const cardSpin = spinner('Publishing Agent Card to DHT...');
-
-        // Use relay addresses from libp2p (populated after reservation), fall back to manual construction
-        const directAddrs = node.getMultiaddrs().filter(a => !a.includes('/p2p-circuit'));
-        const relayAddrs = node.getMultiaddrs().filter(a => a.includes('/p2p-circuit'));
-        const fallbackRelayAddrs = relayAddrs.length === 0
-          ? bootstrapPeers.map((r: string) => `${r}/p2p-circuit/p2p/${node.getPeerId()}`)
-          : [];
-        const allAddrs = [...directAddrs, ...relayAddrs, ...fallbackRelayAddrs];
+        const relayUrls = getRelayUrls(options);
 
         const capabilities = (card.capabilities ?? []).map((capability: string) => ({
           id: capability,
           name: capability,
           description: `Capability: ${capability}`,
         }));
-        if (options.relay) {
-          capabilities.push({
-            id: 'relay',
-            name: 'relay',
-            description: 'Provides circuit relay service for NAT traversal',
-          });
-        }
 
         const agentCard = createAgentCard(
           identity.did,
           card.name,
           card.description,
           capabilities,
-          allAddrs,
-          node.getPeerId()
+          [],
         );
 
         const signedCard = await signAgentCard(agentCard, (data) =>
           sign(data, keyPair.privateKey)
         );
 
-        const dht = createDHTOperations(node.libp2p);
-        await dht.publishAgentCard(signedCard);
-
-        cardSpin.succeed('Agent Card published!');
-
-        // Keep bootstrap connectivity stable: proactively re-dial missing bootstrap peers.
-        const ensureBootstrapConnections = async () => {
-          const connections = node.libp2p.getConnections();
-          const connectedPeerIds = new Set(connections.map((conn) => conn.remotePeer.toString()));
-
-          for (const bootstrapAddr of bootstrapPeers) {
-            const targetPeerId = bootstrapAddr.split('/p2p/')[1];
-            if (!targetPeerId || connectedPeerIds.has(targetPeerId)) continue;
-
-            try {
-              await node.libp2p.dial(bootstrapAddr);
-              info(`Reconnected bootstrap peer: ${targetPeerId}`);
-            } catch {
-              // best effort; keep trying on next tick
-            }
-          }
-        };
+        const relayClient = createRelayClient({
+          relayUrls,
+          did: identity.did,
+          keyPair,
+          card: signedCard,
+        });
 
-        // Keep connection alive by pinging peers periodically
-        const pingInterval = setInterval(async () => {
-          const peers = node.libp2p.getPeers();
-          if (peers.length === 0) {
-            // No peers connected, try to reconnect to bootstrap
-            for (const bootstrapAddr of bootstrapPeers) {
-              try {
-                await node.libp2p.dial(bootstrapAddr);
-                info('Reconnected to bootstrap peer');
-                break;
-              } catch {
-                // try next bootstrap peer
-              }
-            }
-          } else {
-            await ensureBootstrapConnections();
-            // Ping existing peers to keep connection alive
-            for (const peer of peers) {
-              try {
-                await (node.libp2p.services.ping as any).ping(peer);
-              } catch {
-                // ignore ping failures
-              }
-            }
-          }
-        }, 15000); // ping every 15s (reduced from 30s for better stability)
+        await relayClient.start();
 
-        // If a bootstrap peer disconnects, attempt immediate recovery.
-        const onPeerDisconnect = async (evt: any) => {
-          const disconnectedPeerId = evt?.detail?.toString?.() ?? '';
-          if (!bootstrapPeerIds.includes(disconnectedPeerId)) return;
+        spin.succeed('Connected to relay!');
 
-          info(`Bootstrap peer disconnected: ${disconnectedPeerId}, attempting reconnect...`);
-          for (const bootstrapAddr of bootstrapPeers) {
-            if (!bootstrapAddr.endsWith(`/p2p/${disconnectedPeerId}`)) continue;
-            try {
-              await node.libp2p.dial(bootstrapAddr);
-              info(`Recovered bootstrap connection: ${disconnectedPeerId}`);
-              return;
-            } catch {
-              // Continue trying other bootstrap peers if available
-            }
-          }
-        };
-        node.libp2p.addEventListener('peer:disconnect', onPeerDisconnect);
+        info(`DID: ${identity.did}`);
+        info(`Connected relays: ${relayClient.getConnectedRelays().join(', ')}`);
+        info(`Network peers: ${relayClient.getPeerCount()}`);
 
         const verifyFn = async (signature: Uint8Array, data: Uint8Array): Promise<boolean> => {
           try {
@@ -276,16 +98,10 @@ export function registerJoinCommand(program: Command): void {
           }
         };
 
-        // Register message handlers for incoming messages
-        const router = createMessageRouter(
-          node.libp2p,
-          verifyFn,
-          dht
-        );
+        const router = createMessageRouter(relayClient, verifyFn);
 
         const saveDir = resolve(options.saveDir ?? './downloads');
 
-        // Generic message handler that accepts any protocol
         const messageHandler = async (envelope: any) => {
           const payload = envelope.payload as Record<string, unknown>;
           console.log();
@@ -294,7 +110,6 @@ export function registerJoinCommand(program: Command): void {
           info(`    Protocol:   ${envelope.protocol}`);
           info(`    Type:       ${envelope.type}`);
 
-          // Handle file attachment
           let savedPath: string | undefined;
           if (payload.attachment) {
             const att = payload.attachment as {
@@ -305,7 +120,6 @@ export function registerJoinCommand(program: Command): void {
             };
             try {
               await mkdir(saveDir, { recursive: true });
-              // Avoid filename collisions by prefixing with message id fragment
               const safeName = att.filename.replace(/[^a-zA-Z0-9._-]/g, '_');
               savedPath = join(saveDir, `${envelope.id.slice(-8)}_${safeName}`);
               await writeFile(savedPath, Buffer.from(att.data, 'base64'));
@@ -321,7 +135,6 @@ export function registerJoinCommand(program: Command): void {
           }
           console.log();
 
-          // If this is a request, send back a simple acknowledgment response
           if (envelope.type === 'request') {
             info('    Sending acknowledgment response...');
 
@@ -356,11 +169,8 @@ export function registerJoinCommand(program: Command): void {
           return undefined;
         };
 
-        // Register handlers for common protocols
         router.registerHandler('/clawiverse/msg/1.0.0', messageHandler);
         router.registerHandler('/clawiverse/greet/1.0.0', messageHandler);
-
-        // Register catch-all handler for any other protocol
         router.registerCatchAllHandler(messageHandler);
 
         await router.start();
@@ -372,12 +182,10 @@ export function registerJoinCommand(program: Command): void {
 
         process.on('SIGINT', async () => {
           console.log();
-          const stopSpin = spinner('Stopping node...');
-          clearInterval(pingInterval);
-          node.libp2p.removeEventListener('peer:disconnect', onPeerDisconnect);
+          const stopSpin = spinner('Stopping...');
           await router.stop();
-          await node.stop();
-          stopSpin.succeed('Node stopped');
+          await relayClient.stop();
+          stopSpin.succeed('Disconnected');
           process.exit(0);
         });
 

package/src/commands/peers.ts

@@ -0,0 +1,85 @@
+/**
+ * Peers Command - CVP-0010 §2.4
+ *
+ * hw1 peers                         - List online agents
+ * hw1 peers --capability translate  - Filter by capability
+ * hw1 peers --format json
+ */
+
+import { Command } from 'commander';
+import { DaemonClient } from '../daemon/client.js';
+import { createLogger } from '@highway1/core';
+
+const logger = createLogger('cli:peers');
+
+export function registerPeersCommand(program: Command): void {
+  program
+    .command('peers')
+    .description('List agents on the network')
+    .option('--capability <cap>', 'Filter by capability')
+    .option('--query <text>', 'Natural language search')
+    .option('--min-trust <score>', 'Minimum trust score (0-1)')
+    .option('--limit <n>', 'Max results', '20')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        const searchQuery = options.query ?? options.capability ?? '';
+        const params: any = { query: searchQuery };
+        if (options.minTrust) {
+          params.filters = { minTrustScore: parseFloat(options.minTrust) };
+        }
+
+        const results = await client.send('discover', params);
+        const agents: any[] = results ?? [];
+
+        // Filter by capability if specified
+        const filtered = options.capability
+          ? agents.filter((a: any) => {
+              const caps: any[] = a.capabilities ?? [];
+              return caps.some((c: any) => {
+                const name = typeof c === 'string' ? c : c.name ?? c.id ?? '';
+                return name.toLowerCase().includes(options.capability.toLowerCase());
+              });
+            })
+          : agents;
+
+        const limited = filtered.slice(0, parseInt(options.limit, 10));
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify(limited, null, 2));
+          return;
+        }
+
+        if (limited.length === 0) {
+          console.log('No agents found.');
+          return;
+        }
+
+        console.log(`\nPeers (${limited.length} found)\n`);
+        for (const agent of limited) {
+          const trust = agent.trust?.interactionScore ?? 0;
+          const trustStr = `${(trust * 100).toFixed(0)}%`;
+          const caps = (agent.capabilities ?? [])
+            .map((c: any) => typeof c === 'string' ? c : c.name ?? c.id ?? '')
+            .filter(Boolean)
+            .slice(0, 3)
+            .join(', ');
+          const shortDid = agent.did?.slice(0, 30) + '…';
+          console.log(`  ${agent.name ?? shortDid}  trust:${trustStr}`);
+          if (caps) console.log(`    capabilities: ${caps}`);
+          console.log(`    did: ${agent.did}`);
+        }
+        console.log();
+      } catch (err) {
+        logger.error('Peers failed', err);
+        console.error('Error:', (err as Error).message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/send.ts

@@ -1,35 +1,50 @@
 import { Command } from 'commander';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
   importKeyPair,
   createEnvelope,
   signEnvelope,
   createMessageRouter,
-  createDHTOperations,
+  createAgentCard,
+  signAgentCard,
   sign,
   verify,
   extractPublicKey,
 } from '@highway1/core';
-import { getIdentity, getBootstrapPeers } from '../config.js';
+import { getIdentity, getAgentCard } from '../config.js';
 import { success, error, spinner, printHeader, info } from '../ui.js';
 import { readFile } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { DaemonClient } from '../daemon/client.js';
 
+// Default relay URLs (CVP-0011)
+const DEFAULT_RELAY_URLS = [
+  'ws://relay.highway1.net:8080',
+];
+
+function getRelayUrls(options: any): string[] {
+  if (options.relay) return [options.relay];
+  const envRelays = process.env.HW1_RELAY_URLS;
+  if (envRelays) return envRelays.split(',').map((u: string) => u.trim());
+  return DEFAULT_RELAY_URLS;
+}
+
 export function registerSendCommand(program: Command): void {
   program
     .command('send')
     .description('Send a message to another agent')
-    .requiredOption('--to <did>', 'Recipient DID')
-    .requiredOption('--protocol <protocol>', 'Protocol identifier')
+    .requiredOption('--to <did-or-name>', 'Recipient DID or agent name')
+    .option('--protocol <protocol>', 'Protocol identifier', '/clawiverse/msg/1.0.0') // CVP-0010 §3.1: default protocol
+    .option('--message <text>', 'Message text (shorthand for --payload \'{"text":"..."}\')') // CVP-0010 §3.1: --message shorthand
     .option('--payload <json>', 'Message payload (JSON)')
     .option('--file <path>', 'Attach a file (image, binary, text) as payload attachment')
-    .option('--type <type>', 'Message type (request|notification)', 'request')
-    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
-    .option('--peer <multiaddr>', 'Direct peer multiaddr (bypasses DHT lookup)')
+    .option('--type <type>', 'Message type (request|notification)', 'request') // CVP-0010 §3.1: default type
+    .option('--relay <url>', 'Relay WebSocket URL')
+    .option('--format <fmt>', 'Output format: text|json', 'text') // CVP-0010 §3.2: --format json
     .action(async (options) => {
       try {
-        printHeader('Send Message');
+        if (options.format !== 'json') printHeader('Send Message');
 
         const identity = getIdentity();
 
@@ -38,14 +53,18 @@ export function registerSendCommand(program: Command): void {
           process.exit(1);
         }
 
-        if (!options.payload && !options.file) {
-          error('Either --payload <json> or --file <path> is required.');
+        // CVP-0010 §3.1: --message shorthand
+        if (!options.payload && !options.file && !options.message) {
+          error('Either --message <text>, --payload <json>, or --file <path> is required.');
           process.exit(1);
         }
 
         let payload: Record<string, unknown> = {};
 
-        if (options.payload) {
+        // CVP-0010 §3.1: --message shorthand wraps text into {"text": "..."}
+        if (options.message) {
+          payload.text = options.message;
+        } else if (options.payload) {
           try {
             payload = JSON.parse(options.payload);
           } catch {
@@ -85,7 +104,6 @@ export function registerSendCommand(program: Command): void {
               protocol: options.protocol,
               payload,
               type: options.type,
-              peer: options.peer,
             });
 
             spin.succeed('Message sent successfully!');
@@ -135,43 +153,43 @@ export function registerSendCommand(program: Command): void {
           }
         } else {
           console.log();
-          info('⚠ Daemon not running, using ephemeral node (slower)');
+          info('⚠ Daemon not running, using ephemeral relay connection (slower)');
           info('Tip: Start daemon with "clawiverse daemon start" for faster messaging');
           console.log();
         }
 
-        // Fallback: create ephemeral node (original behavior)
-        const spin = spinner('Starting node...');
+        // Fallback: create ephemeral relay connection (CVP-0011)
+        const spin = spinner('Connecting to relay...');
 
         const keyPair = importKeyPair({
           publicKey: identity.publicKey,
           privateKey: identity.privateKey,
         });
 
-        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
+        const relayUrls = getRelayUrls(options);
+        const card = getAgentCard();
+        const capabilities = (card?.capabilities ?? []).map((c: string) => ({
+          id: c, name: c, description: `Capability: ${c}`,
+        }));
+        const agentCard = createAgentCard(
+          identity.did,
+          card?.name ?? 'Clawiverse Agent',
+          card?.description ?? '',
+          capabilities,
+          [],
+        );
+        const signedCard = await signAgentCard(agentCard, (data) => sign(data, keyPair.privateKey));
 
-        const node = await createNode({
+        const relayClient = createRelayClient({
+          relayUrls,
+          did: identity.did,
           keyPair,
-          bootstrapPeers,
-          enableDHT: true,
-          reserveRelaySlot: bootstrapPeers.length > 0,
-        });
-
-        // Register peer:identify listener BEFORE start() so we don't miss the event
-        const identifyDone = new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 2000);
-          node.libp2p.addEventListener('peer:identify', () => {
-            clearTimeout(timeout);
-            resolve();
-          }, { once: true });
+          card: signedCard,
         });
 
-        await node.start();
+        await relayClient.start();
+        spin.text = 'Connected to relay';
 
-        spin.text = 'Connecting to network...';
-        await identifyDone;
-
-        const dht = createDHTOperations(node.libp2p);
         const verifyFn = async (signature: Uint8Array, data: Uint8Array): Promise<boolean> => {
           try {
             const decoded = JSON.parse(new TextDecoder().decode(data)) as { from?: string };
@@ -183,13 +201,7 @@ export function registerSendCommand(program: Command): void {
           }
         };
 
-        const router = createMessageRouter(
-          node.libp2p,
-          verifyFn,
-          dht,
-          bootstrapPeers
-        );
-
+        const router = createMessageRouter(relayClient, verifyFn);
         await router.start();
 
         spin.text = 'Creating message...';
@@ -208,21 +220,7 @@ export function registerSendCommand(program: Command): void {
 
         spin.text = 'Sending message...';
 
-        // Build peer hint from --peer option if provided
-        let peerHint = undefined;
-        if (options.peer) {
-          // Extract peerId from multiaddr (last component after /p2p/)
-          const parts = options.peer.split('/p2p/');
-          if (parts.length >= 2) {
-            peerHint = {
-              peerId: parts[parts.length - 1],
-              multiaddrs: [options.peer],
-            };
-            info(`Direct peer: ${options.peer}`);
-          }
-        }
-
-        const response = await router.sendMessage(signedEnvelope, peerHint);
+        const response = await router.sendMessage(signedEnvelope);
 
         spin.succeed('Message sent successfully!');
 
@@ -261,7 +259,7 @@ export function registerSendCommand(program: Command): void {
         }
 
         await router.stop();
-        await node.stop();
+        await relayClient.stop();
 
         success('Done');
       } catch (err) {