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

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

@@ -1,255 +0,0 @@
-/**
- * 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

@@ -1,233 +0,0 @@
-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__/pty/pty-driver.ts

@@ -1,135 +0,0 @@
-/**
- * PTY TUI driver (CLI-074 TC-07/08).
- *
- * Spawns the built robota CLI in a real pseudo-terminal so Ink renders exactly
- * as in a user terminal, with per-key paced input (expect(1)-style burst input
- * gets bundled as a bracketed paste — the failure mode this driver exists to
- * avoid). Test-only; lives in a dedicated vitest project (*.ptytest.ts).
- */
-
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { spawn } from '@homebridge/node-pty-prebuilt-multiarch';
-
-import type { IPty } from '@homebridge/node-pty-prebuilt-multiarch';
-
-const REPO_ROOT = resolve(__dirname, '../../../../../..');
-const ROBOTA_BIN = join(REPO_ROOT, 'packages/agent-cli/bin/robota.cjs');
-
-// eslint-disable-next-line no-control-regex
-const ANSI_PATTERN = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07]*\x07|\x1b[()][B0]|[\x00-\x08\x0b-\x1f]/g;
-
-export interface IPtySession {
-  /** Type text one key at a time (default 35ms/key — human-ish, avoids paste bundling). */
-  sendKeys(text: string, perKeyDelayMs?: number): Promise<void>;
-  /** Press Enter as a single keystroke. */
-  pressEnter(): Promise<void>;
-  /** Wait until the ANSI-stripped output matches; throws with a snapshot on timeout. */
-  waitFor(pattern: RegExp, timeoutMs?: number): Promise<void>;
-  /** Current ANSI-stripped output. */
-  snapshot(): string;
-  /** Wait for process exit; throws with a snapshot on timeout. */
-  expectExit(timeoutMs?: number): Promise<number>;
-  /** Force-kill (cleanup). */
-  kill(): void;
-}
-
-export interface ISpawnTuiOptions {
-  /** Project cwd (a provider profile settings.json is written here). */
-  projectDir: string;
-  /** Isolated HOME directory. */
-  homeDir: string;
-  cols?: number;
-  rows?: number;
-}
-
-export function writeTuiProviderSettings(projectDir: string): void {
-  const settingsDir = join(projectDir, '.robota');
-  mkdirSync(settingsDir, { recursive: true });
-  writeFileSync(
-    join(settingsDir, 'settings.json'),
-    JSON.stringify({
-      currentProvider: 'anthropic',
-      providers: {
-        // Boot/slash/exit make zero model calls — the key is never used.
-        anthropic: { type: 'anthropic', model: 'claude-test-model', apiKey: 'pty-dummy-key' },
-      },
-    }),
-    'utf8',
-  );
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
-}
-
-export function spawnTui(options: ISpawnTuiOptions): IPtySession {
-  mkdirSync(options.homeDir, { recursive: true });
-  let output = '';
-  let exitCode: number | undefined;
-
-  const pty: IPty = spawn(process.execPath, [ROBOTA_BIN], {
-    name: 'xterm-256color',
-    cols: options.cols ?? 100,
-    rows: options.rows ?? 32,
-    cwd: options.projectDir,
-    env: {
-      PATH: process.env['PATH'] ?? '',
-      HOME: options.homeDir,
-      TERM: 'xterm-256color',
-      // Never inherit real provider keys into PTY runs.
-    },
-  });
-
-  pty.onData((data) => {
-    output += data;
-  });
-  pty.onExit(({ exitCode: code }) => {
-    exitCode = code;
-  });
-
-  const stripped = (): string => output.replace(ANSI_PATTERN, '');
-
-  return {
-    async sendKeys(text: string, perKeyDelayMs = 35): Promise<void> {
-      for (const ch of text) {
-        pty.write(ch);
-        await sleep(perKeyDelayMs);
-      }
-    },
-    async pressEnter(): Promise<void> {
-      await sleep(120);
-      pty.write('\r');
-      await sleep(120);
-    },
-    async waitFor(pattern: RegExp, timeoutMs = 15_000): Promise<void> {
-      const deadline = Date.now() + timeoutMs;
-      while (Date.now() < deadline) {
-        if (pattern.test(stripped())) return;
-        await sleep(100);
-      }
-      throw new Error(
-        `PTY waitFor timeout (${timeoutMs}ms) for ${String(pattern)}\n--- snapshot ---\n${stripped().slice(-2000)}`,
-      );
-    },
-    snapshot: stripped,
-    async expectExit(timeoutMs = 10_000): Promise<number> {
-      const deadline = Date.now() + timeoutMs;
-      while (Date.now() < deadline) {
-        if (exitCode !== undefined) return exitCode;
-        await sleep(100);
-      }
-      throw new Error(
-        `PTY process did not exit within ${timeoutMs}ms\n--- snapshot ---\n${stripped().slice(-2000)}`,
-      );
-    },
-    kill(): void {
-      try {
-        pty.kill();
-      } catch {
-        // allow-fallback: process already exited — kill on a dead pty is a no-op by design
-      }
-    },
-  };
-}

package/src/tui/__tests__/pty/tui-pty.ptytest.ts

@@ -1,61 +0,0 @@
-/**
- * Real-PTY TUI suites (CLI-074 TC-07/08).
- *
- * Runs in the dedicated PTY vitest project (vitest.pty.config.ts) against the
- * BUILT robota binary — `pnpm --filter @robota-sdk/agent-cli build` first.
- */
-
-import { mkdtempSync, rmSync } 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';
-
-describe('TUI through a real PTY (CLI-074)', () => {
-  let projectDir: string;
-  let session: IPtySession | undefined;
-
-  beforeEach(() => {
-    projectDir = mkdtempSync(join(tmpdir(), 'robota-pty-'));
-    writeTuiProviderSettings(projectDir);
-  });
-
-  afterEach(() => {
-    session?.kill();
-    session = undefined;
-    rmSync(projectDir, { recursive: true, force: true });
-  });
-
-  it('TC-07: boots, opens slash autocomplete, and executes /help as a command', async () => {
-    session = spawnTui({ projectDir, homeDir: join(projectDir, 'home') });
-
-    // Boot: prompt + status bar render.
-    await session.waitFor(/Type a message or \/help/);
-    await session.waitFor(/Idle/);
-
-    // '/' opens the autocomplete dropdown listing commands.
-    await session.sendKeys('/');
-    await session.waitFor(/\/help\s+Show available commands/);
-
-    // Typing the rest at human key rate must stay a command, not a paste.
-    await session.sendKeys('help');
-    await session.pressEnter();
-    await session.waitFor(/Available commands|\/cost|\/clear/i, 20_000);
-    expect(session.snapshot()).not.toContain('[Pasted text');
-  }, 60_000);
-
-  it('TC-08: /exit reaches process exit within 10s', async () => {
-    session = spawnTui({ projectDir, homeDir: join(projectDir, 'home') });
-    await session.waitFor(/Type a message or \/help/);
-
-    await session.sendKeys('/exit');
-    await session.pressEnter();
-
-    const exitCode = await session.expectExit(10_000);
-    expect(exitCode).toBe(0);
-  }, 60_000);
-});