@indemn/cli 1.5.0 → 1.7.0

package/src/cli/agents.ts

@@ -1,7 +1,17 @@
 import { Command } from 'commander';
 import ora from 'ora';
 import { IndemnClient } from '../sdk/client.js';
-import { AgentsSDK } from '../sdk/agents.js';
+import { AgentInsightsSDK, AgentsSDK, type Lifecycle } from '../sdk/agents.js';
+import { CliError, EXIT } from '../core/runtime.js';
+import { confirmOrExit } from './link.js';
+import { DistributionSDK } from '../sdk/distribution.js';
+import { readFileSync, writeFileSync } from 'node:fs';
+import chalk from 'chalk';
+import { isNonInteractive } from '../core/runtime.js';
+import { askLine } from './utils/output.js';
+import {
+  createAgentFromSkeleton, exportAgent, importAgent, missingSkeletonFields, parseModel, type AgentBundle, type AgentSkeleton,
+} from '../sdk/agent-bundle.js';
 import { exportAgentCard } from '../report/export.js';
 import { formatTable, printJson, printError, printSuccess, confirm } from './utils/output.js';
 
@@ -98,22 +108,108 @@ export function registerAgentCommands(program: Command): void {
 
   agents
     .command('create')
-    .description('Create a new agent')
-    .requiredOption('--name <name>', 'Agent name')
-    .option('--channels <channels>', 'Comma-separated channels', 'WEB')
+    .description('Create an agent with its basics: name, channels, purpose, prompt and model. Asks for missing ones in a terminal.')
+    .option('--name <name>', 'Agent name')
+    .option('--channels <channels>', 'Comma-separated channels (see `indemn channels list`)', 'WEB')
+    .option('--description <text>', 'What the agent is for')
+    .option('--prompt <text>', 'System prompt')
+    .option('--prompt-file <path>', 'Read the system prompt from a file')
+    .option('--model <provider/model>', 'LLM, for example openai/gpt-4.1 (see `indemn models`)')
+    .option('--allow-duplicate', 'Create even if an agent with this name exists in the org')
+    .option('--template <id>', 'Copy a template instead (see `indemn templates list`); keeps its prompt, model, skills and knowledge')
+    .option('--json', 'Output as JSON')
     .action(async (options) => {
       try {
+        if (options.template) {
+          if (!options.name) throw new CliError('Name the new agent: --name "<name>".', EXIT.NEEDS_INPUT);
+          const client = new IndemnClient();
+          if (!options.allowDuplicate && (await new AgentsSDK(client).findByName(options.name)).length) {
+            throw new CliError(`An agent named "${options.name}" already exists in this org. Choose another name or pass --allow-duplicate.`, EXIT.NEEDS_INPUT);
+          }
+          const res = await new DistributionSDK(client).createFromTemplate(options.template, {
+            name: options.name, channels: String(options.channels).split(',').map((c: string) => c.trim()).filter(Boolean),
+          });
+          if (options.json) { printJson(res); return; }
+          printSuccess(`Agent created from template: ${res.new_agent_id} (${res.new_agent_name})`);
+          console.log(chalk.dim('  Not copied: phone numbers, voice settings, website distributions.'));
+          return;
+        }
+        const skeleton: AgentSkeleton = {
+          name: options.name ?? '',
+          channels: String(options.channels).split(',').map((c: string) => c.trim()).filter(Boolean),
+          description: options.description,
+          system_prompt: options.promptFile ? readFileSync(options.promptFile, 'utf8') : options.prompt,
+          model: options.model ? parseModel(options.model) : undefined,
+        };
+        const missing = missingSkeletonFields(skeleton);
+        if (missing.length && !isNonInteractive()) {
+          if (missing.includes('name')) skeleton.name = await askLine('Agent name: ');
+          if (missing.includes('description')) skeleton.description = await askLine('What is this agent for? (one line, Enter to skip): ');
+          if (missing.includes('system_prompt')) skeleton.system_prompt = await askLine('System prompt (Enter to skip; use --prompt-file for long prompts): ');
+        }
+        if (!skeleton.name.trim()) throw new CliError('An agent needs a name: --name "<name>".', EXIT.NEEDS_INPUT);
+
         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 });
+        const { agent, set } = await createAgentFromSkeleton(client, skeleton, { allowDuplicate: options.allowDuplicate });
         spinner.stop();
-
+        if (options.json) { printJson({ agent, set }); return; }
         printSuccess(`Agent created: ${agent._id}`);
         console.log(`  Name:     ${agent.name}`);
         console.log(`  Channels: ${formatChannels(agent.channels || [])}`);
+        console.log(`  Set:      ${set.join(', ')}`);
+        const unset = missingSkeletonFields(skeleton);
+        if (unset.length) console.log(chalk.dim(`  Not set yet: ${unset.join(', ')}. Use \`indemn config set ${agent._id}\`.`));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('export')
+    .argument('<id>', 'Agent ID')
+    .option('-o, --output <file>', 'Write to a file instead of stdout')
+    .option('--include-secrets', 'Keep API keys and tokens inside skill settings (default: redacted)')
+    .description('Save an agent (prompt, greeting, model, skills, linked knowledge bases) to a JSON bundle')
+    .action(async (id: string, options) => {
+      try {
+        const bundle = await exportAgent(new IndemnClient(), id, { includeSecrets: options.includeSecrets });
+        const text = JSON.stringify(bundle, null, 2) + '\n';
+        if (options.output) {
+          writeFileSync(options.output, text, { mode: options.includeSecrets ? 0o600 : 0o644 });
+          printSuccess(`Wrote ${options.output}.`);
+          if (bundle.redacted.length) console.log(chalk.dim(`  Redacted ${bundle.redacted.length} secret value(s); fill them in after import.`));
+        } else {
+          process.stdout.write(text);
+        }
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('import')
+    .argument('<file>', 'Bundle written by `indemn agents export`')
+    .option('--name <name>', 'Name for the new agent (default: the bundle name)')
+    .option('--link-kbs', 'Link the same knowledge base ids if they exist in this org')
+    .option('--allow-duplicate', 'Create even if an agent with this name exists in the org')
+    .option('--yes', 'Do not ask for confirmation')
+    .option('--json', 'Output as JSON')
+    .description('Create a new agent in the chosen org from an exported bundle')
+    .action(async (file: string, options) => {
+      try {
+        const bundle = JSON.parse(readFileSync(file, 'utf8')) as AgentBundle;
+        const client = new IndemnClient();
+        const org = await client.resolveOrg();
+        await confirmOrExit(`Create agent "${options.name ?? bundle.agent?.name}" with ${bundle.skills?.length ?? 0} skill(s) in ${org.name ?? org.id} on ${client.getEnvironment()}?`, Boolean(options.yes));
+        const report = await importAgent(client, bundle, { name: options.name, allowDuplicate: options.allowDuplicate, linkKnowledgeBases: options.linkKbs });
+        if (options.json) { printJson(report); return; }
+        printSuccess(`Agent created: ${report.agent._id} (${report.skills_created} skill(s) created, ${report.built_in_skills_reused.length} built-in reused)`);
+        for (const f of report.skills_failed) console.log(chalk.yellow(`  Skill ${f.name ?? '(unnamed)'} failed: ${f.error}`));
+        if (report.needs_secrets.length) console.log(chalk.yellow(`  Fill in ${report.needs_secrets.length} redacted secret(s) in the skills.`));
+        if (report.knowledge_bases_skipped.length) console.log(chalk.dim(`  Knowledge bases not linked: ${report.knowledge_bases_skipped.join(', ')}`));
       } catch (err) {
         printError(err);
         process.exit(1);
@@ -156,22 +252,18 @@ export function registerAgentCommands(program: Command): void {
   agents
     .command('delete')
     .argument('<id>', 'Agent ID')
-    .description('Delete an agent')
-    .action(async (id: string) => {
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Delete an agent (asks first; --yes for scripts)')
+    .action(async (id: string, options) => {
       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 agent = await sdk.getAgent(id);
+        const org = await client.resolveOrg();
+        await confirmOrExit(`Delete agent "${agent?.name ?? id}" (${id}) in org ${org.name ?? org.id} on ${client.getEnvironment()}? This cannot be undone.`, Boolean(options.yes));
         const spinner = ora('Deleting agent...').start();
-
         await sdk.deleteAgent(id);
         spinner.stop();
-
         printSuccess(`Agent ${id} deleted.`);
       } catch (err) {
         printError(err);
@@ -179,6 +271,93 @@ export function registerAgentCommands(program: Command): void {
       }
     });
 
+  agents
+    .command('lifecycle')
+    .argument('<id>', 'Agent ID')
+    .argument('<stage>', 'prototype, beta or published')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Change the lifecycle stage (only the owner or an org admin may; checked by the V2 platform)')
+    .action(async (id: string, stage: string, options) => {
+      try {
+        if (!['prototype', 'beta', 'published'].includes(stage)) {
+          throw new CliError('Stage must be prototype, beta or published.', EXIT.NEEDS_INPUT);
+        }
+        const client = new IndemnClient();
+        const insights = new AgentInsightsSDK(client);
+        const before = await insights.detail(id);
+        if (before.lifecycle === stage) {
+          console.log(`Agent ${id} is already ${stage}.`);
+          return;
+        }
+        await confirmOrExit(`Move "${before.name}" from ${before.lifecycle ?? 'prototype'} to ${stage}?`, Boolean(options.yes));
+        const after = await insights.setLifecycle(id, stage as Lifecycle);
+        printSuccess(`Agent ${id} is now ${after.lifecycle}.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('owner')
+    .argument('<id>', 'Agent ID')
+    .argument('[user-id]', 'New owner (user id); omit to show the current owner')
+    .option('--yes', 'Do not ask for confirmation')
+    .option('--json', 'Output as JSON')
+    .description('Show or transfer the owner (transfer: owner or org admin only)')
+    .action(async (id: string, userId: string | undefined, options) => {
+      try {
+        const client = new IndemnClient();
+        const insights = new AgentInsightsSDK(client);
+        const detail = await insights.detail(id);
+        if (!userId) {
+          if (options.json) { printJson({ owner: detail.owner ?? null, lifecycle: detail.lifecycle }); return; }
+          const o = detail.owner;
+          console.log(o ? `${[o.firstname, o.lastname].filter(Boolean).join(' ')} <${o.email ?? ''}> (${o.id})` : 'No owner recorded.');
+          return;
+        }
+        await confirmOrExit(`Transfer "${detail.name}" to user ${userId}?`, Boolean(options.yes));
+        await insights.transferOwner(id, userId);
+        printSuccess(`Owner of ${id} is now ${userId}.`);
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('summary')
+    .argument('<id>', 'Agent ID')
+    .option('--full', 'Skills and knowledge sources instead of one paragraph')
+    .option('--json', 'Output as JSON')
+    .description('What the agent does, written for a person or an AI to read before changing it')
+    .action(async (id: string, options) => {
+      try {
+        const result = await new AgentInsightsSDK(new IndemnClient()).summary(id, { text: !options.full });
+        if (options.json || options.full) { printJson(result); return; }
+        console.log((result as { summary?: string }).summary ?? '');
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
+  agents
+    .command('stats')
+    .argument('<id>', 'Agent ID')
+    .option('--from <date>', 'YYYY-MM-DD (default: 30 days ago)')
+    .option('--to <date>', 'YYYY-MM-DD (default: today)')
+    .option('--channel <channel>', 'web, voice or all', 'all')
+    .description('Conversation metrics for one agent (test conversations excluded)')
+    .action(async (id: string, options) => {
+      try {
+        printJson(await new AgentInsightsSDK(new IndemnClient()).stats(id, { from: options.from, to: options.to, channel: options.channel }));
+      } catch (err) {
+        printError(err);
+        process.exit(1);
+      }
+    });
+
   agents
     .command('card')
     .argument('<id>', 'Agent ID')
@@ -203,14 +382,15 @@ export function registerAgentCommands(program: Command): void {
   agents
     .command('clone')
     .argument('<id>', 'Agent ID to clone')
-    .description('Clone an agent')
-    .action(async (id: string) => {
+    .option('--name <name>', 'Name of the copy')
+    .description('Copy an agent of this org into a new agent in the same org')
+    .action(async (id: string, options) => {
       try {
         const client = new IndemnClient();
         const sdk = new AgentsSDK(client);
         const spinner = ora('Cloning agent...').start();
 
-        const result = await sdk.cloneAgent(id);
+        const result = await sdk.cloneAgent(id, { name: options.name });
         spinner.stop();
 
         // Clone returns { new_agent_id, new_agent_name } or an Agent object

package/src/cli/analytics.ts

@@ -0,0 +1,138 @@
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { IndemnClient } from '../sdk/client.js';
+import { AnalyticsSDK, AuditSDK, OrgSettingsSDK, type MetricKind } from '../sdk/analytics.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);
+  });
+}
+
+function withRange(cmd: Command, agent = true): Command {
+  cmd.option('--from <date>', 'YYYY-MM-DD (default: 30 days ago)').option('--to <date>', 'YYYY-MM-DD (default: today)');
+  if (agent) cmd.option('--agent <id>', 'Only this agent').option('--channel <channel>', 'web, voice or all', 'all');
+  return cmd;
+}
+
+const KINDS: Record<string, MetricKind> = {
+  metrics: 'metrics',
+  performance: 'model-performance',
+  'performance-by-agent': 'model-performance/bots',
+  volume: 'agent-volume',
+  handoffs: 'handoff-precursors',
+  feedback: 'critical-feedback',
+};
+
+export function registerAnalyticsCommands(program: Command): void {
+  const analytics = program.command('analytics').description('The numbers of the dashboard analytics pages (test conversations excluded)');
+
+  for (const [name, kind] of Object.entries(KINDS)) {
+    const perAgent = !['performance-by-agent', 'volume'].includes(name);
+    withRange(analytics.command(name).description(`Analytics: ${kind}`), perAgent)
+      .action((options) => run(async () => {
+        printJson(await new AnalyticsSDK(new IndemnClient()).get(kind, { from: options.from, to: options.to, channel: options.channel, agentId: options.agent }));
+      }));
+  }
+
+  withRange(analytics.command('conversations').description('The conversations behind a number, e.g. --dimension outcome --value handoff'))
+    .option('--dimension <name>', 'outcome, feedback, sentiment, precursor, reason, critical_feedback_theme or attribute:<key>')
+    .option('--value <value>', 'Value of the dimension')
+    .option('--search <text>', 'Text search')
+    .option('--page <n>', 'Page, starting at 1', '1')
+    .option('--page-size <n>', 'Rows per page (at most 200)', '50')
+    .action((options) => run(async () => {
+      printJson(await new AnalyticsSDK(new IndemnClient()).conversations({
+        from: options.from, to: options.to, channel: options.channel, agentId: options.agent, dimension: options.dimension, value: options.value,
+        search: options.search, page: Number(options.page), pageSize: Number(options.pageSize),
+      }));
+    }));
+
+  analytics.command('charts').description('Custom charts configured for the org').action(() => run(async () => {
+    printJson(await new AnalyticsSDK(new IndemnClient()).charts());
+  }));
+
+  withRange(analytics.command('chart').argument('<chart-id>', 'Chart ID from `analytics charts`').description('Data of one custom chart'))
+    .action((id: string, options) => run(async () => {
+      printJson(await new AnalyticsSDK(new IndemnClient()).chart(id, { from: options.from, to: options.to, channel: options.channel, agentId: options.agent }));
+    }));
+
+  const org = program.commands.find((c) => c.name() === 'org');
+  if (!org) throw new Error('org command group must be registered before analytics commands');
+  const config = org.command('config').description('Org settings: timezone, business hours, holidays');
+
+  config.command('get').description('All org settings (handoff settings are read-only)').action(() => run(async () => {
+    printJson(await new OrgSettingsSDK(new IndemnClient()).get());
+  }));
+  config.command('availability').description('Is the org inside business hours now?').action(() => run(async () => {
+    printJson(await new OrgSettingsSDK(new IndemnClient()).availability());
+  }));
+  config.command('timezone')
+    .argument('<zone>', 'For example America/New_York')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((zone: string, options) => run(async () => {
+      await confirmOrExit(`Set the org timezone to ${zone}? Business hours are read in this zone.`, Boolean(options.yes));
+      await new OrgSettingsSDK(new IndemnClient()).setTimezone(zone);
+      printSuccess(`Timezone set to ${zone}.`);
+    }));
+  config.command('business-hours')
+    .requiredOption('--file <path>', 'JSON: { "businessHoursEnabled": true, "businessHours": [{ "day": 1, "slots": [...] }], "businessHoursUtterance": "..." }')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Replace the business hours (days 0 Sunday to 6; empty slots close that day)')
+    .action((options) => run(async () => {
+      const hours = JSON.parse(readFileSync(options.file, 'utf8'));
+      await confirmOrExit('Replace the org business hours? Agents hand off only inside them.', Boolean(options.yes));
+      printJson(await new OrgSettingsSDK(new IndemnClient()).setBusinessHours(hours));
+    }));
+  const holidays = config.command('holidays').description('Days the org is closed');
+  holidays.command('add')
+    .requiredOption('--date <date>', 'YYYY-MM-DD')
+    .requiredOption('--name <name>', 'Holiday name')
+    .option('--message <text>', 'What agents say that day')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((options) => run(async () => {
+      await confirmOrExit(`Close the org on ${options.date} (${options.name})?`, Boolean(options.yes));
+      printJson(await new OrgSettingsSDK(new IndemnClient()).addHolidays([{ name: options.name, date: options.date, ...(options.message ? { holidayFallbackUtterance: options.message } : {}) }]));
+    }));
+  holidays.command('remove')
+    .argument('<dates...>', 'YYYY-MM-DD dates')
+    .option('--yes', 'Do not ask for confirmation')
+    .action((dates: string[], options) => run(async () => {
+      await confirmOrExit(`Remove ${dates.length} holiday(s)?`, Boolean(options.yes));
+      printJson(await new OrgSettingsSDK(new IndemnClient()).removeHolidays(dates));
+    }));
+  config.command('admin')
+    .argument('<settings...>', 'key=value pairs, e.g. enableTickets=true')
+    .option('--yes', 'Do not ask for confirmation')
+    .description('Indemn-only feature switches (the server refuses non-Indemn logins)')
+    .action((pairs: string[], options) => run(async () => {
+      const settings: Record<string, unknown> = {};
+      for (const pair of pairs) {
+        const i = pair.indexOf('=');
+        if (i <= 0) throw new CliError(`"${pair}" is not key=value.`, EXIT.NEEDS_INPUT);
+        const raw = pair.slice(i + 1);
+        settings[pair.slice(0, i)] = raw === 'true' ? true : raw === 'false' ? false : raw === 'null' ? null : Number.isFinite(Number(raw)) && raw !== '' ? Number(raw) : raw;
+      }
+      await confirmOrExit(`Change ${Object.keys(settings).join(', ')} for the org?`, Boolean(options.yes));
+      printJson(await new OrgSettingsSDK(new IndemnClient()).setAdminSettings(settings));
+    }));
+
+  program.command('audit').description('Who changed what in the org').command('list')
+    .option('--since <date>', 'Only entries from this date')
+    .option('--action <name>', 'Only this action or event type')
+    .option('--resource <type>', 'Only this resource type')
+    .option('--user <id>', 'Only this user')
+    .option('--limit <n>', 'At most this many (newest first)', '50')
+    .option('--json', 'Output as JSON')
+    .action((options) => run(async () => {
+      const rows = await new AuditSDK(new IndemnClient()).list({ since: options.since, action: options.action, resourceType: options.resource, user: options.user, limit: Number(options.limit) });
+      if (options.json) { printJson(rows); return; }
+      console.log(formatTable(['When', 'Action', 'Resource', 'User', 'Status'], rows.map((e) => [
+        String(e.createdAt ?? ''), String(e.action ?? e.event_type ?? ''), `${e.resource_type ?? ''} ${e.resource_display ?? e.resource_id ?? ''}`.trim(), String(e.id_user ?? ''), String(e.status ?? ''),
+      ])));
+    }));
+}

package/src/cli/auth.ts

@@ -3,7 +3,10 @@ import chalk from 'chalk';
 import ora from 'ora';
 import * as readline from 'readline';
 import { Writable } from 'node:stream';
-import { login, logout, whoami } from '../sdk/auth.js';
+import { login, logout, whoami, type WhoAmI } from '../sdk/auth.js';
+import { findLinkFile } from '../core/org-resolver.js';
+import { getOrgFlag } from '../core/scope.js';
+import { SessionExpiredError } from '../core/runtime.js';
 import type { Environment } from '../sdk/types.js';
 import { printError, printSuccess, printJson } from './utils/output.js';
 
@@ -39,6 +42,25 @@ function promptPassword(question: string): Promise<string> {
   });
 }
 
+function describeCredential(info: WhoAmI): string {
+  if (info.credential === 'session') {
+    return info.source === 'env' ? 'session token from INDEMN_TOKEN (supplied by a host)' : 'login session';
+  }
+  return info.source === 'env' ? 'API key from INDEMN_API_KEY' : 'API key saved by an older login (run `indemn login` to switch to a session)';
+}
+
+/** Which org commands in this folder would use, without asking anything. */
+function describeOrgRule(info: WhoAmI): string {
+  const flag = getOrgFlag();
+  if (flag) return `${flag} (from --org)`;
+  if (process.env.INDEMN_ORG_ID) return `${process.env.INDEMN_ORG_ID} (from INDEMN_ORG_ID)`;
+  const link = findLinkFile();
+  if (link) return `${link.org_name ?? link.org_id} (linked in ${link.path})`;
+  if (info.orgs.length === 1) return `${info.orgs[0].name} (your only org)`;
+  if (info.orgs.length > 1) return `asked for each command; you belong to ${info.orgs.length}. Use --org <id> or \`indemn link\`.`;
+  return 'looked up on first use';
+}
+
 export function registerAuthCommands(program: Command): void {
   program
     .command('login')
@@ -79,10 +101,19 @@ export function registerAuthCommands(program: Command): void {
               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)}...`));
+          spinner.succeed(`Logged in as ${result.email} on ${result.environment}`);
+          if (result.expiresAt) {
+            console.log(chalk.dim(`  Session valid until ${new Date(result.expiresAt).toLocaleString()}; it renews itself.`));
+          }
+          if (result.orgs.length === 0) {
+            console.log(chalk.yellow('  You are not a member of any organization yet. Ask an admin to add you.'));
+          } else {
+            console.log(chalk.dim(`  Organizations (${result.orgs.length}):`));
+            for (const o of result.orgs) console.log(chalk.dim(`    ${o.id}  ${o.name}`));
+            if (result.orgs.length > 1) {
+              console.log(chalk.dim('  Choose one per command with --org <id>, or pin a project folder with `indemn link --org <id>`.'));
+            }
+          }
         } catch (err) {
           spinner.fail('Authentication failed');
           if (err instanceof Error) {
@@ -100,11 +131,11 @@ export function registerAuthCommands(program: Command): void {
 
   program
     .command('logout')
-    .description('Clear stored credentials')
-    .action(() => {
+    .description('Revoke the session and clear stored credentials')
+    .action(async () => {
       try {
-        logout();
-        printSuccess('Logged out successfully. Credentials cleared.');
+        const { revoked } = await logout();
+        printSuccess(revoked ? 'Logged out. The session was revoked and removed from this machine.' : 'Logged out. Credentials removed from this machine.');
       } catch (err) {
         printError(err);
         process.exit(1);
@@ -119,23 +150,30 @@ export function registerAuthCommands(program: Command): void {
       try {
         const info = whoami();
         if (!info) {
-          printError('Not authenticated. Run `indemn login` first.');
-          process.exit(1);
+          printError(new SessionExpiredError('Not logged in. Run `indemn login` first.'));
+          process.exit(3);
         }
 
         if (options.json) {
-          printJson(info);
+          printJson({ ...info, org_rule: describeOrgRule(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(chalk.bold('Current login'));
+        console.log(`  Platform:    ${info.environment}`);
+        if (info.email) console.log(`  User:        ${info.email}`);
+        console.log(`  Credential:  ${describeCredential(info)}`);
+        if (info.sessionExpiresAt) {
+          console.log(`  Session:     valid until ${new Date(info.sessionExpiresAt).toLocaleString()} (renews itself)`);
+        }
+        console.log(`  Org here:    ${describeOrgRule(info)}`);
+        if (info.orgs.length) {
+          console.log(`  Orgs:`);
+          for (const o of info.orgs) console.log(`    ${o.id}  ${o.name}`);
+        }
         console.log(`  Copilot:     ${info.hosts.copilot}`);
         console.log(`  Evaluations: ${info.hosts.evaluations}`);
-        console.log(`  Middleware:   ${info.hosts.middleware}`);
+        console.log(`  Middleware:  ${info.hosts.middleware}`);
       } catch (err) {
         printError(err);
         process.exit(1);

package/src/cli/billing.ts

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+import { IndemnClient } from '../sdk/client.js';
+import { BillingSDK } from '../sdk/billing.js';
+import { printError, printJson } from './utils/output.js';
+
+function run(fn: () => Promise<void>): Promise<void> {
+  return fn().catch((err) => {
+    printError(err);
+    process.exit(1);
+  });
+}
+const sdk = () => new BillingSDK(new IndemnClient());
+
+export function registerBillingCommands(program: Command): void {
+  const billing = program.command('billing').description('Plan, usage and invoices (read-only: nothing here moves money)');
+  billing.command('status').description('Subscription status and current period').action(() => run(async () => {
+    const s = await sdk().status();
+    printJson(s ?? { subscription: null, message: 'This org has no paid subscription.' });
+  }));
+  billing.command('invoices').option('--unpaid', 'Only open invoices, with their payment links').action((options) => run(async () => {
+    printJson(options.unpaid ? await sdk().unpaid() : await sdk().invoices());
+  }));
+  billing.command('usage-forecast').description('Usage so far this period and the projected cost').action(() => run(async () => printJson(await sdk().usageForecast())));
+  billing.command('plans').description('The org\'s plans and the public plan list').action(() => run(async () => printJson(await sdk().plans())));
+}

package/src/cli/campaigns.ts

@@ -0,0 +1,33 @@
+import { Command } from 'commander';
+import { IndemnClient } from '../sdk/client.js';
+import { CampaignsSDK } from '../sdk/campaigns.js';
+import { formatTable, printError, printJson } from './utils/output.js';
+
+function run(fn: () => Promise<void>): Promise<void> {
+  return fn().catch((err) => {
+    printError(err);
+    process.exit(1);
+  });
+}
+const sdk = () => new CampaignsSDK(new IndemnClient());
+
+export function registerCampaignCommands(program: Command): void {
+  const campaigns = program.command('campaigns').description('Renewal and outreach campaigns (read-only)');
+  campaigns.command('list')
+    .option('--status <status>').option('--solution <id>').option('--limit <n>', 'At most this many', '50').option('--json', 'Output as JSON')
+    .action((options) => run(async () => {
+      const res = await sdk().list({ status: options.status, solutionId: options.solution, limit: Number(options.limit) });
+      if (options.json) { printJson(res); return; }
+      const items = (res.items ?? []) as Array<Record<string, unknown>>;
+      console.log(formatTable(['ID', 'Name', 'Status'], items.map((c) => [String(c._id ?? c.id ?? ''), String(c.name ?? ''), String(c.status ?? '')])));
+    }));
+  campaigns.command('get').argument('<campaign-id>').action((id: string) => run(async () => printJson(await sdk().get(id))));
+  for (const what of ['counts', 'forecast', 'next-touchpoints', 'versions'] as const) {
+    campaigns.command(what).argument('<campaign-id>').option('--days <n>', 'For forecast and next-touchpoints')
+      .action((id: string, options) => run(async () => printJson(await sdk().detail(id, what, options.days ? Number(options.days) : undefined))));
+  }
+  const templates = campaigns.command('templates').description('Message templates of campaigns');
+  templates.command('list').option('--channel <channel>').option('--solution <id>').action((options) => run(async () => printJson(await sdk().templates({ channel: options.channel, solutionId: options.solution }))));
+  templates.command('get').argument('<template-id>').option('--versions', 'Show versions (subject and body)').action((id: string, options) => run(async () => printJson(await sdk().template(id, Boolean(options.versions)))));
+  templates.command('skills').option('--solution <id>').action((options) => run(async () => printJson(await sdk().templateSkills(options.solution))));
+}