@robota-sdk/agent-transport 3.0.0-beta.75 → 3.0.0-beta.76

package/src/tui/__tests__/TuiInteractionChannel.requestAction.test.ts

@@ -1,124 +0,0 @@
-/**
- * Unit tests for TuiInteractionChannel.requestAction() promise protocol.
- *
- * Tests the queue-based action resolution mechanism in isolation —
- * no Ink rendering, no InteractiveSession, no real provider required.
- */
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock('@robota-sdk/agent-framework', async () => {
-  const actual = await vi.importActual<typeof import('@robota-sdk/agent-framework')>(
-    '@robota-sdk/agent-framework',
-  );
-  return {
-    ...actual,
-    InteractiveSession: vi.fn().mockImplementation(() => ({
-      getFullHistory: vi.fn().mockReturnValue([]),
-      setName: vi.fn(),
-      getSessionId: vi.fn().mockReturnValue('test-id'),
-      isInitialized: false,
-      on: vi.fn(),
-      off: vi.fn(),
-    })),
-    CommandRegistry: vi.fn().mockImplementation(() => ({
-      addModule: vi.fn(),
-    })),
-  };
-});
-
-import { TuiInteractionChannel } from '../TuiInteractionChannel.js';
-
-import type { IAIProvider } from '@robota-sdk/agent-core';
-import type { IActionRequest } from '@robota-sdk/agent-interface-transport';
-
-function makeChannel(): TuiInteractionChannel {
-  return new TuiInteractionChannel({
-    cwd: '/tmp',
-    provider: {} as IAIProvider,
-  });
-}
-
-const PICK_ACTION: IActionRequest = {
-  type: 'pick',
-  id: 'mode',
-  title: '/mode',
-  items: [
-    { label: 'plan', value: 'plan' },
-    { label: 'default', value: 'default' },
-  ],
-};
-
-const CONFIRM_ACTION: IActionRequest = {
-  type: 'confirm',
-  id: 'exit',
-  message: 'Exit the session?',
-};
-
-describe('TuiInteractionChannel.requestAction', () => {
-  let channel: TuiInteractionChannel;
-
-  beforeEach(() => {
-    channel = makeChannel();
-  });
-
-  it('sets pendingAction when requestAction is called', () => {
-    void channel.requestAction(PICK_ACTION);
-    expect(channel.pendingAction).toMatchObject({ type: 'pick', id: 'mode' });
-  });
-
-  it('resolves pick response when resolveAction is called', async () => {
-    const responsePromise = channel.requestAction(PICK_ACTION);
-    channel.resolveAction({ type: 'pick', item: { label: 'plan', value: 'plan' } });
-    const response = await responsePromise;
-    expect(response).toEqual({ type: 'pick', item: { label: 'plan', value: 'plan' } });
-  });
-
-  it('clears pendingAction after resolveAction', async () => {
-    const responsePromise = channel.requestAction(PICK_ACTION);
-    channel.resolveAction({ type: 'cancelled' });
-    await responsePromise;
-    expect(channel.pendingAction).toBeNull();
-  });
-
-  it('resolves confirm response when resolveAction is called', async () => {
-    const responsePromise = channel.requestAction(CONFIRM_ACTION);
-    channel.resolveAction({ type: 'confirm', confirmed: true });
-    const response = await responsePromise;
-    expect(response).toEqual({ type: 'confirm', confirmed: true });
-  });
-
-  it('resolves cancelled when resolveAction is called with cancelled', async () => {
-    const responsePromise = channel.requestAction(PICK_ACTION);
-    channel.resolveAction({ type: 'cancelled' });
-    const response = await responsePromise;
-    expect(response).toEqual({ type: 'cancelled' });
-  });
-
-  it('queues multiple actions and processes them sequentially', async () => {
-    const p1 = channel.requestAction(PICK_ACTION);
-    const p2 = channel.requestAction(CONFIRM_ACTION);
-
-    // First action is pending immediately
-    expect(channel.pendingAction).toMatchObject({ type: 'pick' });
-
-    // Resolve first
-    channel.resolveAction({ type: 'pick', item: { label: 'plan', value: 'plan' } });
-    await p1;
-
-    // Second action becomes pending after first resolves
-    expect(channel.pendingAction).toMatchObject({ type: 'confirm' });
-
-    // Resolve second
-    channel.resolveAction({ type: 'confirm', confirmed: false });
-    const r2 = await p2;
-    expect(r2).toEqual({ type: 'confirm', confirmed: false });
-    expect(channel.pendingAction).toBeNull();
-  });
-
-  it('calls onChange when pendingAction changes', () => {
-    const onChange = vi.fn();
-    channel.onChange = onChange;
-    void channel.requestAction(PICK_ACTION);
-    expect(onChange).toHaveBeenCalled();
-  });
-});

