@highway1/cli 0.1.49 → 0.1.52

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.49",
+  "version": "0.1.52",
   "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {
     "clawiverse": "./dist/index.js",
     "hw1": "./dist/index.js"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
   "dependencies": {
-    "@highway1/core": "^0.1.46",
+    "@highway1/core": "^0.1.51",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
@@ -23,10 +28,5 @@
   },
   "engines": {
     "node": ">=22.0.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist"
   }
-}
+}

package/src/commands/ask.ts

@@ -0,0 +1,158 @@
+/**
+ * Ask Command - CVP-0010 §2.1
+ *
+ * One-step network query: discover + send + wait for response.
+ *
+ * hw1 ask "translate hello to Japanese"
+ * hw1 ask "review this code" --file main.py
+ * hw1 ask "translate hello" --to kaito-translator
+ * hw1 ask "summarize" --min-trust 0.8 --format json
+ */
+
+import { Command } from 'commander';
+import { DaemonClient } from '../daemon/client.js';
+import { createLogger } from '@highway1/core';
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+
+const logger = createLogger('cli:ask');
+
+export function registerAskCommand(program: Command): void {
+  program
+    .command('ask <query>')
+    .description('Ask the network — discover an agent and send a request in one step')
+    .option('--to <name-or-did>', 'Skip discovery, send to specific agent name or DID')
+    .option('--min-trust <score>', 'Minimum trust score (0-1)', '0')
+    .option('--timeout <seconds>', 'Response timeout in seconds', '30')
+    .option('--file <path>', 'Attach a file to the request')
+    .option('--protocol <protocol>', 'Protocol to use', '/clawiverse/msg/1.0.0')
+    .option('--dry-run', 'Show what would be sent without sending')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (query: string, options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        let targetDid: string | undefined;
+
+        // Resolve target
+        if (options.to) {
+          if (options.to.startsWith('did:')) {
+            targetDid = options.to;
+          } else {
+            // Name resolution via DHT
+            if (options.format !== 'json') process.stderr.write(`Searching for "${options.to}"...\n`);
+            const results = await client.send('discover', { query: options.to });
+            if (!results || results.length === 0) {
+              console.error(`No agent found matching: ${options.to}`);
+              process.exit(1);
+            }
+            targetDid = results[0].did;
+            if (options.format !== 'json') process.stderr.write(`Found: ${results[0].name ?? targetDid}\n`);
+          }
+        } else {
+          // Semantic discovery
+          if (options.format !== 'json') process.stderr.write(`Searching for agents matching: "${query}"...\n`);
+          const minTrust = parseFloat(options.minTrust);
+          const results = await client.send('discover', {
+            query,
+            filters: minTrust > 0 ? { minTrustScore: minTrust } : undefined,
+          });
+
+          if (!results || results.length === 0) {
+            console.error(`No agents found for: ${query}`);
+            process.exit(1);
+          }
+
+          // Pick highest-trust match
+          const sorted = [...results].sort((a: any, b: any) => {
+            const ta = a.trust?.interactionScore ?? 0;
+            const tb = b.trust?.interactionScore ?? 0;
+            return tb - ta;
+          });
+          targetDid = sorted[0].did;
+          if (options.format !== 'json') {
+            process.stderr.write(`Best match: ${sorted[0].name ?? targetDid} (trust: ${((sorted[0].trust?.interactionScore ?? 0) * 100).toFixed(0)}%)\n`);
+          }
+        }
+
+        // Build payload
+        const payload: Record<string, unknown> = { text: query };
+
+        if (options.file) {
+          const fileBytes = await readFile(options.file);
+          const filename = basename(options.file);
+          payload.attachment = {
+            filename,
+            mimeType: guessMimeType(filename),
+            size: fileBytes.length,
+            data: fileBytes.toString('base64'),
+          };
+        }
+
+        if (options.dryRun) {
+          const out = { to: targetDid, protocol: options.protocol, payload };
+          if (options.format === 'json') {
+            console.log(JSON.stringify(out, null, 2));
+          } else {
+            console.log(`[dry-run] Would send to: ${targetDid}`);
+            console.log(`[dry-run] Protocol: ${options.protocol}`);
+            console.log(`[dry-run] Payload: ${JSON.stringify(payload)}`);
+          }
+          return;
+        }
+
+        if (options.format !== 'json') process.stderr.write(`Sending request...\n`);
+
+        const result = await client.send('send', {
+          to: targetDid,
+          protocol: options.protocol,
+          payload,
+          type: 'request',
+        });
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify({
+            from: targetDid,
+            messageId: result.id,
+            response: result.response ?? null,
+            verified: true,
+          }, null, 2));
+        } else {
+          if (result.response) {
+            const resp = result.response;
+            const p = resp.payload as any;
+            if (p?.text) {
+              console.log(p.text);
+            } else if (p?.result) {
+              console.log(typeof p.result === 'string' ? p.result : JSON.stringify(p.result, null, 2));
+            } else {
+              console.log(JSON.stringify(p, null, 2));
+            }
+          } else {
+            console.log(`Request sent (${result.id.slice(-8)}). No response received within timeout.`);
+          }
+        }
+      } catch (err) {
+        logger.error('Ask failed', err);
+        console.error('Error:', (err as Error).message);
+        process.exit(1);
+      }
+    });
+}
+
+function guessMimeType(filename: string): string {
+  const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+  const map: Record<string, string> = {
+    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
+    gif: 'image/gif', webp: 'image/webp', svg: 'image/svg+xml',
+    pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown',
+    json: 'application/json', csv: 'text/csv',
+    mp3: 'audio/mpeg', mp4: 'video/mp4', wav: 'audio/wav',
+    zip: 'application/zip', gz: 'application/gzip',
+  };
+  return map[ext] ?? 'application/octet-stream';
+}

