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

package/src/__tests__/prompt-queue.test.tsx

@@ -0,0 +1,260 @@
+/**
+ * Tests for prompt queue — submit during execution queues prompt,
+ * auto-executes after completion, backspace cancels queue, ESC aborts.
+ */
+
+import React, { useState, useCallback, useEffect, useRef } from 'react';
+import { cleanup, render } from 'ink-testing-library';
+import { Box, Text, useInput } from 'ink';
+import { afterEach, describe, it, expect, vi } from 'vitest';
+
+interface IQueueTestController {
+  completeCurrent?: () => void;
+}
+
+const WAIT_FOR_ASSERTION_TIMEOUT_MS = 10000;
+const WAIT_FOR_ASSERTION_INTERVAL_MS = 20;
+
+async function waitForAssertion(
+  assertion: () => void,
+  timeoutMs = WAIT_FOR_ASSERTION_TIMEOUT_MS,
+): Promise<void> {
+  const startedAt = Date.now();
+  let lastError: Error | undefined;
+
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      assertion();
+      return;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      await new Promise((resolve) => setTimeout(resolve, WAIT_FOR_ASSERTION_INTERVAL_MS));
+    }
+  }
+
+  if (lastError) throw lastError;
+  throw new Error('Timed out waiting for assertion');
+}
+
+/**
+ * Minimal App that simulates the prompt queue behavior.
+ */
+function QueueTestApp({
+  onExecute,
+  onAbort,
+  controller,
+}: {
+  onExecute: (prompt: string) => void;
+  onAbort?: () => void;
+  controller?: IQueueTestController;
+}): React.ReactElement {
+  const [isThinking, setIsThinking] = useState(false);
+  const thinkingRef = useRef(false);
+  const [pendingPrompt, setPendingPrompt] = useState<string | null>(null);
+  const pendingRef = useRef<string | null>(null);
+  const [isAborting, setIsAborting] = useState(false);
+  const [log, setLog] = useState<string[]>([]);
+
+  const executePrompt = useCallback(
+    async (input: string) => {
+      thinkingRef.current = true;
+      setIsThinking(true);
+      setLog((prev) => [...prev, `exec:${input}`]);
+      onExecute(input);
+      await new Promise<void>((resolve) => {
+        if (controller) {
+          controller.completeCurrent = () => {
+            controller.completeCurrent = undefined;
+            resolve();
+          };
+          return;
+        }
+        setTimeout(resolve, 300);
+      });
+      thinkingRef.current = false;
+      setIsThinking(false);
+    },
+    [controller, onExecute],
+  );
+
+  const handleSubmit = useCallback(
+    async (input: string) => {
+      if (thinkingRef.current) {
+        setPendingPrompt(input);
+        pendingRef.current = input;
+        setLog((prev) => [...prev, `queued:${input}`]);
+        return;
+      }
+      await executePrompt(input);
+    },
+    [executePrompt],
+  );
+
+  useInput((_input, key) => {
+    // ESC always aborts + clears queue
+    if (key.escape && thinkingRef.current) {
+      setIsAborting(true);
+      setPendingPrompt(null);
+      pendingRef.current = null;
+      onAbort?.();
+    }
+    // Backspace cancels queue only
+    if ((key.backspace || key.delete) && pendingRef.current) {
+      setPendingPrompt(null);
+      pendingRef.current = null;
+      setLog((prev) => [...prev, 'queue-cleared']);
+    }
+  });
+
+  // Auto-execute queued prompt when thinking ends
+  useEffect(() => {
+    if (!isThinking) {
+      setIsAborting(false);
+      if (pendingRef.current) {
+        const prompt = pendingRef.current;
+        setPendingPrompt(null);
+        pendingRef.current = null;
+        setTimeout(() => executePrompt(prompt), 0);
+      }
+    }
+  }, [isThinking, executePrompt]);
+
+  return (
+    <Box flexDirection="column">
+      <Text>thinking={String(isThinking)}</Text>
+      <Text>pending={pendingPrompt ?? 'none'}</Text>
+      <Text>aborting={String(isAborting)}</Text>
+      <Text>log={log.join(',')}</Text>
+      <SubmitTrigger onSubmit={handleSubmit} />
+    </Box>
+  );
+}
+
+function SubmitTrigger({
+  onSubmit,
+}: {
+  onSubmit: (input: string) => Promise<void>;
+}): React.ReactElement {
+  useInput((input) => {
+    if (input.startsWith('s:')) {
+      // INFRA-040: `useInput` takes a SYNCHRONOUS handler, so there is no caller to await this. The
+      // rejection is routed to the test runner rather than dropped — a submit that throws would
+      // otherwise leave the case green while the behaviour it drives never happened.
+      onSubmit(input.slice(2)).catch((error: unknown) => {
+        throw error instanceof Error ? error : new Error(String(error));
+      });
+    }
+  });
+  return <></>;
+}
+
+describe('Prompt Queue', () => {
+  afterEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+  });
+
+  it('executes prompt normally when not thinking', async () => {
+    const onExecute = vi.fn();
+    const { stdin } = render(<QueueTestApp onExecute={onExecute} />);
+
+    stdin.write('s:hello');
+    await waitForAssertion(() => expect(onExecute).toHaveBeenCalledWith('hello'));
+
+    expect(onExecute).toHaveBeenCalledWith('hello');
+  });
+
+  it('queues prompt when thinking, auto-executes after completion', async () => {
+    const onExecute = vi.fn();
+    const controller: IQueueTestController = {};
+    const { stdin, lastFrame } = render(
+      <QueueTestApp onExecute={onExecute} controller={controller} />,
+    );
+
+    stdin.write('s:first');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('thinking=true'));
+
+    stdin.write('s:second');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('pending=second'));
+
+    controller.completeCurrent?.();
+    await waitForAssertion(() => expect(onExecute).toHaveBeenCalledWith('second'));
+
+    expect(onExecute).toHaveBeenCalledWith('first');
+    expect(onExecute).toHaveBeenCalledWith('second');
+  });
+
+  it('only queues 1 prompt — last one wins', async () => {
+    const onExecute = vi.fn();
+    const controller: IQueueTestController = {};
+    const { stdin, lastFrame } = render(
+      <QueueTestApp onExecute={onExecute} controller={controller} />,
+    );
+
+    stdin.write('s:first');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('thinking=true'));
+
+    stdin.write('s:second');
+    await new Promise((r) => setTimeout(r, 5));
+    stdin.write('s:third');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('pending=third'));
+
+    controller.completeCurrent?.();
+    await waitForAssertion(() => expect(onExecute).toHaveBeenCalledWith('third'));
+
+    expect(onExecute).toHaveBeenCalledWith('first');
+    expect(onExecute).toHaveBeenCalledWith('third');
+    expect(onExecute).not.toHaveBeenCalledWith('second');
+  });
+
+  it('ESC aborts execution and clears queue', async () => {
+    const onExecute = vi.fn();
+    const onAbort = vi.fn();
+    const controller: IQueueTestController = {};
+    const { stdin, lastFrame } = render(
+      <QueueTestApp onExecute={onExecute} onAbort={onAbort} controller={controller} />,
+    );
+
+    stdin.write('s:first');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('thinking=true'));
+
+    stdin.write('s:queued');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('pending=queued'));
+
+    stdin.write('\x1B');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('pending=none'));
+
+    expect(onAbort).toHaveBeenCalled();
+
+    controller.completeCurrent?.();
+    await new Promise((r) => setTimeout(r, 50));
+    expect(onExecute).not.toHaveBeenCalledWith('queued');
+  });
+
+  it('Backspace cancels queue without aborting', async () => {
+    const onExecute = vi.fn();
+    const onAbort = vi.fn();
+    const controller: IQueueTestController = {};
+    const { stdin, lastFrame } = render(
+      <QueueTestApp onExecute={onExecute} onAbort={onAbort} controller={controller} />,
+    );
+
+    stdin.write('s:first');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('thinking=true'));
+
+    stdin.write('s:queued');
+    await waitForAssertion(() => expect(lastFrame()!).toContain('pending=queued'));
+
+    stdin.write('\x7F'); // backspace
+    await waitForAssertion(() => expect(lastFrame()!).toContain('pending=none'));
+
+    expect(lastFrame()!).toContain('queue-cleared');
+    expect(onAbort).not.toHaveBeenCalled();
+
+    // Execution continues normally
+    controller.completeCurrent?.();
+    await new Promise((r) => setTimeout(r, 50));
+    expect(onExecute).toHaveBeenCalledWith('first');
+    expect(onExecute).not.toHaveBeenCalledWith('queued');
+  });
+});

