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

package/src/__tests__/ListPicker.test.tsx

@@ -0,0 +1,188 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { Text } from 'ink';
+import { describe, it, expect } from 'vitest';
+import ListPicker from '../ListPicker.js';
+import {
+  formatKeyHints,
+  SELECTION_INDICATOR,
+  SELECTION_INDICATOR_NONE,
+} from '../key-hint-footer.js';
+
+describe('ListPicker', () => {
+  it('renders all items with first selected by default', () => {
+    const items = ['Alpha', 'Beta', 'Gamma'];
+    const { lastFrame } = render(
+      <ListPicker
+        items={items}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={() => {}}
+        onCancel={() => {}}
+      />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('> Alpha');
+    expect(frame).toContain('  Beta');
+    expect(frame).toContain('  Gamma');
+  });
+
+  it('renders empty state when no items', () => {
+    const { lastFrame } = render(
+      <ListPicker
+        items={[]}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {String(item)}
+          </Text>
+        )}
+        onSelect={() => {}}
+        onCancel={() => {}}
+      />,
+    );
+    // Should render without crashing
+    expect(lastFrame()).toBeDefined();
+  });
+
+  it('calls onSelect with item on Enter', () => {
+    let selected = '';
+    const items = ['Alpha', 'Beta'];
+    const { stdin } = render(
+      <ListPicker
+        items={items}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={(item) => {
+          selected = item;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('\r');
+    expect(selected).toBe('Alpha');
+  });
+
+  it('navigates down with arrow key and selects', () => {
+    let selected = '';
+    const items = ['Alpha', 'Beta', 'Gamma'];
+    const { stdin } = render(
+      <ListPicker
+        items={items}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={(item) => {
+          selected = item;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('\x1B[B'); // Down arrow
+    stdin.write('\r');
+    expect(selected).toBe('Beta');
+  });
+
+  it('calls onCancel on Escape', async () => {
+    const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+    let cancelled = false;
+    const { stdin } = render(
+      <ListPicker
+        items={['Alpha']}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={() => {}}
+        onCancel={() => {
+          cancelled = true;
+        }}
+      />,
+    );
+    stdin.write('\x1B');
+    await delay(50);
+    expect(cancelled).toBe(true);
+  });
+
+  it('does not go above first item', () => {
+    const items = ['Alpha', 'Beta'];
+    const { stdin, lastFrame } = render(
+      <ListPicker
+        items={items}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={() => {}}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('\x1B[A'); // Up arrow (already at 0)
+    const frame = lastFrame()!;
+    expect(frame).toContain('> Alpha');
+  });
+
+  it('does not go below last item', () => {
+    let selected = '';
+    const items = ['Alpha', 'Beta'];
+    const { stdin } = render(
+      <ListPicker
+        items={items}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={(item) => {
+          selected = item;
+        }}
+        onCancel={() => {}}
+      />,
+    );
+    stdin.write('\x1B[B'); // Down
+    stdin.write('\x1B[B'); // Down (should stay at Beta)
+    stdin.write('\x1B[B'); // Down (should stay at Beta)
+    stdin.write('\r');
+    expect(selected).toBe('Beta');
+  });
+
+  // SCREEN-005: default footer renders through the key-hint SSOT grammar.
+  it('renders the default footer in the shared key-hint grammar', () => {
+    const { lastFrame } = render(
+      <ListPicker
+        items={['Alpha']}
+        renderItem={(item, isSelected) => (
+          <Text>
+            {isSelected ? SELECTION_INDICATOR : SELECTION_INDICATOR_NONE}
+            {item}
+          </Text>
+        )}
+        onSelect={() => {}}
+        onCancel={() => {}}
+      />,
+    );
+    expect(lastFrame()!).toContain(
+      formatKeyHints([
+        { keys: '↑↓', label: 'Navigate' },
+        { keys: 'Enter', label: 'Select' },
+        { keys: 'Esc', label: 'Cancel' },
+      ]),
+    );
+  });
+});

package/src/__tests__/MenuSelect.test.tsx

@@ -0,0 +1,127 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import MenuSelect from '../MenuSelect.js';
+import { formatKeyHints } from '../key-hint-footer.js';
+
+const delay = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe('MenuSelect', () => {
+  const items = [
+    { label: 'Option A', value: 'a' },
+    { label: 'Option B', value: 'b', hint: 'some hint' },
+    { label: 'Option C', value: 'c' },
+  ];
+
+  it('renders title and all items', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test Menu" items={items} onSelect={() => {}} onBack={() => {}} />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain('Test Menu');
+    expect(frame).toContain('Option A');
+    expect(frame).toContain('Option B');
+    expect(frame).toContain('Option C');
+  });
+
+  it('renders hint text when provided', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test" items={items} onSelect={() => {}} onBack={() => {}} />,
+    );
+    expect(lastFrame()!).toContain('some hint');
+  });
+
+  it('highlights first item by default with > prefix', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test" items={items} onSelect={() => {}} onBack={() => {}} />,
+    );
+    expect(lastFrame()!).toContain('>');
+  });
+
+  it('shows loading state', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test" items={[]} onSelect={() => {}} onBack={() => {}} loading />,
+    );
+    expect(lastFrame()!).toContain('Loading');
+  });
+
+  it('shows error state', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test" items={[]} onSelect={() => {}} onBack={() => {}} error="Failed" />,
+    );
+    expect(lastFrame()!).toContain('Failed');
+  });
+
+  it('calls onSelect with value on Enter', () => {
+    let selected = '';
+    const { stdin } = render(
+      <MenuSelect
+        title="Test"
+        items={items}
+        onSelect={(v) => {
+          selected = v;
+        }}
+        onBack={() => {}}
+      />,
+    );
+    stdin.write('\r');
+    expect(selected).toBe('a');
+  });
+
+  it('calls onBack on Escape', async () => {
+    let backed = false;
+    const { stdin } = render(
+      <MenuSelect
+        title="Test"
+        items={items}
+        onSelect={() => {}}
+        onBack={() => {
+          backed = true;
+        }}
+      />,
+    );
+    stdin.write('\x1B');
+    await delay(50);
+    expect(backed).toBe(true);
+  });
+
+  it('navigates down with arrow key', () => {
+    let selected = '';
+    const { stdin } = render(
+      <MenuSelect
+        title="Test"
+        items={items}
+        onSelect={(v) => {
+          selected = v;
+        }}
+        onBack={() => {}}
+      />,
+    );
+    stdin.write('\x1B[B'); // Down arrow
+    stdin.write('\r');
+    expect(selected).toBe('b');
+  });
+
+  // SCREEN-005: footer + error-state hint render through the key-hint SSOT grammar.
+  it('renders the footer in the shared key-hint grammar', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test" items={items} onSelect={() => {}} onBack={() => {}} />,
+    );
+    expect(lastFrame()!).toContain(
+      formatKeyHints([
+        { keys: '↑↓', label: 'Navigate' },
+        { keys: 'Enter', label: 'Select' },
+        { keys: 'Esc', label: 'Back' },
+      ]),
+    );
+  });
+
+  it('renders the error-state hint via the shared key-hint grammar', () => {
+    const { lastFrame } = render(
+      <MenuSelect title="Test" items={[]} onSelect={() => {}} onBack={() => {}} error="Failed" />,
+    );
+    const frame = lastFrame()!;
+    expect(frame).toContain(formatKeyHints([{ keys: 'Esc', label: 'Back' }]));
+    expect(frame).not.toContain('Press Esc to go back');
+  });
+});

