@highway1/cli 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {

package/src/commands/join.ts

@@ -16,19 +16,28 @@ export function registerJoinCommand(program: Command): void {
     .command('join')
     .description('Join the Clawiverse network')
     .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
+    .option('--json', 'Output messages as JSON (for agent automation)')
     .action(async (options) => {
       try {
-        printHeader('Join Clawiverse Network');
+        const jsonMode = options.json;
+
+        if (!jsonMode) {
+          printHeader('Join Clawiverse Network');
+        }
 
         const identity = getIdentity();
         const card = getAgentCard();
 
         if (!identity || !card) {
-          error('No identity found. Run "hw1 init" first.');
+          if (jsonMode) {
+            console.log(JSON.stringify({ error: 'No identity found. Run "hw1 init" first.' }));
+          } else {
+            error('No identity found. Run "hw1 init" first.');
+          }
           process.exit(1);
         }
 
-        const spin = spinner('Starting libp2p node...');
+        const spin = jsonMode ? null : spinner('Starting libp2p node...');
 
         const keyPair = importKeyPair({
           publicKey: identity.publicKey,
@@ -45,14 +54,22 @@ export function registerJoinCommand(program: Command): void {
 
         await node.start();
 
-        spin.succeed('Node started successfully!');
-
-        info(`Peer ID: ${node.getPeerId()}`);
-        info(`DID: ${identity.did}`);
-        info(`Listening on: ${node.getMultiaddrs().join(', ')}`);
+        if (spin) {
+          spin.succeed('Node started successfully!');
+          info(`Peer ID: ${node.getPeerId()}`);
+          info(`DID: ${identity.did}`);
+          info(`Listening on: ${node.getMultiaddrs().join(', ')}`);
+        } else {
+          console.log(JSON.stringify({
+            event: 'node_started',
+            peerId: node.getPeerId(),
+            did: identity.did,
+            multiaddrs: node.getMultiaddrs(),
+          }));
+        }
 
         // Wait for bootstrap peer connection before publishing to DHT
-        const connectSpin = spinner('Connecting to bootstrap peers...');
+        const connectSpin = jsonMode ? null : spinner('Connecting to bootstrap peers...');
         await new Promise<void>((resolve) => {
           const timeout = setTimeout(resolve, 10000);
           node.libp2p.addEventListener('peer:connect', () => {
@@ -60,10 +77,12 @@ export function registerJoinCommand(program: Command): void {
             setTimeout(resolve, 500);
           }, { once: true });
         });
-        connectSpin.succeed('Connected to network!');
+        if (connectSpin) {
+          connectSpin.succeed('Connected to network!');
+        }
 
         // Publish Agent Card with peerId and multiaddrs so others can dial us
-        const cardSpin = spinner('Publishing Agent Card to DHT...');
+        const cardSpin = jsonMode ? null : spinner('Publishing Agent Card to DHT...');
 
         // Include circuit relay addresses so nodes behind NAT can be reached
         const directAddrs = node.getMultiaddrs();
@@ -89,7 +108,11 @@ export function registerJoinCommand(program: Command): void {
         const dht = createDHTOperations(node.libp2p);
         await dht.publishAgentCard(signedCard);
 
-        cardSpin.succeed('Agent Card published!');
+        if (cardSpin) {
+          cardSpin.succeed('Agent Card published!');
+        } else {
+          console.log(JSON.stringify({ event: 'agent_card_published' }));
+        }
 
         // Register message handlers for incoming messages
         const router = createMessageRouter(
@@ -101,17 +124,34 @@ export function registerJoinCommand(program: Command): void {
         // Generic message handler that accepts any protocol
         const messageHandler = async (envelope: any) => {
           const payload = envelope.payload as Record<string, unknown>;
-          console.log();
-          success(`>>> Received message from ${envelope.from}`);
-          info(`    Message ID: ${envelope.id}`);
-          info(`    Protocol:   ${envelope.protocol}`);
-          info(`    Type:       ${envelope.type}`);
-          info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
-          console.log();
+
+          if (jsonMode) {
+            // Output as JSON for agent consumption
+            console.log(JSON.stringify({
+              event: 'message_received',
+              id: envelope.id,
+              from: envelope.from,
+              to: envelope.to,
+              protocol: envelope.protocol,
+              type: envelope.type,
+              payload,
+              timestamp: Date.now(),
+            }));
+          } else {
+            console.log();
+            success(`>>> Received message from ${envelope.from}`);
+            info(`    Message ID: ${envelope.id}`);
+            info(`    Protocol:   ${envelope.protocol}`);
+            info(`    Type:       ${envelope.type}`);
+            info(`    Payload:    ${JSON.stringify(payload, null, 2)}`);
+            console.log();
+          }
 
           // If this is a request, send back a simple acknowledgment response
           if (envelope.type === 'request') {
-            info('    Sending acknowledgment response...');
+            if (!jsonMode) {
+              info('    Sending acknowledgment response...');
+            }
 
             const { createEnvelope, signEnvelope, sign } = await import('@highway1/core');
             const identity = getIdentity();
@@ -153,23 +193,40 @@ export function registerJoinCommand(program: Command): void {
 
         await router.start();
 
-        console.log();
-        success('Successfully joined the Clawiverse network!');
-        info('Listening for incoming messages...');
-        info('Press Ctrl+C to stop');
-
-        process.on('SIGINT', async () => {
+        if (!jsonMode) {
           console.log();
-          const stopSpin = spinner('Stopping node...');
-          await router.stop();
-          await node.stop();
-          stopSpin.succeed('Node stopped');
+          success('Successfully joined the Clawiverse network!');
+          info('Listening for incoming messages...');
+          info('Press Ctrl+C to stop');
+        } else {
+          console.log(JSON.stringify({ event: 'ready', status: 'listening' }));
+        }
+
+        const shutdown = async () => {
+          if (!jsonMode) {
+            console.log();
+            const stopSpin = spinner('Stopping node...');
+            await router.stop();
+            await node.stop();
+            stopSpin.succeed('Node stopped');
+          } else {
+            await router.stop();
+            await node.stop();
+            console.log(JSON.stringify({ event: 'shutdown', status: 'stopped' }));
+          }
           process.exit(0);
-        });
+        };
+
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
 
         await new Promise(() => {});
       } catch (err) {
-        error(`Failed to join network: ${(err as Error).message}`);
+        if (options.json) {
+          console.log(JSON.stringify({ error: (err as Error).message }));
+        } else {
+          error(`Failed to join network: ${(err as Error).message}`);
+        }
         process.exit(1);
       }
     });