package/src/__tests__/provider-definitions-reach-the-session.test.ts

@@ -0,0 +1,75 @@
+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 { IProviderDefinition } from '@robota-sdk/agent-core';
+
+/**
+ * #1844 — the provider definitions must survive the whole mapping chain.
+ *
+ * `providerDefinitions` was declared on the session options and read by `/provider switch`, and no
+ * production code set it. The consequence is not a dormant field: with an empty list the hot-swap
+ * throws `Unknown provider: <name>. Currently supported: ` — an empty supported-list, which is both
+ * wrong and unactionable. Measured, not inferred.
+ *
+ * Each hop is asserted separately because a forward that stops at any one of them restores exactly
+ * the bug, and an end-to-end assertion alone would not say WHERE it stopped.
+ */
+const DEFINITIONS = [
+  { type: 'anthropic', displayName: 'Anthropic' },
+] as unknown as readonly IProviderDefinition[];
+
+const renderOptions = (over: Partial<IRenderOptions> = {}): IRenderOptions =>
+  ({ cwd: '/w', provider: {}, ...over }) as IRenderOptions;
+
+describe('#1844 — provider definitions reach the session', () => {
+  it('render options carry them into the channel options', () => {
+    const channel = toChannelOptions(renderOptions({ providerDefinitions: DEFINITIONS }));
+
+    expect(channel.providerDefinitions).toBe(DEFINITIONS);
+  });
+
+  it('channel options carry them into the session options', () => {
+    const session = buildTuiSessionOptions({
+      cwd: '/w',
+      provider: {},
+      providerDefinitions: DEFINITIONS,
+    } as unknown as ITuiInteractionChannelOptions);
+
+    expect(session).toHaveProperty('providerDefinitions', DEFINITIONS);
+  });
+
+  it('the whole chain preserves them', () => {
+    const session = buildTuiSessionOptions(
+      toChannelOptions(
+        renderOptions({ providerDefinitions: DEFINITIONS }),
+      ) as unknown as ITuiInteractionChannelOptions,
+    );
+
+    expect(session).toHaveProperty('providerDefinitions', DEFINITIONS);
+  });
+
+  it('omits the key entirely when none were supplied, rather than setting an empty list', () => {
+    // An explicit `[]` would look like "the caller supplied none" and read as configured. Absent is
+    // the honest shape for "this surface did not provide them", and it also keeps
+    // `exactOptionalPropertyTypes` callers from having to pass undefined.
+    const session = buildTuiSessionOptions({
+      cwd: '/w',
+      provider: {},
+    } as unknown as ITuiInteractionChannelOptions);
+
+    expect('providerDefinitions' in session).toBe(false);
+  });
+});
+
+it('preserves product provider recovery guidance from render options through the TUI session', () => {
+  const providerErrorGuidance = { authentication: 'Configure product A.' };
+  const session = buildTuiSessionOptions(
+    toChannelOptions(renderOptions({ providerErrorGuidance })),
+  );
+
+  expect(session.providerErrorGuidance).toBe(providerErrorGuidance);
+});

