@indemn/cli 1.5.0 → 1.7.0

package/src/cli/chat.ts

@@ -3,116 +3,80 @@ 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';
+import { exchange, openTestChat } from '../sdk/test-chat.js';
+import { printError, printJson } from './utils/output.js';
+
+/** Print streamed agent text as it arrives (terminal mode only). */
+function attachPrinter(session: ChatSession, state: { receiving: boolean }): void {
+  let streamed = false;
+  session.on('stream', (data: { text?: string; isFirstChunk?: boolean; streamFinished?: boolean }) => {
+    if (data.isFirstChunk) {
+      state.receiving = true;
+      streamed = true;
+      process.stdout.write(chalk.cyan('Agent: '));
+    }
+    if (data.text) process.stdout.write(chalk.cyan(data.text));
+    if (data.streamFinished) {
+      process.stdout.write('\n');
+      state.receiving = false;
+    }
+  });
+  session.on('message', (text: string) => {
+    if (streamed) {
+      streamed = false;
+      return;
+    }
+    if (!state.receiving) console.log(chalk.cyan(`Agent: ${text}`));
+  });
+}
 
 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')
+    .description('Chat with an agent. Always a test conversation: never billed, never in analytics, marked with your name.')
+    .option('--session <session-id>', 'Resume an existing CLI test conversation')
     .option('--message <text>', 'Send a single message and exit (non-interactive)')
+    .option('--json', 'With --message: print { session_id, url, greeting, response } as JSON')
     .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;
-          }
+        const state = { receiving: false };
+        const quiet = Boolean(options.message && options.json);
+        const spinner = quiet ? null : ora('Opening a test conversation...').start();
+
+        const chat = await openTestChat(client, agentId, {
+          sessionId: options.session,
+          onSession: quiet ? undefined : (session) => {
+            session.on('stream', () => spinner?.stop());
+            attachPrinter(session, state);
+          },
         });
+        spinner?.stop();
 
