@indemn/cli 1.6.0 → 1.7.0

package/test/core/runtime.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { cliVersion, EXIT, isNonInteractive, NeedsInputError, SessionExpiredError } from '../../src/core/runtime.js';
+
+describe('isNonInteractive', () => {
+  it.each([
+    [{ CLAUDECODE: '1' }, true, true],
+    [{ CI: 'true' }, true, true],
+    [{ INDEMN_NON_INTERACTIVE: '1' }, true, true],
+    [{}, false, true],
+    [{}, true, false],
+    [{ CI: 'false' }, true, false],
+  ])('env %j with TTY %s gives %s', (env, tty, expected) => {
+    expect(isNonInteractive(env as NodeJS.ProcessEnv, tty)).toBe(expected);
+  });
+});
+
+describe('errors and version', () => {
+  it('uses exit code 2 for a needed choice and 3 for an expired session', () => {
+    const needs = new NeedsInputError('Which org?', [{ id: 'a', label: 'A' }]);
+    expect(needs.exitCode).toBe(EXIT.NEEDS_INPUT);
+    expect(needs.choices).toEqual([{ id: 'a', label: 'A' }]);
+    expect(new SessionExpiredError().exitCode).toBe(EXIT.AUTH);
+  });
+
+  it('reads the version from package.json', () => {
+    const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+    expect(cliVersion()).toBe(pkg.version);
+  });
+});

package/test/core/scope.test.ts

@@ -0,0 +1,93 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { recordFetch } from '../helpers/fetch-recorder.js';
+import { cleanEnv, useTempHome } from '../helpers/config-home.js';
+import { jwtExpiringIn } from '../helpers/jwt.js';
+import { IndemnClient } from '../../src/sdk/client.js';
+import { onOrgResolved, runWithOrg, setAskers, setOrgFlag } from '../../src/core/scope.js';
+import { NeedsInputError } from '../../src/core/runtime.js';
+
+const A = 'aaaaaaaaaaaaaaaaaaaaaaaa';
+const B = 'bbbbbbbbbbbbbbbbbbbbbbbb';
+const AGENT_1 = '111111111111111111111111';
+const AGENT_2 = '222222222222222222222222';
+
+describe('org for each request', () => {
+  let home: ReturnType<typeof useTempHome>;
+  beforeEach(() => {
+    cleanEnv();
+    home = useTempHome();
+    vi.spyOn(process, 'cwd').mockReturnValue(home.dir);
+    setAskers({});
+    setOrgFlag(undefined);
+    IndemnClient.saveConfig({
+      environment: 'dev', user_id: 'u1', session: { token: jwtExpiringIn(5 * 3_600_000) },
+      orgs: [{ id: A, name: 'QA A' }, { id: B, name: 'QA B' }],
+      org_id: B, // legacy default org: must be ignored
+    });
+  });
+  afterEach(() => { setOrgFlag(undefined); home.cleanup(); });
+
+  const bots = (c: IndemnClient) => c.copilotGet('/organization/:org_id/ai-studio/v2/bots');
+
+  it('uses --org, not the legacy org saved in the config', async () => {
+    setOrgFlag(A);
+    const { calls } = recordFetch();
+    await bots(new IndemnClient());
+    expect(calls[0].url).toContain(`/organization/${A}/`);
+  });
+
+  it('with two orgs and nobody to ask, needs input (exit 2) and sends nothing org-scoped', async () => {
+    const { calls } = recordFetch();
+    const err = await bots(new IndemnClient()).catch((e) => e);
+    expect(err).toBeInstanceOf(NeedsInputError);
+    expect(err.exitCode).toBe(2);
+    expect(calls).toHaveLength(0);
+  });
+
+  it('asks when someone can answer, and reports the choice once', async () => {
+    setAskers({ chooseOrg: async () => B });
+    const seen = vi.fn();
+    onOrgResolved(seen);
+    const { calls } = recordFetch();
+    const client = new IndemnClient();
+    await bots(client);
+    await bots(client);
+    expect(calls.every((c) => c.url.includes(`/organization/${B}/`))).toBe(true);
+    expect(seen).toHaveBeenCalledTimes(1);
+    expect(seen).toHaveBeenCalledWith({ id: B, name: 'QA B', source: 'asked', environment: 'dev' });
+  });
+
+  it('uses the linked folder and refuses an agent that is not linked, naming the file', async () => {
+    const project = join(home.dir, 'project');
+    mkdirSync(join(project, '.indemn'), { recursive: true });
+    writeFileSync(join(project, '.indemn', 'project.json'), JSON.stringify({ org_id: A, environment: 'dev', agents: [AGENT_1] }));
+    vi.spyOn(process, 'cwd').mockReturnValue(project);
+    const { calls } = recordFetch();
+    const client = new IndemnClient();
+    await client.copilotGet(`/organization/:org_id/ai-studio/v2/bots/${AGENT_1}`);
+    expect(calls[0].url).toContain(`/organization/${A}/ai-studio/v2/bots/${AGENT_1}`);
+    await expect(client.copilotGet(`/organization/:org_id/ai-studio/bots/${AGENT_2}/configurations`))
+      .rejects.toThrow(join(home.dir, 'project', '.indemn', 'project.json'));
+    expect(calls).toHaveLength(1);
+  });
+
+  it('lets one MCP call act on its own org', async () => {
+    setOrgFlag(A);
+    const { calls } = recordFetch();
+    const client = new IndemnClient();
+    await runWithOrg(B, () => bots(client));
+    expect(calls[0].url).toContain(`/organization/${B}/`);
+  });
+
+  it('uses the only org without asking', async () => {
+    IndemnClient.saveConfig({ orgs: [{ id: A, name: 'QA A' }] });
+    const ask = vi.fn();
+    setAskers({ chooseOrg: ask });
+    const { calls } = recordFetch();
+    await bots(new IndemnClient());
+    expect(calls[0].url).toContain(`/organization/${A}/`);
+    expect(ask).not.toHaveBeenCalled();
+  });
+});