package/src/__tests__/pty/ask-user-question.ptytest.ts

@@ -0,0 +1,72 @@
+/**
+ * CMD-005 TC-03: a model-issued AskUserQuestion renders as the Ink dialog mid-turn and the picked
+ * answer returns to the model — end to end against the BUILT robota binary.
+ *
+ * Boots with `--session-log` (INFRA-018 replay, no model key): the replayed assistant turn calls the
+ * AskUserQuestion tool; the real TUI renders the CMD-004 PendingActionPrompt while the turn is
+ * executing; pressing Enter picks the highlighted option; the tool result resolves and the replayed
+ * follow-up assistant text renders — proving ask → dialog → answer → turn-continue on the real binary.
+ */
+
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { spawnTui, writeTuiProviderSettings } from './pty-driver.js';
+
+import type { IPtySession } from './pty-driver.js';
+
+const FIXTURE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  'fixtures',
+  'ask-user-question.jsonl',
+);
+
+describe('AskUserQuestion dialog through the real binary (CMD-005)', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'robota-ask-pty-')));
+    writeTuiProviderSettings(projectDir); // dummy provider profile; replay answers every call
+  });
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('renders the model question mid-turn, Enter answers it, and the turn continues', async () => {
+    session = spawnTui({
+      projectDir,
+      homeDir: join(projectDir, 'home'),
+      // An explicit --name suppresses LLM auto-naming, which would otherwise consume the first
+      // replayed response (the tool-call turn) as a title.
+      args: ['--session-log', FIXTURE, '--name', 'ask-fixture'],
+    });
+
+    await session.waitFor(/Type a message or \/help/);
+
+    // Trigger the replayed turn: assistant calls AskUserQuestion.
+    await session.sendKeys('go');
+    await session.pressEnter();
+
+    // The CMD-004 dialog renders the model's question with its options while the turn is running.
+    await session.waitFor(/PICK_A_COLOR/, 20_000);
+    const dialog = session.snapshot();
+    expect(dialog).toContain('Red');
+    expect(dialog).toContain('Blue');
+
+    // Enter picks the highlighted first option (Red) → the tool result resolves → the replayed
+    // follow-up assistant text renders (the turn continued with the user's answer).
+    await session.pressEnter();
+    await session.waitFor(/FINAL_AFTER_ANSWER/, 20_000);
+
+    // Back to the idle prompt after the turn.
+    await session.waitFor(/Type a message or \/help/, 20_000);
+  }, 60_000);
+});

