@highway1/cli 0.1.52 → 0.1.54

package/src/daemon/server.ts

@@ -1,481 +0,0 @@
-import { createServer, Socket } from 'net';
-import type { Server } from 'net';
-import { homedir } from 'os';
-import { join } from 'path';
-import {
-  createRelayClient,
-  createRelayIndexOperations,
-  importKeyPair,
-  createMessageRouter,
-  sign,
-  verify,
-  extractPublicKey,
-  createEnvelope,
-  signEnvelope,
-  createTrustSystem,
-  MessageQueue,
-  DefenseMiddleware,
-  type RelayClient,
-  type MessageRouter,
-  type RelayIndexOperations,
-  type TrustSystem,
-  type MessageEnvelope,
-} from '@highway1/core';
-import { createLogger } from '@highway1/core';
-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'
-  | 'status'
-  | 'messages'
-  | 'shutdown'
-  // Queue commands
-  | 'inbox'
-  | 'get_message'
-  | 'mark_read'
-  | 'delete_message'
-  | 'outbox'
-  | 'retry_message'
-  // Defense commands
-  | 'block'
-  | 'unblock'
-  | 'allowlist'
-  // Stats
-  | 'queue_stats';
-
-interface DaemonRequest {
-  id: string;
-  command: DaemonCommand;
-  params: any;
-}
-
-interface DaemonResponse {
-  id: string;
-  success: boolean;
-  data?: any;
-  error?: string;
-}
-
-export class ClawDaemon {
-  private relayClient: RelayClient | null = null;
-  private relayIndex: RelayIndexOperations | null = null;
-  private router: MessageRouter | null = null;
-  private server: Server | null = null;
-  private socketPath: string;
-  private identity: any;
-
-  // Persistent queue + defense
-  private queue: MessageQueue | null = null;
-  private defense: DefenseMiddleware | null = null;
-  private trustSystem: TrustSystem | null = null;
-
-  constructor(socketPath: string = '/tmp/clawiverse.sock') {
-    this.socketPath = socketPath;
-    this.identity = getIdentity();
-
-    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 });
-
-      const keyPair = importKeyPair({
-        publicKey: this.identity.publicKey,
-        privateKey: this.identity.privateKey,
-      });
-
-      // 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,
-        card: signedCard,
-      });
-
-      await this.relayClient.start();
-      logger.info('Relay client started', { relays: this.relayClient.getConnectedRelays() });
-
-      this.relayIndex = createRelayIndexOperations(this.relayClient);
-
-      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.relayClient, verifyFn);
-      await this.router.start();
-      logger.info('Router started');
-
-      // Initialize trust system
-      const dataDir = join(homedir(), '.clawiverse');
-      this.trustSystem = createTrustSystem({
-        dbPath: join(dataDir, 'trust'),
-        getPublicKey: async (did: string) => extractPublicKey(did),
-      });
-      await this.trustSystem.start();
-      logger.info('Trust system started');
-
-      // Initialize message queue (LevelDB persistence per CVP-0010 §2.3)
-      this.queue = new MessageQueue({
-        dbPath: join(dataDir, 'inbox'),
-      });
-      await this.queue.start();
-      logger.info('Message queue started');
-
-      // Initialize defense middleware
-      this.defense = new DefenseMiddleware({
-        trustSystem: this.trustSystem,
-        storage: this.queue.store,
-        minTrustScore: 0,
-      });
-      logger.info('Defense middleware initialized');
-
-      // Register catch-all handler: defense check + queue persistence
-      this.router.registerCatchAllHandler(async (envelope) => {
-        return await this.handleIncomingMessage(envelope);
-      });
-
-      // 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(`  Relays: ${this.relayClient.getConnectedRelays().join(', ')}`);
-      console.log(`  DID: ${this.identity.did}`);
-    } catch (error) {
-      logger.error('Failed to start daemon', error);
-      throw error;
-    }
-  }
-
-  private async handleIncomingMessage(envelope: MessageEnvelope): Promise<MessageEnvelope | void> {
-    if (!this.defense || !this.queue || !this.trustSystem) return;
-
-    const result = await this.defense.checkMessage(envelope);
-    if (!result.allowed) {
-      logger.warn('Message rejected by defense', { id: envelope.id, reason: result.reason });
-      return;
-    }
-
-    await this.queue.enqueueInbound(envelope, result.trustScore);
-
-    await this.trustSystem.recordInteraction({
-      agentDid: envelope.from,
-      timestamp: Date.now(),
-      type: 'message',
-      success: true,
-      responseTime: 0,
-    });
-
-    logger.info('Message queued', { id: envelope.id, from: envelope.from });
-  }
-
-  private handleConnection(socket: Socket): void {
-    let buffer = '';
-
-    socket.on('data', async (data) => {
-      buffer += data.toString();
-      const lines = buffer.split('\n');
-      buffer = lines.pop() ?? '';
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const request: DaemonRequest = JSON.parse(line);
-          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');
-        }
-      }
-
-      if (buffer.trim()) {
-        try {
-          const request: DaemonRequest = JSON.parse(buffer);
-          buffer = '';
-          logger.debug('Received request', { command: request.command, id: request.id });
-          const response = await this.handleRequest(request);
-          socket.write(JSON.stringify(response) + '\n');
-        } catch {
-          // Not complete JSON yet, keep buffering
-        }
-      }
-    });
-
-    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 'messages':   return await this.handleMessages(req);
-        case 'shutdown':
-          await this.shutdown();
-          return { id: req.id, success: true };
-
-        case 'inbox':        return await this.handleInbox(req);
-        case 'get_message':  return await this.handleGetMessage(req);
-        case 'mark_read':    return await this.handleMarkRead(req);
-        case 'delete_message': return await this.handleDeleteMessage(req);
-        case 'outbox':       return await this.handleOutbox(req);
-        case 'retry_message': return await this.handleRetryMessage(req);
-
-        case 'block':      return await this.handleBlock(req);
-        case 'unblock':    return await this.handleUnblock(req);
-        case 'allowlist':  return await this.handleAllowlist(req);
-
-        case 'queue_stats': return await this.handleQueueStats(req);
-
-        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 } = req.params;
-
-    if (!this.router) {
-      return { id: req.id, success: false, error: 'Router not initialized' };
-    }
-
-    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)
-    );
-
-    if (this.queue) {
-      await this.queue.enqueueOutbound(signedEnvelope);
-    }
-
-    const response = await this.router.sendMessage(signedEnvelope);
-
-    if (this.queue) {
-      await this.queue.markOutboundDelivered(signedEnvelope.id);
-    }
-
-    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.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.relayClient) return { id: req.id, success: false, error: 'Relay client not initialized' };
-    return {
-      id: req.id,
-      success: true,
-      data: {
-        running: true,
-        connectedRelays: this.relayClient.getConnectedRelays(),
-        peerCount: this.relayClient.getPeerCount(),
-        did: this.identity.did,
-      },
-    };
-  }
-
-  private async handleMessages(req: DaemonRequest): Promise<DaemonResponse> {
-    const { limit = 10 } = req.params || {};
-    if (this.queue) {
-      const page = await this.queue.getInbox({}, { limit });
-      return {
-        id: req.id,
-        success: true,
-        data: {
-          messages: page.messages.map((m) => ({ ...m.envelope, receivedAt: m.receivedAt })),
-          total: page.total,
-        },
-      };
-    }
-    return { id: req.id, success: true, data: { messages: [], total: 0 } };
-  }
-
-  // ─── Queue Handlers ───────────────────────────────────────────────────────
-
-  private async handleInbox(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    const { filter, pagination } = req.params || {};
-    const page = await this.queue.getInbox(filter, pagination);
-    return { id: req.id, success: true, data: page };
-  }
-
-  private async handleGetMessage(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    const { id } = req.params;
-    const msg = await this.queue.getMessage(id);
-    if (!msg) return { id: req.id, success: false, error: 'Message not found' };
-    return { id: req.id, success: true, data: msg };
-  }
-
-  private async handleMarkRead(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    await this.queue.markAsRead(req.params.id);
-    return { id: req.id, success: true };
-  }
-
-  private async handleDeleteMessage(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    await this.queue.deleteMessage(req.params.id);
-    return { id: req.id, success: true };
-  }
-
-  private async handleOutbox(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    const page = await this.queue.getOutbox(req.params?.pagination);
-    return { id: req.id, success: true, data: page };
-  }
-
-  private async handleRetryMessage(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    await this.queue.retryMessage(req.params.id);
-    return { id: req.id, success: true };
-  }
-
-  // ─── Defense Handlers ─────────────────────────────────────────────────────
-
-  private async handleBlock(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.defense) return { id: req.id, success: false, error: 'Defense not initialized' };
-    const { did, reason = 'Blocked by user' } = req.params;
-    await this.defense.blockAgent(did, reason, this.identity.did);
-    return { id: req.id, success: true };
-  }
-
-  private async handleUnblock(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.defense) return { id: req.id, success: false, error: 'Defense not initialized' };
-    await this.defense.unblockAgent(req.params.did);
-    return { id: req.id, success: true };
-  }
-
-  private async handleAllowlist(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.defense || !this.queue) return { id: req.id, success: false, error: 'Defense not initialized' };
-    const { action, did, note } = req.params;
-    switch (action) {
-      case 'add':
-        await this.defense.allowAgent(did, note);
-        return { id: req.id, success: true };
-      case 'remove':
-        await this.defense.removeFromAllowlist(did);
-        return { id: req.id, success: true };
-      case 'list': {
-        const entries = await this.queue.store.listAllowed();
-        return { id: req.id, success: true, data: entries };
-      }
-      default:
-        return { id: req.id, success: false, error: `Unknown allowlist action: ${action}` };
-    }
-  }
-
-  private async handleQueueStats(req: DaemonRequest): Promise<DaemonResponse> {
-    if (!this.queue) return { id: req.id, success: false, error: 'Queue not initialized' };
-    const stats = await this.queue.getStats();
-    return { id: req.id, success: true, data: stats };
-  }
-
-  async shutdown(): Promise<void> {
-    logger.info('Shutting down daemon');
-
-    if (this.router) {
-      await this.router.stop();
-      this.router = null;
-    }
-
-    if (this.queue) {
-      await this.queue.stop();
-      this.queue = null;
-    }
-
-    if (this.trustSystem) {
-      await this.trustSystem.stop();
-      this.trustSystem = null;
-    }
-
-    if (this.relayClient) {
-      await this.relayClient.stop();
-      this.relayClient = null;
-    }
-
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-
-    logger.info('Daemon stopped');
-  }
-}