package/src/__tests__/PendingActionPrompt.test.tsx

@@ -0,0 +1,193 @@
+import { render } from 'ink-testing-library';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+import PendingActionPrompt from '../PendingActionPrompt.js';
+import { formatKeyHints } from '../key-hint-footer.js';
+
+import type { IActionRequest } from '@robota-sdk/agent-core';
+
+const delay = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 20));
+const ESC = String.fromCharCode(27);
+const DOWN = `${ESC}[B`;
+const ENTER = '\r';
+
+describe('PendingActionPrompt (CMD-004 unified action renderer)', () => {
+  it('single-select: renders options and answers with the chosen value', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'mode',
+      title: 'Select mode',
+      options: [
+        { value: 'plan', label: 'Plan' },
+        { value: 'default', label: 'Default' },
+      ],
+      maxSelect: 1,
+    };
+    const { stdin, lastFrame } = render(
+      <PendingActionPrompt request={request} onAnswer={onAnswer} />,
+    );
+    expect(lastFrame()).toContain('Select mode');
+    expect(lastFrame()).toContain('Plan');
+
+    stdin.write(DOWN);
+    await delay();
+    stdin.write(ENTER);
+    await delay();
+    expect(onAnswer).toHaveBeenCalledWith({ type: 'answer', values: ['default'] });
+  });
+
+  it('single-select: the highlight starts on the request default — a No-default confirmation answers No on Enter (BEHAVIOR-2437)', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'git-commit',
+      title: 'Commit 1 staged file(s)?',
+      options: [
+        { value: 'yes', label: 'Yes' },
+        { value: 'no', label: 'No' },
+      ],
+      maxSelect: 1,
+      default: { values: ['no'] },
+    };
+    const { stdin, lastFrame } = render(
+      <PendingActionPrompt request={request} onAnswer={onAnswer} />,
+    );
+    expect(lastFrame()).toContain('> No');
+    expect(lastFrame()).not.toContain('> Yes');
+
+    stdin.write(ENTER);
+    await delay();
+    expect(onAnswer).toHaveBeenCalledWith({ type: 'answer', values: ['no'] });
+  });
+
+  it('multi-select (maxSelect>1): toggles with Space and confirms with Enter', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'tags',
+      title: 'Pick tags',
+      options: [
+        { value: 'a', label: 'Alpha' },
+        { value: 'b', label: 'Beta' },
+        { value: 'c', label: 'Gamma' },
+      ],
+      minSelect: 1,
+      maxSelect: 3,
+    };
+    const { stdin, lastFrame } = render(
+      <PendingActionPrompt request={request} onAnswer={onAnswer} />,
+    );
+    expect(lastFrame()).toContain('[ ] Alpha');
+
+    stdin.write(' ');
+    await delay();
+    expect(lastFrame()).toContain('[x] Alpha');
+    stdin.write(DOWN);
+    await delay();
+    stdin.write(' ');
+    await delay();
+    stdin.write(ENTER);
+    await delay();
+    expect(onAnswer).toHaveBeenCalledWith({ type: 'answer', values: ['a', 'b'] });
+  });
+
+  it('free-text with masked: hides input and answers with typed text', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'apiKey',
+      title: 'Enter API key',
+      allowFreeText: true,
+      masked: true,
+    };
+    const { stdin, lastFrame } = render(
+      <PendingActionPrompt request={request} onAnswer={onAnswer} />,
+    );
+    expect(lastFrame()).toContain('Enter API key');
+
+    stdin.write('sk-secret');
+    await delay();
+    expect(lastFrame()).not.toContain('sk-secret');
+    expect(lastFrame()).toContain('*'.repeat('sk-secret'.length));
+    stdin.write(ENTER);
+    await delay();
+    expect(onAnswer).toHaveBeenCalledWith({ type: 'answer', values: [], text: 'sk-secret' });
+  });
+
+  it('Esc cancels the request (resolves cancelled)', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'exit',
+      title: 'Exit?',
+      options: [
+        { value: 'yes', label: 'Yes' },
+        { value: 'no', label: 'No' },
+      ],
+      maxSelect: 1,
+    };
+    const { stdin } = render(<PendingActionPrompt request={request} onAnswer={onAnswer} />);
+    stdin.write(ESC);
+    await delay();
+    expect(onAnswer).toHaveBeenCalledWith({ type: 'cancelled' });
+  });
+
+  it('single-select + allowFreeText: "type a custom answer" opens text; Esc returns to picker (not cancel)', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'provider',
+      title: 'Select provider',
+      options: [{ value: 'openai', label: 'OpenAI' }],
+      maxSelect: 1,
+      allowFreeText: true,
+    };
+    const { stdin, lastFrame } = render(
+      <PendingActionPrompt request={request} onAnswer={onAnswer} />,
+    );
+    expect(lastFrame()).toContain('Type a custom answer');
+
+    stdin.write(DOWN); // move to the synthetic "type a custom answer" entry
+    await delay();
+    stdin.write(ENTER); // enter free-text mode
+    await delay();
+    stdin.write(ESC); // Esc here returns to the picker, does NOT cancel the request
+    await delay();
+    expect(onAnswer).not.toHaveBeenCalled();
+    expect(lastFrame()).toContain('OpenAI'); // back at the picker
+  });
+
+  // SCREEN-005: multi-select footer goes through the key-hint SSOT, keeping the dynamic (min N)
+  // segment on the Enter hint until the selection is confirmable.
+  it('multi-select footer shows the (min N) segment until satisfiable, in the shared grammar', async () => {
+    const onAnswer = vi.fn();
+    const request: IActionRequest = {
+      id: 'tags',
+      title: 'Pick tags',
+      options: [
+        { value: 'a', label: 'Alpha' },
+        { value: 'b', label: 'Beta' },
+      ],
+      minSelect: 1,
+      maxSelect: 2,
+    };
+    const { stdin, lastFrame } = render(
+      <PendingActionPrompt request={request} onAnswer={onAnswer} />,
+    );
+    expect(lastFrame()).toContain(
+      formatKeyHints([
+        { keys: '↑↓', label: 'Navigate' },
+        { keys: 'Space', label: 'Toggle' },
+        { keys: 'Enter', label: 'Confirm (min 1)' },
+        { keys: 'Esc', label: 'Cancel' },
+      ]),
+    );
+
+    stdin.write(' '); // toggle Alpha → selection satisfiable → min segment drops
+    await delay();
+    expect(lastFrame()).toContain(
+      formatKeyHints([
+        { keys: '↑↓', label: 'Navigate' },
+        { keys: 'Space', label: 'Toggle' },
+        { keys: 'Enter', label: 'Confirm' },
+        { keys: 'Esc', label: 'Cancel' },
+      ]),
+    );
+  });
+});

package/src/__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-interface-command';
+
+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);
+});