package/src/__tests__/pty/background-work-switcher.ptytest.ts

@@ -0,0 +1,53 @@
+/**
+ * TEST-010 / SCREEN-013: the background-work drill-in entry point, observed through a real PTY.
+ *
+ * Component tests cover the switcher selection + detail pane in isolation; this asserts the
+ * App-level wiring end to end against the BUILT robota binary: pressing `Ctrl+B` in the live TUI
+ * opens the execution-workspace switcher (the only way into a background task), and `Esc` returns to
+ * the prompt. The switcher always lists the main thread, so this is assertable without seeding
+ * background work. Runs in the dedicated PTY project (`pnpm --filter @robota-sdk/agent-ui-terminal
+ * test:pty`) against `packages/agent-cli/bin/robota.cjs`.
+ */
+
+import { mkdtempSync, rmSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { spawnTui, writeTuiProviderSettings } from './pty-driver.js';
+
+import type { IPtySession } from './pty-driver.js';
+
+const CTRL_B = '\x02';
+
+describe('Background-work drill-in entry point through a real PTY (TEST-010 / SCREEN-013)', () => {
+  let projectDir: string;
+  let session: IPtySession | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'robota-bgwork-')));
+    writeTuiProviderSettings(projectDir);
+  });
+
+  afterEach(async () => {
+    await session?.disposeAsync();
+    session = undefined;
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  it('Ctrl+B opens the execution-workspace switcher, Esc returns to the prompt', async () => {
+    session = spawnTui({ projectDir, homeDir: join(projectDir, 'home') });
+    await session.waitFor(/Type a message or \/help/);
+
+    await session.sendKeys(CTRL_B);
+    await session.waitFor(/Execution workspace/, 15_000);
+    const open = session.snapshot();
+    expect(open).toContain('Execution workspace');
+    // The interactive switcher (the only entry into a background task) is reachable and usable.
+    expect(open).toMatch(/Navigate.*Switch|Enter Switch/);
+
+    session.pressEscape();
+    await session.waitFor(/Type a message or \/help/, 15_000);
+  }, 60_000);
+});