package/src/tui/__tests__/UpdateNotice.test.tsx

@@ -1,15 +0,0 @@
-import React from 'react';
-import { render } from 'ink-testing-library';
-import { describe, expect, it } from 'vitest';
-import UpdateNotice from '../UpdateNotice.js';
-
-describe('UpdateNotice', () => {
-  it('renders an update notice outside session history', () => {
-    const { lastFrame } = render(
-      <UpdateNotice message="Robota update available. Run npm install -g '@robota-sdk/agent-cli@latest'." />,
-    );
-
-    expect(lastFrame()).toContain('Robota update available');
-    expect(lastFrame()).toContain('npm install');
-  });
-});

package/src/tui/__tests__/abort-after-permission.test.tsx

@@ -1,169 +0,0 @@
-/**
- * Test: ESC abort after permission prompt was shown and dismissed.
- * Verifies that the global ESC handler remains available after overlays close.
- */
-
-import React, { useState, useCallback } from 'react';
-import { render } from 'ink-testing-library';
-import { Box, Text, useInput } from 'ink';
-import { describe, it, expect } from 'vitest';
-
-/**
- * Simulates App's global ESC handler with permission prompt overlay guard.
- * 1. Start with "thinking" active
- * 2. Permission prompt appears (App-level ESC ignores while overlay is active)
- * 3. Permission resolved (App-level ESC handles abort again)
- * 4. ESC should trigger abort
- */
-function AbortAfterPermissionApp({
-  onAbort,
-  onPermissionReady,
-}: {
-  onAbort: () => void;
-  onPermissionReady: (grantPermission: () => void) => void;
-}): React.ReactElement {
-  const [isThinking, setIsThinking] = useState(true);
-  const [permissionRequest, setPermissionRequest] = useState<{
-    resolve: () => void;
-  } | null>(null);
-  const [aborted, setAborted] = useState(false);
-
-  // Simulate permission prompt appearing after mount
-  const showPermission = useCallback(() => {
-    setPermissionRequest({
-      resolve: () => {
-        setPermissionRequest(null);
-      },
-    });
-  }, []);
-
-  // Give parent a way to grant permission
-  React.useEffect(() => {
-    // Show permission prompt immediately
-    const pr = {
-      resolve: () => setPermissionRequest(null),
-    };
-    setPermissionRequest(pr);
-    onPermissionReady(() => pr.resolve());
-  }, [onPermissionReady]);
-
-  // App's ESC handler — same pattern as real App.tsx
-  useInput((_input: string, key: { escape: boolean }) => {
-    if (!key.escape || !isThinking) return;
-    if (permissionRequest) return;
-    setAborted(true);
-    onAbort();
-  });
-
-  // Permission prompt's own useInput (when active)
-  useInput(
-    (_input: string, key: { return: boolean }) => {
-      if (key.return && permissionRequest) {
-        permissionRequest.resolve();
-      }
-    },
-    { isActive: !!permissionRequest },
-  );
-
-  return (
-    <Box flexDirection="column">
-      {permissionRequest && <Text color="yellow">[Permission Required]</Text>}
-      {!permissionRequest && isThinking && <Text color="cyan">Streaming...</Text>}
-      {aborted && <Text color="red">Aborted!</Text>}
-      <Text dimColor>
-        thinking={String(isThinking)} permission={String(!!permissionRequest)} aborted=
-        {String(aborted)}
-      </Text>
-    </Box>
-  );
-}
-
-describe('ESC abort after permission prompt', () => {
-  it('ESC works when no permission prompt was shown', async () => {
-    let abortCalled = false;
-    const grantHolder: { fn: (() => void) | null } = { fn: null };
-
-    const { stdin, lastFrame } = render(
-      <AbortAfterPermissionApp
-        onAbort={() => {
-          abortCalled = true;
-        }}
-        onPermissionReady={(fn) => {
-          grantHolder.fn = fn;
-        }}
-      />,
-    );
-
-    // Wait for mount
-    await new Promise((r) => setTimeout(r, 20));
-
-    // Grant permission immediately
-    grantHolder.fn?.();
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Now ESC should work
-    stdin.write('\x1B');
-    await new Promise((r) => setTimeout(r, 50));
-
-    expect(abortCalled).toBe(true);
-    expect(lastFrame()!).toContain('Aborted!');
-  });
-
-  it('ESC works AFTER permission prompt was shown and dismissed', async () => {
-    let abortCalled = false;
-    const grantHolder: { fn: (() => void) | null } = { fn: null };
-
-    const { stdin, lastFrame } = render(
-      <AbortAfterPermissionApp
-        onAbort={() => {
-          abortCalled = true;
-        }}
-        onPermissionReady={(fn) => {
-          grantHolder.fn = fn;
-        }}
-      />,
-    );
-
-    // Wait for permission prompt to appear
-    await new Promise((r) => setTimeout(r, 20));
-    expect(lastFrame()!).toContain('[Permission Required]');
-
-    // Grant permission (dismiss prompt)
-    grantHolder.fn?.();
-    await new Promise((r) => setTimeout(r, 50));
-
-    // Permission dismissed, streaming should show
-    expect(lastFrame()!).toContain('Streaming...');
-    expect(lastFrame()!).not.toContain('[Permission Required]');
-
-    // Now press ESC — should trigger abort
-    stdin.write('\x1B');
-    await new Promise((r) => setTimeout(r, 50));
-
-    expect(abortCalled).toBe(true);
-    expect(lastFrame()!).toContain('Aborted!');
-  });
-
-  it('ESC does NOT work during permission prompt', async () => {
-    let abortCalled = false;
-
-    const { stdin, lastFrame } = render(
-      <AbortAfterPermissionApp
-        onAbort={() => {
-          abortCalled = true;
-        }}
-        onPermissionReady={() => {}}
-      />,
-    );
-
-    await new Promise((r) => setTimeout(r, 20));
-    expect(lastFrame()!).toContain('[Permission Required]');
-
-    // ESC during permission prompt should NOT trigger abort
-    stdin.write('\x1B');
-    await new Promise((r) => setTimeout(r, 50));
-
-    expect(abortCalled).toBe(false);
-    expect(lastFrame()!).not.toContain('Aborted!');
-  });
-});

