@robota-sdk/agent-transport 3.0.0-beta.64

package/src/tui/__tests__/command-effect-handler.test.ts

@@ -0,0 +1,128 @@
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { applyCommandEffects } from '../hooks/command-effect-handler.js';
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+import type { TUniversalValue } from '@robota-sdk/agent-core';
+
+function readSettingsFile(path: string): Record<string, TUniversalValue> {
+  if (!existsSync(path)) return {};
+  try {
+    // allow-fallback: test helper; corrupt settings return empty object
+    return JSON.parse(readFileSync(path, 'utf8')) as Record<string, TUniversalValue>;
+  } catch {
+    // allow-fallback: test helper; corrupt settings return empty object
+    return {};
+  }
+}
+
+function writeSettingsFile(path: string, settings: Record<string, TUniversalValue>): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + '\n', 'utf8');
+}
+
+function deleteSettingsFile(path: string): boolean {
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+
+function createCliAdapter(settingsPath: string): ITuiCliAdapter {
+  return {
+    getUserSettingsPath: () => settingsPath,
+    readSettings: readSettingsFile,
+    writeSettings: writeSettingsFile,
+    deleteSettings: deleteSettingsFile,
+    applyStatusLineSettings: vi.fn(),
+    reloadPluginCommandSource: vi.fn(),
+    applyActiveModelChange: vi.fn().mockReturnValue({ applied: true }),
+    getGitBranch: vi.fn().mockReturnValue(undefined),
+    getProviderDisplayName: vi.fn((type: string) => type),
+  };
+}
+
+function createDeps(settingsPath: string) {
+  return {
+    addEntry: vi.fn(),
+    requestShutdown: vi.fn(),
+    requestModelChange: vi.fn(),
+    openPluginTUI: vi.fn(),
+    openTransportTUI: vi.fn(),
+    openSessionPicker: vi.fn(),
+    openAgentSwitcher: vi.fn(),
+    renameSession: vi.fn(),
+    applyStatusLinePatch: vi.fn(),
+    cliAdapter: createCliAdapter(settingsPath),
+  };
+}
+
+describe('applyCommandEffects', () => {
+  let tempHome: string;
+  let settingsPath: string;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    tempHome = mkdtempSync(join(tmpdir(), 'robota-effect-'));
+    settingsPath = join(tempHome, '.robota', 'settings.json');
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('applies session rename effects through the UI dependency boundary', () => {
+    const deps = createDeps(settingsPath);
+
+    const handled = applyCommandEffects([{ type: 'session-renamed', name: 'my-session' }], deps);
+
+    expect(handled).toBe(true);
+    expect(deps.renameSession).toHaveBeenCalledWith('my-session');
+    expect(deps.requestShutdown).not.toHaveBeenCalled();
+  });
+
+  it('applies session picker effects through the UI dependency boundary', () => {
+    const deps = createDeps(settingsPath);
+
+    const handled = applyCommandEffects([{ type: 'session-picker-requested' }], deps);
+
+    expect(handled).toBe(true);
+    expect(deps.openSessionPicker).toHaveBeenCalledTimes(1);
+    expect(deps.requestShutdown).not.toHaveBeenCalled();
+  });
+
+  it('deletes user settings and requests shutdown for settings reset effects', () => {
+    const settingsDir = join(tempHome, '.robota');
+    mkdirSync(settingsDir, { recursive: true });
+    writeFileSync(settingsPath, '{}\n', 'utf8');
+    const deps = createDeps(settingsPath);
+
+    const handled = applyCommandEffects([{ type: 'settings-reset-requested' }], deps);
+
+    expect(handled).toBe(true);
+    expect(existsSync(settingsPath)).toBe(false);
+    expect(deps.addEntry).toHaveBeenCalledTimes(1);
+    expect(JSON.stringify(deps.addEntry.mock.calls[0])).toContain(`Deleted ${settingsPath}`);
+    expect(deps.requestShutdown).toHaveBeenCalledWith('other', 'Reset settings restart');
+  });
+
+  it('reports no-op settings reset when no user settings file exists', () => {
+    const deps = createDeps(settingsPath);
+
+    const handled = applyCommandEffects([{ type: 'settings-reset-requested' }], deps);
+
+    expect(handled).toBe(true);
+    expect(deps.addEntry).toHaveBeenCalledTimes(1);
+    expect(JSON.stringify(deps.addEntry.mock.calls[0])).toContain('No user settings found.');
+    expect(deps.requestShutdown).toHaveBeenCalledWith('other', 'Reset settings restart');
+  });
+});

package/src/tui/__tests__/command-output-summary.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, it } from 'vitest';
+import { formatCommandOutputSummary } from '../command-output-summary.js';
+
+describe('formatCommandOutputSummary', () => {
+  it('renders short command output inline without transcript decoration', () => {
+    const summary = formatCommandOutputSummary({
+      toolName: 'Bash',
+      firstArg: 'echo hello',
+      isRunning: false,
+      result: 'success',
+      toolResultData: JSON.stringify({ success: true, output: 'hello\n', exitCode: 0 }),
+    });
+
+    expect(summary).toMatchObject({
+      status: 'success',
+      statusLabel: 'ok',
+      previewLines: ['hello'],
+      omittedLineCount: 0,
+      transcriptHint: undefined,
+    });
+  });
+
+  it('renders long command output with a bounded preview and transcript hint', () => {
+    const output = Array.from({ length: 8 }, (_, index) => `line-${index + 1}`).join('\n');
+    const summary = formatCommandOutputSummary({
+      toolName: 'Bash',
+      firstArg: 'pnpm test',
+      isRunning: false,
+      result: 'success',
+      toolResultData: JSON.stringify({ success: true, output, exitCode: 0 }),
+    });
+
+    expect(summary?.previewLines).toEqual(['line-1', 'line-2', 'line-3', 'line-4']);
+    expect(summary?.omittedLineCount).toBe(4);
+    expect(summary?.transcriptHint).toBe('... +4 lines (full output in session transcript)');
+  });
+
+  it('keeps stderr distinct when stdout and stderr are structured separately', () => {
+    const summary = formatCommandOutputSummary({
+      toolName: 'Bash',
+      firstArg: 'node script.js',
+      isRunning: false,
+      result: 'success',
+      toolResultData: JSON.stringify({
+        success: true,
+        stdout: 'ok',
+        stderr: 'warn',
+        exitCode: 0,
+      }),
+    });
+
+    expect(summary?.previewLines).toEqual(['ok', '[stderr] warn']);
+  });
+
+  it('marks non-zero exit codes as failed even when the tool transport succeeded', () => {
+    const summary = formatCommandOutputSummary({
+      toolName: 'Bash',
+      firstArg: 'exit 42',
+      isRunning: false,
+      result: 'success',
+      toolResultData: JSON.stringify({ success: true, output: '', exitCode: 42 }),
+    });
+
+    expect(summary?.status).toBe('error');
+    expect(summary?.statusLabel).toBe('exit 42');
+    expect(summary?.previewLines).toEqual([]);
+  });
+
+  it('renders no-output commands without dangling transcript hints', () => {
+    const summary = formatCommandOutputSummary({
+      toolName: 'Bash',
+      firstArg: 'true',
+      isRunning: false,
+      result: 'success',
+      toolResultData: JSON.stringify({ success: true, output: '', exitCode: 0 }),
+    });
+
+    expect(summary?.status).toBe('success');
+    expect(summary?.previewLines).toEqual([]);
+    expect(summary?.omittedLineCount).toBe(0);
+    expect(summary?.transcriptHint).toBeUndefined();
+  });
+
+  it('ignores non-command tools', () => {
+    const summary = formatCommandOutputSummary({
+      toolName: 'Read',
+      firstArg: 'file.ts',
+      isRunning: false,
+      result: 'success',
+      toolResultData: 'large file content',
+    });
+
+    expect(summary).toBeUndefined();
+  });
+});

