@highway1/cli 0.1.50 → 0.1.53

package/src/commands/send.ts

@@ -1,21 +1,35 @@
 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')
@@ -26,8 +40,7 @@ export function registerSendCommand(program: Command): void {
     .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') // CVP-0010 §3.1: default type
-    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
-    .option('--peer <multiaddr>', 'Direct peer multiaddr (bypasses DHT lookup)')
+    .option('--relay <url>', 'Relay WebSocket URL')
     .option('--format <fmt>', 'Output format: text|json', 'text') // CVP-0010 §3.2: --format json
     .action(async (options) => {
       try {
@@ -91,7 +104,6 @@ export function registerSendCommand(program: Command): void {
               protocol: options.protocol,
               payload,
               type: options.type,
-              peer: options.peer,
             });
 
             spin.succeed('Message sent successfully!');
@@ -141,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 };
@@ -189,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...';
@@ -214,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!');
 
@@ -267,7 +259,7 @@ export function registerSendCommand(program: Command): void {
         }
 
         await router.stop();
-        await node.stop();
+        await relayClient.stop();
 
         success('Done');
       } catch (err) {

package/src/daemon/server.ts

@@ -3,10 +3,10 @@ import type { Server } from 'net';
 import { homedir } from 'os';
 import { join } from 'path';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
   importKeyPair,
   createMessageRouter,
-  createDHTOperations,
   sign,
   verify,
   extractPublicKey,
@@ -15,9 +15,9 @@ import {
   createTrustSystem,
   MessageQueue,
   DefenseMiddleware,
-  type ClawiverseNode,
+  type RelayClient,
   type MessageRouter,
-  type DHTOperations,
+  type RelayIndexOperations,
   type TrustSystem,
   type MessageEnvelope,
 } from '@highway1/core';
@@ -26,6 +26,17 @@ import { getIdentity, getBootstrapPeers } from '../config.js';
 
 const logger = createLogger('daemon');
 
+// Default relay URLs (CVP-0011)
+const DEFAULT_RELAY_URLS = [
+  'ws://relay.highway1.net:8080',
+];
+
+function getRelayUrls(): string[] {
+  const envRelays = process.env.HW1_RELAY_URLS;
+  if (envRelays) return envRelays.split(',').map((u) => u.trim());
+  return DEFAULT_RELAY_URLS;
+}
+
 type DaemonCommand =
   | 'send'
   | 'discover'
@@ -60,15 +71,14 @@ interface DaemonResponse {
 }
 
 export class ClawDaemon {
-  private node: ClawiverseNode | null = null;
+  private relayClient: RelayClient | null = null;
+  private relayIndex: RelayIndexOperations | null = null;
   private router: MessageRouter | null = null;
-  private dht: DHTOperations | null = null;
   private server: Server | null = null;
   private socketPath: string;
   private identity: any;
-  private bootstrapPeers: string[];
 
-  // New: persistent queue + defense
+  // Persistent queue + defense
   private queue: MessageQueue | null = null;
   private defense: DefenseMiddleware | null = null;
   private trustSystem: TrustSystem | null = null;
@@ -76,7 +86,6 @@ export class ClawDaemon {
   constructor(socketPath: string = '/tmp/clawiverse.sock') {
     this.socketPath = socketPath;
     this.identity = getIdentity();
-    this.bootstrapPeers = getBootstrapPeers();
 
     if (!this.identity) {
       throw new Error('No identity found. Run "clawiverse init" first.');
@@ -92,17 +101,33 @@ export class ClawDaemon {
         privateKey: this.identity.privateKey,
       });
 
-      this.node = await createNode({
+      // Load agent card for HELLO message
+      const { getAgentCard, createAgentCard, signAgentCard } = await import('@highway1/core');
+      const cardConfig = getAgentCard();
+      const capabilities = (cardConfig?.capabilities ?? []).map((c: string) => ({
+        id: c, name: c, description: `Capability: ${c}`,
+      }));
+      const agentCard = createAgentCard(
+        this.identity.did,
+        cardConfig?.name ?? 'Clawiverse Agent',
+        cardConfig?.description ?? '',
+        capabilities,
+        [],
+      );
+      const signedCard = await signAgentCard(agentCard, (data) => sign(data, keyPair.privateKey));
+
+      const relayUrls = getRelayUrls();
+      this.relayClient = createRelayClient({
+        relayUrls,
+        did: this.identity.did,
         keyPair,
-        bootstrapPeers: this.bootstrapPeers,
-        enableDHT: true,
-        reserveRelaySlot: this.bootstrapPeers.length > 0,
+        card: signedCard,
       });
 
-      await this.node.start();
-      logger.info('Node started', { peerId: this.node.getPeerId() });
+      await this.relayClient.start();
+      logger.info('Relay client started', { relays: this.relayClient.getConnectedRelays() });
 
-      this.dht = createDHTOperations(this.node.libp2p);
+      this.relayIndex = createRelayIndexOperations(this.relayClient);
 
       const verifyFn = async (signature: Uint8Array, data: Uint8Array): Promise<boolean> => {
         try {
@@ -115,13 +140,7 @@ export class ClawDaemon {
         }
       };
 
-      this.router = createMessageRouter(
-        this.node.libp2p,
-        verifyFn,
-        this.dht,
-        this.bootstrapPeers
-      );
-
+      this.router = createMessageRouter(this.relayClient, verifyFn);
       await this.router.start();
       logger.info('Router started');
 
@@ -145,7 +164,7 @@ export class ClawDaemon {
       this.defense = new DefenseMiddleware({
         trustSystem: this.trustSystem,
         storage: this.queue.store,
-        minTrustScore: 0, // Accept all by default
+        minTrustScore: 0,
       });
       logger.info('Defense middleware initialized');
 
@@ -164,7 +183,7 @@ export class ClawDaemon {
 
       console.log(`✓ Clawiverse daemon started`);
       console.log(`  Socket: ${this.socketPath}`);
-      console.log(`  Peer ID: ${this.node.getPeerId()}`);
+      console.log(`  Relays: ${this.relayClient.getConnectedRelays().join(', ')}`);
       console.log(`  DID: ${this.identity.did}`);
     } catch (error) {
       logger.error('Failed to start daemon', error);
@@ -175,17 +194,14 @@ export class ClawDaemon {
   private async handleIncomingMessage(envelope: MessageEnvelope): Promise<MessageEnvelope | void> {
     if (!this.defense || !this.queue || !this.trustSystem) return;
 
-    // Run defense checks
     const result = await this.defense.checkMessage(envelope);
     if (!result.allowed) {
       logger.warn('Message rejected by defense', { id: envelope.id, reason: result.reason });
       return;
     }
 
-    // Persist to inbox
     await this.queue.enqueueInbound(envelope, result.trustScore);
 
-    // Record interaction for trust scoring
     await this.trustSystem.recordInteraction({
       agentDid: envelope.from,
       timestamp: Date.now(),
@@ -202,7 +218,6 @@ export class ClawDaemon {
 
     socket.on('data', async (data) => {
       buffer += data.toString();
-      // Handle newline-delimited JSON
       const lines = buffer.split('\n');
       buffer = lines.pop() ?? '';
 
@@ -223,7 +238,6 @@ export class ClawDaemon {
         }
       }
 
-      // Also handle single-message (no newline) for backward compat
       if (buffer.trim()) {
         try {
           const request: DaemonRequest = JSON.parse(buffer);
@@ -253,7 +267,6 @@ export class ClawDaemon {
           await this.shutdown();
           return { id: req.id, success: true };
 
-        // Queue commands
         case 'inbox':        return await this.handleInbox(req);
         case 'get_message':  return await this.handleGetMessage(req);
         case 'mark_read':    return await this.handleMarkRead(req);
@@ -261,12 +274,10 @@ export class ClawDaemon {
         case 'outbox':       return await this.handleOutbox(req);
         case 'retry_message': return await this.handleRetryMessage(req);
 
-        // Defense commands
         case 'block':      return await this.handleBlock(req);
         case 'unblock':    return await this.handleUnblock(req);
         case 'allowlist':  return await this.handleAllowlist(req);
 
-        // Stats
         case 'queue_stats': return await this.handleQueueStats(req);
 
         default:
@@ -279,7 +290,7 @@ export class ClawDaemon {
   }
 
   private async handleSend(req: DaemonRequest): Promise<DaemonResponse> {
-    const { to, protocol, payload, type, peer } = req.params;
+    const { to, protocol, payload, type } = req.params;
 
     if (!this.router) {
       return { id: req.id, success: false, error: 'Router not initialized' };
@@ -302,20 +313,11 @@ export class ClawDaemon {
       sign(data, keyPair.privateKey)
     );
 
-    // Track outbound in queue
     if (this.queue) {
       await this.queue.enqueueOutbound(signedEnvelope);
     }
 
-    let peerHint = undefined;
-    if (peer) {
-      const parts = peer.split('/p2p/');
-      if (parts.length >= 2) {
-        peerHint = { peerId: parts[parts.length - 1], multiaddrs: [peer] };
-      }
-    }
-
-    const response = await this.router.sendMessage(signedEnvelope, peerHint);
+    const response = await this.router.sendMessage(signedEnvelope);
 
     if (this.queue) {
       await this.queue.markOutboundDelivered(signedEnvelope.id);
@@ -330,27 +332,25 @@ export class ClawDaemon {
 
   private async handleDiscover(req: DaemonRequest): Promise<DaemonResponse> {
     const { query } = req.params;
-    if (!this.dht) return { id: req.id, success: false, error: 'DHT not initialized' };
-    const results = await this.dht.searchSemantic(query);
+    if (!this.relayIndex) return { id: req.id, success: false, error: 'Relay index not initialized' };
+    const results = await this.relayIndex.searchSemantic(query);
     return { id: req.id, success: true, data: results };
   }
 
   private handleStatus(req: DaemonRequest): DaemonResponse {
-    if (!this.node) return { id: req.id, success: false, error: 'Node not initialized' };
+    if (!this.relayClient) return { id: req.id, success: false, error: 'Relay client not initialized' };
     return {
       id: req.id,
       success: true,
       data: {
         running: true,
-        peerId: this.node.getPeerId(),
+        connectedRelays: this.relayClient.getConnectedRelays(),
+        peerCount: this.relayClient.getPeerCount(),
         did: this.identity.did,
-        multiaddrs: this.node.getMultiaddrs(),
-        bootstrapPeers: this.bootstrapPeers,
       },
     };
   }
 
-  /** Legacy messages command — delegates to inbox for backward compat */
   private async handleMessages(req: DaemonRequest): Promise<DaemonResponse> {
     const { limit = 10 } = req.params || {};
     if (this.queue) {
@@ -466,9 +466,9 @@ export class ClawDaemon {
       this.trustSystem = null;
     }
 
-    if (this.node) {
-      await this.node.stop();
-      this.node = null;
+    if (this.relayClient) {
+      await this.relayClient.stop();
+      this.relayClient = null;
     }
 
     if (this.server) {