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

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

@@ -0,0 +1,160 @@
+/**
+ * Test: ESC abort after permission prompt was shown and dismissed.
+ * Verifies that the global ESC handler remains available after overlays close.
+ */
+
+import React, { useState } 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] = useState(true);
+  const [permissionRequest, setPermissionRequest] = useState<{
+    resolve: () => void;
+  } | null>(null);
+  const [aborted, setAborted] = useState(false);
+
+  // 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/__tests__/abort-streaming-e2e.test.tsx

@@ -0,0 +1,183 @@
+/**
+ * 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/__tests__/attached-app-session-switch.test.tsx

@@ -0,0 +1,317 @@
+/**
+ * #3189: the full App on a wire channel. The session picker lists the host's sessions, and choosing
+ * one asks the host to switch instead of building a new channel.
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import App from '../App.js';
+import { WireTuiChannel } from '../wire-tui-channel.js';
+
+import type { IAttachedSessionConnection } from '../attached-session-connection.js';
+import type { ITuiCliAdapter } from '../tui-cli-adapter.js';
+import type { TClientMessage, TServerMessage } from '@robota-sdk/agent-transport/client';
+
+const TICK_MS = 30;
+const FRAME_DEADLINE_MS = 3000;
+
+function tick(ms = TICK_MS): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate: () => boolean, describeFailure: () => string): Promise<void> {
+  const deadline = Date.now() + FRAME_DEADLINE_MS;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await tick(10);
+  }
+  throw new Error(`waitFor timeout\n${describeFailure()}`);
+}
+
+function scriptedConnection(): IAttachedSessionConnection & {
+  sent: TClientMessage[];
+  push: (message: TServerMessage) => void;
+} {
+  const listeners = new Set<(message: TServerMessage) => void>();
+  const sent: TClientMessage[] = [];
+  return {
+    sent,
+    send: (message) => {
+      sent.push(message);
+    },
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    onClose: () => () => undefined,
+    push: (message) => {
+      for (const listener of [...listeners]) listener(message);
+    },
+  };
+}
+
+function cliAdapter(settingsPath: string): ITuiCliAdapter {
+  return {
+    getUserSettingsPath: () => settingsPath,
+    readSettings: () => ({}),
+    reloadPluginCommandSource: vi.fn(),
+    applyActiveModelChange: vi.fn().mockReturnValue({ applied: true }),
+    getGitBranch: vi.fn().mockReturnValue(undefined),
+    getProviderDisplayName: vi.fn((type: string) => type),
+  };
+}
+
+function lastListRequestId(sent: readonly TClientMessage[]): string {
+  const requests = sent.filter(
+    (message): message is Extract<TClientMessage, { type: 'list-sessions' }> =>
+      message.type === 'list-sessions',
+  );
+  return requests.at(-1)?.requestId ?? '';
+}
+
+describe('the full App attached to a host over the wire', () => {
+  let cwd: string;
+
+  beforeEach(() => {
+    cwd = mkdtempSync(join(tmpdir(), 'agent-attached-app-'));
+  });
+
+  afterEach(() => {
+    rmSync(cwd, { recursive: true, force: true });
+  });
+
+  it("lists the host's sessions in the picker and asks the host to switch", async () => {
+    const link = scriptedConnection();
+    const channel = new WireTuiChannel({ connection: link, driverId: 'attach:1' });
+    const createChannel = vi.fn(() => channel);
+    const view = render(
+      <App
+        cwd={cwd}
+        createChannel={createChannel}
+        requestSessionSwitch={(sessionId) => channel.requestSessionSwitch(sessionId)}
+        cliAdapter={cliAdapter(join(cwd, 'settings.json'))}
+      />,
+    );
+    try {
+      await waitFor(
+        () => link.sent.some((message) => message.type === 'list-sessions'),
+        () => JSON.stringify(link.sent),
+      );
+      // `/resume` ran on the host, which routes the picker back to this terminal only.
+      link.push({
+        type: 'ui_intent',
+        event: { intent: { type: 'show-session-picker' }, requesterDriverId: 'attach:1' },
+      });
+      link.push({
+        type: 'sessions',
+        requestId: lastListRequestId(link.sent),
+        listing: {
+          currentSessionId: 'host-current',
+          sessions: [
+            {
+              id: 'host-other-session',
+              name: 'Host session',
+              cwd,
+              updatedAt: '2026-09-26T10:00:00.000Z',
+              messageCount: 4,
+              preview: 'kept by the daemon',
+            },
+          ],
+          unreadableSessionIds: [],
+        },
+      });
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes('Host session'),
+        () => view.lastFrame() ?? '<none>',
+      );
+      expect(view.lastFrame()).toContain('Select a session to resume');
+      await tick();
+
+      link.sent.length = 0;
+      view.stdin.write('\r');
+      await waitFor(
+        () => link.sent.some((message) => message.type === 'switch-session'),
+        () => JSON.stringify(link.sent),
+      );
+      expect(link.sent).toContainEqual({
+        type: 'switch-session',
+        sessionId: 'host-other-session',
+        requestId: expect.any(String),
+      });
+      // The App keeps its channel; the host's `session_switched` is what moves it.
+      expect(createChannel).toHaveBeenCalledTimes(1);
+      // A refusal is shown where the terminal shows what happened, and the switch is over.
+      const request = link.sent.find((message) => message.type === 'switch-session');
+      link.push({
+        type: 'session_change_failed',
+        code: 'limit',
+        message: 'Four sessions are live; none can be closed.',
+        ...(request?.type === 'switch-session' && request.requestId !== undefined
+          ? { requestId: request.requestId }
+          : {}),
+      });
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes('Four sessions are live; none can be closed.'),
+        () => view.lastFrame() ?? '<none>',
+      );
+    } finally {
+      view.unmount();
+      await channel.stop();
+    }
+  });
+
+  async function resumeAgainst(
+    answer: (requestId: string) => TServerMessage,
+    notice: string,
+  ): Promise<string> {
+    const link = scriptedConnection();
+    const channel = new WireTuiChannel({ connection: link, driverId: 'attach:1' });
+    const view = render(
+      <App
+        cwd={cwd}
+        createChannel={() => channel}
+        requestSessionSwitch={(sessionId) => channel.requestSessionSwitch(sessionId)}
+        cliAdapter={cliAdapter(join(cwd, 'settings.json'))}
+      />,
+    );
+    try {
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes('Type a message'),
+        () => view.lastFrame() ?? '<none>',
+      );
+      link.sent.length = 0;
+      link.push({
+        type: 'ui_intent',
+        event: { intent: { type: 'show-session-picker' }, requesterDriverId: 'attach:1' },
+      });
+      link.push(answer(lastListRequestId(link.sent)));
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes(notice),
+        () => view.lastFrame() ?? '<none>',
+      );
+      await tick();
+      return view.lastFrame() ?? '';
+    } finally {
+      view.unmount();
+      await channel.stop();
+    }
+  }
+
+  it('gives the prompt back with the reason when the host cannot list its sessions', async () => {
+    const frame = await resumeAgainst(
+      (requestId) => ({
+        type: 'sessions_error',
+        requestId,
+        code: 'not_available',
+        message: 'Session listing is not available on this host.',
+      }),
+      'Session listing is not available on this host.',
+    );
+    expect(frame).not.toContain('Select a session to resume');
+    expect(frame).not.toContain('Waiting for response');
+    expect(frame).toContain('Type a message');
+  });
+
+  it("prints the new session's transcript when the switch and its history arrive together", async () => {
+    const link = scriptedConnection();
+    const channel = new WireTuiChannel({ connection: link, driverId: 'attach:1' });
+    const view = render(
+      <App
+        cwd={cwd}
+        createChannel={() => channel}
+        requestSessionSwitch={(sessionId) => channel.requestSessionSwitch(sessionId)}
+        cliAdapter={cliAdapter(join(cwd, 'settings.json'))}
+      />,
+    );
+    const entry = (id: string, content: string) => ({
+      id,
+      timestamp: '2026-09-26T10:00:00.000Z',
+      category: 'chat',
+      type: 'user',
+      data: { id: `m-${id}`, role: 'user', content, state: 'complete' },
+    });
+    try {
+      await waitFor(
+        () => link.sent.some((message) => message.type === 'get-history'),
+        () => JSON.stringify(link.sent),
+      );
+      link.push({
+        type: 'history',
+        startIndex: 0,
+        total: 3,
+        entries: [entry('o1', 'old one'), entry('o2', 'old two'), entry('o3', 'old three')],
+      });
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes('old three'),
+        () => view.lastFrame() ?? '<none>',
+      );
+      // One chunk from the host: the switch and the new session's history, handled in one pass.
+      link.push({ type: 'session_switched', event: { sessionId: 'session-2' } });
+      link.push({
+        type: 'history',
+        startIndex: 0,
+        total: 1,
+        entries: [entry('n1', 'new session prompt')],
+      });
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes('new session prompt'),
+        () => view.lastFrame() ?? '<none>',
+      );
+      expect(view.lastFrame()).toContain('Switched to session session-2.');
+    } finally {
+      view.unmount();
+      await channel.stop();
+    }
+  });
+
+  it('detaches on Ctrl-] the way it does on Ctrl-C and /exit', async () => {
+    const link = scriptedConnection();
+    const channel = new WireTuiChannel({ connection: link, driverId: 'attach:1' });
+    const view = render(
+      <App
+        cwd={cwd}
+        createChannel={() => channel}
+        requestSessionSwitch={(sessionId) => channel.requestSessionSwitch(sessionId)}
+        cliAdapter={cliAdapter(join(cwd, 'settings.json'))}
+      />,
+    );
+    try {
+      await waitFor(
+        () => (view.lastFrame() ?? '').includes('Type a message'),
+        () => view.lastFrame() ?? '<none>',
+      );
+      view.stdin.write('\x1d');
+      await waitFor(
+        () => channel.getSnapshot().isShuttingDown,
+        () => view.lastFrame() ?? '<none>',
+      );
+      expect(JSON.stringify(channel.getSnapshot().history)).toContain(
+        'Detached. The session keeps running.',
+      );
+      expect(link.sent.some((message) => message.type === 'submit')).toBe(false);
+    } finally {
+      view.unmount();
+      await channel.stop();
+    }
+  });
+
+  it('opens no empty picker when the host has no sessions to resume', async () => {
+    const frame = await resumeAgainst(
+      (requestId) => ({
+        type: 'sessions',
+        requestId,
+        listing: { currentSessionId: 'host-current', sessions: [], unreadableSessionIds: [] },
+      }),
+      'No saved sessions to resume',
+    );
+    expect(frame).not.toContain('Select a session to resume');
+    expect(frame).not.toContain('Waiting for response');
+    expect(frame).toContain('Type a message');
+  });
+});