@highway1/cli 0.1.44 → 0.1.46

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@highway1/core": "^0.1.44",
+    "@highway1/core": "workspace:*",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",

package/src/commands/daemon.ts

@@ -0,0 +1,207 @@
+import { Command } from 'commander';
+import { ClawDaemon } from '../daemon/server.js';
+import { DaemonClient } from '../daemon/client.js';
+import { spawn } from 'child_process';
+import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'fs';
+import { success, error, info } from '../ui.js';
+
+const PID_FILE = '/tmp/clawiverse.pid';
+const SOCKET_PATH = '/tmp/clawiverse.sock';
+
+export function registerDaemonCommand(program: Command): void {
+  const daemonCommand = program
+    .command('daemon')
+    .description('Manage Clawiverse daemon for fast messaging');
+
+  daemonCommand
+    .command('start')
+    .description('Start daemon in background')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+        if (await client.isDaemonRunning()) {
+          success('Daemon already running');
+          const status = await client.send('status', {});
+          info(`Peer ID: ${status.peerId}`);
+          info(`DID: ${status.did}`);
+          return;
+        }
+
+        // Start daemon as detached background process
+        const child = spawn(process.execPath, [
+          process.argv[1],
+          'daemon',
+          'run'
+        ], {
+          detached: true,
+          stdio: 'ignore'
+        });
+
+        child.unref();
+        writeFileSync(PID_FILE, child.pid!.toString());
+
+        // Wait for daemon to be ready
+        for (let i = 0; i < 20; i++) {
+          await new Promise(resolve => setTimeout(resolve, 500));
+          if (await client.isDaemonRunning()) {
+            success('Daemon started');
+            const status = await client.send('status', {});
+            info(`Peer ID: ${status.peerId}`);
+            info(`DID: ${status.did}`);
+            info(`Socket: ${SOCKET_PATH}`);
+            return;
+          }
+        }
+
+        error('Failed to start daemon (timeout)');
+        process.exit(1);
+      } catch (err) {
+        error(`Failed to start daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('run')
+    .description('Run daemon in foreground (internal use)')
+    .action(async () => {
+      try {
+        const daemon = new ClawDaemon(SOCKET_PATH);
+        await daemon.start();
+
+        // Keep process alive
+        process.on('SIGINT', async () => {
+          console.log('\nShutting down...');
+          await daemon.shutdown();
+          process.exit(0);
+        });
+
+        process.on('SIGTERM', async () => {
+          await daemon.shutdown();
+          process.exit(0);
+        });
+      } catch (err) {
+        error(`Failed to run daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('stop')
+    .description('Stop daemon')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+
+        if (!(await client.isDaemonRunning())) {
+          info('Daemon not running');
+          return;
+        }
+
+        await client.send('shutdown', {});
+        success('Daemon stopped');
+
+        // Clean up PID file
+        try {
+          if (existsSync(PID_FILE)) {
+            unlinkSync(PID_FILE);
+          }
+        } catch {}
+
+        // Clean up socket file
+        try {
+          if (existsSync(SOCKET_PATH)) {
+            unlinkSync(SOCKET_PATH);
+          }
+        } catch {}
+      } catch (err) {
+        error(`Failed to stop daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('status')
+    .description('Check daemon status')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+
+        if (await client.isDaemonRunning()) {
+          const status = await client.send('status', {});
+          success('Daemon running');
+          console.log();
+          info(`Peer ID: ${status.peerId}`);
+          info(`DID: ${status.did}`);
+          info(`Socket: ${SOCKET_PATH}`);
+          info(`Bootstrap peers: ${status.bootstrapPeers.length}`);
+          console.log();
+          info('Multiaddrs:');
+          status.multiaddrs.forEach((addr: string) => {
+            console.log(`  ${addr}`);
+          });
+        } else {
+          info('Daemon not running');
+          console.log();
+          info('Start daemon with: clawiverse daemon start');
+        }
+      } catch (err) {
+        error(`Failed to check status: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  daemonCommand
+    .command('restart')
+    .description('Restart daemon')
+    .action(async () => {
+      try {
+        const client = new DaemonClient(SOCKET_PATH);
+
+        // Stop if running
+        if (await client.isDaemonRunning()) {
+          info('Stopping daemon...');
+          await client.send('shutdown', {});
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        // Clean up files
+        try {
+          if (existsSync(PID_FILE)) unlinkSync(PID_FILE);
+          if (existsSync(SOCKET_PATH)) unlinkSync(SOCKET_PATH);
+        } catch {}
+
+        // Start daemon
+        info('Starting daemon...');
+        const child = spawn(process.execPath, [
+          process.argv[1],
+          'daemon',
+          'run'
+        ], {
+          detached: true,
+          stdio: 'ignore'
+        });
+
+        child.unref();
+        writeFileSync(PID_FILE, child.pid!.toString());
+
+        // Wait for daemon to be ready
+        for (let i = 0; i < 20; i++) {
+          await new Promise(resolve => setTimeout(resolve, 500));
+          if (await client.isDaemonRunning()) {
+            success('Daemon restarted');
+            const status = await client.send('status', {});
+            info(`Peer ID: ${status.peerId}`);
+            info(`DID: ${status.did}`);
+            return;
+          }
+        }
+
+        error('Failed to restart daemon (timeout)');
+        process.exit(1);
+      } catch (err) {
+        error(`Failed to restart daemon: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/join.ts

@@ -12,6 +12,8 @@ import {
 } from '@highway1/core';
 import { getIdentity, getAgentCard, getBootstrapPeers } from '../config.js';
 import { success, error, spinner, printHeader, info } from '../ui.js';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
 
 export function registerJoinCommand(program: Command): void {
   program
@@ -19,6 +21,7 @@ export function registerJoinCommand(program: Command): void {
     .description('Join the Clawiverse network')
     .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
     .option('--relay', 'Run as a relay server and advertise relay capability')
+    .option('--save-dir <path>', 'Directory to save received file attachments', './downloads')
     .action(async (options) => {
       try {
         printHeader('Join Clawiverse Network');
@@ -280,6 +283,8 @@ export function registerJoinCommand(program: Command): void {
           dht
         );
 
+        const saveDir = resolve(options.saveDir ?? './downloads');
+
         // Generic message handler that accepts any protocol
         const messageHandler = async (envelope: any) => {
           const payload = envelope.payload as Record<string, unknown>;
@@ -288,7 +293,32 @@ export function registerJoinCommand(program: Command): void {
           info(`    Message ID: ${envelope.id}`);
           info(`    Protocol:   ${envelope.protocol}`);
           info(`    Type:       ${envelope.type}`);
-          info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
+
+          // Handle file attachment
+          let savedPath: string | undefined;
+          if (payload.attachment) {
+            const att = payload.attachment as {
+              filename: string;
+              mimeType: string;
+              size: number;
+              data: string;
+            };
+            try {
+              await mkdir(saveDir, { recursive: true });
+              // Avoid filename collisions by prefixing with message id fragment
+              const safeName = att.filename.replace(/[^a-zA-Z0-9._-]/g, '_');
+              savedPath = join(saveDir, `${envelope.id.slice(-8)}_${safeName}`);
+              await writeFile(savedPath, Buffer.from(att.data, 'base64'));
+              success(`    Attachment saved: ${savedPath}`);
+              info(`    File: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+            } catch (e) {
+              error(`    Failed to save attachment: ${(e as Error).message}`);
+            }
+            const displayPayload = { ...payload, attachment: '[binary data omitted]' };
+            info(`    Payload:    ${JSON.stringify(displayPayload, null, 2)}`);
+          } else {
+            info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
+          }
           console.log();
 
           // If this is a request, send back a simple acknowledgment response
@@ -303,17 +333,17 @@ export function registerJoinCommand(program: Command): void {
             });
 
             const responseEnvelope = createEnvelope(
-              envelope.to,      // We are the recipient, now we're the sender
-              envelope.from,    // Original sender is now the recipient
+              envelope.to,
+              envelope.from,
               'response',
               envelope.protocol,
               {
                 status: 'received',
                 message: 'Message received and processed',
-                originalPayload: payload,
-                timestamp: Date.now()
+                savedPath: savedPath ?? null,
+                timestamp: Date.now(),
               },
-              envelope.id       // replyTo: original message ID
+              envelope.id
             );
 
             const signedResponse = await signEnvelope(responseEnvelope, (data) =>

package/src/commands/send.ts

@@ -12,6 +12,9 @@ import {
 } from '@highway1/core';
 import { getIdentity, getBootstrapPeers } from '../config.js';
 import { success, error, spinner, printHeader, info } from '../ui.js';
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { DaemonClient } from '../daemon/client.js';
 
 export function registerSendCommand(program: Command): void {
   program
@@ -19,7 +22,8 @@ export function registerSendCommand(program: Command): void {
     .description('Send a message to another agent')
     .requiredOption('--to <did>', 'Recipient DID')
     .requiredOption('--protocol <protocol>', 'Protocol identifier')
-    .requiredOption('--payload <json>', 'Message payload (JSON)')
+    .option('--payload <json>', 'Message payload (JSON)')
+    .option('--file <path>', 'Attach a file (image, binary, text) as payload attachment')
     .option('--type <type>', 'Message type (request|notification)', 'request')
     .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
     .option('--peer <multiaddr>', 'Direct peer multiaddr (bypasses DHT lookup)')
@@ -34,14 +38,108 @@ export function registerSendCommand(program: Command): void {
           process.exit(1);
         }
 
-        let payload;
-        try {
-          payload = JSON.parse(options.payload);
-        } catch {
-          error('Invalid JSON payload');
+        if (!options.payload && !options.file) {
+          error('Either --payload <json> or --file <path> is required.');
           process.exit(1);
         }
 
+        let payload: Record<string, unknown> = {};
+
+        if (options.payload) {
+          try {
+            payload = JSON.parse(options.payload);
+          } catch {
+            error('Invalid JSON payload');
+            process.exit(1);
+          }
+        }
+
+        if (options.file) {
+          const filePath: string = options.file;
+          let fileBytes: Buffer;
+          try {
+            fileBytes = await readFile(filePath);
+          } catch {
+            error(`Cannot read file: ${filePath}`);
+            process.exit(1);
+          }
+          const filename = basename(filePath);
+          const mimeType = guessMimeType(filename);
+          payload.attachment = {
+            filename,
+            mimeType,
+            size: fileBytes.length,
+            data: fileBytes.toString('base64'),
+          };
+          info(`Attaching file: ${filename} (${fileBytes.length} bytes, ${mimeType})`);
+        }
+
+        // Try daemon first for fast path
+        const client = new DaemonClient();
+        if (await client.isDaemonRunning()) {
+          const spin = spinner('Sending message via daemon...');
+
+          try {
+            const result = await client.send('send', {
+              to: options.to,
+              protocol: options.protocol,
+              payload,
+              type: options.type,
+              peer: options.peer,
+            });
+
+            spin.succeed('Message sent successfully!');
+
+            console.log();
+            info(`Message ID: ${result.id}`);
+            info(`To: ${options.to}`);
+            info(`Protocol: ${options.protocol}`);
+            info(`Type: ${options.type}`);
+            if (payload.attachment) {
+              const att = payload.attachment as { filename: string; mimeType: string; size: number };
+              info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+              const rest = { ...payload, attachment: '[binary data omitted]' };
+              info(`Payload: ${JSON.stringify(rest)}`);
+            } else {
+              info(`Payload: ${JSON.stringify(payload)}`);
+            }
+
+            // Display response if received
+            if (result.response) {
+              console.log();
+              success('>>> Received response from recipient');
+              info(`Response ID: ${result.response.id}`);
+              info(`Reply To: ${result.response.replyTo}`);
+              info(`Protocol: ${result.response.protocol}`);
+              const respPayload = result.response.payload as Record<string, unknown>;
+              if (respPayload?.attachment) {
+                const att = respPayload.attachment as { filename: string; mimeType: string; size: number };
+                info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+                info(`Payload: ${JSON.stringify({ ...respPayload, attachment: '[binary data omitted]' }, null, 2)}`);
+              } else {
+                info(`Payload: ${JSON.stringify(result.response.payload, null, 2)}`);
+              }
+            } else if (options.type === 'request') {
+              console.log();
+              info('No response received (recipient may not have returned a response)');
+            }
+
+            success('Done');
+            return;
+          } catch (err) {
+            spin.fail('Daemon send failed, falling back to ephemeral node');
+            console.log();
+            info('Tip: Restart daemon with "clawiverse daemon restart" if issues persist');
+            console.log();
+          }
+        } else {
+          console.log();
+          info('⚠ Daemon not running, using ephemeral node (slower)');
+          info('Tip: Start daemon with "clawiverse daemon start" for faster messaging');
+          console.log();
+        }
+
+        // Fallback: create ephemeral node (original behavior)
         const spin = spinner('Starting node...');
 
         const keyPair = importKeyPair({
@@ -59,10 +157,10 @@ export function registerSendCommand(program: Command): void {
 
         // Register peer:identify listener BEFORE start() so we don't miss the event
         const identifyDone = new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 12000);
+          const timeout = setTimeout(resolve, 2000);
           node.libp2p.addEventListener('peer:identify', () => {
             clearTimeout(timeout);
-            setTimeout(resolve, 500);
+            resolve();
           }, { once: true });
         });
 
@@ -131,7 +229,14 @@ export function registerSendCommand(program: Command): void {
         info(`To: ${options.to}`);
         info(`Protocol: ${options.protocol}`);
         info(`Type: ${options.type}`);
-        info(`Payload: ${JSON.stringify(payload)}`);
+        if (payload.attachment) {
+          const att = payload.attachment as { filename: string; mimeType: string; size: number };
+          info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+          const rest = { ...payload, attachment: '[binary data omitted]' };
+          info(`Payload: ${JSON.stringify(rest)}`);
+        } else {
+          info(`Payload: ${JSON.stringify(payload)}`);
+        }
 
         // Display response if received
         if (response) {
@@ -140,7 +245,14 @@ export function registerSendCommand(program: Command): void {
           info(`Response ID: ${response.id}`);
           info(`Reply To: ${response.replyTo}`);
           info(`Protocol: ${response.protocol}`);
-          info(`Payload: ${JSON.stringify(response.payload, null, 2)}`);
+          const respPayload = response.payload as Record<string, unknown>;
+          if (respPayload?.attachment) {
+            const att = respPayload.attachment as { filename: string; mimeType: string; size: number };
+            info(`Attachment: ${att.filename} (${att.size} bytes, ${att.mimeType})`);
+            info(`Payload: ${JSON.stringify({ ...respPayload, attachment: '[binary data omitted]' }, null, 2)}`);
+          } else {
+            info(`Payload: ${JSON.stringify(response.payload, null, 2)}`);
+          }
         } else if (options.type === 'request') {
           console.log();
           info('No response received (recipient may not have returned a response)');
@@ -158,3 +270,30 @@ export function registerSendCommand(program: Command): void {
       }
     });
 }
+
+function guessMimeType(filename: string): string {
+  const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+  const map: Record<string, string> = {
+    // images
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    svg: 'image/svg+xml',
+    // documents
+    pdf: 'application/pdf',
+    txt: 'text/plain',
+    md: 'text/markdown',
+    json: 'application/json',
+    csv: 'text/csv',
+    // audio/video
+    mp3: 'audio/mpeg',
+    mp4: 'video/mp4',
+    wav: 'audio/wav',
+    // archives
+    zip: 'application/zip',
+    gz: 'application/gzip',
+  };
+  return map[ext] ?? 'application/octet-stream';
+}

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