@highway1/cli 0.1.43 → 0.1.45

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

package/src/commands/trust.ts

@@ -0,0 +1,215 @@
+/**
+ * Trust Command - Manage trust scores and endorsements
+ */
+
+import { Command } from 'commander';
+import { getConfig, getIdentity } from '../config.js';
+import { createLogger, createTrustSystem } from '@highway1/core';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const logger = createLogger('cli:trust');
+
+export function createTrustCommand(): Command {
+  const trust = new Command('trust')
+    .description('Manage trust scores and endorsements');
+
+  // Show trust score
+  trust
+    .command('show')
+    .description('Show trust score for an agent')
+    .argument('<did>', 'Agent DID')
+    .action(async (did: string) => {
+      try {
+        const dataDir = join(homedir(), '.clawiverse');
+        const trustSystem = createTrustSystem({
+          dbPath: `${dataDir}/trust`,
+          getPublicKey: async () => new Uint8Array(), // Placeholder
+        });
+
+        await trustSystem.start();
+
+        const score = await trustSystem.getTrustScore(did);
+        const endorsements = await trustSystem.getEndorsements(did);
+
+        console.log('\n📊 Trust Score for', did);
+        console.log('─'.repeat(60));
+        console.log(`Interaction Score:  ${(score.interactionScore * 100).toFixed(1)}%`);
+        console.log(`Endorsements:       ${score.endorsements}`);
+        console.log(`Completion Rate:    ${(score.completionRate * 100).toFixed(1)}%`);
+        console.log(`Response Time:      ${score.responseTime.toFixed(0)}ms`);
+        console.log(`Uptime:            ${(score.uptime * 100).toFixed(1)}%`);
+        console.log(`Last Updated:       ${new Date(score.lastUpdated).toLocaleString()}`);
+
+        if (endorsements.length > 0) {
+          console.log('\n✨ Endorsements:');
+          for (const e of endorsements) {
+            console.log(`  • From: ${e.from}`);
+            console.log(`    Score: ${(e.score * 100).toFixed(0)}%`);
+            console.log(`    Reason: ${e.reason}`);
+            console.log(`    Date: ${new Date(e.timestamp).toLocaleDateString()}`);
+          }
+        }
+
+        await trustSystem.stop();
+      } catch (error) {
+        logger.error('Failed to show trust score', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Endorse an agent
+  trust
+    .command('endorse')
+    .description('Endorse an agent')
+    .argument('<did>', 'Agent DID to endorse')
+    .option('-s, --score <score>', 'Endorsement score (0-1)', '0.8')
+    .option('-r, --reason <reason>', 'Reason for endorsement', 'Good collaboration')
+    .action(async (did: string, options: { score: string; reason: string }) => {
+      try {
+        const dataDir = join(homedir(), '.clawiverse');
+        const trustSystem = createTrustSystem({
+          dbPath: `${dataDir}/trust`,
+          getPublicKey: async () => new Uint8Array(), // Placeholder
+        });
+
+        await trustSystem.start();
+
+        const score = parseFloat(options.score);
+        if (isNaN(score) || score < 0 || score > 1) {
+          throw new Error('Score must be between 0 and 1');
+        }
+
+        // Load identity for signing
+        const identity = getIdentity();
+        if (!identity) {
+          throw new Error('No identity found. Run "hw1 init" first.');
+        }
+
+        const { importKeyPair } = await import('@highway1/core');
+        const keyPair = importKeyPair({
+          publicKey: identity.publicKey,
+          privateKey: identity.privateKey,
+        });
+
+        const endorsement = await trustSystem.endorse(
+          identity.did,
+          did,
+          score,
+          options.reason,
+          keyPair.sign
+        );
+
+        console.log('\n✅ Endorsement created');
+        console.log(`From: ${endorsement.from}`);
+        console.log(`To: ${endorsement.to}`);
+        console.log(`Score: ${(endorsement.score * 100).toFixed(0)}%`);
+        console.log(`Reason: ${endorsement.reason}`);
+
+        await trustSystem.stop();
+      } catch (error) {
+        logger.error('Failed to endorse agent', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Show interaction history
+  trust
+    .command('history')
+    .description('Show interaction history with an agent')
+    .argument('<did>', 'Agent DID')
+    .option('-l, --limit <limit>', 'Number of interactions to show', '10')
+    .action(async (did: string, options: { limit: string }) => {
+      try {
+        const dataDir = join(homedir(), '.clawiverse');
+        const trustSystem = createTrustSystem({
+          dbPath: `${dataDir}/trust`,
+          getPublicKey: async () => new Uint8Array(), // Placeholder
+        });
+
+        await trustSystem.start();
+
+        const limit = parseInt(options.limit, 10);
+        const history = await trustSystem.getHistory(did, limit);
+
+        console.log(`\n📜 Interaction History with ${did}`);
+        console.log('─'.repeat(60));
+
+        if (history.length === 0) {
+          console.log('No interactions recorded');
+        } else {
+          for (const interaction of history) {
+            const status = interaction.success ? '✅' : '❌';
+            console.log(`${status} ${interaction.type} - ${new Date(interaction.timestamp).toLocaleString()}`);
+            console.log(`   Response time: ${interaction.responseTime}ms`);
+            if (interaction.rating) {
+              console.log(`   Rating: ${'⭐'.repeat(interaction.rating)}`);
+            }
+            if (interaction.feedback) {
+              console.log(`   Feedback: ${interaction.feedback}`);
+            }
+          }
+        }
+
+        await trustSystem.stop();
+      } catch (error) {
+        logger.error('Failed to show history', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Show trust statistics
+  trust
+    .command('stats')
+    .description('Show local trust statistics')
+    .action(async () => {
+      try {
+        const dataDir = join(homedir(), '.clawiverse');
+        const trustSystem = createTrustSystem({
+          dbPath: `${dataDir}/trust`,
+          getPublicKey: async () => new Uint8Array(), // Placeholder
+        });
+
+        await trustSystem.start();
+
+        // Get all agents from interaction history
+        const { InteractionHistory } = await import('@highway1/core');
+        const history = new InteractionHistory(`${dataDir}/trust/interactions`);
+        await history.open();
+
+        const agents = await history.getAllAgents();
+
+        console.log('\n📊 Trust Statistics');
+        console.log('─'.repeat(60));
+        console.log(`Total agents tracked: ${agents.length}`);
+
+        if (agents.length > 0) {
+          console.log('\nTop agents by trust score:');
+          const scores = await Promise.all(
+            agents.map(async (did) => ({
+              did,
+              score: await trustSystem.getTrustScore(did),
+            }))
+          );
+
+          scores.sort((a, b) => b.score.interactionScore - a.score.interactionScore);
+
+          for (const { did, score } of scores.slice(0, 5)) {
+            console.log(`  ${(score.interactionScore * 100).toFixed(0)}% - ${did}`);
+          }
+        }
+
+        await history.close();
+        await trustSystem.stop();
+      } catch (error) {
+        logger.error('Failed to show stats', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  return trust;
+}

package/src/config.ts

@@ -0,0 +1,74 @@
+import Conf from 'conf';
+import { homedir } from 'os';
+import { join } from 'path';
+
+export interface ClawiverseConfig {
+  identity?: {
+    did: string;
+    publicKey: string;
+    privateKey: string;
+  };
+  network?: {
+    bootstrapPeers: string[];
+    listenAddresses: string[];
+  };
+  agentCard?: {
+    name: string;
+    description: string;
+    capabilities: string[];
+  };
+}
+
+const CLAWIVERSE_HOME = process.env.CLAWIVERSE_HOME || join(homedir(), '.clawiverse');
+
+const config = new Conf<ClawiverseConfig>({
+  projectName: 'clawiverse',
+  cwd: CLAWIVERSE_HOME,
+});
+
+export function getConfig(): ClawiverseConfig {
+  return config.store;
+}
+
+export function setConfig(key: string, value: unknown): void {
+  config.set(key, value);
+}
+
+export function getConfigValue<T>(key: string): T | undefined {
+  return config.get(key) as T | undefined;
+}
+
+export function hasIdentity(): boolean {
+  return config.has('identity');
+}
+
+export function getIdentity() {
+  return config.get('identity');
+}
+
+export function setIdentity(identity: ClawiverseConfig['identity']): void {
+  config.set('identity', identity);
+}
+
+export function getAgentCard() {
+  return config.get('agentCard');
+}
+
+export function setAgentCard(card: ClawiverseConfig['agentCard']): void {
+  config.set('agentCard', card);
+}
+
+// Default public bootstrap nodes (update after deployment)
+const DEFAULT_BOOTSTRAP_PEERS: string[] = [
+  '/dns4/hw1.woowot.com/tcp/4001/p2p/12D3KooWH9R8d4bhzpfyWi3aY5wLBsmLp1LU8ZGk9V7rK17sfzaW',
+];
+
+export function getBootstrapPeers(): string[] {
+  const userPeers = config.get('network.bootstrapPeers') as string[] | undefined;
+  if (userPeers && userPeers.length > 0) return userPeers;
+  return DEFAULT_BOOTSTRAP_PEERS;
+}
+
+export function setBootstrapPeers(peers: string[]): void {
+  config.set('network.bootstrapPeers', peers);
+}

package/src/daemon/client.ts

@@ -0,0 +1,68 @@
+import { connect, Socket } from 'net';
+import { createLogger } from '@highway1/core';
+
+const logger = createLogger('daemon-client');
+
+export class DaemonClient {
+  private socketPath: string;
+
+  constructor(socketPath: string = '/tmp/clawiverse.sock') {
+    this.socketPath = socketPath;
+  }
+
+  async send(command: string, params: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const socket = connect(this.socketPath);
+      const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+      let responseReceived = false;
+
+      socket.on('connect', () => {
+        const request = { id: requestId, command, params };
+        logger.debug('Sending request', { command, id: requestId });
+        socket.write(JSON.stringify(request));
+      });
+
+      socket.on('data', (data) => {
+        try {
+          const response = JSON.parse(data.toString());
+          responseReceived = true;
+          socket.end();
+
+          logger.debug('Received response', { success: response.success, id: response.id });
+
+          if (response.success) {
+            resolve(response.data);
+          } else {
+            reject(new Error(response.error));
+          }
+        } catch (error) {
+          reject(new Error(`Failed to parse response: ${(error as Error).message}`));
+        }
+      });
+
+      socket.on('error', (err) => {
+        if (!responseReceived) {
+          logger.debug('Socket error', { error: err.message });
+          reject(err);
+        }
+      });
+
+      socket.setTimeout(30000, () => {
+        if (!responseReceived) {
+          socket.destroy();
+          reject(new Error('Request timeout'));
+        }
+      });
+    });
+  }
+
+  async isDaemonRunning(): Promise<boolean> {
+    try {
+      await this.send('status', {});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/src/daemon/server.ts

@@ -0,0 +1,267 @@
+import { createServer, Socket } from 'net';
+import type { Server } from 'net';
+import {
+  createNode,
+  importKeyPair,
+  createMessageRouter,
+  createDHTOperations,
+  sign,
+  verify,
+  extractPublicKey,
+  createEnvelope,
+  signEnvelope,
+  type ClawiverseNode,
+  type MessageRouter,
+  type DHTOperations,
+} from '@highway1/core';
+import { createLogger } from '@highway1/core';
+import { getIdentity, getBootstrapPeers } from '../config.js';
+
+const logger = createLogger('daemon');
+
+interface DaemonRequest {
+  id: string;
+  command: 'send' | 'discover' | 'status' | 'shutdown';
+  params: any;
+}
+
+interface DaemonResponse {
+  id: string;
+  success: boolean;
+  data?: any;
+  error?: string;
+}
+
+export class ClawDaemon {
+  private node: ClawiverseNode | 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[];
+
+  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.');
+    }
+  }
+
+  async start(): Promise<void> {
+    try {
+      logger.info('Starting Clawiverse daemon', { socketPath: this.socketPath });
+
+      // Initialize node once (eliminates 4s overhead per command)
+      const keyPair = importKeyPair({
+        publicKey: this.identity.publicKey,
+        privateKey: this.identity.privateKey,
+      });
+
+      this.node = await createNode({
+        keyPair,
+        bootstrapPeers: this.bootstrapPeers,
+        enableDHT: true,
+      });
+
+      await this.node.start();
+      logger.info('Node started', { peerId: this.node.getPeerId() });
+
+      // Initialize DHT and router
+      this.dht = createDHTOperations(this.node.libp2p);
+
+      const verifyFn = async (signature: Uint8Array, data: Uint8Array): Promise<boolean> => {
+        try {
+          const decoded = JSON.parse(new TextDecoder().decode(data)) as { from?: string };
+          if (!decoded.from || typeof decoded.from !== 'string') return false;
+          const senderPublicKey = extractPublicKey(decoded.from);
+          return verify(signature, data, senderPublicKey);
+        } catch {
+          return false;
+        }
+      };
+
+      this.router = createMessageRouter(
+        this.node.libp2p,
+        verifyFn,
+        this.dht,
+        this.bootstrapPeers
+      );
+
+      await this.router.start();
+      logger.info('Router started');
+
+      // Create IPC server
+      this.server = createServer((socket) => {
+        this.handleConnection(socket);
+      });
+
+      this.server.listen(this.socketPath);
+      logger.info('Daemon listening', { socketPath: this.socketPath });
+
+      console.log(`✓ Clawiverse daemon started`);
+      console.log(`  Socket: ${this.socketPath}`);
+      console.log(`  Peer ID: ${this.node.getPeerId()}`);
+      console.log(`  DID: ${this.identity.did}`);
+    } catch (error) {
+      logger.error('Failed to start daemon', error);
+      throw error;
+    }
+  }
+
+  private handleConnection(socket: Socket): void {
+    socket.on('data', async (data) => {
+      try {
+        const request: DaemonRequest = JSON.parse(data.toString());
+        logger.debug('Received request', { command: request.command, id: request.id });
+
+        const response = await this.handleRequest(request);
+        socket.write(JSON.stringify(response) + '\n');
+      } catch (error) {
+        const errorResponse: DaemonResponse = {
+          id: 'unknown',
+          success: false,
+          error: (error as Error).message,
+        };
+        socket.write(JSON.stringify(errorResponse) + '\n');
+      }
+    });
+
+    socket.on('error', (error) => {
+      logger.warn('Socket error', { error: error.message });
+    });
+  }
+
+  private async handleRequest(req: DaemonRequest): Promise<DaemonResponse> {
+    try {
+      switch (req.command) {
+        case 'send':
+          return await this.handleSend(req);
+
+        case 'discover':
+          return await this.handleDiscover(req);
+
+        case 'status':
+          return this.handleStatus(req);
+
+        case 'shutdown':
+          await this.shutdown();
+          return { id: req.id, success: true };
+
+        default:
+          return { id: req.id, success: false, error: 'Unknown command' };
+      }
+    } catch (error) {
+      logger.error('Request handler error', { command: req.command, error });
+      return { id: req.id, success: false, error: (error as Error).message };
+    }
+  }
+
+  private async handleSend(req: DaemonRequest): Promise<DaemonResponse> {
+    const { to, protocol, payload, type, peer } = req.params;
+
+    if (!this.router) {
+      return { id: req.id, success: false, error: 'Router not initialized' };
+    }
+
+    // Create and sign envelope
+    const envelope = createEnvelope(
+      this.identity.did,
+      to,
+      type || 'request',
+      protocol,
+      payload
+    );
+
+    const keyPair = importKeyPair({
+      publicKey: this.identity.publicKey,
+      privateKey: this.identity.privateKey,
+    });
+
+    const signedEnvelope = await signEnvelope(envelope, (data) =>
+      sign(data, keyPair.privateKey)
+    );
+
+    // Build peer hint if provided
+    let peerHint = undefined;
+    if (peer) {
+      const parts = peer.split('/p2p/');
+      if (parts.length === 2) {
+        peerHint = {
+          peerId: parts[1],
+          multiaddrs: [peer],
+        };
+      }
+    }
+
+    // Send message
+    const response = await this.router.sendMessage(signedEnvelope, peerHint);
+
+    return {
+      id: req.id,
+      success: true,
+      data: {
+        id: signedEnvelope.id,
+        response: response || null,
+      },
+    };
+  }
+
+  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);
+
+    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' };
+    }
+
+    return {
+      id: req.id,
+      success: true,
+      data: {
+        running: true,
+        peerId: this.node.getPeerId(),
+        did: this.identity.did,
+        multiaddrs: this.node.getMultiaddrs(),
+        bootstrapPeers: this.bootstrapPeers,
+      },
+    };
+  }
+
+  async shutdown(): Promise<void> {
+    logger.info('Shutting down daemon');
+
+    if (this.router) {
+      await this.router.stop();
+      this.router = null;
+    }
+
+    if (this.node) {
+      await this.node.stop();
+      this.node = null;
+    }
+
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+
+    logger.info('Daemon stopped');
+  }
+}