package/src/tui/__tests__/compact-event-bridge.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { createSystemMessage, messageToHistoryEntry } from '@robota-sdk/agent-core';
+import { TuiStateManager } from '../tui-state-manager.js';
+import { applyCompactEventToManager } from '../hooks/useInteractiveSession.js';
+
+describe('compact event bridge', () => {
+  it('syncs session history so automatic compaction notifications render', () => {
+    const manager = new TuiStateManager();
+    const notification = messageToHistoryEntry(
+      createSystemMessage('Auto compacted context: 84% -> 35%'),
+    );
+    const session = {
+      getFullHistory: () => [notification],
+    };
+
+    applyCompactEventToManager(session, manager);
+
+    expect(manager.history).toEqual([notification]);
+  });
+});

package/src/tui/__tests__/confirm-permission-flow.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import {
+  applyConfirmPromptInput,
+  getConfirmPromptInputAction,
+} from '../flows/confirm-prompt-flow.js';
+import {
+  applyPermissionPromptInput,
+  getPermissionPromptInputAction,
+} from '../flows/permission-prompt-flow.js';
+import { createSelectionFlowState } from '../flows/selection-flow.js';
+
+describe('confirm prompt flow', () => {
+  it('Given two options When y shortcut is mapped and applied Then first option is selected', () => {
+    const action = getConfirmPromptInputAction('y', {}, 2);
+    expect(action).toEqual({ type: 'shortcut', index: 0 });
+
+    const result = applyConfirmPromptInput(createSelectionFlowState(), action!, 2);
+
+    expect(result.effect).toEqual({ type: 'select', index: 0 });
+  });
+
+  it('Given more than two options When y or n is typed Then shortcuts are ignored', () => {
+    expect(getConfirmPromptInputAction('y', {}, 3)).toBeUndefined();
+    expect(getConfirmPromptInputAction('n', {}, 3)).toBeUndefined();
+  });
+
+  it('Given selection moved right When enter is applied Then current option is selected', () => {
+    const moved = applyConfirmPromptInput(createSelectionFlowState(), 'next', 2).state;
+
+    const result = applyConfirmPromptInput(moved, 'select', 2);
+
+    expect(result.effect).toEqual({ type: 'select', index: 1 });
+  });
+
+  it('Given prompt is resolved When shortcut is applied Then no second selection is emitted', () => {
+    const selected = applyConfirmPromptInput(createSelectionFlowState(), 'select', 2).state;
+
+    const result = applyConfirmPromptInput(selected, { type: 'shortcut', index: 1 }, 2);
+
+    expect(result.effect).toEqual({ type: 'none' });
+  });
+});
+
+describe('permission prompt flow', () => {
+  it('Given y shortcut When applied Then allow decision is emitted', () => {
+    const action = getPermissionPromptInputAction('y', {});
+
+    const result = applyPermissionPromptInput(createSelectionFlowState(), action!);
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: true });
+  });
+
+  it('Given a shortcut When applied Then allow-session decision is emitted', () => {
+    const action = getPermissionPromptInputAction('a', {});
+
+    const result = applyPermissionPromptInput(createSelectionFlowState(), action!);
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: 'allow-session' });
+  });
+
+  it('Given deny shortcuts When applied Then false decision is emitted', () => {
+    expect(
+      applyPermissionPromptInput(
+        createSelectionFlowState(),
+        getPermissionPromptInputAction('n', {})!,
+      ).effect,
+    ).toEqual({ type: 'resolve', decision: false });
+    expect(
+      applyPermissionPromptInput(
+        createSelectionFlowState(),
+        getPermissionPromptInputAction('3', {})!,
+      ).effect,
+    ).toEqual({ type: 'resolve', decision: false });
+  });
+
+  it('Given arrow navigation When enter is applied Then selected permission is resolved', () => {
+    const moved = applyPermissionPromptInput(createSelectionFlowState(), 'next').state;
+
+    const result = applyPermissionPromptInput(moved, 'select');
+
+    expect(result.effect).toEqual({ type: 'resolve', decision: 'allow-session' });
+  });
+
+  it('Given permission is resolved When shortcut is applied Then no second decision is emitted', () => {
+    const resolved = applyPermissionPromptInput(createSelectionFlowState(), 'select').state;
+
+    const result = applyPermissionPromptInput(resolved, { type: 'shortcut', index: 2 });
+
+    expect(result.effect).toEqual({ type: 'none' });
+  });
+});

