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

package/src/tui/__tests__/model-change-side-effect.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import type { IHistoryEntry, TSessionEndReason } from '@robota-sdk/agent-core';
+import {
+  addModelChangeCancelledMessage,
+  applyConfirmedModelChange,
+  formatModelChangeConfirmationMessage,
+} from '../hooks/model-change-side-effect.js';
+
+interface IShutdownCall {
+  reason: TSessionEndReason;
+  message: string;
+}
+
+interface IModelChangeCall {
+  cwd: string;
+  modelId: string;
+  options?: { providerOverride?: string };
+}
+
+function entryContent(entry: IHistoryEntry): string {
+  return (entry.data as { content: string }).content;
+}
+
+describe('model change side effect', () => {
+  it('persists the selected model for the active provider override before exiting', () => {
+    const entries: IHistoryEntry[] = [];
+    const shutdowns: IShutdownCall[] = [];
+    const calls: IModelChangeCall[] = [];
+    const applyModelChange = (
+      cwd: string,
+      modelId: string,
+      options?: { providerOverride?: string },
+    ): { applied: boolean } => {
+      calls.push({ cwd, modelId, ...(options !== undefined && { options }) });
+      return { applied: true };
+    };
+
+    applyConfirmedModelChange({
+      cwd: '/tmp/project',
+      modelId: 'gpt-4.1',
+      providerOverride: 'openai',
+      addEntry: (entry) => entries.push(entry),
+      requestShutdown: (reason, message) => shutdowns.push({ reason, message }),
+      applyModelChange,
+    });
+
+    expect(calls).toEqual([
+      {
+        cwd: '/tmp/project',
+        modelId: 'gpt-4.1',
+        options: { providerOverride: 'openai' },
+      },
+    ]);
+    expect(entryContent(entries[0]!)).toBe(
+      'Model changed to gpt-4.1. Exiting so the next session uses it.',
+    );
+    expect(shutdowns).toEqual([{ reason: 'other', message: 'Model change applied' }]);
+  });
+
+  it('does not exit when persistence fails', () => {
+    const entries: IHistoryEntry[] = [];
+    const shutdowns: IShutdownCall[] = [];
+
+    applyConfirmedModelChange({
+      cwd: '/tmp/project',
+      modelId: 'gpt-4.1',
+      addEntry: (entry) => entries.push(entry),
+      requestShutdown: (reason, message) => shutdowns.push({ reason, message }),
+      applyModelChange: () => {
+        throw new Error('settings write failed');
+      },
+    });
+
+    expect(entryContent(entries[0]!)).toBe('Failed: settings write failed');
+    expect(shutdowns).toEqual([]);
+  });
+
+  it('reports cancellation without applying settings or exiting', () => {
+    const entries: IHistoryEntry[] = [];
+
+    addModelChangeCancelledMessage((entry) => entries.push(entry));
+
+    expect(entryContent(entries[0]!)).toBe('Model change cancelled.');
+  });
+
+  it('describes model changes as an exit for the next session', () => {
+    expect(formatModelChangeConfirmationMessage('gpt-4.1')).toBe(
+      'Change model to gpt-4.1? This will exit the current session so the next session uses it.',
+    );
+  });
+});

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

