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

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

@@ -0,0 +1,167 @@
+// packages/agent-cli/src/ui/__tests__/PluginTUI.test.tsx
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect, vi } from 'vitest';
+import PluginTUI from '../PluginTUI.js';
+import type { ICommandPluginAdapter } from '@robota-sdk/agent-framework';
+
+function mockCallbacks(): ICommandPluginAdapter {
+  return {
+    listInstalled: vi.fn().mockResolvedValue([]),
+    listAvailablePlugins: vi.fn().mockResolvedValue([]),
+    install: vi.fn().mockResolvedValue(undefined),
+    uninstall: vi.fn().mockResolvedValue(undefined),
+    enable: vi.fn().mockResolvedValue(undefined),
+    disable: vi.fn().mockResolvedValue(undefined),
+    marketplaceAdd: vi.fn().mockResolvedValue('test-marketplace'),
+    marketplaceRemove: vi.fn().mockResolvedValue(undefined),
+    marketplaceUpdate: vi.fn().mockResolvedValue(undefined),
+    marketplaceList: vi.fn().mockResolvedValue([]),
+    reloadPlugins: vi.fn().mockResolvedValue({ loadedPluginCount: 0 }),
+  };
+}
+
+describe('PluginTUI', () => {
+  it('renders main menu with Marketplace and Installed Plugins', () => {
+    const { lastFrame } = render(<PluginTUI callbacks={mockCallbacks()} onClose={() => {}} />);
+    const frame = lastFrame()!;
+    expect(frame).toContain('Marketplace');
+    expect(frame).toContain('Installed Plugins');
+  });
+
+  it('calls onClose when Escape on main menu', async () => {
+    let closed = false;
+    const { stdin } = render(
+      <PluginTUI
+        callbacks={mockCallbacks()}
+        onClose={() => {
+          closed = true;
+        }}
+      />,
+    );
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+    expect(closed).toBe(true);
+  });
+
+  it('navigates to installed plugins and shows actions', async () => {
+    const cbs = mockCallbacks();
+    cbs.listInstalled = vi
+      .fn()
+      .mockResolvedValue([{ name: 'my-plugin', description: 'A plugin', enabled: true }]);
+    const { stdin, lastFrame } = render(<PluginTUI callbacks={cbs} onClose={() => {}} />);
+    stdin.write('\x1B[B'); // Down to "Installed Plugins"
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 100));
+    expect(lastFrame()!).toContain('my-plugin');
+  });
+
+  it('navigates to marketplace list on Enter', async () => {
+    const cbs = mockCallbacks();
+    cbs.marketplaceList = vi.fn().mockResolvedValue([{ name: 'test-mp', type: 'github' }]);
+    const { stdin, lastFrame } = render(<PluginTUI callbacks={cbs} onClose={() => {}} />);
+    stdin.write('\r'); // Enter on "Marketplace"
+    await new Promise((r) => setTimeout(r, 100));
+    const frame = lastFrame()!;
+    expect(frame).toContain('Add Marketplace');
+  });
+
+  // Regression: arrow keys must work after navigating to a sub-screen (resolvedRef reset via key)
+  it('arrow keys work in marketplace list after navigating from main', async () => {
+    const cbs = mockCallbacks();
+    cbs.marketplaceList = vi.fn().mockResolvedValue([
+      { name: 'mp-a', type: 'github' },
+      { name: 'mp-b', type: 'git' },
+    ]);
+    const { stdin, lastFrame } = render(<PluginTUI callbacks={cbs} onClose={() => {}} />);
+    stdin.write('\r'); // Enter on "Marketplace"
+    await new Promise((r) => setTimeout(r, 100));
+    // Should be on marketplace-list with arrow keys working
+    stdin.write('\x1B[B'); // Down from "Add Marketplace" to "mp-a"
+    stdin.write('\x1B[B'); // Down to "mp-b"
+    await new Promise((r) => setTimeout(r, 50));
+    const frame = lastFrame()!;
+    // "mp-b" should be highlighted (has > prefix)
+    expect(frame).toContain('mp-b');
+    // Select mp-b → should navigate to marketplace-action
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 50));
+    expect(lastFrame()!).toContain('Browse plugins');
+  });
+
+  // Regression: installed plugin browse shows uninstall for already-installed plugins
+  it('selecting installed plugin in browse shows uninstall action', async () => {
+    const cbs = mockCallbacks();
+    cbs.marketplaceList = vi.fn().mockResolvedValue([{ name: 'test-mp', type: 'github' }]);
+    cbs.listAvailablePlugins = vi.fn().mockResolvedValue([
+      { name: 'my-plugin', description: 'A plugin', installed: true },
+      { name: 'new-plugin', description: 'Not installed', installed: false },
+    ]);
+    const { stdin, lastFrame } = render(<PluginTUI callbacks={cbs} onClose={() => {}} />);
+    // Main → Marketplace
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 100));
+    // Marketplace list → select test-mp
+    stdin.write('\x1B[B'); // Down to "test-mp"
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 50));
+    // Marketplace action → Browse plugins
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 100));
+    // Browse → select installed "my-plugin"
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 50));
+    // Should show uninstall action, not install scope
+    expect(lastFrame()!).toContain('Uninstall');
+    expect(lastFrame()!).not.toContain('User scope');
+  });
+
+  // Regression: uninstalled plugin in browse shows install scope selection
+  it('selecting uninstalled plugin in browse shows install scope', async () => {
+    const cbs = mockCallbacks();
+    cbs.marketplaceList = vi.fn().mockResolvedValue([{ name: 'test-mp', type: 'github' }]);
+    cbs.listAvailablePlugins = vi
+      .fn()
+      .mockResolvedValue([{ name: 'new-plugin', description: 'Not installed', installed: false }]);
+    const { stdin, lastFrame } = render(<PluginTUI callbacks={cbs} onClose={() => {}} />);
+    // Main → Marketplace
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 100));
+    // Marketplace list → select test-mp
+    stdin.write('\x1B[B');
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 50));
+    // Marketplace action → Browse plugins
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 100));
+    // Browse → select "new-plugin"
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 50));
+    // Should show install scope, not uninstall
+    expect(lastFrame()!).toContain('User scope');
+    expect(lastFrame()!).toContain('Project scope');
+  });
+
+  // Regression: install passes name@marketplace format to callback
+  it('install callback receives pluginId in name@marketplace format', async () => {
+    const cbs = mockCallbacks();
+    cbs.marketplaceList = vi.fn().mockResolvedValue([{ name: 'test-mp', type: 'github' }]);
+    cbs.listAvailablePlugins = vi
+      .fn()
+      .mockResolvedValue([{ name: 'new-plugin', description: 'A plugin', installed: false }]);
+    const { stdin } = render(<PluginTUI callbacks={cbs} onClose={() => {}} />);
+    // Main → Marketplace → test-mp → Browse → new-plugin → User scope
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 100));
+    stdin.write('\x1B[B');
+    stdin.write('\r');
+    await new Promise((r) => setTimeout(r, 50));
+    stdin.write('\r'); // Browse plugins
+    await new Promise((r) => setTimeout(r, 100));
+    stdin.write('\r'); // new-plugin
+    await new Promise((r) => setTimeout(r, 50));
+    stdin.write('\r'); // User scope
+    await new Promise((r) => setTimeout(r, 100));
+    expect(cbs.install).toHaveBeenCalledWith('new-plugin@test-mp', 'user');
+  }, 15000);
+});

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