package/src/index.ts

@@ -1,61 +0,0 @@
-#!/usr/bin/env node
-
-// Polyfill for Node.js < v22.0.0
-if (!Promise.withResolvers) {
-  Promise.withResolvers = function <T>() {
-    let resolve: (value: T | PromiseLike<T>) => void;
-    let reject: (reason?: any) => void;
-    const promise = new Promise<T>((res, rej) => {
-      resolve = res;
-      reject = rej;
-    });
-    return { promise, resolve: resolve!, reject: reject! };
-  };
-}
-
-import { Command } from 'commander';
-import { createRequire } from 'module';
-import { registerInitCommand } from './commands/init.js';
-import { registerJoinCommand } from './commands/join.js';
-import { registerDiscoverCommand } from './commands/discover.js';
-import { registerSendCommand } from './commands/send.js';
-import { registerStatusCommand } from './commands/status.js';
-import { registerIdentityCommand } from './commands/identity.js';
-import { registerCardCommand } from './commands/card.js';
-import { createTrustCommand } from './commands/trust.js';
-import { registerDaemonCommand } from './commands/daemon.js';
-import { createInboxCommand } from './commands/inbox.js';
-import { registerStopCommand } from './commands/stop.js';
-import { registerAskCommand } from './commands/ask.js';
-import { registerServeCommand } from './commands/serve.js';
-import { registerPeersCommand } from './commands/peers.js';
-
-const require = createRequire(import.meta.url);
-const { version } = require('../package.json');
-
-const program = new Command();
-
-const binName = process.argv[1]?.includes('hw1') ? 'hw1' : 'clawiverse';
-
-program
-  .name(binName)
-  .description('CLI tool for decentralized AI agent communication')
-  .version(version);
-
-// Register commands
-registerInitCommand(program);
-registerJoinCommand(program);
-registerDiscoverCommand(program);
-registerSendCommand(program);
-registerAskCommand(program);
-registerServeCommand(program);
-registerPeersCommand(program);
-registerStatusCommand(program);
-registerIdentityCommand(program);
-registerCardCommand(program);
-registerDaemonCommand(program);
-registerStopCommand(program);
-program.addCommand(createTrustCommand());
-program.addCommand(createInboxCommand());
-
-program.parse();

package/src/ui.ts

@@ -1,38 +0,0 @@
-import chalk from 'chalk';
-import ora, { Ora } from 'ora';
-
-export function success(message: string): void {
-  console.log(chalk.green('✓'), message);
-}
-
-export function error(message: string): void {
-  console.log(chalk.red('✗'), message);
-}
-
-export function info(message: string): void {
-  console.log(chalk.blue('ℹ'), message);
-}
-
-export function warn(message: string): void {
-  console.log(chalk.yellow('⚠'), message);
-}
-
-export function spinner(text: string): Ora {
-  return ora(text).start();
-}
-
-export function printHeader(title: string): void {
-  console.log();
-  console.log(chalk.bold.cyan(title));
-  console.log(chalk.gray('─'.repeat(title.length)));
-  console.log();
-}
-
-export function printKeyValue(key: string, value: string): void {
-  console.log(chalk.gray(`${key}:`), chalk.white(value));
-}
-
-export function printSection(title: string): void {
-  console.log();
-  console.log(chalk.bold(title));
-}