package/src/tui/__tests__/abort-streaming-e2e.test.tsx

@@ -1,183 +0,0 @@
-/**
- * E2E-style test for abort during streaming.
- * Uses ink-testing-library to verify that:
- * 1. Streaming text debounce works (renders batched, not per-delta)
- * 2. ESC during streaming triggers abort
- * 3. Partial text is preserved after abort
- */
-
-import React, { useState, useCallback, useRef, useEffect } from 'react';
-import { render } from 'ink-testing-library';
-import { Box, Text, useInput } from 'ink';
-import { describe, it, expect } from 'vitest';
-
-/**
- * Minimal streaming component that simulates the debounced onTextDelta pattern.
- * Accepts deltas via a callback ref, renders accumulated text.
- */
-function StreamingTestApp({
-  onReady,
-  onAbort,
-}: {
-  onReady: (appendDelta: (text: string) => void) => void;
-  onAbort: () => void;
-}): React.ReactElement {
-  const [text, setText] = useState('');
-  const textRef = useRef('');
-  const [aborted, setAborted] = useState(false);
-  const flushTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const renderCountRef = useRef(0);
-
-  // Debounced delta handler (same pattern as InteractiveSession)
-  const appendDelta = useCallback((delta: string) => {
-    textRef.current += delta;
-    if (!flushTimerRef.current) {
-      flushTimerRef.current = setTimeout(() => {
-        setText(textRef.current);
-        flushTimerRef.current = null;
-      }, 16);
-    }
-  }, []);
-
-  // ESC handler
-  useInput((_input, key) => {
-    if (key.escape) {
-      setAborted(true);
-      onAbort();
-      // Force flush any pending text
-      if (flushTimerRef.current) {
-        clearTimeout(flushTimerRef.current);
-        flushTimerRef.current = null;
-      }
-      setText(textRef.current);
-    }
-  });
-
-  // Notify parent that we're ready
-  useEffect(() => {
-    onReady(appendDelta);
-  }, [onReady, appendDelta]);
-
-  renderCountRef.current++;
-
-  return (
-    <Box flexDirection="column">
-      <Text>{text}</Text>
-      {aborted && <Text color="yellow">Interrupted by user.</Text>}
-      <Text dimColor>renders: {renderCountRef.current}</Text>
-    </Box>
-  );
-}
-
-describe('Streaming abort E2E', () => {
-  it('debounced streaming renders fewer times than delta count', async () => {
-    let appendDelta: ((text: string) => void) | null = null;
-
-    const { lastFrame } = render(
-      React.createElement(StreamingTestApp, {
-        onReady: (fn: (text: string) => void) => {
-          appendDelta = fn;
-        },
-        onAbort: () => {},
-      }),
-    );
-
-    // Wait for component to mount
-    await new Promise((r) => setTimeout(r, 20));
-    expect(appendDelta).not.toBeNull();
-
-    // Send 20 rapid deltas
-    for (let i = 0; i < 20; i++) {
-      appendDelta!(`chunk${i} `);
-    }
-
-    // Wait for debounce flush
-    await new Promise((r) => setTimeout(r, 50));
-
-    const frame = lastFrame()!;
-    // All text should be present
-    expect(frame).toContain('chunk0');
-    expect(frame).toContain('chunk19');
-
-    // Render count should be MUCH less than 20 (debounced)
-    const renderMatch = frame.match(/renders: (\d+)/);
-    expect(renderMatch).not.toBeNull();
-    const renderCount = parseInt(renderMatch![1], 10);
-    // With 16ms debounce and ~50ms total time, expect 3-5 renders, not 20+
-    expect(renderCount).toBeLessThan(10);
-  });
-
-  it('ESC during rapid streaming triggers abort and shows text', async () => {
-    let appendDelta: ((text: string) => void) | null = null;
-    let abortCalled = false;
-
-    const { stdin, lastFrame } = render(
-      React.createElement(StreamingTestApp, {
-        onReady: (fn: (text: string) => void) => {
-          appendDelta = fn;
-        },
-        onAbort: () => {
-          abortCalled = true;
-        },
-      }),
-    );
-
-    await new Promise((r) => setTimeout(r, 20));
-
-    // Send some deltas
-    for (let i = 0; i < 5; i++) {
-      appendDelta!(`line${i} `);
-    }
-
-    // Press ESC
-    stdin.write('\x1B');
-    await new Promise((r) => setTimeout(r, 50));
-
-    expect(abortCalled).toBe(true);
-
-    const frame = lastFrame()!;
-    // Text should be visible (flush on abort)
-    expect(frame).toContain('line0');
-    expect(frame).toContain('line4');
-    // Cancelled indicator
-    expect(frame).toContain('Interrupted by user.');
-  });
-
-  it('ESC during ongoing streaming stops further rendering', async () => {
-    let appendDelta: ((text: string) => void) | null = null;
-    let abortCalled = false;
-
-    const { stdin, lastFrame } = render(
-      React.createElement(StreamingTestApp, {
-        onReady: (fn: (text: string) => void) => {
-          appendDelta = fn;
-        },
-        onAbort: () => {
-          abortCalled = true;
-        },
-      }),
-    );
-
-    await new Promise((r) => setTimeout(r, 20));
-
-    // Send first batch
-    appendDelta!('before_abort ');
-
-    // Wait for flush
-    await new Promise((r) => setTimeout(r, 20));
-
-    // Press ESC
-    stdin.write('\x1B');
-    await new Promise((r) => setTimeout(r, 30));
-
-    expect(abortCalled).toBe(true);
-
-    // Send more deltas AFTER abort (should still accumulate in ref but component should show Cancelled)
-    appendDelta!('after_abort ');
-    await new Promise((r) => setTimeout(r, 50));
-
-    const frame = lastFrame()!;
-    expect(frame).toContain('before_abort');
-    expect(frame).toContain('Interrupted by user.');
-  });
-});

