@highway1/cli 0.1.44 → 0.1.45

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

package/src/index.ts

@@ -23,6 +23,7 @@ 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';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -44,6 +45,7 @@ registerSendCommand(program);
 registerStatusCommand(program);
 registerIdentityCommand(program);
 registerCardCommand(program);
+registerDaemonCommand(program);
 program.addCommand(createTrustCommand());
 
 program.parse();