package/test/harness.test.ts

@@ -0,0 +1,24 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { recordFetch, on } from './helpers/fetch-recorder.js';
+import { cleanEnv, useTempHome } from './helpers/config-home.js';
+import { IndemnClient } from '../src/sdk/client.js';
+
+describe('test harness', () => {
+  let home: ReturnType<typeof useTempHome>;
+  afterEach(() => home?.cleanup());
+
+  it('records fetch calls and answers with scripted JSON', async () => {
+    const { calls } = recordFetch([on('GET', '/ping', { json: { pong: true } })]);
+    const res = await fetch('https://example.test/ping', { headers: { 'X-Test': '1' } });
+    expect(await res.json()).toEqual({ pong: true });
+    expect(calls).toEqual([
+      { method: 'GET', url: 'https://example.test/ping', headers: { 'x-test': '1' }, body: undefined },
+    ]);
+  });
+
+  it('isolates HOME so no real config is read', () => {
+    cleanEnv();
+    home = useTempHome();
+    expect(IndemnClient.loadConfig()).toBeNull();
+  });
+});

package/test/helpers/config-home.ts

@@ -0,0 +1,22 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { vi } from 'vitest';
+
+/** Point HOME at a fresh temporary folder so tests never touch ~/.indemn. */
+export function useTempHome() {
+  const dir = mkdtempSync(join(tmpdir(), 'indemn-test-'));
+  vi.stubEnv('HOME', dir);
+  return { dir, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
+}
+
+/** Clear every variable that changes CLI behaviour, including the ones Claude Code sets. */
+export function cleanEnv() {
+  for (const name of [
+    'CLAUDECODE', 'CI', 'INDEMN_NON_INTERACTIVE', 'INDEMN_DEBUG', 'INDEMN_ENV', 'INDEMN_API_KEY',
+    'INDEMN_TOKEN', 'INDEMN_ORG_ID', 'INDEMN_NO_BANNER', 'INDEMN_COPILOT_URL', 'INDEMN_EVALS_URL',
+    'INDEMN_MIDDLEWARE_URL', 'INDEMN_PLATFORM_URL',
+  ]) {
+    vi.stubEnv(name, undefined as unknown as string);
+  }
+}

package/test/helpers/fake-middleware.ts

@@ -0,0 +1,56 @@
+import { createServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { Server } from 'socket.io';
+
+export interface FakeMiddleware {
+  url: string;
+  sessionRequests: Array<Record<string, any>>;
+  userMessages: Array<Record<string, any>>;
+  closed: Array<Record<string, any>>;
+  close: () => Promise<void>;
+}
+
+/**
+ * A stand-in for middleware-socket-service: confirms a session, streams a
+ * greeting for new sessions, and answers each user message with a streamed
+ * reply "echo: <message>".
+ */
+export async function startFakeMiddleware(opts: { sessionId?: string; greeting?: string } = {}): Promise<FakeMiddleware> {
+  const http = createServer();
+  const io = new Server(http, { transports: ['websocket'] });
+  const state: FakeMiddleware = { url: '', sessionRequests: [], userMessages: [], closed: [], close: async () => {} };
+  let streamCount = 0;
+
+  const stream = (socket: import('socket.io').Socket, text: string) => {
+    const streamId = `s${++streamCount}`;
+    const words = text.split(' ');
+    words.forEach((w, i) => {
+      socket.emit('stream_bot_uttered', {
+        streamId,
+        isFirstChunk: i === 0,
+        text: (i ? ' ' : '') + w,
+        streamFinished: false,
+      });
+    });
+    socket.emit('stream_bot_uttered', { streamId, text: '', streamFinished: true });
+  };
+
+  io.on('connection', (socket) => {
+    socket.on('session_request', (req) => {
+      state.sessionRequests.push(req);
+      const sessionId = req.session_id || opts.sessionId || 'sess-1';
+      socket.emit('session_confirm', { session_id: sessionId });
+      if (!req.session_id) setTimeout(() => stream(socket, opts.greeting ?? 'Hello there'), 10);
+    });
+    socket.on('user_uttered', (msg) => {
+      state.userMessages.push(msg);
+      setTimeout(() => stream(socket, `echo: ${msg.message}`), 10);
+    });
+    socket.on('session_closed', (msg) => state.closed.push(msg));
+  });
+
+  await new Promise<void>((resolve) => http.listen(0, '127.0.0.1', resolve));
+  state.url = `http://127.0.0.1:${(http.address() as AddressInfo).port}`;
+  state.close = () => new Promise((resolve) => { io.close(() => resolve()); });
+  return state;
+}

package/test/helpers/fetch-recorder.ts

@@ -0,0 +1,75 @@
+import { vi } from 'vitest';
+
+export interface RecordedCall {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  body: unknown;
+}
+
+export interface ScriptedResponse {
+  status?: number;
+  json?: unknown;
+  text?: string;
+  /** Throw a network error instead of answering. */
+  networkError?: boolean;
+}
+
+export type Responder = (call: RecordedCall) => ScriptedResponse | undefined;
+
+function parseBody(body: unknown): unknown {
+  if (typeof body !== 'string') return body instanceof URLSearchParams ? body.toString() : body;
+  try {
+    return JSON.parse(body);
+  } catch {
+    return body;
+  }
+}
+
+function toResponse(r: ScriptedResponse): Response {
+  const status = r.status ?? 200;
+  if (r.json !== undefined) {
+    return new Response(JSON.stringify(r.json), { status, headers: { 'content-type': 'application/json' } });
+  }
+  return new Response(r.text ?? '', { status });
+}
+
+/**
+ * Replace global fetch with a recorder. Responders are tried in order; the
+ * first one that returns a response answers the call. Unmatched calls get
+ * 200 `{ success: true, data: [] }`.
+ */
+export function recordFetch(responders: Responder[] = []) {
+  const calls: RecordedCall[] = [];
+  const fn = vi.fn(async (input: string | URL | Request, init: RequestInit = {}) => {
+    const headers: Record<string, string> = {};
+    new Headers(init.headers).forEach((value, key) => {
+      headers[key] = value;
+    });
+    const call: RecordedCall = {
+      method: (init.method || 'GET').toUpperCase(),
+      url: typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url,
+      headers,
+      body: parseBody(init.body),
+    };
+    calls.push(call);
+    for (const responder of responders) {
+      const res = responder(call);
+      if (res) {
+        if (res.networkError) throw new TypeError('fetch failed');
+        return toResponse(res);
+      }
+    }
+    return toResponse({ json: { success: true, data: [] } });
+  });
+  vi.stubGlobal('fetch', fn);
+  return { calls, fn };
+}
+
+/** Match a call by method and a URL substring. */
+export function on(method: string, urlPart: string, res: ScriptedResponse | ((c: RecordedCall) => ScriptedResponse)): Responder {
+  return (call) => {
+    if (call.method !== method.toUpperCase() || !call.url.includes(urlPart)) return undefined;
+    return typeof res === 'function' ? res(call) : res;
+  };
+}

package/test/helpers/jwt.ts

@@ -0,0 +1,9 @@
+/** An unsigned JWT-shaped string with the given claims. Only the payload matters to the CLI. */
+export function fakeJwt(claims: Record<string, unknown>): string {
+  const enc = (o: unknown) => Buffer.from(JSON.stringify(o)).toString('base64url');
+  return `${enc({ alg: 'HS256', typ: 'JWT' })}.${enc(claims)}.sig`;
+}
+
+export function jwtExpiringIn(ms: number, extra: Record<string, unknown> = {}): string {
+  return fakeJwt({ _id: 'user1', email: 'qa@indemn.ai', exp: Math.floor((Date.now() + ms) / 1000), ...extra });
+}

package/test/helpers/mcp-pair.ts

@@ -0,0 +1,38 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { ElicitRequestSchema, type ElicitResult } from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * A real MCP server and client joined in memory. Pass `elicit` to make the
+ * client advertise elicitation and answer every question with it.
+ */
+export async function connectPair(
+  setup: (server: McpServer) => void,
+  opts: { elicit?: (params: { message: string; requestedSchema: unknown }) => ElicitResult } = {},
+) {
+  const server = new McpServer({ name: 'test', version: '0.0.0' });
+  setup(server);
+  const client = new Client(
+    { name: 'test-client', version: '0.0.0' },
+    { capabilities: opts.elicit ? { elicitation: {} } : {} },
+  );
+  const questions: Array<{ message: string; requestedSchema: unknown }> = [];
+  if (opts.elicit) {
+    client.setRequestHandler(ElicitRequestSchema, async (req) => {
+      const params = req.params as { message: string; requestedSchema: unknown };
+      questions.push(params);
+      return opts.elicit!(params);
+    });
+  }
+  const [a, b] = InMemoryTransport.createLinkedPair();
+  await Promise.all([server.connect(a), client.connect(b)]);
+  const call = async (name: string, args: Record<string, unknown> = {}) => {
+    const res = await client.callTool({ name, arguments: args });
+    const content = res.content as Array<{ type: string; text: string }>;
+    let parsed: unknown = content[0]?.text;
+    try { parsed = JSON.parse(content[0].text); } catch { /* plain text */ }
+    return { raw: res, body: parsed as any, isError: Boolean(res.isError) };
+  };
+  return { server, client, call, questions, close: () => Promise.all([client.close(), server.close()]) };
+}

package/test/mcp/__snapshots__/tools-snapshot.test.ts.snap

@@ -0,0 +1,145 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`MCP tool list > gives every tool a title and annotations 1`] = `
+[
+  "add_function_parameter",
+  "add_holiday",
+  "add_kb_data",
+  "agent_stats",
+  "agent_summary",
+  "archive_ticket",
+  "attach_phone_number",
+  "bulk_create_skills",
+  "buy_phone_number",
+  "chat_with_agent",
+  "clone_agent",
+  "compare_eval_runs",
+  "create_agent",
+  "create_agent_from_template",
+  "create_distribution",
+  "create_function",
+  "create_knowledge_base",
+  "create_rubric",
+  "create_template",
+  "create_test_set",
+  "create_ticket",
+  "delete_agent",
+  "delete_function",
+  "delete_function_parameter",
+  "delete_kb_data",
+  "delete_knowledge_base",
+  "delete_rubric",
+  "delete_template",
+  "delete_test_set",
+  "delete_ticket_rule",
+  "detach_phone_number",
+  "eval_gate_verdict",
+  "eval_quality_metrics",
+  "eval_report_link",
+  "eval_trends",
+  "evaluate_transcript",
+  "export_agent",
+  "export_agent_card",
+  "export_eval_markdown",
+  "export_eval_report",
+  "export_functions",
+  "export_kb",
+  "generate_skills_from_doc",
+  "get_agent",
+  "get_agent_voice",
+  "get_analytics",
+  "get_billing",
+  "get_bot_context",
+  "get_campaigns",
+  "get_config",
+  "get_conversation",
+  "get_custom_chart",
+  "get_embed_code",
+  "get_eval_results",
+  "get_eval_status",
+  "get_knowledge_base",
+  "get_org_settings",
+  "get_phone_number",
+  "get_prompt",
+  "get_rubric",
+  "get_test_set",
+  "get_ticket",
+  "import_agent",
+  "import_functions",
+  "import_kb",
+  "jarvis_chat",
+  "jarvis_create_job",
+  "jarvis_jobs",
+  "kb_check",
+  "kb_chunks",
+  "kb_gaps",
+  "kb_scrape_status",
+  "link_kb",
+  "list_agent_numbers",
+  "list_agents",
+  "list_analytics_conversations",
+  "list_audit_logs",
+  "list_channels",
+  "list_conversations",
+  "list_custom_charts",
+  "list_distributions",
+  "list_evaluator_configs",
+  "list_function_parameters",
+  "list_functions",
+  "list_kb_data",
+  "list_knowledge_bases",
+  "list_llm_models",
+  "list_master_functions",
+  "list_org_members",
+  "list_organizations",
+  "list_prod_calls",
+  "list_rubric_versions",
+  "list_rubrics",
+  "list_solutions",
+  "list_templates",
+  "list_test_set_versions",
+  "list_test_sets",
+  "list_ticket_rules",
+  "list_tickets",
+  "list_voice_models",
+  "list_voices",
+  "mark_conversation_test",
+  "org_evaluations",
+  "platform_delete",
+  "platform_get",
+  "platform_list",
+  "platform_save",
+  "promote_prod_call",
+  "reimport_kb_source",
+  "run_evaluation",
+  "run_simulation",
+  "save_ticket_rule",
+  "scrape_url",
+  "search_phone_numbers",
+  "set_agent_lifecycle",
+  "set_agent_transcriber",
+  "set_agent_voice",
+  "set_business_hours",
+  "set_config",
+  "set_org_admin_settings",
+  "set_org_timezone",
+  "set_prompt",
+  "simulation_status",
+  "test_function",
+  "transfer_agent_owner",
+  "unlink_kb",
+  "update_agent",
+  "update_distribution",
+  "update_function",
+  "update_function_parameter",
+  "update_kb_data",
+  "update_knowledge_base",
+  "update_rubric",
+  "update_test_set",
+  "update_ticket",
+  "upload_kb_file",
+  "validate_platform_template",
+  "voice_preview",
+  "whoami",
+]
+`;

package/test/mcp/askers.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { recordFetch } from '../helpers/fetch-recorder.js';
+import { cleanEnv, useTempHome } from '../helpers/config-home.js';
+import { jwtExpiringIn } from '../helpers/jwt.js';
+import { connectPair } from '../helpers/mcp-pair.js';
+import { IndemnClient } from '../../src/sdk/client.js';
+import { registerTools } from '../../src/mcp/tools.js';
+import { mcpAskers } from '../../src/mcp/server.js';
+import { setAskers } from '../../src/core/scope.js';
+
+const A = 'aaaaaaaaaaaaaaaaaaaaaaaa';
+const B = 'bbbbbbbbbbbbbbbbbbbbbbbb';
+
+describe('MCP asks which org', () => {
+  let home: ReturnType<typeof useTempHome>;
+  beforeEach(() => {
+    cleanEnv();
+    home = useTempHome();
+    vi.spyOn(process, 'cwd').mockReturnValue(home.dir);
+    IndemnClient.saveConfig({
+      environment: 'dev', user_id: 'u1', session: { token: jwtExpiringIn(5 * 3_600_000) },
+      orgs: [{ id: A, name: 'QA A' }, { id: B, name: 'QA B' }],
+    });
+  });
+  afterEach(() => { setAskers({}); home.cleanup(); });
+
+  function setup(server: Parameters<typeof mcpAskers>[0]) {
+    setAskers(mcpAskers(server));
+    registerTools(server, new IndemnClient());
+  }
+
+  it('asks the person through the host and acts on the org they pick', async () => {
+    const { calls } = recordFetch();
+    const pair = await connectPair(setup, { elicit: () => ({ action: 'accept', content: { org_id: B } }) });
+    const res = await pair.call('list_agents');
+    expect(calls[0].url).toContain(`/organization/${B}/ai-studio/v2/bots`);
+    expect(res.body.context).toEqual({ org_id: B, org_name: 'QA B', environment: 'dev' });
+    expect(JSON.stringify(pair.questions[0].requestedSchema)).toContain('QA A');
+    await pair.close();
+  });
+
+  it('without elicitation, returns the choices instead of guessing', async () => {
+    const { calls } = recordFetch();
+    const pair = await connectPair(setup);
+    const res = await pair.call('list_agents');
+    expect(res.isError).toBe(false);
+    expect(res.body).toMatchObject({ needs_input: true, choices: [{ id: A, label: 'QA A' }, { id: B, label: 'QA B' }] });
+    expect(calls).toHaveLength(0);
+    await pair.close();
+  });
+
+  it('an explicit org_id needs no question', async () => {
+    const { calls } = recordFetch();
+    const pair = await connectPair(setup, { elicit: () => { throw new Error('should not ask'); } });
+    await pair.call('list_agents', { org_id: A });
+    expect(calls[0].url).toContain(`/organization/${A}/`);
+    expect(pair.questions).toHaveLength(0);
+    await pair.close();
+  });
+});

package/test/mcp/elicit-timeout.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it, vi } from 'vitest';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { guardDestructive } from '../../src/mcp/registry.js';
+import { PERSON_TIMEOUT_MS } from '../../src/core/runtime.js';
+
+function serverAskingWith(impl: (...a: unknown[]) => Promise<unknown>) {
+  const server = new McpServer({ name: 't', version: '0' });
+  vi.spyOn(server.server, 'getClientCapabilities').mockReturnValue({ elicitation: {} });
+  const spy = vi.spyOn(server.server, 'elicitInput').mockImplementation(impl as never);
+  return { server, spy };
+}
+
+describe('asking a person through the host', () => {
+  it('gives the person 10 minutes, not the MCP default of 60 seconds', async () => {
+    const { server, spy } = serverAskingWith(async () => ({ action: 'accept', content: { confirm: true } }));
+    await expect(guardDestructive(server, 'wipe', {}, 'This will wipe.')).resolves.toMatchObject({ proceed: true });
+    expect(spy.mock.calls[0][1]).toEqual({ timeout: PERSON_TIMEOUT_MS });
+    expect(PERSON_TIMEOUT_MS).toBe(600_000);
+  });
+
+  it('treats no answer in time as cancelled, never as a dry run to self-confirm', async () => {
+    const { server } = serverAskingWith(async () => { throw new McpError(ErrorCode.RequestTimeout, 'Request timed out'); });
+    const res = await guardDestructive(server, 'wipe', { confirm: true }, 'This will wipe.');
+    expect(res.proceed).toBe(false);
+    const body = JSON.parse((res as { result: { content: Array<{ text: string }> } }).result.content[0].text);
+    expect(body).toMatchObject({ cancelled: true, reason: 'No answer within 10 minutes; nothing was changed.' });
+  });
+});