@highway1/cli 0.1.43 → 0.1.45

package/package.json

@@ -1,20 +1,32 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.43",
-  "description": "CLI tool for decentralized AI agent network",
+  "version": "0.1.45",
+  "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {
+    "clawiverse": "./dist/index.js",
     "hw1": "./dist/index.js"
   },
-  "keywords": ["ai", "agent", "p2p", "cli"],
-  "license": "MIT",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
   "dependencies": {
-    "@highway1/core": "^0.1.43",
-    "commander": "^12.1.0",
+    "@highway1/core": "^0.1.45",
     "chalk": "^5.3.0",
-    "ora": "^8.1.0",
-    "inquirer": "^13.3.0",
     "cli-table3": "^0.6.5",
-    "conf": "^13.0.1"
+    "commander": "^12.1.0",
+    "conf": "^13.0.1",
+    "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"
   }
 }

package/src/commands/card.ts

@@ -0,0 +1,99 @@
+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/daemon.ts

@@ -0,0 +1,207 @@
+import { Command } from 'commander';
+import { ClawDaemon } from '../daemon/server.js';
+import { DaemonClient } from '../daemon/client.js';
+import { spawn } from 'child_process';
+import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'fs';
+import { success, error, info } from '../ui.js';
+
+const PID_FILE = '/tmp/clawiverse.pid';
+const SOCKET_PATH = '/tmp/clawiverse.sock';
+
+export function registerDaemonCommand(program: Command): void {
+  const daemonCommand = program
+    .command('daemon')
+    .description('Manage Clawiverse daemon for fast messaging');
+
+  daemonCommand
+    .command('start')
+    .description('Start daemon in background')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+        if (await client.isDaemonRunning()) {
+          success('Daemon already running');
+          const status = await client.send('status', {});
+          info(`Peer ID: ${status.peerId}`);
+          info(`DID: ${status.did}`);
+          return;
+        }
+
+        // Start daemon as detached background process
+        const child = spawn(process.execPath, [
+          process.argv[1],
+          'daemon',
+          'run'
+        ], {
+          detached: true,
+          stdio: 'ignore'
+        });
+
+        child.unref();
+        writeFileSync(PID_FILE, child.pid!.toString());
+
+        // Wait for daemon to be ready
+        for (let i = 0; i < 20; i++) {
+          await new Promise(resolve => setTimeout(resolve, 500));
+          if (await client.isDaemonRunning()) {
+            success('Daemon started');
+            const status = await client.send('status', {});
+            info(`Peer ID: ${status.peerId}`);
+            info(`DID: ${status.did}`);
+            info(`Socket: ${SOCKET_PATH}`);
+            return;
+          }
+        }
+
+        error('Failed to start daemon (timeout)');
+        process.exit(1);
+      } catch (err) {
+        error(`Failed to start daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('run')
+    .description('Run daemon in foreground (internal use)')
+    .action(async () => {
+      try {
+        const daemon = new ClawDaemon(SOCKET_PATH);
+        await daemon.start();
+
+        // Keep process alive
+        process.on('SIGINT', async () => {
+          console.log('\nShutting down...');
+          await daemon.shutdown();
+          process.exit(0);
+        });
+
+        process.on('SIGTERM', async () => {
+          await daemon.shutdown();
+          process.exit(0);
+        });
+      } catch (err) {
+        error(`Failed to run daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('stop')
+    .description('Stop daemon')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+
+        if (!(await client.isDaemonRunning())) {
+          info('Daemon not running');
+          return;
+        }
+
+        await client.send('shutdown', {});
+        success('Daemon stopped');
+
+        // Clean up PID file
+        try {
+          if (existsSync(PID_FILE)) {
+            unlinkSync(PID_FILE);
+          }
+        } catch {}
+
+        // Clean up socket file
+        try {
+          if (existsSync(SOCKET_PATH)) {
+            unlinkSync(SOCKET_PATH);
+          }
+        } catch {}
+      } catch (err) {
+        error(`Failed to stop daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('status')
+    .description('Check daemon status')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+
+        if (await client.isDaemonRunning()) {
+          const status = await client.send('status', {});
+          success('Daemon running');
+          console.log();
+          info(`Peer ID: ${status.peerId}`);
+          info(`DID: ${status.did}`);
+          info(`Socket: ${SOCKET_PATH}`);
+          info(`Bootstrap peers: ${status.bootstrapPeers.length}`);
+          console.log();
+          info('Multiaddrs:');
+          status.multiaddrs.forEach((addr: string) => {
+            console.log(`  ${addr}`);
+          });
+        } else {
+          info('Daemon not running');
+          console.log();
+          info('Start daemon with: clawiverse daemon start');
+        }
+      } catch (err) {
+        error(`Failed to check status: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('restart')
+    .description('Restart daemon')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+
+        // Stop if running
+        if (await client.isDaemonRunning()) {
+          info('Stopping daemon...');
+          await client.send('shutdown', {});
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        // Clean up files
+        try {
+          if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+          if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH);
+        } catch {}
+
+        // Start daemon
+        info('Starting daemon...');
+        const child = spawn(process.execPath, [
+          process.argv[1],
+          'daemon',
+          'run'
+        ], {
+          detached: true,
+          stdio: 'ignore'
+        });
+
+        child.unref();
+        writeFileSync(PID_FILE, child.pid!.toString());
+
+        // Wait for daemon to be ready
+        for (let i = 0; i < 20; i++) {
+          await new Promise(resolve => setTimeout(resolve, 500));
+          if (await client.isDaemonRunning()) {
+            success('Daemon restarted');
+            const status = await client.send('status', {});
+            info(`Peer ID: ${status.peerId}`);
+            info(`DID: ${status.did}`);
+            return;
+          }
+        }
+
+        error('Failed to restart daemon (timeout)');
+        process.exit(1);
+      } catch (err) {
+        error(`Failed to restart daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/discover.ts

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

@@ -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,54 @@
+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);
+      }
+    });
+}