@highway1/cli 0.1.53 → 0.1.54

package/src/commands/send.ts

@@ -1,299 +0,0 @@
-import { Command } from 'commander';
-import {
-  createRelayClient,
-  createRelayIndexOperations,
-  importKeyPair,
-  createEnvelope,
-  signEnvelope,
-  createMessageRouter,
-  createAgentCard,
-  signAgentCard,
-  sign,
-  verify,
-  extractPublicKey,
-} from '@highway1/core';
-import { getIdentity, getAgentCard } 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';
-
-// Default relay URLs (CVP-0011)
-const DEFAULT_RELAY_URLS = [
-  'ws://relay.highway1.net:8080',
-];
-
-function getRelayUrls(options: any): string[] {
-  if (options.relay) return [options.relay];
-  const envRelays = process.env.HW1_RELAY_URLS;
-  if (envRelays) return envRelays.split(',').map((u: string) => u.trim());
-  return DEFAULT_RELAY_URLS;
-}
-
-export function registerSendCommand(program: Command): void {
-  program
-    .command('send')
-    .description('Send a message to another agent')
-    .requiredOption('--to <did-or-name>', 'Recipient DID or agent name')
-    .option('--protocol <protocol>', 'Protocol identifier', '/clawiverse/msg/1.0.0') // CVP-0010 §3.1: default protocol
-    .option('--message <text>', 'Message text (shorthand for --payload \'{"text":"..."}\')') // CVP-0010 §3.1: --message shorthand
-    .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') // CVP-0010 §3.1: default type
-    .option('--relay <url>', 'Relay WebSocket URL')
-    .option('--format <fmt>', 'Output format: text|json', 'text') // CVP-0010 §3.2: --format json
-    .action(async (options) => {
-      try {
-        if (options.format !== 'json') printHeader('Send Message');
-
-        const identity = getIdentity();
-
-        if (!identity) {
-          error('No identity found. Run "hw1 init" first.');
-          process.exit(1);
-        }
-
-        // CVP-0010 §3.1: --message shorthand
-        if (!options.payload && !options.file && !options.message) {
-          error('Either --message <text>, --payload <json>, or --file <path> is required.');
-          process.exit(1);
-        }
-
-        let payload: Record<string, unknown> = {};
-
-        // CVP-0010 §3.1: --message shorthand wraps text into {"text": "..."}
-        if (options.message) {
-          payload.text = options.message;
-        } else 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,
-            });
-
-            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');
-            info(`Daemon error: ${(err as Error).message}`);
-            console.log();
-            info('Tip: Restart daemon with "clawiverse daemon restart" if issues persist');
-            console.log();
-          }
-        } else {
-          console.log();
-          info('⚠ Daemon not running, using ephemeral relay connection (slower)');
-          info('Tip: Start daemon with "clawiverse daemon start" for faster messaging');
-          console.log();
-        }
-
-        // Fallback: create ephemeral relay connection (CVP-0011)
-        const spin = spinner('Connecting to relay...');
-
-        const keyPair = importKeyPair({
-          publicKey: identity.publicKey,
-          privateKey: identity.privateKey,
-        });
-
-        const relayUrls = getRelayUrls(options);
-        const card = getAgentCard();
-        const capabilities = (card?.capabilities ?? []).map((c: string) => ({
-          id: c, name: c, description: `Capability: ${c}`,
-        }));
-        const agentCard = createAgentCard(
-          identity.did,
-          card?.name ?? 'Clawiverse Agent',
-          card?.description ?? '',
-          capabilities,
-          [],
-        );
-        const signedCard = await signAgentCard(agentCard, (data) => sign(data, keyPair.privateKey));
-
-        const relayClient = createRelayClient({
-          relayUrls,
-          did: identity.did,
-          keyPair,
-          card: signedCard,
-        });
-
-        await relayClient.start();
-        spin.text = 'Connected to relay';
-
-        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;
-          }
-        };
-
-        const router = createMessageRouter(relayClient, verifyFn);
-        await router.start();
-
-        spin.text = 'Creating message...';
-
-        const envelope = createEnvelope(
-          identity.did,
-          options.to,
-          options.type,
-          options.protocol,
-          payload
-        );
-
-        const signedEnvelope = await signEnvelope(envelope, (data) =>
-          sign(data, keyPair.privateKey)
-        );
-
-        spin.text = 'Sending message...';
-
-        const response = await router.sendMessage(signedEnvelope);
-
-        spin.succeed('Message sent successfully!');
-
-        console.log();
-        info(`Message ID: ${signedEnvelope.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 (response) {
-          console.log();
-          success('>>> Received response from recipient');
-          info(`Response ID: ${response.id}`);
-          info(`Reply To: ${response.replyTo}`);
-          info(`Protocol: ${response.protocol}`);
-          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)');
-        }
-
-        await router.stop();
-        await relayClient.stop();
-
-        success('Done');
-      } catch (err) {
-        error(`Failed to send message: ${(err as Error).message}`);
-        if ((err as Error).cause) error(`Cause: ${((err as Error).cause as Error).message}`);
-        console.error(err);
-        process.exit(1);
-      }
-    });
-}
-
-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/commands/serve.ts

@@ -1,271 +0,0 @@
-/**
- * Serve Command - CVP-0010 §2.2
- *
- * Registers custom handlers that execute when matching requests arrive.
- *
- * hw1 serve --on "translate" --exec "./translate.sh"
- * hw1 serve --on "code_review" --exec "python review.py"
- * hw1 serve --handlers ./my-handlers/
- */
-
-import { Command } from 'commander';
-import { DaemonClient } from '../daemon/client.js';
-import { createLogger } from '@highway1/core';
-import { spawn } from 'child_process';
-import { readdir, stat } from 'node:fs/promises';
-import { join, resolve, basename } from 'node:path';
-
-const logger = createLogger('cli:serve');
-
-const MAX_PAYLOAD_BYTES = 256 * 1024; // 256 KiB
-
-interface HandlerEntry {
-  capability: string;
-  exec: string;
-}
-
-export function registerServeCommand(program: Command): void {
-  program
-    .command('serve')
-    .description('Register handlers for incoming requests (CVP-0010 §2.2)')
-    .option('--on <capability>', 'Capability name to handle')
-    .option('--exec <script>', 'Script to execute for matching requests')
-    .option('--handlers <dir>', 'Directory of handler scripts (filename = capability name)')
-    .option('--allow-from <dids...>', 'Only accept requests from these DIDs (default: deny-all except allowlist)')
-    .option('--public', 'Accept requests from any agent (overrides --allow-from)')
-    .option('--max-concurrency <n>', 'Max concurrent handler executions', '4')
-    .option('--timeout <seconds>', 'Handler execution timeout in seconds', '60')
-    .option('--format <fmt>', 'Output format: text|json', 'text')
-    .action(async (options) => {
-      const client = new DaemonClient();
-      if (!(await client.isDaemonRunning())) {
-        console.error('Daemon not running. Start with: hw1 join');
-        process.exit(1);
-      }
-
-      // Build handler list
-      const handlers: HandlerEntry[] = [];
-
-      if (options.on && options.exec) {
-        handlers.push({ capability: options.on, exec: resolve(options.exec) });
-      }
-
-      if (options.handlers) {
-        const dir = resolve(options.handlers);
-        const entries = await readdir(dir);
-        for (const entry of entries) {
-          const fullPath = join(dir, entry);
-          const s = await stat(fullPath);
-          if (!s.isFile()) continue;
-          // Strip extension to get capability name; skip _default for now
-          const cap = basename(entry).replace(/\.[^.]+$/, '');
-          handlers.push({ capability: cap, exec: fullPath });
-        }
-      }
-
-      if (handlers.length === 0) {
-        console.error('No handlers specified. Use --on/--exec or --handlers <dir>');
-        process.exit(1);
-      }
-
-      const maxConcurrency = parseInt(options.maxConcurrency, 10);
-      const timeoutMs = parseInt(options.timeout, 10) * 1000;
-      let activeCount = 0;
-
-      // Apply allowlist if --allow-from specified
-      if (options.allowFrom && !options.public) {
-        for (const did of options.allowFrom) {
-          await client.send('allowlist', { action: 'add', did, note: 'hw1 serve --allow-from' });
-        }
-        if (options.format !== 'json') {
-          console.log(`Allowlisted ${options.allowFrom.length} DID(s)`);
-        }
-      }
-
-      if (options.format !== 'json') {
-        console.log(`\nServing ${handlers.length} handler(s):`);
-        for (const h of handlers) {
-          console.log(`  ${h.capability} → ${h.exec}`);
-        }
-        console.log(`\nMax concurrency: ${maxConcurrency}, timeout: ${options.timeout}s`);
-        console.log('Waiting for requests... (Ctrl+C to stop)\n');
-      }
-
-      // Subscribe to incoming messages via queue
-      const subscriptionFilter = {
-        protocol: handlers.map((h) => `clawiverse/${h.capability}`),
-      };
-
-      // Poll inbox for new messages matching our capabilities
-      const poll = async () => {
-        try {
-          const page = await client.send('inbox', {
-            filter: { unreadOnly: true, status: 'pending' },
-            pagination: { limit: 10 },
-          });
-
-          for (const msg of page.messages ?? []) {
-            const envelope = msg.envelope;
-            const protocol: string = envelope.protocol ?? '';
-
-            // Find matching handler
-            const handler = handlers.find((h) =>
-              protocol.includes(h.capability) ||
-              (envelope.payload as any)?.capability === h.capability
-            );
-
-            if (!handler) continue;
-
-            // Mark as read immediately to avoid double-processing
-            await client.send('mark_read', { id: envelope.id });
-
-            // Concurrency control
-            if (activeCount >= maxConcurrency) {
-              if (options.format !== 'json') {
-                console.log(`[BUSY] Rejected ${envelope.id.slice(-8)} from ${envelope.from.slice(0, 20)}…`);
-              }
-              // Send BUSY response
-              await client.send('send', {
-                to: envelope.from,
-                protocol: envelope.protocol,
-                payload: { error: 'BUSY', message: 'Server at capacity, try again later' },
-                type: 'response',
-              });
-              continue;
-            }
-
-            // Payload size check
-            const payloadStr = JSON.stringify(envelope.payload ?? '');
-            if (payloadStr.length > MAX_PAYLOAD_BYTES) {
-              await client.send('send', {
-                to: envelope.from,
-                protocol: envelope.protocol,
-                payload: { error: 'PAYLOAD_TOO_LARGE', message: `Max payload is ${MAX_PAYLOAD_BYTES} bytes` },
-                type: 'response',
-              });
-              continue;
-            }
-
-            // Execute handler
-            activeCount++;
-            const startTime = Date.now();
-
-            if (options.format !== 'json') {
-              console.log(`[${new Date().toLocaleTimeString()}] ${handler.capability} ← ${envelope.from.slice(0, 30)}…`);
-            }
-
-            executeHandler(handler.exec, envelope.payload, timeoutMs)
-              .then(async (result) => {
-                const latencyMs = Date.now() - startTime;
-                await client.send('send', {
-                  to: envelope.from,
-                  protocol: envelope.protocol,
-                  payload: result,
-                  type: 'response',
-                });
-
-                if (options.format === 'json') {
-                  console.log(JSON.stringify({
-                    event: 'handled',
-                    capability: handler.capability,
-                    from: envelope.from,
-                    latencyMs,
-                    success: true,
-                  }));
-                } else {
-                  console.log(`  → responded in ${latencyMs}ms`);
-                }
-              })
-              .catch(async (err) => {
-                const latencyMs = Date.now() - startTime;
-                const isTimeout = err.message?.includes('timeout');
-                await client.send('send', {
-                  to: envelope.from,
-                  protocol: envelope.protocol,
-                  payload: {
-                    error: isTimeout ? 'TIMEOUT' : 'HANDLER_ERROR',
-                    message: err.message,
-                  },
-                  type: 'response',
-                });
-
-                if (options.format === 'json') {
-                  console.log(JSON.stringify({
-                    event: 'error',
-                    capability: handler.capability,
-                    from: envelope.from,
-                    latencyMs,
-                    error: err.message,
-                  }));
-                } else {
-                  console.error(`  → error after ${latencyMs}ms: ${err.message}`);
-                }
-              })
-              .finally(() => {
-                activeCount--;
-              });
-          }
-        } catch (err) {
-          logger.warn('Poll error', err);
-        }
-      };
-
-      // Poll every 500ms
-      const interval = setInterval(poll, 500);
-
-      // Graceful shutdown
-      const shutdown = () => {
-        clearInterval(interval);
-        if (options.format !== 'json') console.log('\nStopped serving.');
-        process.exit(0);
-      };
-      process.on('SIGINT', shutdown);
-      process.on('SIGTERM', shutdown);
-    });
-}
-
-async function executeHandler(
-  scriptPath: string,
-  payload: unknown,
-  timeoutMs: number
-): Promise<unknown> {
-  return new Promise((resolve, reject) => {
-    const child = spawn(scriptPath, [], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env },
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (d: Buffer) => { stdout += d.toString(); });
-    child.stderr.on('data', (d: Buffer) => { stderr += d.toString(); });
-
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      reject(new Error(`Handler timeout after ${timeoutMs}ms`));
-    }, timeoutMs);
-
-    child.on('close', (code) => {
-      clearTimeout(timer);
-      if (code !== 0) {
-        reject(new Error(`Handler exited with code ${code}: ${stderr.trim()}`));
-        return;
-      }
-      try {
-        resolve(JSON.parse(stdout.trim()));
-      } catch {
-        resolve({ result: stdout.trim() });
-      }
-    });
-
-    child.on('error', (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-
-    // Write payload to stdin
-    child.stdin.write(JSON.stringify(payload));
-    child.stdin.end();
-  });
-}

package/src/commands/status.ts

@@ -1,60 +0,0 @@
-import { Command } from 'commander';
-import { getIdentity, getAgentCard, getBootstrapPeers } from '../config.js';
-import { error, printHeader, printKeyValue, printSection } from '../ui.js';
-
-export function registerStatusCommand(program: Command): void {
-  program
-    .command('status')
-    .description('Show current status')
-    .option('--format <fmt>', 'Output format: text|json', 'text')
-    .action(async (options) => {
-      try {
-        const identity = getIdentity();
-        const card = getAgentCard();
-        const bootstrapPeers = getBootstrapPeers();
-
-        if (!identity) {
-          error('No identity configured. Run "hw1 init" first.');
-          process.exit(1);
-        }
-
-        if (options.format === 'json') {
-          console.log(JSON.stringify({
-            identity: {
-              did: identity.did,
-              publicKey: identity.publicKey,
-            },
-            agentCard: card || null,
-            network: {
-              bootstrapPeers,
-            },
-          }, null, 2));
-          return;
-        }
-
-        printHeader('Clawiverse Status');
-
-        printSection('Identity');
-        printKeyValue('DID', identity.did);
-        printKeyValue('Public Key', identity.publicKey.substring(0, 16) + '...');
-
-        if (card) {
-          printSection('Agent Card');
-          printKeyValue('Name', card.name);
-          printKeyValue('Description', card.description);
-          printKeyValue('Capabilities', card.capabilities.join(', ') || 'None');
-        }
-
-        printSection('Network');
-        printKeyValue(
-          'Bootstrap Peers',
-          bootstrapPeers.length > 0 ? bootstrapPeers.join(', ') : 'None configured'
-        );
-
-        console.log();
-      } catch (err) {
-        error(`Failed to show status: ${(err as Error).message}`);
-        process.exit(1);
-      }
-    });
-}

package/src/commands/stop.ts

@@ -1,49 +0,0 @@
-/**
- * Stop Command - CVP-0010 §2.5
- *
- * Cleaner alternative to `hw1 daemon stop`
- */
-
-import { Command } from 'commander';
-import { DaemonClient } from '../daemon/client.js';
-import { existsSync, unlinkSync } from 'fs';
-import { success, info } from '../ui.js';
-
-const PID_FILE = '/tmp/clawiverse.pid';
-const SOCKET_PATH = '/tmp/clawiverse.sock';
-
-export function registerStopCommand(program: Command): void {
-  program
-    .command('stop')
-    .description('Stop the Highway 1 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) {
-        console.error(`Failed to stop daemon: ${(err as Error).message}`);
-        process.exit(1);
-      }
-    });
-}