package/src/commands/card.ts

@@ -9,10 +9,9 @@ export function registerCardCommand(program: Command): void {
   card
     .command('show')
     .description('Show current Agent Card')
-    .action(async () => {
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
       try {
-        printHeader('Agent Card');
-
         const agentCard = getAgentCard();
 
         if (!agentCard) {
@@ -20,6 +19,12 @@ export function registerCardCommand(program: Command): void {
           process.exit(1);
         }
 
+        if (options.format === 'json') {
+          console.log(JSON.stringify(agentCard, null, 2));
+          return;
+        }
+
+        printHeader('Agent Card');
         console.log(JSON.stringify(agentCard, null, 2));
       } catch (err) {
         error(`Failed to show card: ${(err as Error).message}`);

package/src/commands/discover.ts

@@ -1,13 +1,25 @@
 import { Command } from 'commander';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
   importKeyPair,
-  createDHTOperations,
+  createAgentCard,
+  signAgentCard,
+  sign,
 } from '@highway1/core';
-import { getIdentity, getBootstrapPeers } from '../config.js';
+import { getIdentity, getAgentCard } from '../config.js';
 import { error, spinner, printHeader, info, success } from '../ui.js';
 import Table from 'cli-table3';
 
+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 registerDiscoverCommand(program: Command): void {
   program
     .command('discover')
@@ -18,7 +30,7 @@ export function registerDiscoverCommand(program: Command): void {
     .option('--min-trust <score>', 'Minimum trust score (0-1)')
     .option('--language <lang>', 'Filter by language')
     .option('--limit <number>', 'Maximum number of results', '10')
-    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
+    .option('--relay <url>', 'Relay WebSocket URL')
     .action(async (options) => {
       try {
         printHeader('Discover Agents');
@@ -30,56 +42,58 @@ export function registerDiscoverCommand(program: Command): void {
           process.exit(1);
         }
 
-        const spin = spinner('Starting node...');
+        const spin = spinner('Connecting to relay...');
 
         const keyPair = importKeyPair({
           publicKey: identity.publicKey,
           privateKey: identity.privateKey,
         });
 
-        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
-
-        const node = await createNode({
+        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,
-          bootstrapPeers,
-          enableDHT: true,
-        });
-
-        await node.start();
-
-        spin.text = 'Waiting for DHT peers...';
-        // Wait until connected to at least one peer, then give DHT time to sync
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 15000);
-          node.libp2p.addEventListener('peer:connect', () => {
-            clearTimeout(timeout);
-            setTimeout(resolve, 3000); // give DHT routing table time to populate
-          }, { once: true });
+          card: signedCard,
         });
 
-        spin.text = 'Querying DHT...';
+        await relayClient.start();
+        spin.text = 'Querying relay...';
 
-        const dht = createDHTOperations(node.libp2p);
+        const relayIndex = createRelayIndexOperations(relayClient);
 
         if (options.did) {
-          const card = await dht.queryAgentCard(options.did);
+          const agentCard = await relayIndex.queryAgentCard(options.did);
 
-          if (card) {
+          if (agentCard) {
             spin.succeed('Agent found!');
             console.log();
-            info(`DID:          ${card.did}`);
-            info(`Name:         ${card.name}`);
-            info(`Description:  ${card.description}`);
-            info(`Version:      ${card.version}`);
-            info(`Capabilities: ${card.capabilities.join(', ') || '(none)'}`);
-            info(`Peer ID:      ${card.peerId || '(unknown)'}`);
-            info(`Endpoints:    ${card.endpoints.length > 0 ? card.endpoints.join('\n              ') : '(none)'}`);
-            info(`Timestamp:    ${new Date(card.timestamp).toISOString()}`);
+            info(`DID:          ${agentCard.did}`);
+            info(`Name:         ${agentCard.name}`);
+            info(`Description:  ${agentCard.description}`);
+            info(`Version:      ${agentCard.version}`);
+            const caps = agentCard.capabilities.map((c: any) =>
+              typeof c === 'string' ? c : c.name
+            ).join(', ');
+            info(`Capabilities: ${caps || '(none)'}`);
+            info(`Timestamp:    ${new Date(agentCard.timestamp).toISOString()}`);
           } else {
             spin.fail('Agent not found');
           }
         } else if (options.capability || options.query) {
-          // Semantic search
           const query: any = {
             limit: parseInt(options.limit, 10),
           };
@@ -91,9 +105,7 @@ export function registerDiscoverCommand(program: Command): void {
           }
 
           if (options.minTrust) {
-            query.filters = {
-              minTrustScore: parseFloat(options.minTrust),
-            };
+            query.filters = { minTrustScore: parseFloat(options.minTrust) };
           }
 
           if (options.language) {
@@ -101,7 +113,7 @@ export function registerDiscoverCommand(program: Command): void {
             query.filters.language = options.language;
           }
 
-          const cards = await dht.searchSemantic(query);
+          const cards = await relayIndex.searchSemantic(query);
 
           spin.succeed(`Found ${cards.length} agents`);
 
@@ -133,7 +145,6 @@ export function registerDiscoverCommand(program: Command): void {
             console.log();
             console.log(table.toString());
 
-            // Show detailed info for first result if query was used
             if (options.query && cards.length > 0) {
               const card = cards[0];
               console.log();
@@ -156,10 +167,9 @@ export function registerDiscoverCommand(program: Command): void {
           info('Usage: hw1 discover --did <did>');
           info('       hw1 discover --capability <capability>');
           info('       hw1 discover --query "translate Japanese"');
-          info('       hw1 discover --query "code review" --min-trust 0.8');
         }
 
-        await node.stop();
+        await relayClient.stop();
       } catch (err) {
         error(`Failed to discover: ${(err as Error).message}`);
         process.exit(1);

package/src/commands/identity.ts

@@ -6,10 +6,9 @@ export function registerIdentityCommand(program: Command): void {
   program
     .command('identity')
     .description('Show current identity information')
-    .action(async () => {
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
       try {
-        printHeader('Clawiverse Identity');
-
         const identity = getIdentity();
         const card = getAgentCard();
 
@@ -18,6 +17,16 @@ export function registerIdentityCommand(program: Command): void {
           process.exit(1);
         }
 
+        if (options.format === 'json') {
+          console.log(JSON.stringify({
+            did: identity.did,
+            publicKey: identity.publicKey,
+            agentCard: card || null,
+          }, null, 2));
+          return;
+        }
+
+        printHeader('Clawiverse Identity');
         printKeyValue('DID', identity.did);
         printKeyValue('Public Key', identity.publicKey.substring(0, 16) + '...');
 

package/src/commands/inbox.ts

@@ -0,0 +1,222 @@
+/**
+ * Inbox Command - CVP-0010 §2.3
+ *
+ * hw1 inbox                    - List messages (newest first)
+ * hw1 inbox --unread           - Only unread
+ * hw1 inbox read <id>          - Show full message
+ * hw1 inbox reply <id>         - Reply to a message
+ * hw1 inbox delete <id>        - Delete a message
+ */
+
+import { Command } from 'commander';
+import { DaemonClient } from '../daemon/client.js';
+import { createLogger } from '@highway1/core';
+
+const logger = createLogger('cli:inbox');
+
+function shortDid(did: string): string {
+  if (did.startsWith('did:clawiverse:')) return did.slice(15, 29) + '…';
+  if (did.length > 30) return did.slice(0, 14) + '…' + did.slice(-8);
+  return did;
+}
+
+function formatAge(ts: number): string {
+  const secs = Math.floor((Date.now() - ts) / 1000);
+  if (secs < 60) return `${secs}s ago`;
+  if (secs < 3600) return `${Math.floor(secs / 60)}m ago`;
+  if (secs < 86400) return `${Math.floor(secs / 3600)}h ago`;
+  return `${Math.floor(secs / 86400)}d ago`;
+}
+
+export function createInboxCommand(): Command {
+  const inbox = new Command('inbox')
+    .description('Manage your message inbox (CVP-0010 §2.3)')
+    .option('--unread', 'Show only unread messages')
+    .option('--from <did>', 'Filter by sender DID')
+    .option('--protocol <protocol>', 'Filter by protocol')
+    .option('--limit <n>', 'Max messages to show', '50')
+    .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);
+      }
+
+      try {
+        const filter: any = {};
+        if (options.unread) filter.unreadOnly = true;
+        if (options.from) filter.fromDid = options.from;
+        if (options.protocol) filter.protocol = options.protocol;
+
+        const page = await client.send('inbox', {
+          filter,
+          pagination: { limit: parseInt(options.limit, 10) },
+        });
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify(page, null, 2));
+          return;
+        }
+
+        const unreadCount = page.messages.filter((m: any) => !m.readAt).length;
+        console.log(`\nInbox (${page.total} total, ${unreadCount} unread)\n`);
+
+        if (page.messages.length === 0) {
+          console.log('  No messages.');
+          return;
+        }
+
+        for (const msg of page.messages) {
+          const unread = !msg.readAt ? '●' : ' ';
+          const from = shortDid(msg.envelope.from);
+          const age = formatAge(msg.receivedAt ?? msg.envelope.timestamp);
+          const id = msg.envelope.id.slice(-8);
+          const proto = msg.envelope.protocol ?? '';
+          const text = typeof msg.envelope.payload === 'object' && msg.envelope.payload !== null
+            ? (msg.envelope.payload as any).text ?? (msg.envelope.payload as any).message ?? ''
+            : String(msg.envelope.payload ?? '');
+
+          console.log(`${unread} [${id}] ${from}  ${age}  ${proto}`);
+          if (text) {
+            const preview = String(text).slice(0, 72);
+            console.log(`    ${preview}${text.length > 72 ? '…' : ''}`);
+          }
+        }
+        console.log();
+      } catch (error) {
+        logger.error('Inbox list failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // hw1 inbox read <id>
+  inbox
+    .command('read <id>')
+    .description('Show full message')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (id: string, options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        // Support short IDs: find by suffix
+        let msg = await client.send('get_message', { id }).catch(() => null);
+
+        if (!msg) {
+          // Try to find by short suffix via inbox list
+          const page = await client.send('inbox', { filter: {}, pagination: { limit: 200 } });
+          const match = page.messages.find((m: any) => m.envelope.id.endsWith(id));
+          if (match) {
+            msg = await client.send('get_message', { id: match.envelope.id });
+          }
+        }
+
+        if (!msg) {
+          console.error(`Message not found: ${id}`);
+          process.exit(1);
+        }
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify(msg, null, 2));
+        } else {
+          console.log('\n' + '─'.repeat(60));
+          console.log(`ID:        ${msg.envelope.id}`);
+          console.log(`From:      ${msg.envelope.from}`);
+          console.log(`Protocol:  ${msg.envelope.protocol}`);
+          console.log(`Type:      ${msg.envelope.type}`);
+          console.log(`Received:  ${new Date(msg.receivedAt ?? msg.envelope.timestamp).toLocaleString()}`);
+          if (msg.trustScore != null) {
+            console.log(`Trust:     ${(msg.trustScore * 100).toFixed(0)}%`);
+          }
+          console.log('─'.repeat(60));
+          console.log(JSON.stringify(msg.envelope.payload, null, 2));
+          console.log();
+        }
+
+        // Mark as read
+        await client.send('mark_read', { id: msg.envelope.id });
+      } catch (error) {
+        logger.error('Read message failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // hw1 inbox reply <id> --message "..."
+  inbox
+    .command('reply <id>')
+    .description('Reply to a message')
+    .requiredOption('-m, --message <text>', 'Reply text')
+    .option('--protocol <protocol>', 'Protocol to use', 'clawiverse/chat/1.0.0')
+    .action(async (id: string, options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        // Resolve message
+        let msg = await client.send('get_message', { id }).catch(() => null);
+        if (!msg) {
+          const page = await client.send('inbox', { filter: {}, pagination: { limit: 200 } });
+          const match = page.messages.find((m: any) => m.envelope.id.endsWith(id));
+          if (match) msg = await client.send('get_message', { id: match.envelope.id });
+        }
+
+        if (!msg) {
+          console.error(`Message not found: ${id}`);
+          process.exit(1);
+        }
+
+        const result = await client.send('send', {
+          to: msg.envelope.from,
+          protocol: options.protocol,
+          payload: { text: options.message, replyTo: msg.envelope.id },
+          type: 'response',
+        });
+
+        console.log(`Reply sent (${result.id.slice(-8)})`);
+      } catch (error) {
+        logger.error('Reply failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // hw1 inbox delete <id>
+  inbox
+    .command('delete <id>')
+    .description('Delete a message')
+    .action(async (id: string) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        // Resolve short ID
+        let fullId = id;
+        if (id.length < 36) {
+          const page = await client.send('inbox', { filter: {}, pagination: { limit: 200 } });
+          const match = page.messages.find((m: any) => m.envelope.id.endsWith(id));
+          if (match) fullId = match.envelope.id;
+        }
+
+        await client.send('delete_message', { id: fullId });
+        console.log(`Deleted message ${id}`);
+      } catch (error) {
+        logger.error('Delete failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  return inbox;
+}