package/src/tui/__tests__/background-task-panel.test.tsx

@@ -1,53 +0,0 @@
-import React from 'react';
-import { describe, expect, it } from 'vitest';
-import { render } from 'ink-testing-library';
-import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-transport';
-import BackgroundTaskPanel from '../BackgroundTaskPanel.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: 'general-purpose',
-    subtitle: 'agent',
-    preview: 'Analyze backlog',
-    unread: false,
-    attention: 'none',
-    visibility: 'default',
-    updatedAt: '2026-05-09T00:00:00.000Z',
-    controls: ['select', 'cancel'],
-    ...overrides,
-  };
-}
-
-describe('BackgroundTaskPanel', () => {
-  it('renders SDK workspace entries with compact markers instead of raw task ids', () => {
-    const { lastFrame } = render(
-      <BackgroundTaskPanel
-        entries={[
-          makeEntry({ id: 'task:agent_1', status: 'running' }),
-          makeEntry({ id: 'task:agent_2', status: 'completed', preview: 'Done' }),
-          makeEntry({
-            id: 'task:agent_3',
-            status: 'failed',
-            attention: 'failed',
-            preview: 'Timed out',
-          }),
-        ]}
-      />,
-    );
-
-    const frame = lastFrame()!;
-    expect(frame).toContain('Background work');
-    expect(frame).toContain('├ □ general-purpose agent');
-    expect(frame).toContain('├ ■ general-purpose agent · completed');
-    expect(frame).toContain('└ ■ general-purpose agent · failed');
-    expect(frame).not.toContain('agent_1');
-    expect(frame).not.toContain('agent_2');
-    expect(frame).not.toContain('agent_3');
-  });
-});