-        // 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}`));
+        chat.session.on('disconnected', (reason: string) => {
+          // Our own disconnect is followed by an explicit exit; this handles the server dropping us.
+          if (reason === 'io client disconnect') return;
+          if (!quiet) 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}`));
+        if (!quiet) {
+          console.log(chalk.dim(`Test conversation with ${chat.agent.name} · tester ${chat.tester ?? 'unknown'} · session ${chat.sessionId}`));
+          console.log(chalk.dim(`Open in the dashboard: ${chat.url}`));
+        }
 
-        // 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();
+          if (!quiet) console.log(chalk.green(`You: ${options.message}`));
+          const { greeting, response } = await exchange(chat, options.message, { timeoutMs: 30_000 });
+          await chat.session.disconnect();
+          if (quiet) printJson({ session_id: chat.sessionId, url: chat.url, greeting, response });
           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: '),
-        });
-
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: chalk.green('You: ') });
         rl.prompt();
 
         rl.on('line', (line) => {
@@ -121,38 +85,25 @@ export function registerChatCommand(program: Command): void {
             rl.prompt();
             return;
           }
-
-          session.send(message);
-
-          // Wait briefly before showing prompt again to let response start streaming
+          chat.session.send(message);
+          // Re-prompt once the reply has finished streaming.
           setTimeout(() => {
-            if (!receiving) {
-              rl.prompt();
-            } else {
-              // Re-prompt after stream finishes
-              const checkDone = setInterval(() => {
-                if (!receiving) {
-                  clearInterval(checkDone);
-                  rl.prompt();
-                }
-              }, 100);
-            }
+            const check = setInterval(() => {
+              if (!state.receiving) {
+                clearInterval(check);
+                rl.prompt();
+              }
+            }, 100);
           }, 200);
         });
 
-        rl.on('close', () => {
+        const close = async () => {
           console.log(chalk.dim('\nClosing session...'));
-          session.disconnect();
+          await chat.session.disconnect();
           process.exit(0);
-        });
-
-        // Handle Ctrl+C
-        process.on('SIGINT', () => {
-          console.log(chalk.dim('\nClosing session...'));
-          session.disconnect();
-          rl.close();
-          process.exit(0);
-        });
+        };
+        rl.on('close', close);
+        process.on('SIGINT', close);
       } catch (err) {
         printError(err);
         process.exit(1);

package/src/cli/config.ts

@@ -3,7 +3,25 @@ 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';
+import chalk from 'chalk';
+import { confirm, printJson, printError, printSuccess } from './utils/output.js';
+import { confirmOrExit } from './link.js';
+import { CliError, EXIT, isNonInteractive } from '../core/runtime.js';
+import { diffStats, formatDiff } from '../core/diff.js';
+import { applyConfigChange, mayBeLive, modelArg, planConfigChange, type ConfigChange, type ConfigPlan } from '../sdk/config-change.js';
+
+function printPlan(plan: ConfigPlan): void {
+  console.log(chalk.bold(`Agent ${plan.agentId}`) + chalk.dim(` · lifecycle ${plan.lifecycle}`));
+  if (plan.changes.includes('system_prompt')) {
+    const { added, removed } = diffStats(plan.promptDiff);
+    console.log(chalk.bold(`Prompt: +${added} / -${removed} lines`));
+    for (const line of formatDiff(plan.promptDiff).split('\n')) {
+      console.log(line.startsWith('+') ? chalk.green(line) : line.startsWith('-') ? chalk.red(line) : chalk.dim(line));
+    }
+  }
+  if (plan.changes.includes('greeting')) console.log(`Greeting: ${chalk.red(plan.current.greeting || '(none)')} -> ${chalk.green(plan.next.greeting)}`);
+  if (plan.changes.includes('model')) console.log(`Model: ${chalk.red(plan.current.model || '(none)')} -> ${chalk.green(plan.next.model)}`);
+}
 
 export function registerConfigCommands(program: Command): void {
   const config = program.command('config').description('Manage agent configuration');
@@ -32,7 +50,7 @@ export function registerConfigCommands(program: Command): void {
               value = cfg.ai_config?.system_prompt;
               break;
             case 'greeting':
-              value = cfg.first_message;
+              value = cfg.first_message?.text;
               break;
             case 'model': {
               const llm = cfg.llm_config as Record<string, unknown> | undefined;
@@ -89,46 +107,62 @@ export function registerConfigCommands(program: Command): void {
   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')
+    .description('Change the prompt, greeting or model. Shows the change and asks first')
+    .option('--prompt <prompt>', 'New system prompt text')
+    .option('--prompt-file <path>', 'New system prompt from a file')
+    .option('--greeting <text>', 'New greeting (first message)')
+    .option('--model <model>', 'provider/model, e.g. openai/gpt-4.1 (a bare name guesses the provider)')
+    .option('--dry-run', 'Show the change and stop')
+    .option('--yes', 'Do not ask for confirmation (not enough for a published agent)')
+    .option('--confirm-published', 'Also required to change a published agent without a prompt')
     .action(async (agentId: string, options) => {
       try {
-        const input: Record<string, unknown> = {};
-
+        const change: ConfigChange = {};
         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 (!fs.existsSync(filePath)) throw new CliError(`File not found: ${filePath}`);
+          change.system_prompt = fs.readFileSync(filePath, 'utf-8');
+        } else if (options.prompt !== undefined) {
+          change.system_prompt = options.prompt;
         }
-
-        if (options.model) {
-          const model = options.model as string;
-          const provider = model.startsWith('claude') ? 'anthropic'
-            : model.startsWith('gemini') ? 'google'
-            : 'openai';
-          input.llm_config = { model, provider };
+        if (options.greeting !== undefined) change.greeting = options.greeting;
+        if (options.model) change.model = modelArg(options.model);
+        if (Object.keys(change).length === 0) {
+          throw new CliError('Nothing to change. Use --prompt, --prompt-file, --greeting or --model.', EXIT.NEEDS_INPUT);
         }
 
-        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 plan = await planConfigChange(client, agentId, change);
+        if (plan.changes.length === 0) {
+          console.log('No change: the agent already has these values.');
+          return;
+        }
+        printPlan(plan);
+        if (options.dryRun) return;
+
+        if (mayBeLive(plan.lifecycle)) {
+          console.log(chalk.red.bold(plan.lifecycle === 'published'
+            ? 'This agent is PUBLISHED: customers are talking to it now.'
+            : 'Could not read whether this agent is live, so it is treated as published.'));
+          if (isNonInteractive()) {
+            if (!(options.yes && options.confirmPublished)) {
+              throw new CliError('Changing a published agent without a person at the terminal needs both --yes and --confirm-published.', EXIT.NEEDS_INPUT);
+            }
+          } else if (!(await confirm('Change the published agent?'))) {
+            console.log('Cancelled.');
+            return;
+          }
+        } else {
+          await confirmOrExit(`Apply ${plan.changes.length} change(s) to agent ${agentId}?`, Boolean(options.yes));
         }
 
-        const client = new IndemnClient();
-        const sdk = new ConfigSDK(client);
         const spinner = ora('Updating configuration...').start();
-
-        await sdk.setConfig(agentId, input);
+        const result = await applyConfigChange(client, plan, change);
         spinner.stop();
-
-        printSuccess(`Configuration updated for agent ${agentId}.`);
+        if (result.mismatched.length) {
+          throw new CliError(`Saved: ${result.applied.join(', ') || 'nothing'}. NOT saved (read back differs): ${result.mismatched.join(', ')}.`);
+        }
+        printSuccess(`Updated ${result.applied.join(', ')} for agent ${agentId} (read back and confirmed).`);
       } catch (err) {
         printError(err);
         process.exit(1);

package/src/cli/conversations.ts

@@ -0,0 +1,133 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { writeFileSync } from 'node:fs';
+import { IndemnClient } from '../sdk/client.js';
+import {
+  ConversationsSDK, conversationToTestSet, conversationUrl, isCliConversation, isTestConversation, projectOfAgent,
+} from '../sdk/conversations.js';
+import { confirmOrExit } from './link.js';
+import { formatTable, printError, printJson, printSuccess } from './utils/output.js';
+
+export function registerConversationCommands(program: Command): void {
+  const conv = program.command('conversations').alias('conv').description('Read conversations of an agent, export them, or mark them as test');
+
+  conv
+    .command('list')
+    .requiredOption('--agent <id>', 'Agent whose conversations to list')
+    .option('--limit <n>', 'Rows per page (at most 100)', '50')
+    .option('--page <n>', 'Page, starting at 0', '0')
+    .option('--live-only', 'Hide test conversations')
+    .option('--cli-only', 'Only conversations opened by the CLI')
+    .option('--from <date>', 'Created on or after (ISO date)')
+    .option('--to <date>', 'Created before (ISO date)')
+    .option('--json', 'Output as JSON')
+    .description('List conversations of an agent, newest first')
+    .action(async (options) => {
+      try {
+        const client = new IndemnClient();
+        const { conversations } = await new ConversationsSDK(client).list(options.agent, {
+          limit: Number(options.limit), page: Number(options.page), includeTest: !options.liveOnly,
+          cliOnly: options.cliOnly, from: options.from, to: options.to,
+        });
+        if (options.json) {
+          printJson(conversations);
+          return;
+        }
+        if (conversations.length === 0) {
+          console.log('No conversations on this page.');
+          return;
+        }
+        console.log(formatTable(
+          ['Conversation', 'Created', 'Test', 'CLI', 'First message'],
+          conversations.map((c) => [
+            c.request_id,
+            new Date(String(c.created_at ?? c.createdAt ?? '')).toLocaleString(),
+            isTestConversation(c) ? 'test' : chalk.yellow('LIVE'),
+            isCliConversation(c) ? 'yes' : '',
+            String(c.first_text ?? '').slice(0, 50),
+          ]),
+        ));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  conv
+    .command('get')
+    .argument('<conversation-id>', 'Conversation (request) id')
+    .requiredOption('--agent <id>', 'Agent the conversation belongs to')
+    .option('--json', 'Output as JSON')
+    .description('Show a conversation and its messages')
+    .action(async (id: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new ConversationsSDK(client);
+        const projectId = await projectOfAgent(client, options.agent);
+        const [conversation, messages] = await Promise.all([sdk.get(projectId, id), sdk.messages(projectId, id, options.agent)]);
+        if (options.json) {
+          printJson({ conversation, messages });
+          return;
+        }
+        console.log(chalk.bold(`Conversation ${id}`) + (conversation.isTestMode ? chalk.dim('  test') : chalk.yellow('  LIVE')));
+        console.log(chalk.dim(conversationUrl(client, projectId, id)));
+        for (const m of messages) {
+          const who = m.role === 'agent' ? chalk.cyan('Agent') : m.role === 'user' ? chalk.green('User ') : chalk.dim('System');
+          console.log(`${who}: ${m.text ?? ''}`);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  conv
+    .command('export')
+    .argument('<conversation-id>', 'Conversation (request) id')
+    .requiredOption('--agent <id>', 'Agent the conversation belongs to')
+    .option('--as-testset', 'Write an evaluation test set (one scenario item) instead of the raw conversation')
+    .option('-o, --output <file>', 'Write to a file instead of stdout')
+    .description('Export a conversation as JSON, or as a test set to replay it in evaluations')
+    .action(async (id: string, options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new ConversationsSDK(client);
+        const projectId = await projectOfAgent(client, options.agent);
+        const [conversation, messages] = await Promise.all([sdk.get(projectId, id), sdk.messages(projectId, id, options.agent)]);
+        const out = options.asTestset ? conversationToTestSet(conversation, messages, options.agent) : { conversation, messages };
+        const text = JSON.stringify(out, null, 2) + '\n';
+        if (options.output) {
+          writeFileSync(options.output, text);
+          printSuccess(`Wrote ${options.output}.`);
+          if (options.asTestset) console.log(chalk.dim('Add success criteria to the item, then: indemn testset create --file ' + options.output));
+        } else {
+          process.stdout.write(text);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  conv
+    .command('mark-test')
+    .argument('<conversation-ids...>', 'Conversation (request) ids')
+    .requiredOption('--agent <id>', 'Agent the conversations belong to')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Mark conversations as test (removes them from analytics and reverses usage billing, as the dashboard does)')
+    .action(async (ids: string[], options) => {
+      try {
+        const client = new IndemnClient();
+        const sdk = new ConversationsSDK(client);
+        const projectId = await projectOfAgent(client, options.agent);
+        await confirmOrExit(`Mark ${ids.length} conversation(s) of agent ${options.agent} as test?`, Boolean(options.yes));
+        for (const id of ids) {
+          await sdk.markTest(projectId, id);
+          console.log(`  ${id}  marked as test`);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/distribution.ts

@@ -0,0 +1,116 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { IndemnClient } from '../sdk/client.js';
+import { DistributionSDK } from '../sdk/distribution.js';
+import { idOf } from '../sdk/conversations.js';
+import { CliError, EXIT } from '../core/runtime.js';
+import { confirmOrExit } from './link.js';
+import { formatTable, printError, printJson, printSuccess } from './utils/output.js';
+
+function run(fn: () => Promise<void>): Promise<void> {
+  return fn().catch((err) => {
+    printError(err);
+    process.exit(1);
+  });
+}
+
+export function registerDistributionCommands(program: Command): void {
+  const dist = program.command('distributions').description('Which website paths open which agent (web widget)');
+
+  dist.command('list')
+    .option('--json', 'Output as JSON')
+    .action((options) => run(async () => {
+      const d = await new DistributionSDK(new IndemnClient()).list();
+      if (options.json) { printJson(d); return; }
+      console.log(formatTable(['ID', 'Host', 'Path', 'Agent'], (d.paths ?? []).map((p) => [String(p.id), String(p.host_name ?? ''), String(p.path_expression ?? p.path_name ?? ''), String(p.bot_name ?? idOf(p.id_bot))])));
+      if (d.scriptTag) console.log(chalk.dim(`Embed code for every path: ${d.scriptTag}`));
+    }));
+
+  dist.command('create')
+    .requiredOption('--agent <id>', 'Agent to open')
+    .requiredOption('--host <host>', 'Website host, for example www.example.com')
+    .requiredOption('--path <path>', 'Page path, for example /quote')
+    .option('--path-expression <expr>', 'Pattern of pages (default: the path)')
+    .option('--greeting <text>', 'Greeting for this path')
+    .option('--allow-upload', 'Let visitors attach files')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Open an agent on a website path (live for visitors once the embed code is on the site)')
+    .action((options) => run(async () => {
+      await confirmOrExit(`Open agent ${options.agent} on ${options.host}${options.pathExpression ?? options.path}? Visitors of that page see it.`, Boolean(options.yes));
+      printJson(await new DistributionSDK(new IndemnClient()).create({
+        agentId: options.agent, host: options.host, path: options.path, pathExpression: options.pathExpression, greeting: options.greeting, allowUpload: options.allowUpload,
+      }));
+    }));
+
+  dist.command('update')
+    .argument('<distribution-id>', 'Distribution ID (from `distributions list`)')
+    .option('--agent <id>', 'Open another agent')
+    .option('--greeting <text>', 'New greeting')
+    .option('--path-expression <expr>', 'New page pattern')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((id: string, options) => run(async () => {
+      const changes: Record<string, unknown> = {};
+      if (options.agent) changes.id_bot = options.agent;
+      if (options.greeting) changes.greetingMessage = options.greeting;
+      if (options.pathExpression) changes.pathExpression = options.pathExpression;
+      if (!Object.keys(changes).length) throw new CliError('Nothing to change. Use --agent, --greeting or --path-expression.', EXIT.NEEDS_INPUT);
+      await confirmOrExit(`Change distribution ${id} (${Object.keys(changes).join(', ')})? Visitors see it immediately.`, Boolean(options.yes));
+      printJson(await new DistributionSDK(new IndemnClient()).update(id, changes));
+    }));
+
+  const templates = program.command('templates').description('Agent templates (shared by every org on the platform)');
+  templates.command('list')
+    .option('--json', 'Output as JSON')
+    .action((options) => run(async () => {
+      const list = await new DistributionSDK(new IndemnClient()).listTemplates();
+      if (options.json) { printJson(list); return; }
+      console.log(formatTable(['ID', 'Name', 'Category', 'Source agent'], list.map((t) => [String(t._id), t.name, (t.category ?? []).join(', '), typeof t.agent_id === 'object' && t.agent_id ? String(t.agent_id.name ?? idOf(t.agent_id._id)) : String(t.agent_id ?? '')])));
+    }));
+  templates.command('create')
+    .requiredOption('--agent <id>', 'Agent of this org to publish as a template')
+    .requiredOption('--name <name>', 'Template name')
+    .option('--description <text>', 'Description')
+    .option('--category <list>', 'Comma-separated categories')
+    .option('--tags <list>', 'Comma-separated tags')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Publish an agent as a template; every org on the platform can copy it')
+    .action((options) => run(async () => {
+      await confirmOrExit(`Publish agent ${options.agent} as template "${options.name}"? Every org on the platform can see and copy it, including its prompt and skills.`, Boolean(options.yes));
+      printJson(await new DistributionSDK(new IndemnClient()).createTemplate({
+        agentId: options.agent, name: options.name, description: options.description,
+        category: options.category?.split(',').map((s: string) => s.trim()), tags: options.tags?.split(',').map((s: string) => s.trim()),
+      }));
+    }));
+  templates.command('update')
+    .argument('<template-id>')
+    .option('--name <name>')
+    .option('--description <text>')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((id: string, options) => run(async () => {
+      await confirmOrExit(`Change template ${id}? Every org sees the change.`, Boolean(options.yes));
+      printJson(await new DistributionSDK(new IndemnClient()).updateTemplate(id, { name: options.name, description: options.description }));
+    }));
+  templates.command('delete')
+    .argument('<template-id>')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((id: string, options) => run(async () => {
+      await confirmOrExit(`Remove template ${id} for every org?`, Boolean(options.yes));
+      await new DistributionSDK(new IndemnClient()).deleteTemplate(id);
+      printSuccess(`Template ${id} removed.`);
+    }));
+
+  program.command('solutions').description('Solutions of the org').command('list')
+    .action(() => run(async () => printJson(await new DistributionSDK(new IndemnClient()).listSolutions())));
+
+  const agents = program.commands.find((c) => c.name() === 'agents');
+  if (!agents) throw new Error('agents command group must be registered before distribution commands');
+  agents.command('embed')
+    .argument('<agent-id>', 'Agent ID')
+    .description('The embed code and the website paths that open this agent')
+    .action((agentId: string) => run(async () => {
+      const res = await new DistributionSDK(new IndemnClient()).embed(agentId);
+      console.log(res.scriptTag ?? '(no embed code)');
+      if (!res.paths.length) console.log(chalk.dim('No website path opens this agent yet: indemn distributions create --agent ' + agentId + ' --host <host> --path <path>'));
+      for (const p of res.paths) console.log(chalk.dim(`  ${p.host_name}${p.path_expression ?? p.path_name}`));
+    }));
+}