@@ -0,0 +1,255 @@
+/**
+ * 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:')) {
+      onSubmit(input.slice(2));
+    }
+  });
+  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/tui/__tests__/provider-setup-pty-e2e.test.ts

@@ -0,0 +1,233 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as pty from '@homebridge/node-pty-prebuilt-multiarch';
+
+const require = createRequire(import.meta.url);
+const TSX_ESM_HOOK_PATH: string = require.resolve('tsx/esm');
+
+const openaiDefaults = {
+  model: 'gpt-4o',
+  apiKey: '$ENV:OPENAI_API_KEY',
+};
+
+const DRIVER_PATH = fileURLToPath(
+  new URL('./fixtures/provider-setup-prompt-driver.tsx', import.meta.url),
+);
+const TEST_TIMEOUT_MS = 30000;
+const WAIT_TIMEOUT_MS = 15000;
+const INPUT_SETTLE_MS = 75;
+const OUTPUT_TAIL_LENGTH = 2000;
+
+interface IPtyHarness {
+  submit(input?: string): Promise<void>;
+  waitFor(text: string): Promise<void>;
+  waitForExit(): Promise<number>;
+  dispose(): void;
+}
+
+const tempDirs: string[] = [];
+const activeHarnesses: IPtyHarness[] = [];
+
+afterEach(() => {
+  for (const harness of activeHarnesses.splice(0)) {
+    harness.dispose();
+  }
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('provider setup interaction PTY E2E', () => {
+  it(
+    'submits OpenAI values through a real pseudo terminal',
+    async () => {
+      const { harness, outputPath } = spawnProviderSetupDriver('openai');
+
+      await harness.waitFor('OpenAI model');
+      await harness.waitFor('https://platform.openai.com/api-keys');
+      await harness.submit(openaiDefaults.model);
+      await harness.waitFor('OpenAI API key');
+      await harness.submit();
+
+      expect(await harness.waitForExit()).toBe(0);
+      harness.dispose();
+      expect(readResult(outputPath)).toEqual({
+        profile: 'openai',
+        type: 'openai',
+        model: openaiDefaults.model,
+        apiKey: openaiDefaults.apiKey,
+        setCurrent: true,
+      });
+    },
+    TEST_TIMEOUT_MS,
+  );
+
+  it(
+    'submits Anthropic values typed through a real pseudo terminal',
+    async () => {
+      const { harness, outputPath } = spawnProviderSetupDriver('anthropic');
+
+      await harness.waitFor('Anthropic API key');
+      await harness.submit('sk-test');
+      await harness.waitFor('Anthropic model');
+      await harness.submit('claude-test');
+
+      expect(await harness.waitForExit()).toBe(0);
+      harness.dispose();
+      expect(readResult(outputPath)).toEqual({
+        profile: 'anthropic',
+        type: 'anthropic',
+        model: 'claude-test',
+        apiKey: 'sk-test',
+        setCurrent: true,
+      });
+    },
+    TEST_TIMEOUT_MS,
+  );
+});
+
+function spawnProviderSetupDriver(type: 'openai' | 'anthropic'): {
+  harness: IPtyHarness;
+  outputPath: string;
+} {
+  const dir = mkdtempSync(join(tmpdir(), 'robota-provider-pty-'));
+  tempDirs.push(dir);
+  const outputPath = join(dir, 'result.json');
+  const proc = pty.spawn(
+    process.execPath,
+    ['--import', TSX_ESM_HOOK_PATH, DRIVER_PATH, outputPath, type],
+    {
+      cols: 120,
+      rows: 40,
+      cwd: fileURLToPath(new URL('../../../../..', import.meta.url)),
+      env: createPtyEnv(),
+    },
+  );
+  const harness = createHarness(proc);
+  activeHarnesses.push(harness);
+  return { harness, outputPath };
+}
+
+function createHarness(proc: pty.IPty): IPtyHarness {
+  let output = '';
+  let exitCode: number | undefined;
+  const waiters: Array<() => void> = [];
+
+  proc.onData((data) => {
+    output += data;
+    notifyWaiters(waiters);
+  });
+  proc.onExit((event) => {
+    exitCode = event.exitCode;
+    notifyWaiters(waiters);
+  });
+
+  return {
+    async submit(input = '') {
+      await sleep(INPUT_SETTLE_MS);
+      if (input) {
+        proc.write(input);
+        await sleep(INPUT_SETTLE_MS);
+      }
+      proc.write('\r');
+    },
+    waitFor(text: string) {
+      return waitUntil(
+        () => output.includes(text),
+        waiters,
+        () => {
+          return new Error(`Timed out waiting for "${text}". Output:\n${tail(output)}`);
+        },
+      );
+    },
+    waitForExit() {
+      return waitUntil(
+        () => exitCode !== undefined,
+        waiters,
+        () => {
+          return new Error(`Timed out waiting for PTY exit. Output:\n${tail(output)}`);
+        },
+      ).then(() => exitCode ?? -1);
+    },
+    dispose() {
+      if (exitCode === undefined) {
+        proc.kill();
+      }
+    },
+  };
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function createPtyEnv(): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    FORCE_COLOR: '0',
+    TERM: 'xterm-256color',
+  };
+  delete env.CI;
+  return env;
+}
+
+function waitUntil(
+  predicate: () => boolean,
+  waiters: Array<() => void>,
+  createTimeoutError: () => Error,
+): Promise<void> {
+  if (predicate()) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const removeWaiter = (waiter: () => void): void => {
+      const index = waiters.indexOf(waiter);
+      if (index >= 0) {
+        waiters.splice(index, 1);
+      }
+    };
+    const check = () => {
+      if (settled) {
+        return;
+      }
+      if (!predicate()) {
+        return;
+      }
+      settled = true;
+      clearTimeout(deadline);
+      removeWaiter(check);
+      resolve();
+    };
+    const deadline = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      removeWaiter(check);
+      reject(createTimeoutError());
+    }, WAIT_TIMEOUT_MS);
+    waiters.push(check);
+  });
+}
+
+function notifyWaiters(waiters: Array<() => void>): void {
+  for (const waiter of [...waiters]) {
+    waiter();
+  }
+}
+
+function readResult(outputPath: string): Record<string, string | boolean> {
+  expect(existsSync(outputPath)).toBe(true);
+  return JSON.parse(readFileSync(outputPath, 'utf8')) as Record<string, string | boolean>;
+}
+
+function tail(output: string): string {
+  return output.slice(-OUTPUT_TAIL_LENGTH);
+}

package/src/tui/__tests__/render-markdown.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { renderMarkdown } from '../render-markdown.js';
+
+const ANSI_LIGHT_RED = '\u001b[38;5;210m';
+const ANSI_LIGHT_GREEN = '\u001b[38;5;120m';
+const ANSI_DARK_RED_BACKGROUND = '\u001b[48;5;52m';
+const ANSI_DARK_GREEN_BACKGROUND = '\u001b[48;5;22m';
+const ANSI_RESET = '\u001b[0m';
+const CODE_BLOCK_INDENT = '    ';
+
+describe('renderMarkdown', () => {
+  it('renders diff fenced code blocks with addition and removal colors', () => {
+    const output = renderMarkdown(
+      ['Before', '', '```diff', '- const oldValue = true;', '+ const newValue = true;', '```'].join(
+        '\n',
+      ),
+      { color: true },
+    );
+
+    expect(output).toContain(`${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}`);
+    expect(output).toContain(`${CODE_BLOCK_INDENT}- const oldValue = true;`);
+    expect(output).toContain(`${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}`);
+    expect(output).toContain(`${CODE_BLOCK_INDENT}+ const newValue = true;`);
+  });
+
+  it('pads added and removed diff rows before applying background colors', () => {
+    const codeBlockWidth = 24;
+    const removedRow = `${CODE_BLOCK_INDENT}- removed`.padEnd(codeBlockWidth);
+    const addedRow = `${CODE_BLOCK_INDENT}+ added`.padEnd(codeBlockWidth);
+    const output = renderMarkdown(['```diff', '- removed', '+ added', '```'].join('\n'), {
+      color: true,
+      codeBlockWidth,
+    });
+
+    expect(output).toContain(
+      `${ANSI_DARK_RED_BACKGROUND}${ANSI_LIGHT_RED}${removedRow}${ANSI_RESET}`,
+    );
+    expect(output).toContain(
+      `${ANSI_DARK_GREEN_BACKGROUND}${ANSI_LIGHT_GREEN}${addedRow}${ANSI_RESET}`,
+    );
+  });
+
+  it('keeps diff fenced code block content readable when color is disabled', () => {
+    const output = renderMarkdown(
+      ['```diff', '- removed line', '+ added line', ' unchanged line', '```'].join('\n'),
+      { color: false },
+    );
+
+    expect(output).toContain('- removed line');
+    expect(output).toContain('+ added line');
+    expect(output).toContain(' unchanged line');
+    expect(output).not.toContain(ANSI_LIGHT_RED);
+    expect(output).not.toContain(ANSI_LIGHT_GREEN);
+    expect(output).not.toContain(ANSI_DARK_RED_BACKGROUND);
+    expect(output).not.toContain(ANSI_DARK_GREEN_BACKGROUND);
+  });
+
+  it('keeps regular fenced code blocks as code output', () => {
+    const output = renderMarkdown(['```ts', 'const value: string = "ok";', '```'].join('\n'), {
+      color: false,
+    });
+
+    expect(output).toContain('const value: string = "ok";');
+  });
+
+  it('keeps inline markdown formatting readable', () => {
+    const output = renderMarkdown('Use **bold** and `code` here.', { color: false });
+
+    expect(output).toContain('bold');
+    expect(output).toContain('code');
+  });
+});