@@ -0,0 +1,140 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import SlashAutocomplete from '../SlashAutocomplete.js';
+import type { ICommand } from '@robota-sdk/agent-framework';
+
+// ink-testing-library fixes stdout.columns = 100
+// outer box chrome = 4 → rowWidth = 96 in tests
+const NAME_COL_MAX = 20;
+
+function makeCmd(name: string, description: string): ICommand {
+  return { name, description } as ICommand;
+}
+
+describe('SlashAutocomplete', () => {
+  it('renders nothing when not visible', () => {
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[makeCmd('help', 'Show help')]}
+        selectedIndex={0}
+        visible={false}
+      />,
+    );
+    expect(lastFrame()).toBe('');
+  });
+
+  it('renders nothing when command list is empty', () => {
+    const { lastFrame } = render(
+      <SlashAutocomplete commands={[]} selectedIndex={0} visible={true} />,
+    );
+    expect(lastFrame()).toBe('');
+  });
+
+  it('aligns descriptions to the same column across all rows', () => {
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[
+          makeCmd('go', 'Short'),
+          makeCmd('session-persistence', 'Manage sessions'),
+          makeCmd('help', 'Show help'),
+        ]}
+        selectedIndex={0}
+        visible={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    const lines = frame
+      .split('\n')
+      .filter((l) => l.includes('Short') || l.includes('Manage') || l.includes('Show help'));
+    // All description texts should start at the same column index
+    const descPositions = lines.map((l) => {
+      // find position after the two-space separator following the name
+      const match = / {2}\S/.exec(l.slice(l.indexOf('/') + 1));
+      return match ? l.indexOf('/') + 1 + match.index + 2 : -1;
+    });
+    expect(new Set(descPositions).size).toBe(1);
+  });
+
+  it('pads short names to match the longest name in visible set', () => {
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[makeCmd('go', 'Run'), makeCmd('help', 'Show help')]}
+        selectedIndex={0}
+        visible={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    // 'go' should be padded to 4 chars (length of 'help')
+    expect(frame).toContain('/go  ');
+  });
+
+  it('caps name column at NAME_COL_MAX and truncates with ellipsis', () => {
+    const longName = 'a'.repeat(NAME_COL_MAX + 5);
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[makeCmd(longName, 'Description'), makeCmd('go', 'Short')]}
+        selectedIndex={0}
+        visible={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('…');
+    expect(frame).not.toContain(longName);
+  });
+
+  it('does not truncate name exactly at NAME_COL_MAX', () => {
+    const exactName = 'b'.repeat(NAME_COL_MAX);
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[makeCmd(exactName, 'Desc'), makeCmd('go', 'Short')]}
+        selectedIndex={0}
+        visible={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain(exactName);
+  });
+
+  it('truncates long row text with ellipsis via Ink wrap', () => {
+    const longDesc = 'X'.repeat(100);
+    const { lastFrame } = render(
+      <SlashAutocomplete commands={[makeCmd('cmd', longDesc)]} selectedIndex={0} visible={true} />,
+    );
+    expect(lastFrame()).toContain('…');
+    expect(lastFrame()).not.toContain(longDesc);
+  });
+
+  it('handles undefined description gracefully', () => {
+    const cmd = { name: 'cmd' } as ICommand;
+    const { lastFrame } = render(
+      <SlashAutocomplete commands={[cmd]} selectedIndex={0} visible={true} />,
+    );
+    expect(lastFrame()).toContain('cmd');
+  });
+
+  it('shows slash prefix in normal mode', () => {
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[makeCmd('help', 'Show help')]}
+        selectedIndex={0}
+        visible={true}
+      />,
+    );
+    expect(lastFrame()).toContain('/help');
+  });
+
+  it('omits slash prefix in subcommand mode', () => {
+    const { lastFrame } = render(
+      <SlashAutocomplete
+        commands={[makeCmd('run', 'Run task')]}
+        selectedIndex={0}
+        visible={true}
+        isSubcommandMode={true}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).not.toContain('/run');
+    expect(frame).toContain('Run task');
+  });
+});

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