package/src/tui/__tests__/confirm-prompt.test.tsx

@@ -0,0 +1,87 @@
+import React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import ConfirmPrompt from '../ConfirmPrompt.js';
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe('ConfirmPrompt', () => {
+  it('renders message text', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Are you sure?" onSelect={() => {}} />);
+    expect(lastFrame()).toContain('Are you sure?');
+  });
+
+  it('renders default Yes/No options', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Confirm?" onSelect={() => {}} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Yes');
+    expect(frame).toContain('No');
+  });
+
+  it('renders custom options', () => {
+    const { lastFrame } = render(
+      <ConfirmPrompt message="Pick" options={['A', 'B', 'C']} onSelect={() => {}} />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('A');
+    expect(frame).toContain('B');
+    expect(frame).toContain('C');
+  });
+
+  it('first option is highlighted by default', () => {
+    const { lastFrame } = render(<ConfirmPrompt message="Confirm?" onSelect={() => {}} />);
+    const frame = lastFrame()!;
+    // The selected item has '> ' prefix
+    expect(frame).toContain('> Yes');
+  });
+
+  it('selects first option on Enter', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('\r');
+    expect(onSelect).toHaveBeenCalledWith(0);
+  });
+
+  it('navigates to second option with arrow down and selects', async () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    // Arrow down (move to No)
+    stdin.write('\x1b[B');
+    await delay(50);
+    stdin.write('\r');
+    expect(onSelect).toHaveBeenCalledWith(1);
+  });
+
+  it('y shortcut selects first option (Yes)', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('y');
+    expect(onSelect).toHaveBeenCalledWith(0);
+  });
+
+  it('n shortcut selects second option (No)', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('n');
+    expect(onSelect).toHaveBeenCalledWith(1);
+  });
+
+  it('y/n shortcuts do not work with more than 2 options', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(
+      <ConfirmPrompt message="Pick" options={['A', 'B', 'C']} onSelect={onSelect} />,
+    );
+    stdin.write('y');
+    stdin.write('n');
+    expect(onSelect).not.toHaveBeenCalled();
+  });
+
+  it('ignores input after selection (no double-fire)', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(<ConfirmPrompt message="Confirm?" onSelect={onSelect} />);
+    stdin.write('\r');
+    stdin.write('\r');
+    stdin.write('y');
+    expect(onSelect).toHaveBeenCalledTimes(1);
+  });
+});

