@robota-sdk/agent-ui-terminal 3.0.0-beta.81

package/src/__tests__/message-list-rendering.test.tsx

@@ -0,0 +1,473 @@
+/**
+ * Rendering tests for MessageList — verifies that IHistoryEntry[]
+ * entries render with correct labels and content.
+ *
+ * These tests catch rendering bugs that data-flow tests miss:
+ * - tool execution list must show "Tool:" label with tool names
+ * - chat messages must show correct role labels
+ * - event entries must show formatted content
+ */
+
+import React from 'react';
+import chalk from 'chalk';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import MessageList from '../MessageList.js';
+import { STATUS_SYMBOL, statusGlyphColor } from '../status-glyph.js';
+import { DARK_THEME } from '../theme/built-in-themes.js';
+import type { IHistoryEntry } from '@robota-sdk/agent-core';
+import {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  createToolMessage,
+  messageToHistoryEntry,
+} from '@robota-sdk/agent-core';
+
+function makeToolSummaryEntry(): IHistoryEntry {
+  return {
+    id: 'tool-1',
+    timestamp: new Date(),
+    category: 'event',
+    type: 'tool-summary',
+    data: {
+      tools: [
+        { toolName: 'Read', firstArg: 'file.ts', isRunning: false, result: 'success' },
+        { toolName: 'Edit', firstArg: 'file.ts', isRunning: false, result: 'success' },
+      ],
+      summary: '✓ Read(file.ts)\n✓ Edit(file.ts)',
+    },
+  };
+}
+
+function makeSkillInvocationEntry(): IHistoryEntry {
+  return {
+    id: 'evt-1',
+    timestamp: new Date(),
+    category: 'event',
+    type: 'skill-activation',
+    data: {
+      type: 'skill-activation',
+      skillName: 'audit',
+      source: 'plugin',
+      invocation: 'user-slash',
+      mode: 'inject',
+      status: 'started',
+      timestamp: '2026-05-06T00:00:00.000Z',
+      message: 'Invoking plugin skill: audit',
+    },
+  };
+}
+
+describe('MessageList rendering', () => {
+  // ── Tool summary rendering ────────────────────────────────────
+
+  it('tool execution list renders with "Tool:" label and tool names', () => {
+    const history: IHistoryEntry[] = [makeToolSummaryEntry()];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Tool:');
+    expect(output).toContain('Read(file.ts)');
+    expect(output).toContain('Edit(file.ts)');
+  });
+
+  // ── SCREEN-006: status colors come from the status symbol + theme colour SSOT ─
+
+  it('denied tool summary renders the denied status colour (yellowBright) and glyph', () => {
+    // Pin color bytes regardless of the test process's TTY detection (cjk-fallback precedent).
+    const originalChalkLevel = chalk.level;
+    chalk.level = 3;
+    const history: IHistoryEntry[] = [
+      {
+        id: 'tool-denied-1',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [{ toolName: 'Edit', firstArg: 'file.ts', isRunning: false, result: 'denied' }],
+          summary: '⊘ Edit(file.ts)',
+        },
+      },
+    ];
+    try {
+      const { lastFrame } = render(<MessageList history={history} />);
+      const output = lastFrame() ?? '';
+
+      expect(statusGlyphColor(DARK_THEME.colors, 'denied')).toBe('yellowBright');
+      expect(output).toContain(STATUS_SYMBOL.denied);
+      // chalk yellowBright opens with ESC[93m; the old hand-rolled mapping drifted to
+      // plain yellow (ESC[33m) — this pins the tool summary to the SSOT color.
+      expect(output).toContain('\u001b[93m');
+    } finally {
+      chalk.level = originalChalkLevel;
+    }
+  });
+
+  // ── Skill invocation rendering ────────────────────────────────
+
+  it('skill-activation event renders with "System:" label and message', () => {
+    const history: IHistoryEntry[] = [makeSkillInvocationEntry()];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('System:');
+    expect(output).toContain('Invoking plugin skill: audit');
+  });
+
+  // ── Chat message rendering ────────────────────────────────────
+
+  it('renders nothing for a recorded event that carries no message', () => {
+    const history: IHistoryEntry[] = ['provider-call-trace', 'usage-observation'].map((type) => ({
+      id: type,
+      timestamp: new Date(),
+      category: 'event',
+      type,
+      data: { traceId: 'trace-1', outcome: 'success' },
+    }));
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = chalk.reset(lastFrame() ?? '');
+
+    expect(output).not.toContain('System:');
+    expect(output).not.toContain('provider-call-trace');
+    expect(output).not.toContain('usage-observation');
+  });
+
+  it('user message renders with "You:" label', () => {
+    const history: IHistoryEntry[] = [messageToHistoryEntry(createUserMessage('hello'))];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('You:');
+    expect(output).toContain('hello');
+  });
+
+  it('assistant message renders with "Assistant:" label', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createAssistantMessage('response text')),
+    ];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Assistant:');
+    expect(output).toContain('response text');
+  });
+
+  it('assistant message preserves CJK and emoji content', () => {
+    const content = '긴 한국어 응답과 emoji 🎉 를 표시합니다';
+    const history: IHistoryEntry[] = [messageToHistoryEntry(createAssistantMessage(content))];
+    const { lastFrame } = render(<MessageList history={history} />);
+
+    expect(lastFrame()).toContain(content);
+  });
+
+  it('assistant message renders markdown diff fenced code block content', () => {
+    const response = [
+      'Patch preview:',
+      '',
+      '```diff',
+      '- const oldValue = true;',
+      '+ const newValue = true;',
+      '```',
+    ].join('\n');
+    const history: IHistoryEntry[] = [messageToHistoryEntry(createAssistantMessage(response))];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Assistant:');
+    expect(output).toContain('Patch preview:');
+    expect(output).toContain('- const oldValue = true;');
+    expect(output).toContain('+ const newValue = true;');
+  });
+
+  it('tool message diff summary renders through markdown diff body format', () => {
+    const toolSummary = [
+      {
+        line: 'Edit(/src/index.ts)',
+        diffFile: '/src/index.ts',
+        diffLines: [
+          { type: 'remove', lineNumber: 1, text: 'const oldValue = true;' },
+          { type: 'add', lineNumber: 1, text: 'const newValue = true;' },
+        ],
+      },
+    ];
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(
+        createToolMessage(JSON.stringify(toolSummary), {
+          toolCallId: 'call_1',
+          name: 'tools',
+        }),
+      ),
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('/src/index.ts');
+    expect(output).toContain('- 1 | const oldValue = true;');
+    expect(output).toContain('+ 1 | const newValue = true;');
+    expect(output).not.toContain('│ 1 - const oldValue = true;');
+  });
+
+  it('tool-summary event renders persisted edit diff metadata', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'summary_1',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [
+            {
+              toolName: 'Edit',
+              firstArg: '/src/index.ts',
+              isRunning: false,
+              result: 'success',
+              diffFile: '/src/index.ts',
+              diffLines: [
+                { type: 'remove', lineNumber: 1, text: 'const temporary = true;' },
+                { type: 'add', lineNumber: 1, text: 'const original = true;' },
+              ],
+            },
+          ],
+          summary: '✓ Edit(/src/index.ts)',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('/src/index.ts');
+    expect(output).toContain('- 1 | const temporary = true;');
+    expect(output).toContain('+ 1 | const original = true;');
+  });
+
+  it('tool-summary event collapses long command output with transcript hint', () => {
+    const commandOutput = Array.from({ length: 7 }, (_, index) => `line-${index + 1}`).join('\n');
+    const history: IHistoryEntry[] = [
+      {
+        id: 'summary_command_long',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [
+            {
+              toolName: 'Bash',
+              firstArg: 'pnpm test',
+              isRunning: false,
+              result: 'success',
+              toolResultData: JSON.stringify({
+                success: true,
+                output: commandOutput,
+                exitCode: 0,
+              }),
+            },
+          ],
+          summary: '✓ Bash(pnpm test)',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('✓ Bash(pnpm test)');
+    expect(output).toContain('line-1');
+    expect(output).toContain('line-4');
+    expect(output).not.toContain('line-5');
+    expect(output).toContain('... +3 lines (full output in session transcript)');
+  });
+
+  it('tool-summary event marks non-zero command exits as failed', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'summary_command_failed',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'tool-summary',
+        data: {
+          tools: [
+            {
+              toolName: 'Bash',
+              firstArg: 'exit 42',
+              isRunning: false,
+              result: 'success',
+              toolResultData: JSON.stringify({ success: true, output: '', exitCode: 42 }),
+            },
+          ],
+          summary: '✓ Bash(exit 42)',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('✗ Bash(exit 42)');
+    expect(output).toContain('exit 42');
+  });
+
+  it('usage-summary event renders compact token and cost visibility', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'usage_1',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'usage-summary',
+        data: {
+          kind: 'exact',
+          scope: 'turn',
+          promptTokens: 100,
+          completionTokens: 50,
+          totalTokens: 150,
+          contextUsedTokens: 150,
+          contextMaxTokens: 1000,
+          contextUsedPercentage: 15,
+          costStatus: 'unknown',
+        },
+      },
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('Usage:');
+    expect(output).toContain('exact');
+    expect(output).toContain('150 tokens');
+    expect(output).toContain('in 100');
+    expect(output).toContain('out 50');
+    expect(output).toContain('cost unknown');
+  });
+
+  it('usage-summary from another source names it and omits the context window', () => {
+    const history: IHistoryEntry[] = [
+      {
+        id: 'usage_advisor',
+        timestamp: new Date(),
+        category: 'event',
+        type: 'usage-summary',
+        data: {
+          kind: 'exact',
+          scope: 'turn',
+          promptTokens: 3000,
+          completionTokens: 400,
+          totalTokens: 3400,
+          contextUsedTokens: 0,
+          contextMaxTokens: 0,
+          contextUsedPercentage: 0,
+          costStatus: 'estimated',
+          costUsd: 0.05,
+          source: { scope: 'tool', id: 'advisor:big-model', label: 'Advisor (big-model)' },
+        },
+      },
+    ];
+
+    const output = render(<MessageList history={history} />).lastFrame() ?? '';
+
+    expect(output).toContain('Usage (Advisor (big-model)):');
+    expect(output).toContain('out 400');
+    expect(output).not.toContain('Context');
+  });
+
+  it('system message renders with "System:" label', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createSystemMessage('Interrupted by user.')),
+    ];
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    expect(output).toContain('System:');
+    expect(output).toContain('Interrupted by user.');
+  });
+
+  // ── Display order after abort ─────────────────────────────────
+
+  it('abort display order: You → Tool → Assistant → System', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createUserMessage('/audit')),
+      makeToolSummaryEntry(),
+      messageToHistoryEntry(createAssistantMessage('partial response')),
+      messageToHistoryEntry(createSystemMessage('Interrupted by user.')),
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    const youIdx = output.indexOf('You:');
+    const toolIdx = output.indexOf('Tool:');
+    const assistantIdx = output.indexOf('Assistant:');
+    const systemIdx = output.indexOf('Interrupted by user.');
+
+    // All must be present
+    expect(youIdx).toBeGreaterThanOrEqual(0);
+    expect(toolIdx).toBeGreaterThanOrEqual(0);
+    expect(assistantIdx).toBeGreaterThanOrEqual(0);
+    expect(systemIdx).toBeGreaterThanOrEqual(0);
+
+    // Order: You → Tool → Assistant → System
+    expect(youIdx).toBeLessThan(toolIdx);
+    expect(toolIdx).toBeLessThan(assistantIdx);
+    expect(assistantIdx).toBeLessThan(systemIdx);
+  });
+
+  // ── Mixed history ─────────────────────────────────────────────
+
+  it('renders mixed chat and event entries in order', () => {
+    const history: IHistoryEntry[] = [
+      messageToHistoryEntry(createUserMessage('hello')),
+      makeSkillInvocationEntry(),
+      makeToolSummaryEntry(),
+      messageToHistoryEntry(createAssistantMessage('done')),
+    ];
+
+    const { lastFrame } = render(<MessageList history={history} />);
+    const output = lastFrame() ?? '';
+
+    // All four entries rendered
+    expect(output).toContain('You:');
+    expect(output).toContain('Invoking plugin skill: audit');
+    expect(output).toContain('Tool:');
+    expect(output).toContain('Assistant:');
+  });
+});
+
+/**
+ * PEER-007 (issue #1915) — a co-driven transcript must say WHO drove each turn.
+ *
+ * Before this, every user message rendered `You:`, so a peer session's message was
+ * indistinguishable from the operator's own — the transcript asserted something false about who
+ * spoke. The label reads the DERIVED driver id (`peer:<session-id>`) carried on the message; it is
+ * display attribution and never an authorization signal (issue #1809).
+ */
+describe('MessageList driver attribution (PEER-007)', () => {
+  it("labels a peer-driven message with the peer's id instead of You:", () => {
+    const entry = messageToHistoryEntry(
+      createUserMessage('deploy the staging branch', {
+        metadata: { driverId: 'peer:session-abc' },
+      }),
+    );
+    const { lastFrame } = render(<MessageList history={[entry]} />);
+    const output = chalk.reset(lastFrame() ?? '');
+
+    expect(output).toContain('peer:session-abc:');
+    expect(output).not.toContain('You:');
+  });
+
+  it('still labels the owner as You:', () => {
+    const entry = messageToHistoryEntry(
+      createUserMessage('deploy the staging branch', { metadata: { driverId: 'owner' } }),
+    );
+    const { lastFrame } = render(<MessageList history={[entry]} />);
+
+    expect(chalk.reset(lastFrame() ?? '')).toContain('You:');
+  });
+
+  it('labels an unattributed message You: — the pre-PEER-007 transcript is unchanged', () => {
+    const entry = messageToHistoryEntry(createUserMessage('deploy the staging branch'));
+    const { lastFrame } = render(<MessageList history={[entry]} />);
+
+    expect(chalk.reset(lastFrame() ?? '')).toContain('You:');
+  });
+});