package/src/tui/__tests__/background-task-row-format.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { IExecutionWorkspaceEntry } from '@robota-sdk/agent-interface-transport';
-import { formatBackgroundTaskRow } from '../background-task-row-format.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: 'Analyze backlog',
-    unread: false,
-    attention: 'none',
-    visibility: 'default',
-    updatedAt: '2026-05-09T00:00:00.000Z',
-    controls: ['select', 'cancel'],
-    ...overrides,
-  };
-}
-
-describe('formatBackgroundTaskRow', () => {
-  it('formats running SDK workspace entries without raw task ids', () => {
-    const row = formatBackgroundTaskRow(makeEntry({ id: 'task:agent_1' }), { isLast: true });
-
-    expect(row.connector).toBe('└');
-    expect(row.marker).toBe('□');
-    expect(row.label).toBe('Explore agent');
-    expect(row.segments).toEqual(['running', 'agent · general-purpose']);
-    expect(row.preview).toBe('Analyze backlog');
-    expect(row.accessibleText).not.toContain('agent_1');
-  });
-
-  it('formats failed and completed rows from SDK-owned status and attention', () => {
-    const failed = formatBackgroundTaskRow(
-      makeEntry({
-        id: 'task:agent_2',
-        status: 'failed',
-        attention: 'failed',
-        preview: 'Timed out',
-      }),
-      { isLast: false },
-    );
-    const completed = formatBackgroundTaskRow(
-      makeEntry({ id: 'task:agent_3', status: 'completed', preview: 'Summary ready' }),
-    );
-
-    expect(failed.connector).toBe('├');
-    expect(failed.marker).toBe('■');
-    expect(failed.color).toBe('red');
-    expect(failed.preview).toBe('Timed out');
-    expect(completed.marker).toBe('■');
-    expect(completed.color).toBe('green');
-    expect(completed.preview).toBe('Summary ready');
-  });
-});