@highway1/cli 0.1.37 → 0.1.39

package/package.json

@@ -1,32 +1,20 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.37",
-  "description": "CLI tool for Clawiverse network",
+  "version": "0.1.39",
+  "description": "CLI tool for decentralized AI agent network",
   "type": "module",
   "bin": {
-    "clawiverse": "./dist/index.js",
     "hw1": "./dist/index.js"
   },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist"
-  },
+  "keywords": ["ai", "agent", "p2p", "cli"],
+  "license": "MIT",
   "dependencies": {
-    "@highway1/core": "0.1.26",
-    "chalk": "^5.3.0",
-    "cli-table3": "^0.6.5",
+    "@highway1/core": "^0.1.39",
     "commander": "^12.1.0",
-    "conf": "^13.0.1",
+    "chalk": "^5.3.0",
+    "ora": "^8.1.0",
     "inquirer": "^13.3.0",
-    "ora": "^8.1.0"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.2",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.2"
-  },
-  "engines": {
-    "node": ">=22.0.0"
+    "cli-table3": "^0.6.5",
+    "conf": "^13.0.1"
   }
 }

package/bin/clawiverse.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '../dist/index.js';

package/src/commands/card.ts

@@ -1,99 +0,0 @@
-import { Command } from 'commander';
-import { getAgentCard, setAgentCard } from '../config.js';
-import { success, error, printHeader } from '../ui.js';
-import inquirer from 'inquirer';
-
-export function registerCardCommand(program: Command): void {
-  const card = program.command('card').description('Manage Agent Card');
-
-  card
-    .command('show')
-    .description('Show current Agent Card')
-    .action(async () => {
-      try {
-        printHeader('Agent Card');
-
-        const agentCard = getAgentCard();
-
-        if (!agentCard) {
-          error('No Agent Card found. Run "hw1 init" first.');
-          process.exit(1);
-        }
-
-        console.log(JSON.stringify(agentCard, null, 2));
-      } catch (err) {
-        error(`Failed to show card: ${(err as Error).message}`);
-        process.exit(1);
-      }
-    });
-
-  card
-    .command('edit')
-    .description('Edit Agent Card')
-    .option('--name <name>', 'Agent name')
-    .option('--description <description>', 'Agent description')
-    .option('--capabilities <capabilities>', 'Capabilities (comma-separated)')
-    .action(async (options) => {
-      try {
-        printHeader('Edit Agent Card');
-
-        const currentCard = getAgentCard();
-
-        if (!currentCard) {
-          error('No Agent Card found. Run "hw1 init" first.');
-          process.exit(1);
-        }
-
-        let updatedCard;
-
-        // If any options provided, use non-interactive mode
-        if (options.name || options.description || options.capabilities) {
-          updatedCard = {
-            name: options.name || currentCard.name,
-            description: options.description || currentCard.description,
-            capabilities: options.capabilities
-              ? options.capabilities.split(',').map((c: string) => c.trim()).filter((c: string) => c.length > 0)
-              : currentCard.capabilities,
-          };
-        } else {
-          // Interactive mode
-          const answers = await inquirer.prompt([
-            {
-              type: 'input',
-              name: 'name',
-              message: 'Agent name:',
-              default: currentCard.name,
-            },
-            {
-              type: 'input',
-              name: 'description',
-              message: 'Agent description:',
-              default: currentCard.description,
-            },
-            {
-              type: 'input',
-              name: 'capabilities',
-              message: 'Capabilities (comma-separated):',
-              default: currentCard.capabilities.join(', '),
-            },
-          ]);
-
-          updatedCard = {
-            name: answers.name,
-            description: answers.description,
-            capabilities: answers.capabilities
-              .split(',')
-              .map((c: string) => c.trim())
-              .filter((c: string) => c.length > 0),
-          };
-        }
-
-        setAgentCard(updatedCard);
-
-        success('Agent Card updated successfully!');
-      } catch (err) {
-        error(`Failed to edit card: ${(err as Error).message}`);
-        process.exit(1);
-      }
-    });
-}

package/src/commands/discover.ts