package/src/__tests__/org-policy-reaches-the-channel.test.ts

@@ -0,0 +1,77 @@
+/**
+ * CLI-083 (issue #2287) — the org policy survives the TUI projection.
+ *
+ * `toChannelOptions` builds the channel's options field by field. `orgPolicy` was not among them, so
+ * a policy forwarded from the shell arrived here and was dropped, and `blockedCommands` enforcement
+ * stayed dead on the plain `robota` path — the most common one — after two rounds of wiring it.
+ *
+ * The reason it was silent is worth keeping: the shell forwards with
+ * `...(orgPolicy === null ? {} : { orgPolicy })`, and a SPREAD BYPASSES TypeScript's excess-property
+ * check. Written as `orgPolicy,` it would not have compiled against an `IRenderOptions` that lacks
+ * the field. The idiom chosen to be safe about optionality disabled the check that would have caught
+ * the missing declaration.
+ */
+
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { loadOrgPolicy } from '@robota-sdk/agent-framework';
+import { describe, expect, it, vi } from 'vitest';
+
+import { toChannelOptions } from '../render.js';
+import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
+import { buildTuiSessionOptions } from '../tui-session-options.js';
+
+import type { IRenderOptions } from '../render.js';
+
+const POLICY = { blockedCommands: ['clear'], adminContact: 'ops@x' };
+
+function renderOptions(extra: Partial<IRenderOptions> = {}): IRenderOptions {
+  return { cwd: '/work', provider: {} as never, ...extra } as IRenderOptions;
+}
+
+describe('CLI-083: the TUI projection carries the org policy', () => {
+  it('copies a supplied policy into the channel options', () => {
+    const channel = toChannelOptions(renderOptions({ orgPolicy: POLICY as never }));
+
+    expect((channel as { orgPolicy?: unknown }).orgPolicy).toEqual(POLICY);
+  });
+
+  it('carries none when none was supplied, so absence stays distinguishable', () => {
+    const channel = toChannelOptions(renderOptions());
+
+    expect((channel as { orgPolicy?: unknown }).orgPolicy).toBeUndefined();
+  });
+
+  it('preserves the same policy through the channel into the session', () => {
+    const channel = toChannelOptions(renderOptions({ orgPolicy: POLICY as never }));
+
+    expect((buildTuiSessionOptions(channel) as { orgPolicy?: unknown }).orgPolicy).toBe(POLICY);
+  });
+
+  it('enforces a blocked command from a policy file in a real TUI-owned session', async () => {
+    const home = realpathSync(mkdtempSync(join(tmpdir(), 'robota-tui-policy-')));
+    mkdirSync(join(home, '.robota'));
+    writeFileSync(join(home, '.robota', 'org-policy.json'), JSON.stringify(POLICY));
+    vi.stubEnv('HOME', home);
+    let channel: TuiInteractionChannel | undefined;
+    try {
+      const policy = loadOrgPolicy(join(home, '.robota', 'org-policy.json'));
+      expect(policy).not.toBeNull();
+      channel = new TuiInteractionChannel(
+        toChannelOptions(renderOptions({ cwd: home, orgPolicy: policy ?? undefined })),
+      );
+
+      const result = await channel.getSession().executeCommand('clear', '');
+
+      expect(result?.success).toBe(false);
+      expect(result?.message).toContain('Command /clear is blocked');
+      expect(result?.message).toContain('ops@x');
+    } finally {
+      await channel?.stop();
+      vi.unstubAllEnvs();
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/output-style-reaches-session.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+
+import { toChannelOptions } from '../render.js';
+import { buildTuiSessionOptions } from '../tui-session-options.js';
+
+import type { IRenderOptions } from '../render.js';
+import type { ITuiInteractionChannelOptions } from '../TuiInteractionChannel.js';
+import type { IOutputStylePrompt } from '@robota-sdk/agent-framework';
+
+const STYLE: IOutputStylePrompt = {
+  id: 'concise',
+  name: 'Concise',
+  instructions: 'Lead with the answer.',
+  keepCodingInstructions: true,
+  tokenCost: 'low',
+};
+
+const renderOptions = (over: Partial<IRenderOptions> = {}): IRenderOptions =>
+  ({ cwd: '/w', provider: {}, ...over }) as IRenderOptions;
+
+describe('CLI-1988 output-style projection', () => {
+  it('preserves the resolved style from render options through the TUI session options', () => {
+    const channel = toChannelOptions(renderOptions({ outputStyle: STYLE }));
+    expect(channel.outputStyle).toBe(STYLE);
+
+    const session = buildTuiSessionOptions(channel as ITuiInteractionChannelOptions);
+    expect(session).toHaveProperty('outputStyle', STYLE);
+  });
+
+  it('omits the style when no startup selection was supplied', () => {
+    expect(
+      'outputStyle' in buildTuiSessionOptions(renderOptions() as ITuiInteractionChannelOptions),
+    ).toBe(false);
+  });
+});