@highway1/cli 0.1.49 → 0.1.52

package/src/daemon/server.ts

@@ -1,27 +1,65 @@
 import { createServer, Socket } from 'net';
 import type { Server } from 'net';
+import { homedir } from 'os';
+import { join } from 'path';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
   importKeyPair,
   createMessageRouter,
-  createDHTOperations,
   sign,
   verify,
   extractPublicKey,
   createEnvelope,
   signEnvelope,
-  type ClawiverseNode,
+  createTrustSystem,
+  MessageQueue,
+  DefenseMiddleware,
+  type RelayClient,
   type MessageRouter,
-  type DHTOperations,
+  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: 'send' | 'discover' | 'status' | 'shutdown';
+  command: DaemonCommand;
   params: any;
 }
 
@@ -33,18 +71,21 @@ interface DaemonResponse {
 }
 
 export class ClawDaemon {
-  private node: ClawiverseNode | null = null;
+  private relayClient: RelayClient | null = null;
+  private relayIndex: RelayIndexOperations | 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[];
+
+  // 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();
-    this.bootstrapPeers = getBootstrapPeers();
 
     if (!this.identity) {
       throw new Error('No identity found. Run "clawiverse init" first.');
@@ -55,24 +96,38 @@ export class ClawDaemon {
     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({
+      // 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,
-        bootstrapPeers: this.bootstrapPeers,
-        enableDHT: true,
-        reserveRelaySlot: this.bootstrapPeers.length > 0,
+        card: signedCard,
       });
 
-      await this.node.start();
-      logger.info('Node started', { peerId: this.node.getPeerId() });
+      await this.relayClient.start();
+      logger.info('Relay client started', { relays: this.relayClient.getConnectedRelays() });
 
-      // Initialize DHT and router
-      this.dht = createDHTOperations(this.node.libp2p);
+      this.relayIndex = createRelayIndexOperations(this.relayClient);
 
       const verifyFn = async (signature: Uint8Array, data: Uint8Array): Promise<boolean> => {
         try {
@@ -85,16 +140,39 @@ export class ClawDaemon {
         }
       };
 
-      this.router = createMessageRouter(
-        this.node.libp2p,
-        verifyFn,
-        this.dht,
-        this.bootstrapPeers
-      );
-
+      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);
@@ -105,7 +183,7 @@ export class ClawDaemon {
 
       console.log(`✓ Clawiverse daemon started`);
       console.log(`  Socket: ${this.socketPath}`);
-      console.log(`  Peer ID: ${this.node.getPeerId()}`);
+      console.log(`  Relays: ${this.relayClient.getConnectedRelays().join(', ')}`);
       console.log(`  DID: ${this.identity.did}`);
     } catch (error) {
       logger.error('Failed to start daemon', error);
@@ -113,21 +191,63 @@ export class ClawDaemon {
     }
   }
 
+  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) => {
-      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');
+      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
+        }
       }
     });
 
@@ -139,19 +259,27 @@ export class ClawDaemon {
   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 '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' };
       }
@@ -162,13 +290,12 @@ export class ClawDaemon {
   }
 
   private async handleSend(req: DaemonRequest): Promise<DaemonResponse> {
-    const { to, protocol, payload, type, peer } = req.params;
+    const { to, protocol, payload, type } = 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,
@@ -186,65 +313,141 @@ export class ClawDaemon {
       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[parts.length - 1],
-          multiaddrs: [peer],
-        };
-      }
+    if (this.queue) {
+      await this.queue.enqueueOutbound(signedEnvelope);
     }
 
-    // Send message
-    const response = await this.router.sendMessage(signedEnvelope, peerHint);
+    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,
-      },
+      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,
-    };
+    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.node) {
-      return { id: req.id, success: false, error: 'Node not initialized' };
-    }
-
+    if (!this.relayClient) return { id: req.id, success: false, error: 'Relay client not initialized' };
     return {
       id: req.id,
       success: true,
       data: {
         running: true,
-        peerId: this.node.getPeerId(),
+        connectedRelays: this.relayClient.getConnectedRelays(),
+        peerCount: this.relayClient.getPeerCount(),
         did: this.identity.did,
-        multiaddrs: this.node.getMultiaddrs(),
-        bootstrapPeers: this.bootstrapPeers,
       },
     };
   }
 
+  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');
 
@@ -253,9 +456,19 @@ export class ClawDaemon {
       this.router = null;
     }
 
-    if (this.node) {
-      await this.node.stop();
-      this.node = 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) {

package/src/index.ts

@@ -24,6 +24,11 @@ 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');
@@ -42,10 +47,15 @@ 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/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Clawiverse Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.