agenticpool 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenticpool",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "CLI for AgenticPool - Social Network for Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,6 +29,8 @@
   "author": "AgenticPool",
   "license": "MIT",
   "dependencies": {
+    "@agenticpool/datamodel": "file:../datamodel",
+    "@toon-format/toon": "^1.0.0",
     "axios": "^1.6.5",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
@@ -38,7 +40,7 @@
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.11.0",
-    "firebase-admin": "^13.7.0",
+    "firebase-admin": "^10.3.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",

package/src/auth/AuthHelper.ts

@@ -12,7 +12,7 @@ export interface AuthResult {
 }
 
 export class AuthHelper {
-  static async ensureAuthenticated(networkId: string): Promise<AuthResult> {
+  static async ensureAuthenticated(networkId: string, reason?: string): Promise<AuthResult> {
     const config = await configManager.getGlobalConfig();
     const client = new ApiClient(config.apiUrl);
     client.setFormat(config.defaultFormat);
@@ -23,16 +23,30 @@ export class AuthHelper {
       const bufferTime = 5 * 60 * 1000;
       if (Date.now() < (existingCreds.expiresAt - bufferTime)) {
         client.setAuthToken(existingCreds.jwt);
+        if (reason) {
+          try {
+            await client.post('/v1/auth/login', {
+              networkId,
+              publicToken: existingCreds.publicToken,
+              privateKey: existingCreds.privateKey,
+              reason
+            });
+          } catch (e) {
+            // Ignore background reason update failures
+          }
+        }
         return { client, credentials: existingCreds, isNewUser: false };
       }
     }
 
     if (existingCreds && existingCreds.privateKey) {
+      console.log(chalk.gray(`  Attempting login for ${networkId}...`));
       try {
         const response = await client.post<{ jwt: string; expiresAt: number; publicToken: string }>('/v1/auth/login', {
           networkId,
           publicToken: existingCreds.publicToken,
-          privateKey: existingCreds.privateKey
+          privateKey: existingCreds.privateKey,
+          reason
         });
 
         if (response.success && response.data) {
@@ -52,6 +66,7 @@ export class AuthHelper {
       }
     }
 
+    console.log(chalk.gray('  Generating new identity keys...'));
     const keysResponse = await client.get<{ publicToken: string; privateKey: string }>('/v1/auth/generate-keys');
     
     if (!keysResponse.success || !keysResponse.data) {
@@ -59,11 +74,13 @@ export class AuthHelper {
     }
 
     const keys = keysResponse.data;
+    console.log(chalk.gray(`  Registering in network ${networkId}...`));
 
     const registerResponse = await client.post<{ member: any; tokens: { jwt: string; expiresAt: number; publicToken: string } }>('/v1/auth/register', {
       networkId,
       publicToken: keys.publicToken,
-      privateKey: keys.privateKey
+      privateKey: keys.privateKey,
+      reason
     });
 
     if (registerResponse.success && registerResponse.data) {
@@ -77,9 +94,7 @@ export class AuthHelper {
       await configManager.saveCredentials(networkId, newCreds);
       client.setAuthToken(registerResponse.data.tokens.jwt);
 
-      console.log(chalk.green('✓ Auto-registered in network:'), networkId);
-      console.log(chalk.gray('Public Token:'), keys.publicToken);
-
+      console.log(chalk.green(`  ✓ Auto-registered in network: ${networkId}`));
       return { client, credentials: newCreds, isNewUser: true };
     }
 
@@ -93,8 +108,8 @@ export class AuthHelper {
     return client;
   }
 
-  static async getAuthenticatedClient(networkId: string): Promise<ApiClient> {
-    const result = await this.ensureAuthenticated(networkId);
+  static async getAuthenticatedClient(networkId: string, reason?: string): Promise<ApiClient> {
+    const result = await this.ensureAuthenticated(networkId, reason);
     return result.client;
   }
 

package/src/commands/auth.ts

@@ -12,25 +12,33 @@ export function registerAuthCommands(program: Command): void {
     .description('Connect to a network (auto-register if needed)')
     .argument('<networkId>', 'Network ID')
     .option('-k, --private-key <key>', 'Existing private key (optional)')
+    .option('-r, --reason <text>', 'Reason for joining this network (for local records)')
     .action(async (networkId, options) => {
       try {
-        const result = await AuthHelper.ensureAuthenticated(networkId);
+        console.log(chalk.cyan(`Connecting to network: ${networkId}...`));
+        const result = await AuthHelper.ensureAuthenticated(networkId, options.reason);
         
         if (result.isNewUser) {
           console.log(chalk.green('✓ Registered and connected!'));
         } else {
           console.log(chalk.green('✓ Connected!'));
         }
+
+        // Record the network and reason locally
+        await configManager.addRegisteredNetwork(networkId, options.reason);
         
         console.log(chalk.gray('Network:'), networkId);
         console.log(chalk.gray('Public Token:'), result.credentials.publicToken);
+        if (options.reason) {
+          console.log(chalk.gray('Reason:'), options.reason);
+        }
         
         if (result.credentials.expiresAt) {
           const expires = new Date(result.credentials.expiresAt);
           console.log(chalk.gray('Token expires:'), expires.toISOString());
         }
       } catch (error) {
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        console.error(chalk.red('\nError:'), error instanceof Error ? error.message : 'Unknown error');
       }
     });
 
@@ -48,14 +56,15 @@ export function registerAuthCommands(program: Command): void {
     .description('Generate a new public token and private key pair')
     .action(async () => {
       try {
+        console.log(chalk.cyan('Requesting new key pair from server...'));
         const client = await AuthHelper.getApiClient();
         const response = await client.get<{ publicToken: string; privateKey: string }>('/v1/auth/generate-keys');
 
         if (response.success && response.data) {
-          console.log(chalk.green('Generated keys:'));
-          console.log(chalk.cyan('Public Token:'), response.data.publicToken);
-          console.log(chalk.cyan('Private Key:'), response.data.privateKey);
-          console.log(chalk.yellow('\n⚠️  Save your private key securely. It will not be shown again.'));
+          console.log(chalk.green('✓ Keys generated successfully!\n'));
+          console.log(chalk.cyan.bold('Public Token:'), chalk.white(response.data.publicToken));
+          console.log(chalk.cyan.bold('Private Key: '), chalk.yellow(response.data.privateKey));
+          console.log(chalk.red('\n⚠️  CRITICAL: Save your private key now. It is your ONLY proof of identity.'));
         } else {
           console.error(chalk.red('Error:'), response.error?.message || 'Failed to generate keys');
         }
@@ -70,13 +79,16 @@ export function registerAuthCommands(program: Command): void {
     .requiredOption('-n, --network <id>', 'Network ID')
     .requiredOption('-p, --public-token <token>', 'Your public token')
     .requiredOption('-k, --private-key <key>', 'Your private key')
+    .option('-r, --reason <text>', 'Reason for registering')
     .action(async (options) => {
       try {
+        console.log(chalk.cyan(`Registering in ${options.network}...`));
         const client = await AuthHelper.getApiClient();
         const response = await client.post('/v1/auth/register', {
           networkId: options.network,
           publicToken: options.publicToken,
-          privateKey: options.privateKey
+          privateKey: options.privateKey,
+          reason: options.reason
         });
 
         if (response.success && response.data) {
@@ -87,9 +99,10 @@ export function registerAuthCommands(program: Command): void {
             jwt: data.tokens.jwt,
             expiresAt: data.tokens.expiresAt
           });
+          await configManager.addRegisteredNetwork(options.network, options.reason);
 
           console.log(chalk.green('✓ Registered successfully!'));
-          console.log(chalk.gray('Credentials saved for network:'), options.network);
+          console.log(chalk.gray('Credentials saved locally.'));
         } else {
           console.error(chalk.red('Error:'), response.error?.message || 'Registration failed');
         }
@@ -104,13 +117,16 @@ export function registerAuthCommands(program: Command): void {
     .requiredOption('-n, --network <id>', 'Network ID')
     .requiredOption('-p, --public-token <token>', 'Your public token')
     .requiredOption('-k, --private-key <key>', 'Your private key')
+    .option('-r, --reason <text>', 'Reason for login')
     .action(async (options) => {
       try {
+        console.log(chalk.cyan(`Logging in to ${options.network}...`));
         const client = await AuthHelper.getApiClient();
         const response = await client.post('/v1/auth/login', {
           networkId: options.network,
           publicToken: options.publicToken,
-          privateKey: options.privateKey
+          privateKey: options.privateKey,
+          reason: options.reason
         });
 
         if (response.success && response.data) {
@@ -121,9 +137,10 @@ export function registerAuthCommands(program: Command): void {
             jwt: tokens.jwt,
             expiresAt: tokens.expiresAt
           });
+          await configManager.addRegisteredNetwork(options.network, options.reason);
 
           console.log(chalk.green('✓ Logged in successfully!'));
-          console.log(chalk.gray('Token expires at:'), new Date(tokens.expiresAt).toISOString());
+          console.log(chalk.gray('New JWT session established.'));
         } else {
           console.error(chalk.red('Error:'), response.error?.message || 'Login failed');
         }

package/src/commands/identities.ts

@@ -1,6 +1,7 @@
 import { Command } from 'commander';
 import { ApiClient } from '../api';
 import { configManager } from '../config';
+import { encode } from '@agenticpool/datamodel';
 import chalk from 'chalk';
 
 const DEFAULT_HUMANS_API_URL = 'https://us-central1-agenticpool-humans.cloudfunctions.net/api';
@@ -14,11 +15,13 @@ export function registerIdentityCommands(program: Command): void {
     .requiredOption('-n, --network <id>', 'Network ID')
     .requiredOption('-p, --public-token <token>', 'Your agent public token on this network')
     .requiredOption('-d, --description <text>', 'Agent description for this identity')
+    .option('--format <format>', 'Output format: toon, json, text', 'toon')
     .action(async (options) => {
       try {
         const { client, humanUid } = await getHumanAuthenticatedClient();
+        client.setFormat(options.format === 'json' ? 'json' : 'toon');
 
-        const response = await client.post('/v1/identities', {
+        const response = await client.post<any>('/v1/identities', {
           humanUid,
           networkId: options.network,
           publicToken: options.publicToken,
@@ -26,11 +29,17 @@ export function registerIdentityCommands(program: Command): void {
         });
 
         if (response.success && response.data) {
-          const identity = response.data as any;
-          console.log(chalk.green('✓ Identity registered!'));
-          console.log(chalk.gray('ID:'), identity.id);
-          console.log(chalk.gray('Network:'), options.network);
-          console.log(chalk.gray('Public Token:'), options.publicToken);
+          if (options.format === 'json') {
+            console.log(JSON.stringify(response.data, null, 2));
+          } else if (options.format === 'toon') {
+            console.log(encode(response.data));
+          } else {
+            const identity = response.data;
+            console.log(chalk.green('✓ Identity registered!'));
+            console.log(chalk.gray('ID:'), identity.id);
+            console.log(chalk.gray('Network:'), options.network);
+            console.log(chalk.gray('Public Token:'), options.publicToken);
+          }
         } else {
           console.error(chalk.red('Error:'), response.error?.message || 'Failed to register identity');
         }
@@ -42,30 +51,38 @@ export function registerIdentityCommands(program: Command): void {
   identities
     .command('list')
     .description('List your registered identities')
-    .action(async () => {
+    .option('--format <format>', 'Output format: toon, json, text', 'toon')
+    .action(async (options) => {
       try {
         const { client, humanUid } = await getHumanAuthenticatedClient();
+        client.setFormat(options.format === 'json' ? 'json' : 'toon');
 
         const response = await client.get<any[]>('/v1/identities');
 
         if (response.success && response.data) {
-          if (response.data.length === 0) {
-            console.log(chalk.yellow('No identities registered.'));
-            return;
-          }
-
-          console.log(chalk.green.bold(`\nYour Identities (${response.data.length}):\n`));
-
-          response.data.forEach((identity: any) => {
-            console.log(chalk.cyan.bold(identity.networkId));
-            console.log(chalk.gray('  ID:'), identity.id);
-            console.log(chalk.gray('  Public Token:'), identity.publicToken);
-            console.log(chalk.gray('  Description:'), identity.agentDescription || '(none)');
-            if (identity.addedAt) {
-              console.log(chalk.gray('  Added:'), formatTimestamp(identity.addedAt));
+          if (options.format === 'json') {
+            console.log(JSON.stringify(response.data, null, 2));
+          } else if (options.format === 'toon') {
+            console.log(encode(response.data));
+          } else {
+            if (response.data.length === 0) {
+              console.log(chalk.yellow('No identities registered.'));
+              return;
             }
-            console.log();
-          });
+
+            console.log(chalk.green.bold(`\nYour Identities (${response.data.length}):\n`));
+
+            response.data.forEach((identity: any) => {
+              console.log(chalk.cyan.bold(identity.networkId));
+              console.log(chalk.gray('  ID:'), identity.id);
+              console.log(chalk.gray('  Public Token:'), identity.publicToken);
+              console.log(chalk.gray('  Description:'), identity.agentDescription || '(none)');
+              if (identity.addedAt) {
+                console.log(chalk.gray('  Added:'), formatTimestamp(identity.addedAt));
+              }
+              console.log();
+            });
+          }
         } else {
           console.error(chalk.red('Error:'), response.error?.message || 'Failed to list identities');
         }