package/src/tui/__tests__/execution-workspace-switcher.test.tsx

@@ -0,0 +1,110 @@
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { render } from 'ink-testing-library';
+import type {
+  IExecutionWorkspaceEntry,
+  IExecutionWorkspaceSnapshot,
+} from '@robota-sdk/agent-framework';
+import ExecutionWorkspaceSwitcher from '../ExecutionWorkspaceSwitcher.js';
+import ExecutionWorkspaceDetailPane from '../ExecutionWorkspaceDetailPane.js';
+
+function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {
+  return {
+    id: 'main:session_1',
+    sourceId: 'session_1',
+    kind: 'main_thread',
+    origin: { kind: 'user_prompt', sessionId: 'session_1' },
+    status: 'idle',
+    title: 'Main thread',
+    subtitle: '2 history entries',
+    unread: false,
+    attention: 'none',
+    visibility: 'default',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    controls: ['select'],
+    ...overrides,
+  };
+}
+
+function makeSnapshot(): IExecutionWorkspaceSnapshot {
+  return {
+    sessionId: 'session_1',
+    selectedEntryId: 'main:session_1',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    entries: [
+      makeEntry({ id: 'main:session_1', kind: 'main_thread', title: 'Main thread' }),
+      makeEntry({
+        id: 'task:agent_1',
+        sourceId: 'agent_1',
+        kind: 'background_task',
+        taskKind: 'agent',
+        status: 'running',
+        title: 'Explore',
+        subtitle: 'general-purpose',
+        preview: 'Inspect task layer',
+        controls: ['select', 'cancel'],
+      }),
+    ],
+  };
+}
+
+describe('ExecutionWorkspaceSwitcher', () => {
+  it('renders main and background entries with selected radio markers', () => {
+    const { lastFrame } = render(
+      <ExecutionWorkspaceSwitcher
+        snapshot={makeSnapshot()}
+        selectedEntryId="task:agent_1"
+        onSelect={vi.fn()}
+        onClose={vi.fn()}
+      />,
+    );
+
+    const frame = lastFrame()!;
+    expect(frame).toContain('Execution workspace');
+    expect(frame).toContain('○ Main thread');
+    expect(frame).toContain('● Explore agent');
+    expect(frame).toContain('Inspect task layer');
+  });
+
+  it('commits the highlighted entry on enter without invoking task controls', () => {
+    const onSelect = vi.fn();
+    const { stdin } = render(
+      <ExecutionWorkspaceSwitcher
+        snapshot={makeSnapshot()}
+        selectedEntryId="main:session_1"
+        onSelect={onSelect}
+        onClose={vi.fn()}
+      />,
+    );
+
+    stdin.write('\u001B[B');
+    stdin.write('\r');
+
+    expect(onSelect).toHaveBeenCalledWith('task:agent_1');
+  });
+
+  it('renders selected entry detail records from the SDK detail page', () => {
+    const entry = makeEntry({
+      id: 'task:agent_1',
+      sourceId: 'agent_1',
+      kind: 'background_task',
+      taskKind: 'agent',
+      status: 'completed',
+      title: 'Explore',
+      preview: 'Done',
+    });
+    const { lastFrame } = render(
+      <ExecutionWorkspaceDetailPane
+        entry={entry}
+        page={{
+          entryId: 'task:agent_1',
+          records: [{ id: 'r1', kind: 'result', text: 'Final background result' }],
+        }}
+      />,
+    );
+
+    const frame = lastFrame()!;
+    expect(frame).toContain('Viewing Explore agent');
+    expect(frame).toContain('Final background result');
+  });
+});