@@ -0,0 +1,98 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import TextPrompt from '../TextPrompt.js';
+
+describe('TextPrompt', () => {
+  it('renders title', () => {
+    const { lastFrame } = render(
+      <TextPrompt title="Enter URL" onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    expect(lastFrame()!).toContain('Enter URL');
+  });
+
+  it('renders placeholder when provided', () => {
+    const { lastFrame } = render(
+      <TextPrompt title="Enter" placeholder="owner/repo" onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    expect(lastFrame()!).toContain('owner/repo');
+  });
+
+  it('calls onCancel on Escape', async () => {
+    let cancelled = false;
+    const { stdin } = render(
+      <TextPrompt
+        title="Enter"
+        onSubmit={() => {}}
+        onCancel={() => {
+          cancelled = true;
+        }}
+      />,
+    );
+    stdin.write('\x1B');
+    await new Promise((r) => setTimeout(r, 50));
+    expect(cancelled).toBe(true);
+  });
+
+  it('calls onSubmit with value on Enter', () => {
+    let submitted = '';
+    const { stdin } = render(
+      <TextPrompt
+        title="Enter"
+        onSubmit={(v) => {
+          submitted = v;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('hello');
+    stdin.write('\r');
+    expect(submitted).toBe('hello');
+  });
+
+  it('can submit an empty value when allowed', () => {
+    let submitted = 'not-called';
+    const { stdin } = render(
+      <TextPrompt
+        title="Enter"
+        allowEmpty
+        onSubmit={(v) => {
+          submitted = v;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('\r');
+    expect(submitted).toBe('');
+  });
+
+  it('masks typed values when requested', async () => {
+    const { stdin, lastFrame } = render(
+      <TextPrompt title="Secret" masked onSubmit={() => {}} onCancel={() => {}} />,
+    );
+    stdin.write('abc');
+    await new Promise((r) => setTimeout(r, 50));
+    expect(lastFrame()!).toContain('***');
+    expect(lastFrame()!).not.toContain('abc');
+  });
+
+  it('shows validation error and blocks submit', async () => {
+    let submitted = false;
+    const validate = (v: string) => (v.length < 3 ? 'Too short' : undefined);
+    const { stdin, lastFrame } = render(
+      <TextPrompt
+        title="Enter"
+        onSubmit={() => {
+          submitted = true;
+        }}
+        onCancel={() => {}}
+        validate={validate}
+      />,
+    );
+    stdin.write('ab');
+    stdin.write('\r');
+    expect(submitted).toBe(false);
+    await new Promise((r) => setTimeout(r, 50));
+    expect(lastFrame()!).toContain('Too short');
+  });
+});

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,169 @@
+/**
+ * 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!');
+  });
+});