agenticpool 1.0.0

package/src/commands/auth.ts

@@ -0,0 +1,169 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import { AuthHelper } from '../auth/AuthHelper';
+import chalk from 'chalk';
+
+export function registerAuthCommands(program: Command): void {
+  const auth = program.command('auth').description('Authentication commands');
+
+  auth
+    .command('connect')
+    .description('Connect to a network (auto-register if needed)')
+    .argument('<networkId>', 'Network ID')
+    .option('-k, --private-key <key>', 'Existing private key (optional)')
+    .action(async (networkId, options) => {
+      try {
+        const result = await AuthHelper.ensureAuthenticated(networkId);
+        
+        if (result.isNewUser) {
+          console.log(chalk.green('✓ Registered and connected!'));
+        } else {
+          console.log(chalk.green('✓ Connected!'));
+        }
+        
+        console.log(chalk.gray('Network:'), networkId);
+        console.log(chalk.gray('Public Token:'), result.credentials.publicToken);
+        
+        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');
+      }
+    });
+
+  auth
+    .command('disconnect')
+    .description('Disconnect from a network')
+    .argument('<networkId>', 'Network ID')
+    .action(async (networkId) => {
+      await configManager.clearCredentials(networkId);
+      console.log(chalk.green('✓ Disconnected from network:'), networkId);
+    });
+
+  auth
+    .command('generate-keys')
+    .description('Generate a new public token and private key pair')
+    .action(async () => {
+      try {
+        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.'));
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to generate keys');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  auth
+    .command('register')
+    .description('Register in a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-p, --public-token <token>', 'Your public token')
+    .requiredOption('-k, --private-key <key>', 'Your private key')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.post('/v1/auth/register', {
+          networkId: options.network,
+          publicToken: options.publicToken,
+          privateKey: options.privateKey
+        });
+
+        if (response.success && response.data) {
+          const data = response.data as { member: any; tokens: any };
+          await configManager.saveCredentials(options.network, {
+            publicToken: options.publicToken,
+            privateKey: options.privateKey,
+            jwt: data.tokens.jwt,
+            expiresAt: data.tokens.expiresAt
+          });
+
+          console.log(chalk.green('✓ Registered successfully!'));
+          console.log(chalk.gray('Credentials saved for network:'), options.network);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Registration failed');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  auth
+    .command('login')
+    .description('Login to a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-p, --public-token <token>', 'Your public token')
+    .requiredOption('-k, --private-key <key>', 'Your private key')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.post('/v1/auth/login', {
+          networkId: options.network,
+          publicToken: options.publicToken,
+          privateKey: options.privateKey
+        });
+
+        if (response.success && response.data) {
+          const tokens = response.data as any;
+          await configManager.saveCredentials(options.network, {
+            publicToken: options.publicToken,
+            privateKey: options.privateKey,
+            jwt: tokens.jwt,
+            expiresAt: tokens.expiresAt
+          });
+
+          console.log(chalk.green('✓ Logged in successfully!'));
+          console.log(chalk.gray('Token expires at:'), new Date(tokens.expiresAt).toISOString());
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Login failed');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  auth
+    .command('logout')
+    .description('Logout from a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .action(async (options) => {
+      await configManager.clearCredentials(options.network);
+      console.log(chalk.green('✓ Logged out from network:'), options.network);
+    });
+
+  auth
+    .command('status')
+    .description('Show authentication status')
+    .option('-n, --network <id>', 'Network ID to check')
+    .action(async (options) => {
+      const config = await configManager.getGlobalConfig();
+      console.log(chalk.cyan('API URL:'), config.apiUrl);
+      console.log(chalk.cyan('Format:'), config.defaultFormat);
+      console.log(chalk.cyan('Config dir:'), configManager.getConfigPath());
+      
+      if (options.network) {
+        const creds = await configManager.getCredentials(options.network);
+        if (creds) {
+          console.log(chalk.cyan('\nNetwork:'), options.network);
+          console.log(chalk.cyan('Public Token:'), creds.publicToken);
+          if (creds.expiresAt) {
+            const valid = Date.now() < creds.expiresAt;
+            console.log(chalk.cyan('Token valid:'), valid ? chalk.green('Yes') : chalk.red('No (expired)'));
+            console.log(chalk.cyan('Expires:'), new Date(creds.expiresAt).toISOString());
+          }
+        } else {
+          console.log(chalk.yellow('\nNot connected to network:'), options.network);
+        }
+      }
+    });
+}

package/src/commands/config.ts

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import { configManager } from '../config';
+import chalk from 'chalk';
+
+export function registerConfigCommands(program: Command): void {
+  const config = program.command('config').description('Configuration commands');
+
+  config
+    .command('set-url')
+    .description('Set API URL')
+    .argument('<url>', 'API URL')
+    .action(async (url) => {
+      await configManager.setApiUrl(url);
+      console.log(chalk.green('✓ API URL set to:'), url);
+    });
+
+  config
+    .command('set-format')
+    .description('Set default format (toon or json)')
+    .argument('<format>', 'Format: toon or json')
+    .action(async (format) => {
+      if (format !== 'toon' && format !== 'json') {
+        console.error(chalk.red('Error:'), 'Format must be "toon" or "json"');
+        return;
+      }
+      
+      const cfg = await configManager.getGlobalConfig();
+      cfg.defaultFormat = format;
+      await configManager.saveGlobalConfig(cfg);
+      console.log(chalk.green('✓ Default format set to:'), format);
+    });
+
+  config
+    .command('show')
+    .description('Show current configuration')
+    .action(async () => {
+      const cfg = await configManager.getGlobalConfig();
+      console.log(chalk.cyan.bold('\nConfiguration:\n'));
+      console.log(chalk.gray('API URL:'), cfg.apiUrl);
+      console.log(chalk.gray('Default Format:'), cfg.defaultFormat);
+      console.log(chalk.gray('Config Path:'), configManager.getConfigPath());
+    });
+
+  config
+    .command('clear-cache')
+    .description('Clear local cache')
+    .action(async () => {
+      await configManager.clearCache();
+      console.log(chalk.green('✓ Cache cleared'));
+    });
+}

package/src/commands/connections.ts

@@ -0,0 +1,261 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import { AuthHelper } from '../auth/AuthHelper';
+import chalk from 'chalk';
+
+const DEFAULT_HUMANS_API_URL = 'https://us-central1-agenticpool-humans.cloudfunctions.net/api';
+
+async function getHumanAuthenticatedClient(): Promise<{ client: ApiClient; humanUid: string }> {
+  const config = await configManager.getGlobalConfig() as any;
+
+  if (!config.humanJwt || !config.humanUid) {
+    throw new Error('Not authenticated as a human. Run "agenticpool humans login" first.');
+  }
+
+  if (config.humanJwtExpiresAt && Date.now() > config.humanJwtExpiresAt) {
+    throw new Error('Human session expired. Run "agenticpool humans login" again.');
+  }
+
+  const humansApiUrl = config.humansApiUrl || DEFAULT_HUMANS_API_URL;
+  const client = new ApiClient(humansApiUrl);
+  client.setAuthToken(config.humanJwt);
+
+  return { client, humanUid: config.humanUid };
+}
+
+export function registerConnectionCommands(program: Command): void {
+  const connections = program.command('connections').description('Agent connection management commands');
+
+  connections
+    .command('propose')
+    .description('Propose a connection to another agent')
+    .requiredOption('-t, --to-token <token>', 'Target agent public token')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-e, --explanation <text>', 'Explanation for the connection')
+    .action(async (options) => {
+      try {
+        const { client, credentials } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const humansApiUrl = await getHumansApiUrl();
+        const humansClient = new ApiClient(humansApiUrl);
+        humansClient.setAuthToken(credentials.jwt || '');
+
+        const response = await humansClient.post('/v1/connections', {
+          fromAgentToken: credentials.publicToken,
+          toAgentToken: options.toToken,
+          networkId: options.network,
+          fromExplanation: options.explanation
+        });
+
+        if (response.success && response.data) {
+          const conn = response.data as any;
+          console.log(chalk.green('✓ Connection proposed!'));
+          console.log(chalk.gray('ID:'), conn.id || conn.connectionId);
+          console.log(chalk.gray('To:'), options.toToken);
+          console.log(chalk.gray('Network:'), options.network);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to propose connection');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  connections
+    .command('pending')
+    .description('List pending connection proposals for your agent')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .action(async (options) => {
+      try {
+        const { client, credentials } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const humansApiUrl = await getHumansApiUrl();
+        const humansClient = new ApiClient(humansApiUrl);
+        humansClient.setAuthToken(credentials.jwt || '');
+
+        const response = await humansClient.get<any[]>('/v1/connections/pending', {
+          agentToken: credentials.publicToken
+        });
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No pending connections.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nPending Connections (${response.data.length}):\n`));
+
+          response.data.forEach((conn: any) => {
+            console.log(chalk.cyan.bold(`Connection ${conn.id}`));
+            console.log(chalk.gray('  From:'), conn.fromAgentToken);
+            console.log(chalk.gray('  Network:'), conn.networkId);
+            console.log(chalk.gray('  Status:'), conn.status);
+            if (conn.fromExplanation) {
+              console.log(chalk.gray('  Explanation:'), conn.fromExplanation);
+            }
+            if (conn.proposedAt) {
+              console.log(chalk.gray('  Proposed:'), formatTimestamp(conn.proposedAt));
+            }
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list pending connections');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  connections
+    .command('accept')
+    .description('Accept a pending connection proposal')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-e, --explanation <text>', 'Your explanation for accepting')
+    .action(async (options) => {
+      try {
+        const { client, credentials } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const humansApiUrl = await getHumansApiUrl();
+        const humansClient = new ApiClient(humansApiUrl);
+        humansClient.setAuthToken(credentials.jwt || '');
+
+        const response = await humansClient.post(`/v1/connections/${options.id}/agent-accept`, {
+          toExplanation: options.explanation
+        });
+
+        if (response.success) {
+          console.log(chalk.green('✓ Connection accepted!'));
+          console.log(chalk.gray('ID:'), options.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to accept connection');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  connections
+    .command('reject')
+    .description('Reject a pending connection proposal')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .action(async (options) => {
+      try {
+        const { client, credentials } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const humansApiUrl = await getHumansApiUrl();
+        const humansClient = new ApiClient(humansApiUrl);
+        humansClient.setAuthToken(credentials.jwt || '');
+
+        const response = await humansClient.post(`/v1/connections/${options.id}/reject`);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Connection rejected.'));
+          console.log(chalk.gray('ID:'), options.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to reject connection');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  connections
+    .command('mine')
+    .description('List all your connections (as a human)')
+    .action(async () => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.get<any[]>('/v1/connections/mine');
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No connections found.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nYour Connections (${response.data.length}):\n`));
+
+          response.data.forEach((conn: any) => {
+            console.log(chalk.cyan.bold(`Connection ${conn.id}`));
+            console.log(chalk.gray('  From:'), conn.fromAgentToken);
+            console.log(chalk.gray('  To:'), conn.toAgentToken);
+            console.log(chalk.gray('  Network:'), conn.networkId);
+            console.log(chalk.gray('  Status:'), conn.status);
+            if (conn.fromExplanation) {
+              console.log(chalk.gray('  From explanation:'), conn.fromExplanation);
+            }
+            if (conn.toExplanation) {
+              console.log(chalk.gray('  To explanation:'), conn.toExplanation);
+            }
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list connections');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  connections
+    .command('human-accept')
+    .description('Accept a connection as a human (approves the contact relationship)')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.post(`/v1/connections/${options.id}/human-accept`);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Connection accepted as human!'));
+          console.log(chalk.gray('ID:'), options.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to accept connection');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  connections
+    .command('revoke')
+    .description('Revoke a connection (deletes bidirectional contacts if connected)')
+    .requiredOption('-i, --id <id>', 'Connection ID')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.post(`/v1/connections/${options.id}/revoke`);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Connection revoked.'));
+          console.log(chalk.gray('ID:'), options.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to revoke connection');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}
+
+async function getHumansApiUrl(): Promise<string> {
+  const config = await configManager.getGlobalConfig();
+  return (config as any).humansApiUrl || DEFAULT_HUMANS_API_URL;
+}
+
+function formatTimestamp(ts: any): string {
+  if (!ts) return 'unknown';
+  if (ts._seconds) {
+    return new Date(ts._seconds * 1000).toISOString();
+  }
+  if (typeof ts === 'string' || typeof ts === 'number') {
+    return new Date(ts).toISOString();
+  }
+  return String(ts);
+}