package/src/tui/__tests__/execution-workspace-view-model.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  IExecutionWorkspaceEntry,
+  IExecutionWorkspaceSnapshot,
+} from '@robota-sdk/agent-framework';
+import {
+  countActiveBackgroundWorkspaceEntries,
+  formatExecutionDetailRecord,
+  formatExecutionWorkspaceEntryRow,
+  getDefaultBackgroundWorkspaceEntries,
+} from '../execution-workspace-view-model.js';
+
+function makeEntry(overrides: Partial<IExecutionWorkspaceEntry>): IExecutionWorkspaceEntry {
+  return {
+    id: 'task:agent_1',
+    sourceId: 'agent_1',
+    kind: 'background_task',
+    origin: { kind: 'slash_command', sessionId: 'session_1', commandName: 'agent' },
+    taskKind: 'agent',
+    status: 'running',
+    title: 'Explore',
+    subtitle: 'general-purpose',
+    preview: 'Map the CLI state manager',
+    unread: false,
+    attention: 'none',
+    visibility: 'default',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    controls: ['select', 'cancel'],
+    ...overrides,
+  };
+}
+
+function makeSnapshot(entries: readonly IExecutionWorkspaceEntry[]): IExecutionWorkspaceSnapshot {
+  return {
+    sessionId: 'session_1',
+    selectedEntryId: 'main:session_1',
+    updatedAt: '2026-05-09T00:00:00.000Z',
+    entries,
+  };
+}
+
+describe('execution workspace view model', () => {
+  it('renders selected and inactive entries with radio markers', () => {
+    const row = formatExecutionWorkspaceEntryRow(makeEntry({ id: 'task:agent_1' }), {
+      selectedEntryId: 'task:agent_1',
+    });
+    const inactive = formatExecutionWorkspaceEntryRow(makeEntry({ id: 'task:process_1' }), {
+      selectedEntryId: 'task:agent_1',
+    });
+
+    expect(row.radio).toBe('●');
+    expect(row.title).toBe('Explore agent');
+    expect(row.subtitle).toBe('agent · general-purpose');
+    expect(row.statusLabel).toBe('running');
+    expect(inactive.radio).toBe('○');
+  });
+
+  it('filters default-visible background task entries for the compact panel', () => {
+    const snapshot = makeSnapshot([
+      makeEntry({ id: 'main:session_1', kind: 'main_thread', title: 'Main thread' }),
+      makeEntry({ id: 'task:agent_1', visibility: 'default' }),
+      makeEntry({ id: 'task:agent_2', visibility: 'collapsed' }),
+      makeEntry({ id: 'group:group_1', kind: 'background_group', visibility: 'default' }),
+    ]);
+
+    expect(getDefaultBackgroundWorkspaceEntries(snapshot).map((entry) => entry.id)).toEqual([
+      'task:agent_1',
+    ]);
+  });
+
+  it('counts active default-visible background tasks without treating collapsed tasks as active', () => {
+    const snapshot = makeSnapshot([
+      makeEntry({ id: 'task:queued', status: 'queued' }),
+      makeEntry({ id: 'task:running', status: 'running' }),
+      makeEntry({ id: 'task:permission', status: 'waiting_permission' }),
+      makeEntry({ id: 'task:done', status: 'completed' }),
+      makeEntry({ id: 'task:hidden', status: 'running', visibility: 'collapsed' }),
+    ]);
+
+    expect(countActiveBackgroundWorkspaceEntries(snapshot)).toBe(3);
+  });
+
+  it('bounds detail record text without parsing runner-specific output', () => {
+    const text = formatExecutionDetailRecord({
+      id: 'record_1',
+      kind: 'process_output',
+      text: ` ${'a'.repeat(180)} `,
+    });
+
+    expect(text).toHaveLength(163);
+    expect(text.endsWith('...')).toBe(true);
+  });
+});