@highway1/cli 0.1.49 → 0.1.50

package/src/daemon/server.ts

@@ -1,5 +1,7 @@
 import { createServer, Socket } from 'net';
 import type { Server } from 'net';
+import { homedir } from 'os';
+import { join } from 'path';
 import {
   createNode,
   importKeyPair,
@@ -10,18 +12,43 @@ import {
   extractPublicKey,
   createEnvelope,
   signEnvelope,
+  createTrustSystem,
+  MessageQueue,
+  DefenseMiddleware,
   type ClawiverseNode,
   type MessageRouter,
   type DHTOperations,
+  type TrustSystem,
+  type MessageEnvelope,
 } from '@highway1/core';
 import { createLogger } from '@highway1/core';
 import { getIdentity, getBootstrapPeers } from '../config.js';
 
 const logger = createLogger('daemon');
 
+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;
 }
 
@@ -41,6 +68,11 @@ export class ClawDaemon {
   private identity: any;
   private bootstrapPeers: string[];
 
+  // New: 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();
@@ -55,7 +87,6 @@ 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,
@@ -71,7 +102,6 @@ export class ClawDaemon {
       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> => {
@@ -95,6 +125,35 @@ export class ClawDaemon {
       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, // Accept all by default
+      });
+      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);
@@ -113,21 +172,68 @@ export class ClawDaemon {
     }
   }
 
+  private async handleIncomingMessage(envelope: MessageEnvelope): Promise<MessageEnvelope | void> {
+    if (!this.defense || !this.queue || !this.trustSystem) return;
+
+    // Run defense checks
+    const result = await this.defense.checkMessage(envelope);
+    if (!result.allowed) {
+      logger.warn('Message rejected by defense', { id: envelope.id, reason: result.reason });
+      return;
+    }
+
+    // Persist to inbox
+    await this.queue.enqueueInbound(envelope, result.trustScore);
+
+    // Record interaction for trust scoring
+    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();
+      // Handle newline-delimited JSON
+      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');
+        }
+      }
+
+      // Also handle single-message (no newline) for backward compat
+      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 +245,30 @@ 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 };
 
+        // Queue commands
+        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);
+
+        // Defense commands
+        case 'block':      return await this.handleBlock(req);
+        case 'unblock':    return await this.handleUnblock(req);
+        case 'allowlist':  return await this.handleAllowlist(req);
+
+        // Stats
+        case 'queue_stats': return await this.handleQueueStats(req);
+
         default:
           return { id: req.id, success: false, error: 'Unknown command' };
       }
@@ -168,7 +285,6 @@ export class ClawDaemon {
       return { id: req.id, success: false, error: 'Router not initialized' };
     }
 
-    // Create and sign envelope
     const envelope = createEnvelope(
       this.identity.did,
       to,
@@ -186,52 +302,41 @@ export class ClawDaemon {
       sign(data, keyPair.privateKey)
     );
 
-    // Build peer hint if provided
+    // Track outbound in queue
+    if (this.queue) {
+      await this.queue.enqueueOutbound(signedEnvelope);
+    }
+
     let peerHint = undefined;
     if (peer) {
       const parts = peer.split('/p2p/');
       if (parts.length >= 2) {
-        peerHint = {
-          peerId: parts[parts.length - 1],
-          multiaddrs: [peer],
-        };
+        peerHint = { peerId: parts[parts.length - 1], multiaddrs: [peer] };
       }
     }
 
-    // Send message
     const response = await this.router.sendMessage(signedEnvelope, peerHint);
 
+    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' };
-    }
-
+    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,
-    };
+    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.node) return { id: req.id, success: false, error: 'Node not initialized' };
     return {
       id: req.id,
       success: true,
@@ -245,6 +350,104 @@ export class ClawDaemon {
     };
   }
 
+  /** Legacy messages command — delegates to inbox for backward compat */
+  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,6 +456,16 @@ export class ClawDaemon {
       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.node) {
       await this.node.stop();
       this.node = null;

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.