@@ -1,168 +0,0 @@
-import { Command } from 'commander';
-import {
-  createNode,
-  importKeyPair,
-  createDHTOperations,
-} from '@highway1/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, then give DHT time to sync
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 15000);
-          node.libp2p.addEventListener('peer:connect', () => {
-            clearTimeout(timeout);
-            setTimeout(resolve, 3000); // give DHT routing table time to populate
-          }, { 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

@@ -1,37 +0,0 @@
-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

@@ -1,54 +0,0 @@
-import { Command } from 'commander';
-import { generateKeyPair, exportKeyPair, deriveDID } from '@highway1/core';
-import { hasIdentity, setIdentity, setAgentCard } from '../config.js';
-import { success, error, spinner, printHeader, printKeyValue } from '../ui.js';
-
-export function registerInitCommand(program: Command): void {
-  program
-    .command('init')
-    .description('Initialize a new Clawiverse identity')
-    .option('--name <name>', 'Agent name', 'My Agent')
-    .option('--description <description>', 'Agent description', 'A Clawiverse agent')
-    .option('--force', 'Overwrite existing identity')
-    .action(async (options) => {
-      try {
-        printHeader('Initialize Clawiverse Identity');
-
-        if (hasIdentity() && !options.force) {
-          error('Identity already exists. Use --force to overwrite.');
-          process.exit(1);
-        }
-
-        const spin = spinner('Generating key pair...');
-
-        const keyPair = await generateKeyPair();
-        const exported = exportKeyPair(keyPair);
-        const did = deriveDID(keyPair.publicKey);
-
-        setIdentity({
-          did,
-          publicKey: exported.publicKey,
-          privateKey: exported.privateKey,
-        });
-
-        setAgentCard({
-          name: options.name,
-          description: options.description,
-          capabilities: [],
-        });
-
-        spin.succeed('Identity created successfully!');
-
-        console.log();
-        printKeyValue('DID', did);
-        printKeyValue('Name', options.name);
-        printKeyValue('Description', options.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

@@ -1,243 +0,0 @@
-import { Command } from 'commander';
-import {
-  createNode,
-  importKeyPair,
-  createAgentCard,
-  signAgentCard,
-  createDHTOperations,
-  createMessageRouter,
-  sign,
-} from '@highway1/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')
-    .option('--relay', 'Run as a relay server and advertise relay capability')
-    .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,
-          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)
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 10000);
-          node.libp2p.addEventListener('peer:connect', () => {
-            clearTimeout(timeout);
-            resolve();
-          }, { once: true });
-        });
-
-        // Phase 2: wait for relay reservation (up to 10s)
-        const hasRelayAddr = () => node.getMultiaddrs().some(a => a.includes('/p2p-circuit'));
-        if (!hasRelayAddr()) {
-          info('Waiting for relay reservation...');
-          info(`Listen addresses configured: ${JSON.stringify((node.libp2p as any).components?.addressManager?.getListenAddrs?.() || [])}`);
-
-          await new Promise<void>((resolve) => {
-            const timeout = setTimeout(() => {
-              info(`Relay reservation timeout after 10s.`);
-              info(`Final multiaddrs: ${node.getMultiaddrs().join(', ')}`);
-              info(`Connected peers: ${node.libp2p.getPeers().map(p => p.toString()).join(', ')}`);
-              resolve();
-            }, 10000);
-
-            // Listen for relay:reservation event (fires when reservation succeeds)
-            const onReservation = (evt: any) => {
-              info(`Relay reservation successful! Details: ${JSON.stringify(evt.detail)}`);
-              clearTimeout(timeout);
-              // Wait a bit for multiaddrs to update
-              setTimeout(() => {
-                info(`Relay addresses: ${node.getMultiaddrs().filter(a => a.includes('/p2p-circuit')).join(', ')}`);
-                resolve();
-              }, 500);
-            };
-
-            // Also listen for self:peer:update as fallback
-            const onPeerUpdate = () => {
-              if (hasRelayAddr()) {
-                info(`Relay address acquired via peer update`);
-                clearTimeout(timeout);
-                resolve();
-              }
-            };
-
-            node.libp2p.addEventListener('relay:reservation', onReservation, { once: true });
-            node.libp2p.addEventListener('self:peer:update', onPeerUpdate);
-
-            setTimeout(() => {
-              node.libp2p.removeEventListener('relay:reservation', onReservation);
-              node.libp2p.removeEventListener('self:peer:update', onPeerUpdate);
-            }, 10000);
-          });
-        } else {
-          info(`Relay address already present: ${node.getMultiaddrs().filter(a => a.includes('/p2p-circuit')).join(', ')}`);
-        }
-
-        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 => `${r}/p2p-circuit/p2p/${node.getPeerId()}`)
-          : [];
-        const allAddrs = [...directAddrs, ...relayAddrs, ...fallbackRelayAddrs];
-
-        const capabilities = [...(card.capabilities ?? [])];
-        if (options.relay) capabilities.push('relay');
-
-        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 connection alive by pinging bootstrap peers periodically
-        const pingInterval = setInterval(async () => {
-          for (const peer of node.libp2p.getPeers()) {
-            try {
-              await node.libp2p.services.ping.ping(peer);
-            } catch {
-              // ignore ping failures
-            }
-          }
-        }, 30000); // ping every 30s
-
-        // 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('@highway1/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...');
-          clearInterval(pingInterval);
-          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);
-      }
-    });
-}