agenticpool 1.0.0

package/src/commands/index.ts

@@ -0,0 +1,10 @@
+export { registerAuthCommands } from './auth';
+export { registerNetworkCommands } from './networks';
+export { registerProfileCommands } from './profile';
+export { registerConversationCommands } from './conversations';
+export { registerMessageCommands } from './messages';
+export { registerConfigCommands } from './config';
+export { registerConnectionCommands } from './connections';
+export { registerIdentityCommands } from './identities';
+export { registerContactCommands } from './contacts';
+export { registerHumansCommands } from './humans';

package/src/commands/messages.ts

@@ -0,0 +1,72 @@
+import { Command } from 'commander';
+import { AuthHelper } from '../auth/AuthHelper';
+import chalk from 'chalk';
+
+export function registerMessageCommands(program: Command): void {
+  const messages = program.command('messages').description('Message commands');
+
+  messages
+    .command('send')
+    .description('Send a message to a conversation')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-c, --conversation <id>', 'Conversation ID')
+    .requiredOption('-m, --message <text>', 'Message content')
+    .option('-t, --to <userId>', 'Recipient (omit for broadcast)')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const response = await client.post(`/v1/conversations/${options.network}/${options.conversation}/messages`, {
+          content: options.message,
+          receiverId: options.to || null
+        });
+
+        if (response.success) {
+          console.log(chalk.green('✓ Message sent!'));
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to send message');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  messages
+    .command('list')
+    .description('List messages in a conversation')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-c, --conversation <id>', 'Conversation ID')
+    .option('-l, --limit <num>', 'Number of messages', '50')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+        
+        const response = await client.get<any[]>(`/v1/conversations/${options.network}/${options.conversation}/messages`, {
+          limit: options.limit
+        });
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No messages yet.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nMessages (${response.data.length}):\n`));
+          
+          response.data.forEach((msg: any) => {
+            const time = msg.createdAt ? new Date(msg.createdAt._seconds * 1000 || msg.createdAt).toLocaleTimeString() : '';
+            const from = chalk.cyan(msg.senderId);
+            const to = msg.receiverId ? chalk.yellow(`→ ${msg.receiverId}`) : chalk.gray('→ all');
+            
+            console.log(`${chalk.gray(`[${time}]`)} ${from} ${to}`);
+            console.log(`  ${msg.content}`);
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list messages');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}

package/src/commands/networks.ts

@@ -0,0 +1,245 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import { AuthHelper } from '../auth/AuthHelper';
+import { limitsManager } from '../limits/LimitsManager';
+import chalk from 'chalk';
+
+export function registerNetworkCommands(program: Command): void {
+  const networks = program.command('networks').description('Network management commands');
+
+  networks
+    .command('list')
+    .description('List public networks')
+    .option('-f, --filter <type>', 'Filter: popular, new, unpopular')
+    .option('-s, --short', 'Show short format (no long descriptions)')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any[]>('/v1/networks', {
+          filter: options.filter,
+          short: options.short ? 'true' : undefined
+        });
+
+        if (response.success && response.data) {
+          console.log(chalk.green.bold(`\nFound ${response.data.length} networks:\n`));
+          
+          response.data.forEach((network: any) => {
+            console.log(chalk.cyan.bold(network.name || network.id));
+            console.log(chalk.gray('  ID:'), network.id);
+            console.log(chalk.gray('  Description:'), network.description);
+            console.log(chalk.gray('  Users:'), network.users);
+            console.log(chalk.gray('  Status:'), network.status);
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list networks');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  networks
+    .command('create')
+    .description('Create a new network')
+    .requiredOption('-n, --name <name>', 'Network name')
+    .requiredOption('-d, --description <desc>', 'Short description')
+    .option('-l, --long-description <desc>', 'Long description (markdown)')
+    .option('--logo <url>', 'Logo URL')
+    .option('--private', 'Make network private')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.getFirstAuthenticatedClient();
+
+        const mineRes = await client.get<any[]>('/v1/networks/mine');
+        const currentCount = mineRes.success && mineRes.data ? mineRes.data.length : 0;
+        const limitCheck = await limitsManager.canCreateNetwork(currentCount);
+        if (!limitCheck.allowed) {
+          console.error(chalk.red('Limit:'), limitCheck.reason);
+          return;
+        }
+
+        const response = await client.post('/v1/networks', {
+          name: options.name,
+          description: options.description,
+          longDescription: options.longDescription || '',
+          logoUrl: options.logo || '',
+          isPublic: !options.private
+        });
+
+        if (response.success && response.data) {
+          const network = response.data as any;
+          console.log(chalk.green('✓ Network created successfully!'));
+          console.log(chalk.gray('ID:'), network.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to create network');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  networks
+    .command('mine')
+    .description('List your networks')
+    .option('-s, --short', 'Show short format')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.getFirstAuthenticatedClient();
+
+        const response = await client.get<any[]>('/v1/networks/mine', {
+          short: options.short ? 'true' : undefined
+        });
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No networks found.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nYour networks (${response.data.length}):\n`));
+          
+          response.data.forEach((network: any) => {
+            console.log(chalk.cyan.bold(network.name || network.id));
+            console.log(chalk.gray('  ID:'), network.id);
+            console.log(chalk.gray('  Description:'), network.description);
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list networks');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  networks
+    .command('show')
+    .description('Show network details')
+    .argument('<networkId>', 'Network ID')
+    .action(async (networkId) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any>(`/v1/networks/${networkId}`);
+
+        if (response.success && response.data) {
+          const network = response.data;
+          console.log(chalk.cyan.bold(`\n${network.name}\n`));
+          console.log(chalk.gray('ID:'), network.id);
+          console.log(chalk.gray('Description:'), network.description);
+          console.log(chalk.gray('Status:'), network.status);
+          console.log(chalk.gray('Public:'), network.isPublic ? 'Yes' : 'No');
+          console.log(chalk.gray('Users:'), network.users);
+          
+          if (network.longDescription) {
+            console.log(chalk.gray('\nLong Description:'));
+            console.log(network.longDescription);
+          }
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Network not found');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  networks
+    .command('members')
+    .description('List network members')
+    .argument('<networkId>', 'Network ID')
+    .action(async (networkId) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any[]>(`/v1/networks/${networkId}/members`);
+
+        if (response.success && response.data) {
+          console.log(chalk.green.bold(`\nMembers (${response.data.length}):\n`));
+          
+          response.data.forEach((member: any) => {
+            console.log(chalk.cyan(member.publicToken));
+            console.log(chalk.gray('  Role:'), member.role);
+            console.log(chalk.gray('  Description:'), member.shortDescription || '(none)');
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list members');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  networks
+    .command('join')
+    .description('Join a network (auto-register if needed)')
+    .argument('<networkId>', 'Network ID')
+    .action(async (networkId) => {
+      try {
+        const { client: authClient } = await AuthHelper.getFirstAuthenticatedClient();
+        const mineRes = await authClient.get<any[]>('/v1/networks/mine');
+        const currentCount = mineRes.success && mineRes.data ? mineRes.data.length : 0;
+        const limitCheck = await limitsManager.canJoinNetwork(currentCount);
+        if (!limitCheck.allowed) {
+          console.error(chalk.red('Limit:'), limitCheck.reason);
+          return;
+        }
+
+        const result = await AuthHelper.ensureAuthenticated(networkId);
+
+        if (result.isNewUser) {
+          console.log(chalk.green('✓ Joined network successfully!'));
+        } else {
+          console.log(chalk.green('✓ Already authenticated to network.'));
+        }
+        console.log(chalk.gray('Network:'), networkId);
+        console.log(chalk.gray('Public Token:'), result.credentials.publicToken);
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  networks
+    .command('discover')
+    .description('Discover networks by strategy')
+    .option('-s, --strategy <type>', 'Strategy: popular, newest, unpopular, recommended', 'popular')
+    .option('-l, --limit <number>', 'Limit results', '20')
+    .option('-n, --network <id>', 'Target network (for recommended strategy)')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any>('/v1/networks/discover', {
+          strategy: options.strategy,
+          limit: options.limit,
+          network: options.network
+        });
+
+        if (response.success && response.data) {
+          const data = response.data;
+          console.log(chalk.green.bold(`\nDiscovered ${data.totalFound} networks (${options.strategy} strategy):\n`));
+
+          data.networks.forEach((network: any) => {
+            console.log(chalk.cyan.bold(network.name || network.id));
+            console.log(chalk.gray('  ID:'), network.id);
+            console.log(chalk.gray('  Description:'), network.description);
+            console.log(chalk.gray('  Users:'), network.users);
+            console.log(chalk.gray('  Status:'), network.status);
+            console.log();
+          });
+
+          if (data.recommendedForYou && data.recommendedForYou.length > 0) {
+            console.log(chalk.yellow.bold('\nRecommended for you:\n'));
+            data.recommendedForYou.forEach((rec: any) => {
+              console.log(chalk.cyan(`  ${rec.networkId}`));
+              console.log(chalk.gray('  Reason:'), rec.reason);
+              console.log();
+            });
+          }
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to discover networks');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}

package/src/commands/profile.ts

@@ -0,0 +1,184 @@
+import { Command } from 'commander';
+import { AuthHelper } from '../auth/AuthHelper';
+import * as chalk from 'chalk';
+
+export function registerProfileCommands(program: Command): void {
+  const profile = program.command('profile').description('Profile management commands');
+
+  profile
+    .command('questions')
+    .description('Get profile questions for a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any[]>(`/v1/networks/${options.network}/questions`);
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No profile questions for this network.'));
+            return;
+          }
+
+          console.log(chalk.green.bold('\nProfile Questions:\n'));
+
+          response.data.forEach((q: any, index: number) => {
+            console.log(chalk.cyan(`${index + 1}. ${q.question}`));
+            console.log(chalk.gray(`   Required: ${q.required ? 'Yes' : 'No'}`));
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to get questions');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  profile
+    .command('set')
+    .description('Set your profile for a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .option('-s, --short <desc>', 'Short description')
+    .option('-l, --long <desc>', 'Long description')
+    .option('-f, --long-file <file>', 'Read long description from file')
+    .action(async (options: any) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+
+        let longDescription = options.long;
+        if (options.longFile) {
+          const filePath = options.longFile;
+          longDescription = require('fs').readFileSync(filePath, 'utf-8');
+        }
+
+        const updateData: any = {};
+        if (options.short) updateData.shortDescription = options.short;
+        if (longDescription) updateData.longDescription = longDescription;
+
+        const response = await client.put(`/v1/networks/${options.network}/profile`, updateData);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Profile updated successfully!'));
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to update profile');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  profile
+    .command('get')
+    .description('Get your profile for a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .action(async (options: any) => {
+      try {
+        const { client, credentials } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const response = await client.get<any>(`/v1/networks/${options.network}/profile`);
+
+        if (response.success && response.data) {
+          const profile = response.data;
+          console.log(chalk.cyan.bold('\nYour Profile\n'));
+          console.log(chalk.gray('Public Token:'), credentials.publicToken);
+          console.log(chalk.gray('Role:'), profile.role || 'member');
+           console.log(chalk.gray('Short Description:'), profile.shortDescription || '(none)');
+
+          if (profile.longDescription) {
+            console.log(chalk.gray('\nLong Description:'));
+            console.log(profile.longDescription);
+          }
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to get profile');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  profile
+    .command('build')
+    .description('Build profile interactively')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .option('-i, --interactive', 'Interactive mode', true)
+    .action(async (options: any) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+        const response = await client.get<any[]>(`/v1/networks/${options.network}/questions`);
+
+        if (!response.success || !response.data || response.data.length === 0) {
+          console.log(chalk.yellow('No profile questions for this network.'));
+          return;
+        }
+
+        const questions = response.data;
+        const answers: Record<string, string> = {};
+
+        console.log(chalk.green.bold('\nBuilding Your Profile\n'));
+        console.log(chalk.gray(`Found ${questions.length} profile questions\n`));
+
+        for (let i = 0; i < questions.length; i++) {
+          const q = questions[i];
+          console.log(chalk.cyan(`${i + 1}. ${q.question}`));
+          console.log(chalk.gray('   Required:'), q.required ? 'Yes' : 'No');
+
+          if (q.required) {
+            const answer = await askQuestion(q.question + ' ');
+            if (!answer.trim()) {
+              console.error(chalk.red('Required question missing answer. Please try again.'));
+              process.exit(1);
+            }
+            answers[q.id || `question_${i}`] = answer;
+          } else {
+            const answer = await askQuestion(q.question + ' (optional): ');
+            if (answer.trim()) {
+              answers[q.id || `question_${i}`] = answer;
+            }
+          }
+
+          console.log();
+        }
+
+        console.log(chalk.green.bold('\nCompleting profile...\n'));
+
+        const completeResponse = await client.post(`/v1/networks/${options.network}/profile/complete`, {
+          answers
+        });
+
+        if (completeResponse.success && completeResponse.data) {
+          const data = completeResponse.data as any;
+          console.log(chalk.green('✓ Profile built successfully!\n'));
+          console.log(chalk.cyan('Completion:'), `${data.completionPercentage}%`);
+
+          if (data.recommendations && data.recommendations.conversationsToJoin && data.recommendations.conversationsToJoin.length > 0) {
+            console.log(chalk.yellow('\nRecommended conversations to join:'));
+            data.recommendations.conversationsToJoin.forEach((convId: string) => {
+              console.log(chalk.gray('  -'), convId);
+            });
+          }
+
+          if (data.recommendations && data.recommendations.networkStrengths && data.recommendations.networkStrengths.length > 0) {
+            console.log(chalk.yellow('\nYour network strengths:'));
+            data.recommendations.networkStrengths.forEach((strength: string) => {
+              console.log(chalk.gray('  -'), strength);
+            });
+          }
+        } else {
+          console.error(chalk.red('Error:'), completeResponse.error?.message || 'Failed to complete profile');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}
+
+async function askQuestion(prompt: string): Promise<string> {
+  return new Promise((resolve) => {
+    process.stdout.write(prompt);
+    process.stdin.setEncoding('utf-8');
+    process.stdin.once('data', (data) => {
+      resolve(data.toString().trim());
+    });
+  });
+}

package/src/config/ConfigManager.ts

@@ -0,0 +1,137 @@
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs-extra';
+
+const CONFIG_DIR = path.join(os.homedir(), '.agenticpool');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const CREDENTIALS_DIR = path.join(CONFIG_DIR, 'credentials');
+const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+const CACHE_DIR = path.join(CONFIG_DIR, 'cache');
+
+export interface GlobalConfig {
+  apiUrl: string;
+  defaultFormat: 'toon' | 'json';
+  humansApiUrl?: string;
+  humanUid?: string;
+  humanJwt?: string;
+  humanJwtExpiresAt?: number;
+}
+
+export interface NetworkCredentials {
+  publicToken: string;
+  privateKey: string;
+  jwt?: string;
+  expiresAt?: number;
+}
+
+export class ConfigManager {
+  private initialized = false;
+
+  async init(): Promise<void> {
+    if (this.initialized) return;
+    
+    await fs.ensureDir(CONFIG_DIR);
+    await fs.ensureDir(CREDENTIALS_DIR);
+    await fs.ensureDir(PROFILES_DIR);
+    await fs.ensureDir(CACHE_DIR);
+    
+    if (!(await fs.pathExists(CONFIG_FILE))) {
+      await this.saveGlobalConfig({
+        apiUrl: 'https://api.agenticpool.net',
+        defaultFormat: 'toon'
+      });
+    }
+    
+    this.initialized = true;
+  }
+
+  async getGlobalConfig(): Promise<GlobalConfig> {
+    await this.init();
+    return fs.readJson(CONFIG_FILE);
+  }
+
+  async saveGlobalConfig(config: GlobalConfig): Promise<void> {
+    await this.init();
+    await fs.writeJson(CONFIG_FILE, config, { spaces: 2 });
+  }
+
+  async setApiUrl(url: string): Promise<void> {
+    const config = await this.getGlobalConfig();
+    config.apiUrl = url;
+    await this.saveGlobalConfig(config);
+  }
+
+  async getCredentials(networkId: string): Promise<NetworkCredentials | null> {
+    await this.init();
+    const credFile = path.join(CREDENTIALS_DIR, `${networkId}.json`);
+    
+    if (!(await fs.pathExists(credFile))) {
+      return null;
+    }
+    
+    const creds = await fs.readJson(credFile);
+    
+    if (creds.expiresAt && Date.now() > creds.expiresAt) {
+      return null;
+    }
+    
+    return creds;
+  }
+
+  async saveCredentials(networkId: string, credentials: NetworkCredentials): Promise<void> {
+    await this.init();
+    const credFile = path.join(CREDENTIALS_DIR, `${networkId}.json`);
+    await fs.writeJson(credFile, credentials, { spaces: 2 });
+  }
+
+  async clearCredentials(networkId: string): Promise<void> {
+    await this.init();
+    const credFile = path.join(CREDENTIALS_DIR, `${networkId}.json`);
+    await fs.remove(credFile);
+  }
+
+  async getProfile(networkId: string): Promise<string | null> {
+    await this.init();
+    const profileFile = path.join(PROFILES_DIR, `${networkId}.md`);
+    
+    if (!(await fs.pathExists(profileFile))) {
+      return null;
+    }
+    
+    return fs.readFile(profileFile, 'utf-8');
+  }
+
+  async saveProfile(networkId: string, content: string): Promise<void> {
+    await this.init();
+    const profileFile = path.join(PROFILES_DIR, `${networkId}.md`);
+    await fs.writeFile(profileFile, content);
+  }
+
+  async getCache<T>(key: string): Promise<T | null> {
+    await this.init();
+    const cacheFile = path.join(CACHE_DIR, `${key}.json`);
+    
+    if (!(await fs.pathExists(cacheFile))) {
+      return null;
+    }
+    
+    return fs.readJson(cacheFile);
+  }
+
+  async setCache<T>(key: string, data: T): Promise<void> {
+    await this.init();
+    const cacheFile = path.join(CACHE_DIR, `${key}.json`);
+    await fs.writeJson(cacheFile, data, { spaces: 2 });
+  }
+
+  async clearCache(): Promise<void> {
+    await this.init();
+    await fs.emptyDir(CACHE_DIR);
+  }
+
+  getConfigPath(): string {
+    return CONFIG_DIR;
+  }
+}
+
+export const configManager = new ConfigManager();

package/src/config/index.ts

@@ -0,0 +1 @@
+export { ConfigManager, configManager, GlobalConfig, NetworkCredentials } from './ConfigManager';

package/src/index.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import {
+  registerAuthCommands,
+  registerNetworkCommands,
+  registerProfileCommands,
+  registerConversationCommands,
+  registerMessageCommands,
+  registerConfigCommands,
+  registerConnectionCommands,
+  registerIdentityCommands,
+  registerContactCommands,
+  registerHumansCommands
+} from './commands';
+
+const program = new Command();
+
+program
+  .name('agenticpool')
+  .description('CLI for AgenticPool - Social Network for Agents')
+  .version('1.0.0');
+
+registerAuthCommands(program);
+registerNetworkCommands(program);
+registerProfileCommands(program);
+registerConversationCommands(program);
+registerMessageCommands(program);
+registerConfigCommands(program);
+registerConnectionCommands(program);
+registerIdentityCommands(program);
+registerContactCommands(program);
+registerHumansCommands(program);
+
+program.parse();