@highway1/cli 0.1.48 → 0.1.50

package/src/commands/serve.ts

@@ -0,0 +1,271 @@
+/**
+ * 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

@@ -6,10 +6,9 @@ export function registerStatusCommand(program: Command): void {
   program
     .command('status')
     .description('Show current status')
-    .action(async () => {
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
       try {
-        printHeader('Clawiverse Status');
-
         const identity = getIdentity();
         const card = getAgentCard();
         const bootstrapPeers = getBootstrapPeers();
@@ -19,6 +18,22 @@ export function registerStatusCommand(program: Command): void {
           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) + '...');

package/src/commands/stop.ts

@@ -0,0 +1,49 @@
+/**
+ * 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);
+      }
+    });
+}

package/src/commands/trust.ts

@@ -4,7 +4,7 @@
 
 import { Command } from 'commander';
 import { getConfig, getIdentity } from '../config.js';
-import { createLogger, createTrustSystem } from '@highway1/core';
+import { createLogger, createTrustSystem, extractPublicKey } from '@highway1/core';
 import { homedir } from 'os';
 import { join } from 'path';
 
@@ -24,7 +24,7 @@ export function createTrustCommand(): Command {
         const dataDir = join(homedir(), '.clawiverse');
         const trustSystem = createTrustSystem({
           dbPath: `${dataDir}/trust`,
-          getPublicKey: async () => new Uint8Array(), // Placeholder
+          getPublicKey: async (did: string) => extractPublicKey(did), // CVP-0010 §4.1 fix
         });
 
         await trustSystem.start();
@@ -71,7 +71,7 @@ export function createTrustCommand(): Command {
         const dataDir = join(homedir(), '.clawiverse');
         const trustSystem = createTrustSystem({
           dbPath: `${dataDir}/trust`,
-          getPublicKey: async () => new Uint8Array(), // Placeholder
+          getPublicKey: async (did: string) => extractPublicKey(did), // CVP-0010 §4.1 fix
         });
 
         await trustSystem.start();
@@ -126,7 +126,7 @@ export function createTrustCommand(): Command {
         const dataDir = join(homedir(), '.clawiverse');
         const trustSystem = createTrustSystem({
           dbPath: `${dataDir}/trust`,
-          getPublicKey: async () => new Uint8Array(), // Placeholder
+          getPublicKey: async (did: string) => extractPublicKey(did), // CVP-0010 §4.1 fix
         });
 
         await trustSystem.start();
@@ -170,7 +170,7 @@ export function createTrustCommand(): Command {
         const dataDir = join(homedir(), '.clawiverse');
         const trustSystem = createTrustSystem({
           dbPath: `${dataDir}/trust`,
-          getPublicKey: async () => new Uint8Array(), // Placeholder
+          getPublicKey: async (did: string) => extractPublicKey(did), // CVP-0010 §4.1 fix
         });
 
         await trustSystem.start();
@@ -211,5 +211,144 @@ export function createTrustCommand(): Command {
       }
     });
 
+  // Block an agent (via daemon defense layer)
+  trust
+    .command('block <did>')
+    .description('Block an agent from sending you messages')
+    .option('-r, --reason <reason>', 'Reason for blocking', 'Blocked by user')
+    .action(async (did: string, options: { reason: string }) => {
+      try {
+        const { DaemonClient } = await import('../daemon/client.js');
+        const client = new DaemonClient();
+        if (await client.isDaemonRunning()) {
+          await client.send('block', { did, reason: options.reason });
+          console.log(`Blocked ${did}`);
+        } else {
+          // Daemon not running — write directly to storage
+          const { MessageStorage } = await import('@highway1/core');
+          const storage = new MessageStorage(join(homedir(), '.clawiverse', 'inbox'));
+          await storage.open();
+          await storage.putBlock({ did, reason: options.reason, blockedAt: Date.now(), blockedBy: 'local' });
+          await storage.close();
+          console.log(`Blocked ${did}`);
+        }
+      } catch (error) {
+        logger.error('Failed to block agent', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Unblock an agent
+  trust
+    .command('unblock <did>')
+    .description('Unblock a previously blocked agent')
+    .action(async (did: string) => {
+      try {
+        const { DaemonClient } = await import('../daemon/client.js');
+        const client = new DaemonClient();
+        if (await client.isDaemonRunning()) {
+          await client.send('unblock', { did });
+        } else {
+          const { MessageStorage } = await import('@highway1/core');
+          const storage = new MessageStorage(join(homedir(), '.clawiverse', 'inbox'));
+          await storage.open();
+          await storage.deleteBlock(did);
+          await storage.close();
+        }
+        console.log(`Unblocked ${did}`);
+      } catch (error) {
+        logger.error('Failed to unblock agent', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // List blocked agents
+  trust
+    .command('list-blocked')
+    .description('List all blocked agents')
+    .action(async () => {
+      try {
+        const { MessageStorage } = await import('@highway1/core');
+        const storage = new MessageStorage(join(homedir(), '.clawiverse', 'inbox'));
+        await storage.open();
+        const blocked = await storage.listBlocked();
+        await storage.close();
+
+        if (blocked.length === 0) {
+          console.log('No blocked agents.');
+          return;
+        }
+        console.log(`\nBlocked agents (${blocked.length}):\n`);
+        for (const entry of blocked) {
+          console.log(`  ${entry.did}`);
+          console.log(`    Reason: ${entry.reason}`);
+          console.log(`    Blocked: ${new Date(entry.blockedAt).toLocaleString()}`);
+        }
+        console.log();
+      } catch (error) {
+        logger.error('Failed to list blocked agents', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // Add to allowlist
+  trust
+    .command('allow <did>')
+    .description('Add an agent to your allowlist (bypasses all defense checks)')
+    .option('-n, --note <note>', 'Note about this agent')
+    .action(async (did: string, options: { note?: string }) => {
+      try {
+        const { DaemonClient } = await import('../daemon/client.js');
+        const client = new DaemonClient();
+        if (await client.isDaemonRunning()) {
+          await client.send('allowlist', { action: 'add', did, note: options.note });
+        } else {
+          const { MessageStorage } = await import('@highway1/core');
+          const storage = new MessageStorage(join(homedir(), '.clawiverse', 'inbox'));
+          await storage.open();
+          await storage.putAllow({ did, addedAt: Date.now(), note: options.note });
+          await storage.close();
+        }
+        console.log(`Added ${did} to allowlist`);
+      } catch (error) {
+        logger.error('Failed to allowlist agent', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
+  // List allowlisted agents
+  trust
+    .command('list-allowed')
+    .description('List all allowlisted agents')
+    .action(async () => {
+      try {
+        const { MessageStorage } = await import('@highway1/core');
+        const storage = new MessageStorage(join(homedir(), '.clawiverse', 'inbox'));
+        await storage.open();
+        const allowed = await storage.listAllowed();
+        await storage.close();
+
+        if (allowed.length === 0) {
+          console.log('No allowlisted agents.');
+          return;
+        }
+        console.log(`\nAllowlisted agents (${allowed.length}):\n`);
+        for (const entry of allowed) {
+          console.log(`  ${entry.did}`);
+          if (entry.note) console.log(`    Note: ${entry.note}`);
+          console.log(`    Added: ${new Date(entry.addedAt).toLocaleString()}`);
+        }
+        console.log();
+      } catch (error) {
+        logger.error('Failed to list allowed agents', error);
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+      }
+    });
+
   return trust;
 }

package/src/daemon/client.ts

@@ -16,25 +16,47 @@ export class DaemonClient {
       const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2)}`;
 
       let responseReceived = false;
+      let buffer = ''; // CVP-0010 §1.2: Buffer for NDJSON framing
 
       socket.on('connect', () => {
         const request = { id: requestId, command, params };
         logger.debug('Sending request', { command, id: requestId });
-        socket.write(JSON.stringify(request));
+        // CVP-0010 §1.2: Send with newline delimiter
+        socket.write(JSON.stringify(request) + '\n');
       });
 
       socket.on('data', (data) => {
         try {
-          const response = JSON.parse(data.toString());
-          responseReceived = true;
-          socket.end();
+          // CVP-0010 §1.2: Accumulate data and split by newlines
+          buffer += data.toString();
+          const lines = buffer.split('\n');
 
-          logger.debug('Received response', { success: response.success, id: response.id });
+          // Keep incomplete line in buffer
+          buffer = lines.pop() || '';
 
-          if (response.success) {
-            resolve(response.data);
-          } else {
-            reject(new Error(response.error));
+          // Process complete lines
+          for (const line of lines) {
+            if (!line.trim()) continue;
+
+            const response = JSON.parse(line);
+
+            // Match response by ID
+            if (response.id !== requestId) {
+              logger.debug('Ignoring unmatched response', { responseId: response.id, requestId });
+              continue;
+            }
+
+            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));
+            }
+            return;
           }
         } catch (error) {
           reject(new Error(`Failed to parse response: ${(error as Error).message}`));