@highway1/cli 0.1.9 → 0.1.12

package/src/commands/discover.ts

@@ -0,0 +1,168 @@
+import { Command } from 'commander';
+import {
+  createNode,
+  importKeyPair,
+  createDHTOperations,
+} from '@clawiverse/core';
+import { getIdentity, getBootstrapPeers } from '../config.js';
+import { error, spinner, printHeader, info, success } from '../ui.js';
+import Table from 'cli-table3';
+
+export function registerDiscoverCommand(program: Command): void {
+  program
+    .command('discover')
+    .description('Discover agents on the network')
+    .option('--capability <capability>', 'Filter by capability')
+    .option('--did <did>', 'Query specific DID')
+    .option('--query <text>', 'Natural language query (e.g., "translate Japanese")')
+    .option('--min-trust <score>', 'Minimum trust score (0-1)')
+    .option('--language <lang>', 'Filter by language')
+    .option('--limit <number>', 'Maximum number of results', '10')
+    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
+    .action(async (options) => {
+      try {
+        printHeader('Discover Agents');
+
+        const identity = getIdentity();
+
+        if (!identity) {
+          error('No identity found. Run "hw1 init" first.');
+          process.exit(1);
+        }
+
+        const spin = spinner('Starting node...');
+
+        const keyPair = importKeyPair({
+          publicKey: identity.publicKey,
+          privateKey: identity.privateKey,
+        });
+
+        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
+
+        const node = await createNode({
+          keyPair,
+          bootstrapPeers,
+          enableDHT: true,
+        });
+
+        await node.start();
+
+        spin.text = 'Waiting for DHT peers...';
+        // Wait until connected to at least one peer, or timeout after 15s
+        await new Promise<void>((resolve) => {
+          const timeout = setTimeout(resolve, 15000);
+          node.libp2p.addEventListener('peer:connect', () => {
+            clearTimeout(timeout);
+            setTimeout(resolve, 1000); // brief settle time after first connection
+          }, { once: true });
+        });
+
+        spin.text = 'Querying DHT...';
+
+        const dht = createDHTOperations(node.libp2p);
+
+        if (options.did) {
+          const card = await dht.queryAgentCard(options.did);
+
+          if (card) {
+            spin.succeed('Agent found!');
+            console.log();
+            info(`DID:          ${card.did}`);
+            info(`Name:         ${card.name}`);
+            info(`Description:  ${card.description}`);
+            info(`Version:      ${card.version}`);
+            info(`Capabilities: ${card.capabilities.join(', ') || '(none)'}`);
+            info(`Peer ID:      ${card.peerId || '(unknown)'}`);
+            info(`Endpoints:    ${card.endpoints.length > 0 ? card.endpoints.join('\n              ') : '(none)'}`);
+            info(`Timestamp:    ${new Date(card.timestamp).toISOString()}`);
+          } else {
+            spin.fail('Agent not found');
+          }
+        } else if (options.capability || options.query) {
+          // Semantic search
+          const query: any = {
+            limit: parseInt(options.limit, 10),
+          };
+
+          if (options.query) {
+            query.text = options.query;
+          } else if (options.capability) {
+            query.capability = options.capability;
+          }
+
+          if (options.minTrust) {
+            query.filters = {
+              minTrustScore: parseFloat(options.minTrust),
+            };
+          }
+
+          if (options.language) {
+            query.filters = query.filters || {};
+            query.filters.language = options.language;
+          }
+
+          const cards = await dht.searchSemantic(query);
+
+          spin.succeed(`Found ${cards.length} agents`);
+
+          if (cards.length > 0) {
+            const table = new Table({
+              head: ['DID', 'Name', 'Capabilities', 'Trust'],
+              colWidths: [40, 20, 35, 10],
+            });
+
+            for (const card of cards) {
+              const capabilities = Array.isArray(card.capabilities)
+                ? card.capabilities.map((cap: any) =>
+                    typeof cap === 'string' ? cap : cap.name
+                  ).join(', ')
+                : '';
+
+              const trustScore = card.trust
+                ? `${(card.trust.interactionScore * 100).toFixed(0)}%`
+                : 'N/A';
+
+              table.push([
+                card.did.substring(0, 35) + '...',
+                card.name,
+                capabilities.substring(0, 30) + (capabilities.length > 30 ? '...' : ''),
+                trustScore,
+              ]);
+            }
+
+            console.log();
+            console.log(table.toString());
+
+            // Show detailed info for first result if query was used
+            if (options.query && cards.length > 0) {
+              const card = cards[0];
+              console.log();
+              info('Top match details:');
+              info(`  DID:         ${card.did}`);
+              info(`  Name:        ${card.name}`);
+              info(`  Description: ${card.description}`);
+
+              if (Array.isArray(card.capabilities) && card.capabilities.length > 0) {
+                const cap = card.capabilities[0];
+                if (typeof cap === 'object' && cap !== null) {
+                  info(`  Capability:  ${cap.name}`);
+                  info(`               ${cap.description}`);
+                }
+              }
+            }
+          }
+        } else {
+          spin.fail('Please specify --did, --capability, or --query');
+          info('Usage: hw1 discover --did <did>');
+          info('       hw1 discover --capability <capability>');
+          info('       hw1 discover --query "translate Japanese"');
+          info('       hw1 discover --query "code review" --min-trust 0.8');
+        }
+
+        await node.stop();
+      } catch (err) {
+        error(`Failed to discover: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/identity.ts

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { getIdentity, getAgentCard } from '../config.js';
+import { error, printHeader, printKeyValue } from '../ui.js';
+
+export function registerIdentityCommand(program: Command): void {
+  program
+    .command('identity')
+    .description('Show current identity information')
+    .action(async () => {
+      try {
+        printHeader('Clawiverse Identity');
+
+        const identity = getIdentity();
+        const card = getAgentCard();
+
+        if (!identity) {
+          error('No identity found. Run "hw1 init" first.');
+          process.exit(1);
+        }
+
+        printKeyValue('DID', identity.did);
+        printKeyValue('Public Key', identity.publicKey.substring(0, 16) + '...');
+
+        if (card) {
+          console.log();
+          printKeyValue('Name', card.name);
+          printKeyValue('Description', card.description);
+          printKeyValue('Capabilities', card.capabilities.join(', ') || 'None');
+        }
+
+        console.log();
+      } catch (err) {
+        error(`Failed to show identity: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/init.ts

@@ -0,0 +1,79 @@
+import { Command } from 'commander';
+import { generateKeyPair, exportKeyPair, deriveDID } from '@clawiverse/core';
+import { hasIdentity, setIdentity, setAgentCard } from '../config.js';
+import { success, error, spinner, printHeader, printKeyValue } from '../ui.js';
+import inquirer from 'inquirer';
+
+export function registerInitCommand(program: Command): void {
+  program
+    .command('init')
+    .description('Initialize a new Clawiverse identity')
+    .option('--name <name>', 'Agent name')
+    .option('--description <description>', 'Agent description')
+    .option('--force', 'Overwrite existing identity')
+    .action(async (options) => {
+      try {
+        printHeader('Initialize Clawiverse Identity');
+
+        // Check if identity already exists
+        if (hasIdentity() && !options.force) {
+          error('Identity already exists. Use --force to overwrite.');
+          process.exit(1);
+        }
+
+        // Prompt for agent details if not provided
+        let name = options.name;
+        let description = options.description;
+
+        if (!name) name = 'My Agent';
+        if (!description) description = 'A Clawiverse agent';
+
+        if (!options.name) {
+          const { name: inputName } = await inquirer.prompt({
+            type: 'input', name: 'name', message: 'Agent name:', default: name,
+          });
+          name = inputName || name;
+        }
+        if (!options.description) {
+          const { description: inputDesc } = await inquirer.prompt({
+            type: 'input', name: 'description', message: 'Agent description:', default: description,
+          });
+          description = inputDesc || description;
+        }
+
+        const spin = spinner('Generating key pair...');
+
+        // Generate key pair
+        const keyPair = await generateKeyPair();
+        const exported = exportKeyPair(keyPair);
+        const did = deriveDID(keyPair.publicKey);
+
+        // Save identity
+        setIdentity({
+          did,
+          publicKey: exported.publicKey,
+          privateKey: exported.privateKey,
+        });
+
+        // Save agent card
+        setAgentCard({
+          name,
+          description,
+          capabilities: [],
+        });
+
+        spin.succeed('Identity created successfully!');
+
+        console.log();
+        printKeyValue('DID', did);
+        printKeyValue('Name', name);
+        printKeyValue('Description', description);
+        console.log();
+
+        success('Run "hw1 join" to connect to the network');
+      } catch (err) {
+        error(`Failed to initialize: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/join.ts

@@ -0,0 +1,176 @@
+import { Command } from 'commander';
+import {
+  createNode,
+  importKeyPair,
+  createAgentCard,
+  signAgentCard,
+  createDHTOperations,
+  createMessageRouter,
+  sign,
+} from '@clawiverse/core';
+import { getIdentity, getAgentCard, getBootstrapPeers } from '../config.js';
+import { success, error, spinner, printHeader, info } from '../ui.js';
+
+export function registerJoinCommand(program: Command): void {
+  program
+    .command('join')
+    .description('Join the Clawiverse network')
+    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
+    .action(async (options) => {
+      try {
+        printHeader('Join Clawiverse Network');
+
+        const identity = getIdentity();
+        const card = getAgentCard();
+
+        if (!identity || !card) {
+          error('No identity found. Run "hw1 init" first.');
+          process.exit(1);
+        }
+
+        const spin = spinner('Starting libp2p node...');
+
+        const keyPair = importKeyPair({
+          publicKey: identity.publicKey,
+          privateKey: identity.privateKey,
+        });
+
+        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
+
+        const node = await createNode({
+          keyPair,
+          bootstrapPeers,
+          enableDHT: true,
+        });
+
+        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...');
+        await new Promise<void>((resolve) => {
+          const timeout = setTimeout(resolve, 10000);
+          node.libp2p.addEventListener('peer:connect', () => {
+            clearTimeout(timeout);
+            setTimeout(resolve, 500);
+          }, { once: true });
+        });
+        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...');
+
+        // Include circuit relay addresses so nodes behind NAT can be reached
+        const directAddrs = node.getMultiaddrs();
+        const relayAddrs = bootstrapPeers.map((relayAddr) => {
+          const peerId = node.getPeerId();
+          return `${relayAddr}/p2p-circuit/p2p/${peerId}`;
+        });
+        const allAddrs = [...directAddrs, ...relayAddrs];
+
+        const agentCard = createAgentCard(
+          identity.did,
+          card.name,
+          card.description,
+          card.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!');
+
+        // Register message handlers for incoming messages
+        const router = createMessageRouter(
+          node.libp2p,
+          async () => true,
+          dht
+        );
+
+        // Generic message handler that accepts any protocol
+        const messageHandler = async (envelope: any) => {
+          const payload = envelope.payload as Record<string, unknown>;
+          console.log();
+          success(`>>> Received message from ${envelope.from}`);
+          info(`    Message ID: ${envelope.id}`);
+          info(`    Protocol:   ${envelope.protocol}`);
+          info(`    Type:       ${envelope.type}`);
+          info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
+          console.log();
+
+          // If this is a request, send back a simple acknowledgment response
+          if (envelope.type === 'request') {
+            info('    Sending acknowledgment response...');
+
+            const { createEnvelope, signEnvelope, sign } = await import('@clawiverse/core');
+            const identity = getIdentity();
+            const keyPair = importKeyPair({
+              publicKey: identity!.publicKey,
+              privateKey: identity!.privateKey,
+            });
+
+            const responseEnvelope = createEnvelope(
+              envelope.to,      // We are the recipient, now we're the sender
+              envelope.from,    // Original sender is now the recipient
+              'response',
+              envelope.protocol,
+              {
+                status: 'received',
+                message: 'Message received and processed',
+                originalPayload: payload,
+                timestamp: Date.now()
+              },
+              envelope.id       // replyTo: original message ID
+            );
+
+            const signedResponse = await signEnvelope(responseEnvelope, (data) =>
+              sign(data, keyPair.privateKey)
+            );
+
+            return signedResponse;
+          }
+
+          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();
+
+        console.log();
+        success('Successfully joined the Clawiverse network!');
+        info('Listening for incoming messages...');
+        info('Press Ctrl+C to stop');
+
+        process.on('SIGINT', async () => {
+          console.log();
+          const stopSpin = spinner('Stopping node...');
+          await router.stop();
+          await node.stop();
+          stopSpin.succeed('Node stopped');
+          process.exit(0);
+        });
+
+        await new Promise(() => {});
+      } catch (err) {
+        error(`Failed to join network: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/send.ts

@@ -0,0 +1,137 @@
+import { Command } from 'commander';
+import {
+  createNode,
+  importKeyPair,
+  createEnvelope,
+  signEnvelope,
+  createMessageRouter,
+  createDHTOperations,
+  sign,
+} from '@clawiverse/core';
+import { getIdentity, getBootstrapPeers } from '../config.js';
+import { success, error, spinner, printHeader, info } from '../ui.js';
+
+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('--payload <json>', 'Message payload (JSON)')
+    .option('--type <type>', 'Message type (request|notification)', 'request')
+    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
+    .option('--peer <multiaddr>', 'Direct peer multiaddr (bypasses DHT lookup)')
+    .action(async (options) => {
+      try {
+        printHeader('Send Message');
+
+        const identity = getIdentity();
+
+        if (!identity) {
+          error('No identity found. Run "hw1 init" first.');
+          process.exit(1);
+        }
+
+        let payload;
+        try {
+          payload = JSON.parse(options.payload);
+        } catch {
+          error('Invalid JSON payload');
+          process.exit(1);
+        }
+
+        const spin = spinner('Starting node...');
+
+        const keyPair = importKeyPair({
+          publicKey: identity.publicKey,
+          privateKey: identity.privateKey,
+        });
+
+        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
+
+        const node = await createNode({
+          keyPair,
+          bootstrapPeers,
+          enableDHT: true,
+        });
+
+        await node.start();
+
+        spin.text = 'Connecting to network...';
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+
+        const dht = createDHTOperations(node.libp2p);
+
+        const router = createMessageRouter(
+          node.libp2p,
+          async () => true,
+          dht,
+          bootstrapPeers
+        );
+
+        await router.start();
+
+        spin.text = 'Creating message...';
+
+        const envelope = createEnvelope(
+          identity.did,
+          options.to,
+          options.type,
+          options.protocol,
+          payload
+        );
+
+        const signedEnvelope = await signEnvelope(envelope, (data) =>
+          sign(data, keyPair.privateKey)
+        );
+
+        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[1],
+              multiaddrs: [options.peer],
+            };
+            info(`Direct peer: ${options.peer}`);
+          }
+        }
+
+        const response = await router.sendMessage(signedEnvelope, peerHint);
+
+        spin.succeed('Message sent successfully!');
+
+        console.log();
+        info(`Message ID: ${signedEnvelope.id}`);
+        info(`To: ${options.to}`);
+        info(`Protocol: ${options.protocol}`);
+        info(`Type: ${options.type}`);
+        info(`Payload: ${JSON.stringify(payload)}`);
+
+        // Display response if received
+        if (response) {
+          console.log();
+          success('>>> Received response from recipient');
+          info(`Response ID: ${response.id}`);
+          info(`Reply To: ${response.replyTo}`);
+          info(`Protocol: ${response.protocol}`);
+          info(`Payload: ${JSON.stringify(response.payload, null, 2)}`);
+        } else if (options.type === 'request') {
+          console.log();
+          info('No response received (recipient may not have returned a response)');
+        }
+
+        await router.stop();
+        await node.stop();
+
+        success('Done');
+      } catch (err) {
+        error(`Failed to send message: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/status.ts

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import { getIdentity, getAgentCard, getBootstrapPeers } from '../config.js';
+import { error, printHeader, printKeyValue, printSection } from '../ui.js';
+
+export function registerStatusCommand(program: Command): void {
+  program
+    .command('status')
+    .description('Show current status')
+    .action(async () => {
+      try {
+        printHeader('Clawiverse Status');
+
+        const identity = getIdentity();
+        const card = getAgentCard();
+        const bootstrapPeers = getBootstrapPeers();
+
+        if (!identity) {
+          error('No identity configured. Run "hw1 init" first.');
+          process.exit(1);
+        }
+
+        printSection('Identity');
+        printKeyValue('DID', identity.did);
+        printKeyValue('Public Key', identity.publicKey.substring(0, 16) + '...');
+
+        if (card) {
+          printSection('Agent Card');
+          printKeyValue('Name', card.name);
+          printKeyValue('Description', card.description);
+          printKeyValue('Capabilities', card.capabilities.join(', ') || 'None');
+        }
+
+        printSection('Network');
+        printKeyValue(
+          'Bootstrap Peers',
+          bootstrapPeers.length > 0 ? bootstrapPeers.join(', ') : 'None configured'
+        );
+
+        console.log();
+      } catch (err) {
+        error(`Failed to show status: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}