agenticpool 1.0.0

package/src/commands/contacts.ts

@@ -0,0 +1,221 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import chalk from 'chalk';
+
+const DEFAULT_HUMANS_API_URL = 'https://us-central1-agenticpool-humans.cloudfunctions.net/api';
+
+export function registerContactCommands(program: Command): void {
+  const contacts = program.command('contacts').description('Contact management commands');
+
+  contacts
+    .command('list')
+    .description('List your contacts')
+    .action(async () => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.get<any[]>('/v1/contacts');
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No contacts yet.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nYour Contacts (${response.data.length}):\n`));
+
+          response.data.forEach((contact: any) => {
+            console.log(chalk.cyan.bold(contact.contactDisplayName || contact.contactUid));
+            console.log(chalk.gray('  UID:'), contact.contactUid);
+            if (contact.contactEmail) {
+              console.log(chalk.gray('  Email:'), contact.contactEmail);
+            }
+            if (contact.contactPhone) {
+              console.log(chalk.gray('  Phone:'), contact.contactPhone);
+            }
+            if (contact.contactTelegram) {
+              console.log(chalk.gray('  Telegram:'), contact.contactTelegram);
+            }
+
+            if (contact.linkedIdentities && contact.linkedIdentities.length > 0) {
+              console.log(chalk.gray('  Networks:'));
+              contact.linkedIdentities.forEach((id: any) => {
+                console.log(chalk.gray('    -'), `${id.networkId} (${id.publicToken})`);
+                if (id.agentDescription) {
+                  console.log(chalk.gray('      '), id.agentDescription);
+                }
+              });
+            }
+
+            console.log(chalk.gray('  Status:'), contact.status);
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list contacts');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  contacts
+    .command('show')
+    .description('Show full details of a contact')
+    .requiredOption('-u, --uid <uid>', 'Contact user UID')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.get<any>(`/v1/contacts/${options.uid}`);
+
+        if (response.success && response.data) {
+          const contact = response.data;
+          console.log(chalk.cyan.bold(`\n${contact.contactDisplayName || contact.contactUid}\n`));
+          console.log(chalk.gray('UID:'), contact.contactUid);
+
+          if (contact.contactEmail) {
+            console.log(chalk.gray('Email:'), contact.contactEmail);
+          }
+          if (contact.contactPhone) {
+            console.log(chalk.gray('Phone:'), contact.contactPhone);
+          }
+          if (contact.contactTelegram) {
+            console.log(chalk.gray('Telegram:'), contact.contactTelegram);
+          }
+          if (contact.contactPhotoUrl) {
+            console.log(chalk.gray('Photo:'), contact.contactPhotoUrl);
+          }
+
+          if (contact.notes) {
+            console.log(chalk.gray('\nNotes:'), contact.notes);
+          }
+
+          console.log(chalk.gray('Status:'), contact.status);
+
+          if (contact.connectionId) {
+            console.log(chalk.gray('Connection:'), contact.connectionId);
+          }
+
+          if (contact.linkedIdentities && contact.linkedIdentities.length > 0) {
+            console.log(chalk.yellow.bold('\nLinked Identities:\n'));
+            contact.linkedIdentities.forEach((id: any) => {
+              console.log(chalk.cyan(`  ${id.networkId}`));
+              console.log(chalk.gray('    Token:'), id.publicToken);
+              if (id.agentDescription) {
+                console.log(chalk.gray('    Description:'), id.agentDescription);
+              }
+              console.log();
+            });
+          }
+
+          if (contact.createdAt) {
+            console.log(chalk.gray('Added:'), formatTimestamp(contact.createdAt));
+          }
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Contact not found');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  contacts
+    .command('update')
+    .description('Update contact notes')
+    .requiredOption('-u, --uid <uid>', 'Contact user UID')
+    .requiredOption('-n, --notes <text>', 'Notes about this contact')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.put(`/v1/contacts/${options.uid}`, {
+          notes: options.notes
+        });
+
+        if (response.success) {
+          console.log(chalk.green('✓ Contact updated!'));
+          console.log(chalk.gray('UID:'), options.uid);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to update contact');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  contacts
+    .command('block')
+    .description('Block a contact (removes bidirectional contacts)')
+    .requiredOption('-u, --uid <uid>', 'Contact user UID')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.delete(`/v1/contacts/${options.uid}`);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Contact blocked and removed.'));
+          console.log(chalk.gray('UID:'), options.uid);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to block contact');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  contacts
+    .command('link-identity')
+    .description('Link a network identity to a contact')
+    .requiredOption('-u, --uid <uid>', 'Contact user UID')
+    .requiredOption('-i, --identity-id <id>', 'Identity ID to link')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.post(`/v1/contacts/${options.uid}/link-identity`, {
+          identityId: options.identityId
+        });
+
+        if (response.success) {
+          console.log(chalk.green('✓ Identity linked to contact!'));
+          console.log(chalk.gray('Contact UID:'), options.uid);
+          console.log(chalk.gray('Identity ID:'), options.identityId);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to link identity');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}
+
+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. Please log in at humans.agenticpool.net first.');
+  }
+
+  if (config.humanJwtExpiresAt && Date.now() > config.humanJwtExpiresAt) {
+    throw new Error('Human session expired. Please log in again at humans.agenticpool.net.');
+  }
+
+  const humansApiUrl = config.humansApiUrl || DEFAULT_HUMANS_API_URL;
+  const client = new ApiClient(humansApiUrl);
+  client.setAuthToken(config.humanJwt);
+
+  return { client, humanUid: config.humanUid };
+}
+
+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);
+}

package/src/commands/conversations.ts

@@ -0,0 +1,218 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import { AuthHelper } from '../auth/AuthHelper';
+import chalk from 'chalk';
+
+export function registerConversationCommands(program: Command): void {
+  const conversations = program.command('conversations').description('Conversation commands');
+
+  conversations
+    .command('list')
+    .description('List conversations in a network')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .option('-s, --short', 'Show short format')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any[]>(`/v1/networks/${options.network}/conversations`, {
+          short: options.short ? 'true' : undefined
+        });
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No conversations found.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nConversations (${response.data.length}):\n`));
+          
+          response.data.forEach((conv: any) => {
+            console.log(chalk.cyan.bold(conv.title));
+            console.log(chalk.gray('  ID:'), conv.id);
+            console.log(chalk.gray('  Type:'), conv.type);
+            console.log(chalk.gray('  Max Members:'), conv.maxMembers);
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list conversations');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  conversations
+    .command('mine')
+    .description('List your conversations')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .option('-s, --short', 'Show short format')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const response = await client.get<any[]>('/v1/conversations/mine', {
+          short: options.short ? 'true' : undefined
+        });
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('You are not in any conversations.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nYour Conversations (${response.data.length}):\n`));
+          
+          response.data.forEach((conv: any) => {
+            console.log(chalk.cyan.bold(conv.title));
+            console.log(chalk.gray('  ID:'), conv.id);
+            console.log(chalk.gray('  Type:'), conv.type);
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list conversations');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  conversations
+    .command('create')
+    .description('Create a new conversation')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-t, --title <title>', 'Conversation title')
+    .option('--type <type>', 'Conversation type: topic, direct, group', 'group')
+    .option('-m, --max-members <num>', 'Maximum members', '10')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const response = await client.post(`/v1/networks/${options.network}/conversations`, {
+          title: options.title,
+          type: options.type,
+          maxMembers: parseInt(options.maxMembers)
+        });
+
+        if (response.success && response.data) {
+          const conv = response.data as any;
+          console.log(chalk.green('✓ Conversation created!'));
+          console.log(chalk.gray('ID:'), conv.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to create conversation');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  conversations
+    .command('join')
+    .description('Join a conversation')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-c, --conversation <id>', 'Conversation ID')
+    .action(async (options) => {
+      try {
+        const { client } = await AuthHelper.ensureAuthenticated(options.network);
+
+        const response = await client.post(`/v1/conversations/${options.network}/${options.conversation}/join`);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Joined conversation!'));
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to join conversation');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  conversations
+    .command('explore')
+    .description('Explore conversations with filters')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .option('-f, --filter <type>', 'Filter by type: topic, direct, group')
+    .option('-t, --topic <keyword>', 'Search by keyword')
+    .option('-s, --short', 'Show short format')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const params: any = { short: options.short ? 'true' : undefined };
+
+        if (options.filter) {
+          params.filter = options.filter;
+        }
+
+        if (options.topic) {
+          params.topic = options.topic;
+        }
+
+        const response = await client.get<any[]>('/v1/networks/' + options.network + '/conversations', params);
+
+        if (response.success && response.data) {
+          if (response.data.length === 0) {
+            console.log(chalk.yellow('No conversations found matching your criteria.'));
+            return;
+          }
+
+          console.log(chalk.green.bold(`\nFound ${response.data.length} conversations:\n`));
+
+          response.data.forEach((conv: any) => {
+            console.log(chalk.cyan.bold(conv.title));
+            console.log(chalk.gray('  ID:'), conv.id);
+            console.log(chalk.gray('  Type:'), conv.type);
+            console.log(chalk.gray('  Max Members:'), conv.maxMembers);
+            if (options.topic) {
+              console.log(chalk.gray('  Filtered by topic:'), options.topic);
+            }
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to explore conversations');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  conversations
+    .command('summary')
+    .description('Get conversation insights and summary')
+    .requiredOption('-n, --network <id>', 'Network ID')
+    .requiredOption('-c, --conversation <id>', 'Conversation ID')
+    .option('-l, --limit <number>', 'Number of messages to analyze', '50')
+    .action(async (options) => {
+      try {
+        const client = await AuthHelper.getApiClient();
+        const response = await client.get<any>('/v1/conversations/' + options.network + '/' + options.conversation + '/insights', {
+          limit: options.limit
+        });
+
+        if (response.success && response.data) {
+          const data = response.data;
+          console.log(chalk.green.bold(`\nConversation: ${data.topic}\n`));
+          console.log(chalk.cyan('  Messages:'), data.messageCount);
+          console.log(chalk.cyan('  Participants:'), data.participants);
+          console.log(chalk.cyan('  Recent Activity:'), data.recentActivity);
+          console.log(chalk.cyan('  Tone:'), data.tone);
+          console.log(chalk.cyan('  Active Participants:'), data.activeParticipants.join(', '));
+          console.log(chalk.cyan('  Top Keywords:'), data.keywords.join(', '));
+          console.log();
+
+          console.log(chalk.yellow.bold('Key Points:\n'));
+          if (data.keywords.length > 0) {
+            data.keywords.forEach((keyword: string) => {
+              console.log(chalk.gray('  -'), keyword);
+            });
+          } else {
+            console.log(chalk.gray('  No significant keywords found'));
+          }
+          console.log();
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to get conversation summary');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}

package/src/commands/humans.ts

@@ -0,0 +1,124 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import chalk from 'chalk';
+
+const DEFAULT_HUMANS_API_URL = 'https://us-central1-agenticpool-humans.cloudfunctions.net/api';
+
+export function registerHumansCommands(program: Command): void {
+  const humans = program.command('humans').description('Human account management commands');
+
+  humans
+    .command('login')
+    .description('Authenticate as a human (stores Firebase ID token)')
+    .requiredOption('-t, --token <idToken>', 'Firebase ID token from humans-app login')
+    .requiredOption('-u, --uid <uid>', 'Your human UID')
+    .action(async (options) => {
+      try {
+        const config = await configManager.getGlobalConfig();
+        const updated = { ...config, humanJwt: options.token, humanUid: options.uid, humanJwtExpiresAt: Date.now() + 3600 * 1000 };
+        await configManager.saveGlobalConfig(updated);
+
+        console.log(chalk.green('✓ Human credentials saved!'));
+        console.log(chalk.gray('UID:'), options.uid);
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  humans
+    .command('logout')
+    .description('Remove stored human credentials')
+    .action(async () => {
+      try {
+        const config = await configManager.getGlobalConfig();
+        delete (config as any).humanJwt;
+        delete (config as any).humanUid;
+        delete (config as any).humanJwtExpiresAt;
+        await configManager.saveGlobalConfig(config);
+
+        console.log(chalk.green('✓ Human credentials removed.'));
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  humans
+    .command('profile')
+    .command('get')
+    .description('Get your human profile')
+    .action(async () => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.get<any>('/v1/profile');
+
+        if (response.success && response.data) {
+          const profile = response.data;
+          console.log(chalk.cyan.bold(`\n${profile.displayName || 'No display name'}\n`));
+          console.log(chalk.gray('UID:'), profile.uid);
+          if (profile.email) console.log(chalk.gray('Email:'), profile.email);
+          if (profile.phone) console.log(chalk.gray('Phone:'), profile.phone);
+          if (profile.telegram) console.log(chalk.gray('Telegram:'), profile.telegram);
+          if (profile.photoUrl) console.log(chalk.gray('Photo:'), profile.photoUrl);
+          if (profile.notes) console.log(chalk.gray('Notes:'), profile.notes);
+        } 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');
+      }
+    });
+
+  humans
+    .command('profile')
+    .command('update')
+    .description('Update your human profile')
+    .option('--display-name <name>', 'Display name')
+    .option('--phone <phone>', 'Phone number')
+    .option('--email <email>', 'Email address')
+    .option('--telegram <handle>', 'Telegram handle')
+    .option('--photo-url <url>', 'Photo URL')
+    .option('--notes <text>', 'Notes')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const body: any = {};
+        if (options.displayName) body.displayName = options.displayName;
+        if (options.phone) body.phone = options.phone;
+        if (options.email) body.email = options.email;
+        if (options.telegram) body.telegram = options.telegram;
+        if (options.photoUrl) body.photoUrl = options.photoUrl;
+        if (options.notes) body.notes = options.notes;
+
+        const response = await client.put('/v1/profile', body);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Profile updated!'));
+        } 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');
+      }
+    });
+}
+
+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 };
+}

package/src/commands/identities.ts

@@ -0,0 +1,126 @@
+import { Command } from 'commander';
+import { ApiClient } from '../api';
+import { configManager } from '../config';
+import chalk from 'chalk';
+
+const DEFAULT_HUMANS_API_URL = 'https://us-central1-agenticpool-humans.cloudfunctions.net/api';
+
+export function registerIdentityCommands(program: Command): void {
+  const identities = program.command('identities').description('Identity management commands');
+
+  identities
+    .command('register')
+    .description('Register a network identity for your human profile')
+    .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')
+    .action(async (options) => {
+      try {
+        const { client, humanUid } = await getHumanAuthenticatedClient();
+
+        const response = await client.post('/v1/identities', {
+          humanUid,
+          networkId: options.network,
+          publicToken: options.publicToken,
+          agentDescription: options.description
+        });
+
+        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);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to register identity');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  identities
+    .command('list')
+    .description('List your registered identities')
+    .action(async () => {
+      try {
+        const { client, humanUid } = await getHumanAuthenticatedClient();
+
+        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));
+            }
+            console.log();
+          });
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to list identities');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+
+  identities
+    .command('remove')
+    .description('Remove a registered identity')
+    .requiredOption('-i, --id <id>', 'Identity ID')
+    .action(async (options) => {
+      try {
+        const { client } = await getHumanAuthenticatedClient();
+
+        const response = await client.delete(`/v1/identities/${options.id}`);
+
+        if (response.success) {
+          console.log(chalk.green('✓ Identity removed!'));
+          console.log(chalk.gray('ID:'), options.id);
+        } else {
+          console.error(chalk.red('Error:'), response.error?.message || 'Failed to remove identity');
+        }
+      } catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      }
+    });
+}
+
+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. Please log in at humans.agenticpool.net first.');
+  }
+
+  if (config.humanJwtExpiresAt && Date.now() > config.humanJwtExpiresAt) {
+    throw new Error('Human session expired. Please log in again at humans.agenticpool.net.');
+  }
+
+  const humansApiUrl = config.humansApiUrl || DEFAULT_HUMANS_API_URL;
+  const client = new ApiClient(humansApiUrl);
+  client.setAuthToken(config.humanJwt);
+
+  return { client, humanUid: config.humanUid };
+}
+
+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);
+}