@indemn/cli 1.0.0

package/src/cli/agents.ts

@@ -0,0 +1,206 @@
+import { Command } from 'commander';
+import ora from 'ora';
+import { IndemnClient } from '../sdk/client.js';
+import { AgentsSDK } from '../sdk/agents.js';
+import { formatTable, printJson, printError, printSuccess, confirm } from './utils/output.js';
+
+function formatChannels(channels: unknown[]): string {
+  if (!channels || channels.length === 0) return 'WEB';
+  return channels.map((c) =>
+    typeof c === 'string' ? c : (c as Record<string, string>).name || (c as Record<string, string>).type || String(c)
+  ).join(', ');
+}
+
+export function registerAgentCommands(program: Command): void {
+  const agents = program.command('agents').description('Manage AI agents');
+
+  agents
+    .command('list')
+    .description('List all agents')
+    .option('--json', 'Output as JSON')
+    .option('--limit <n>', 'Limit number of results')
+    .option('--page <n>', 'Page number (use with --limit)')
+    .action(async (options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new AgentsSDK(client);
+        const spinner = ora('Fetching agents...').start();
+
+        let agentList = await sdk.listAgents();
+        spinner.stop();
+
+        if (options.page && options.limit) {
+          const page = parseInt(options.page, 10);
+          const limit = parseInt(options.limit, 10);
+          agentList = agentList.slice((page - 1) * limit, page * limit);
+        } else if (options.limit) {
+          agentList = agentList.slice(0, parseInt(options.limit, 10));
+        }
+
+        if (options.json) {
+          printJson(agentList);
+          return;
+        }
+
+        if (agentList.length === 0) {
+          console.log('No agents found.');
+          return;
+        }
+
+        const rows = agentList.map((a) => [
+          a._id,
+          a.name || '',
+          formatChannels(a.channels || []),
+          a.updatedAt ? new Date(a.updatedAt).toLocaleDateString() : '',
+        ]);
+
+        console.log(formatTable(['ID', 'Name', 'Channels', 'Updated'], rows));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('get')
+    .argument('<id>', 'Agent ID')
+    .description('Get agent details')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new AgentsSDK(client);
+        const spinner = ora('Fetching agent...').start();
+
+        const agent = await sdk.getAgent(id);
+        spinner.stop();
+
+        if (options.json) {
+          printJson(agent);
+          return;
+        }
+
+        console.log(`ID:          ${agent._id}`);
+        console.log(`Name:        ${agent.name}`);
+        console.log(`Description: ${agent.description || '(none)'}`);
+        console.log(`Channels:    ${formatChannels(agent.channels || [])}`);
+        console.log(`Webhook URL: ${agent.webhook_url || '(none)'}`);
+        console.log(`Webhook:     ${agent.webhook_enabled ? 'enabled' : 'disabled'}`);
+        console.log(`Project:     ${agent.id_project || '(none)'}`);
+        console.log(`Created:     ${agent.createdAt || ''}`);
+        console.log(`Updated:     ${agent.updatedAt || ''}`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('create')
+    .description('Create a new agent')
+    .requiredOption('--name <name>', 'Agent name')
+    .option('--channels <channels>', 'Comma-separated channels', 'WEB')
+    .action(async (options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new AgentsSDK(client);
+        const spinner = ora('Creating agent...').start();
+
+        const channels = options.channels.split(',').map((c: string) => c.trim());
+        const agent = await sdk.createAgent({ name: options.name, channels });
+        spinner.stop();
+
+        printSuccess(`Agent created: ${agent._id}`);
+        console.log(`  Name:     ${agent.name}`);
+        console.log(`  Channels: ${formatChannels(agent.channels || [])}`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('update')
+    .argument('<id>', 'Agent ID')
+    .description('Update an agent')
+    .option('--name <name>', 'New agent name')
+    .option('--description <description>', 'Agent description')
+    .option('--webhook-url <url>', 'Webhook URL')
+    .action(async (id: string, options) => {
+      try {
+        const input: Record<string, unknown> = {};
+        if (options.name) input.name = options.name;
+        if (options.description) input.description = options.description;
+        if (options.webhookUrl) input.webhook_url = options.webhookUrl;
+
+        if (Object.keys(input).length === 0) {
+          printError('No update options provided. Use --name, --description, or --webhook-url.');
+          process.exit(1);
+        }
+
+        const client = new IndemnClient();
+        const sdk = new AgentsSDK(client);
+        const spinner = ora('Updating agent...').start();
+
+        const agent = await sdk.updateAgent(id, input);
+        spinner.stop();
+
+        printSuccess(`Agent ${agent._id} updated.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('delete')
+    .argument('<id>', 'Agent ID')
+    .description('Delete an agent')
+    .action(async (id: string) => {
+      try {
+        const confirmed = await confirm(`Delete agent ${id}? This cannot be undone.`);
+        if (!confirmed) {
+          console.log('Cancelled.');
+          return;
+        }
+
+        const client = new IndemnClient();
+        const sdk = new AgentsSDK(client);
+        const spinner = ora('Deleting agent...').start();
+
+        await sdk.deleteAgent(id);
+        spinner.stop();
+
+        printSuccess(`Agent ${id} deleted.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('clone')
+    .argument('<id>', 'Agent ID to clone')
+    .description('Clone an agent')
+    .action(async (id: string) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new AgentsSDK(client);
+        const spinner = ora('Cloning agent...').start();
+
+        const result = await sdk.cloneAgent(id);
+        spinner.stop();
+
+        // Clone returns { new_agent_id, new_agent_name } or an Agent object
+        const raw = result as unknown as Record<string, unknown>;
+        const cloneId = raw.new_agent_id || result._id;
+        const cloneName = raw.new_agent_name || result.name;
+        printSuccess(`Agent cloned: ${cloneId}`);
+        console.log(`  Name:     ${cloneName}`);
+        console.log(`  Source:   ${id}`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/auth.ts

@@ -0,0 +1,170 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as readline from 'readline';
+import { login, logout, whoami } from '../sdk/auth.js';
+import type { Environment } from '../sdk/types.js';
+import { printError, printSuccess, printJson } from './utils/output.js';
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function promptPassword(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    // Disable echoing by writing to stdout manually
+    process.stdout.write(question);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+
+    let password = '';
+    const onData = (char: Buffer) => {
+      const c = char.toString('utf8');
+      if (c === '\n' || c === '\r' || c === '\u0004') {
+        if (stdin.isTTY) {
+          stdin.setRawMode(wasRaw ?? false);
+        }
+        stdin.removeListener('data', onData);
+        process.stdout.write('\n');
+        rl.close();
+        resolve(password);
+      } else if (c === '\u0003') {
+        // Ctrl+C
+        if (stdin.isTTY) {
+          stdin.setRawMode(wasRaw ?? false);
+        }
+        stdin.removeListener('data', onData);
+        rl.close();
+        process.exit(1);
+      } else if (c === '\u007f' || c === '\b') {
+        // Backspace
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          process.stdout.write('\b \b');
+        }
+      } else {
+        password += c;
+        process.stdout.write('*');
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+export function registerAuthCommands(program: Command): void {
+  program
+    .command('login')
+    .description('Authenticate with Indemn platform')
+    .option('--env <environment>', 'Target environment', 'dev')
+    .action(async (options) => {
+      try {
+        const env = options.env as Environment;
+        if (env !== 'dev' && env !== 'production') {
+          printError('Environment must be "dev" or "production"');
+          process.exit(1);
+        }
+
+        const email = await prompt('Email: ');
+        if (!email) {
+          printError('Email is required');
+          process.exit(1);
+        }
+
+        const password = await promptPassword('Password: ');
+        if (!password) {
+          printError('Password is required');
+          process.exit(1);
+        }
+
+        const spinner = ora('Authenticating...').start();
+
+        try {
+          const result = await login(email, password, env, {
+            mfaCodePrompt: async () => {
+              spinner.stop();
+              console.log(chalk.yellow('MFA code sent to your email.'));
+              const code = await prompt('MFA Code: ');
+              if (!code) {
+                throw new Error('MFA code is required');
+              }
+              spinner.start('Verifying MFA code...');
+              return code;
+            },
+          });
+          spinner.succeed('Authenticated successfully');
+          console.log(chalk.dim(`  Org:         ${result.orgId}`));
+          console.log(chalk.dim(`  Environment: ${result.environment}`));
+          console.log(chalk.dim(`  API Key:     ${result.apiKey.substring(0, 12)}...`));
+        } catch (err) {
+          spinner.fail('Authentication failed');
+          throw err;
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('logout')
+    .description('Clear stored credentials')
+    .action(() => {
+      try {
+        logout();
+        printSuccess('Logged out successfully. Credentials cleared.');
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command('whoami')
+    .description('Display current user and environment info')
+    .option('--json', 'Output as JSON')
+    .action((options) => {
+      try {
+        const info = whoami();
+        if (!info) {
+          printError('Not authenticated. Run `indemn login` first.');
+          process.exit(1);
+        }
+
+        if (options.json) {
+          printJson(info);
+          return;
+        }
+
+        console.log(chalk.bold('Current Authentication'));
+        console.log(`  API Key:     ${info.apiKey}`);
+        console.log(`  Org ID:      ${info.orgId}`);
+        console.log(`  User ID:     ${info.userId}`);
+        console.log(`  Environment: ${info.environment}`);
+        console.log(`  Copilot:     ${info.hosts.copilot}`);
+        console.log(`  Evaluations: ${info.hosts.evaluations}`);
+        console.log(`  Middleware:   ${info.hosts.middleware}`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/chat.ts

@@ -0,0 +1,161 @@
+import { Command } from 'commander';
+import * as readline from 'readline';
+import chalk from 'chalk';
+import ora from 'ora';
+import { IndemnClient } from '../sdk/client.js';
+import { AgentsSDK } from '../sdk/agents.js';
+import { ChatSession } from '../sdk/chat.js';
+import { printError } from './utils/output.js';
+
+export function registerChatCommand(program: Command): void {
+  program
+    .command('chat')
+    .argument('<agent-id>', 'Agent ID to chat with')
+    .description('Interactive chat with an agent (or send a single message with --message)')
+    .option('--session <session-id>', 'Resume existing session')
+    .option('--message <text>', 'Send a single message and exit (non-interactive)')
+    .action(async (agentId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const agentsSDK = new AgentsSDK(client);
+
+        const fetchSpinner = ora('Connecting to agent...').start();
+
+        const agent = await agentsSDK.getAgent(agentId);
+        const hosts = client.getHosts();
+
+        const session = new ChatSession(agent._id, hosts.middleware, options.session);
+
+        // Track whether we're currently receiving a streamed response
+        let receiving = false;
+        let streamedResponse = false;
+
+        // Handle stream chunks — write directly to stdout
+        session.on('stream', (data: { text?: string; isFirstChunk?: boolean; streamFinished?: boolean }) => {
+          if (data.isFirstChunk) {
+            receiving = true;
+            streamedResponse = true;
+            process.stdout.write(chalk.cyan('Agent: '));
+          }
+          if (data.text) {
+            process.stdout.write(chalk.cyan(data.text));
+          }
+          if (data.streamFinished) {
+            process.stdout.write('\n');
+            receiving = false;
+          }
+        });
+
+        // Handle non-streamed bot messages (skip if already printed via streaming)
+        session.on('message', (text: string) => {
+          if (streamedResponse) {
+            streamedResponse = false;
+            return;
+          }
+          if (!receiving) {
+            console.log(chalk.cyan(`Agent: ${text}`));
+          }
+        });
+
+        session.on('disconnected', (reason: string) => {
+          console.log(chalk.dim(`\nDisconnected: ${reason}`));
+          process.exit(0);
+        });
+
+        // Connect and get session ID
+        const sessionId = await session.connect();
+        fetchSpinner.stop();
+
+        console.log(chalk.dim(`Connected to ${agent.name}`));
+        console.log(chalk.dim(`Session: ${sessionId}`));
+
+        // Non-interactive mode: send one message, wait for response, exit
+        if (options.message) {
+          // Wait for greeting to finish streaming
+          await new Promise<void>((resolve) => {
+            const check = setInterval(() => {
+              if (!receiving) {
+                clearInterval(check);
+                resolve();
+              }
+            }, 100);
+            // Timeout after 8s even if no greeting
+            setTimeout(() => { clearInterval(check); resolve(); }, 8000);
+          });
+
+          console.log(chalk.green(`You: ${options.message}`));
+          session.send(options.message);
+
+          // Wait for response to finish streaming
+          await new Promise<void>((resolve) => {
+            let started = false;
+            const check = setInterval(() => {
+              if (receiving) started = true;
+              if (started && !receiving) {
+                clearInterval(check);
+                resolve();
+              }
+            }, 100);
+            // Timeout after 30s
+            setTimeout(() => { clearInterval(check); resolve(); }, 30000);
+          });
+
+          session.disconnect();
+          process.exit(0);
+        }
+
+        // Interactive mode
+        console.log(chalk.dim('Type your message and press Enter. Ctrl+C to exit.\n'));
+
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+          prompt: chalk.green('You: '),
+        });
+
+        rl.prompt();
+
+        rl.on('line', (line) => {
+          const message = line.trim();
+          if (!message) {
+            rl.prompt();
+            return;
+          }
+
+          session.send(message);
+
+          // Wait briefly before showing prompt again to let response start streaming
+          setTimeout(() => {
+            if (!receiving) {
+              rl.prompt();
+            } else {
+              // Re-prompt after stream finishes
+              const checkDone = setInterval(() => {
+                if (!receiving) {
+                  clearInterval(checkDone);
+                  rl.prompt();
+                }
+              }, 100);
+            }
+          }, 200);
+        });
+
+        rl.on('close', () => {
+          console.log(chalk.dim('\nClosing session...'));
+          session.disconnect();
+          process.exit(0);
+        });
+
+        // Handle Ctrl+C
+        process.on('SIGINT', () => {
+          console.log(chalk.dim('\nClosing session...'));
+          session.disconnect();
+          rl.close();
+          process.exit(0);
+        });
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/config.ts

@@ -0,0 +1,131 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import ora from 'ora';
+import { IndemnClient } from '../sdk/client.js';
+import { ConfigSDK } from '../sdk/config.js';
+import { printJson, printError, printSuccess } from './utils/output.js';
+
+export function registerConfigCommands(program: Command): void {
+  const config = program.command('config').description('Manage agent configuration');
+
+  config
+    .command('get')
+    .argument('<agent-id>', 'Agent ID')
+    .description('Get agent configuration')
+    .option('--field <field>', 'Get specific field (prompt, greeting, model)')
+    .option('--json', 'Output as JSON')
+    .action(async (agentId: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new ConfigSDK(client);
+        const spinner = ora('Fetching configuration...').start();
+
+        const cfg = await sdk.getConfig(agentId);
+        spinner.stop();
+
+        if (options.field) {
+          const field = options.field as string;
+          let value: unknown;
+
+          switch (field) {
+            case 'prompt':
+              value = cfg.ai_config?.system_prompt;
+              break;
+            case 'greeting':
+              value = cfg.first_message;
+              break;
+            case 'model':
+              value = cfg.ai_config?.kb_configuration;
+              break;
+            default:
+              value = (cfg as Record<string, unknown>)[field];
+          }
+
+          if (value === undefined) {
+            console.log(`Field "${field}" is not set.`);
+            return;
+          }
+
+          if (options.json || typeof value === 'object') {
+            printJson(value);
+          } else {
+            console.log(String(value));
+          }
+          return;
+        }
+
+        if (options.json) {
+          printJson(cfg);
+          return;
+        }
+
+        // Pretty print the configuration
+        console.log('Agent Configuration:');
+        if (cfg.ai_config?.system_prompt) {
+          console.log('\nSystem Prompt:');
+          console.log('  ' + cfg.ai_config.system_prompt.replace(/\n/g, '\n  '));
+        }
+        if (cfg.first_message) {
+          console.log('\nGreeting:');
+          if (cfg.first_message.text) {
+            console.log(`  Text: ${cfg.first_message.text}`);
+          }
+          if (cfg.first_message.quick_replies?.length) {
+            console.log(`  Quick Replies: ${cfg.first_message.quick_replies.map((q) => q.title).join(', ')}`);
+          }
+        }
+        if (cfg.ai_config?.kb_configuration) {
+          console.log('\nKB Configuration:');
+          printJson(cfg.ai_config.kb_configuration);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  config
+    .command('set')
+    .argument('<agent-id>', 'Agent ID')
+    .description('Update agent configuration')
+    .option('--prompt <prompt>', 'Set system prompt text')
+    .option('--prompt-file <path>', 'Set system prompt from file')
+    .option('--model <model>', 'Set model name')
+    .action(async (agentId: string, options) => {
+      try {
+        const input: Record<string, unknown> = {};
+
+        if (options.promptFile) {
+          const filePath = options.promptFile as string;
+          if (!fs.existsSync(filePath)) {
+            printError(`File not found: ${filePath}`);
+            process.exit(1);
+          }
+          input.system_prompt = fs.readFileSync(filePath, 'utf-8');
+        } else if (options.prompt) {
+          input.system_prompt = options.prompt;
+        }
+
+        if (options.model) {
+          input.model = options.model;
+        }
+
+        if (Object.keys(input).length === 0) {
+          printError('No configuration options provided. Use --prompt, --prompt-file, or --model.');
+          process.exit(1);
+        }
+
+        const client = new IndemnClient();
+        const sdk = new ConfigSDK(client);
+        const spinner = ora('Updating configuration...').start();
+
+        await sdk.setConfig(agentId, input);
+        spinner.stop();
+
+        printSuccess(`Configuration updated for agent ${agentId}.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+}