1417 lines
51 KiB
TypeScript
1417 lines
51 KiB
TypeScript
/**
|
|
* Tests for extensionsSlice — global catalog caches.
|
|
*/
|
|
|
|
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
import { createTestStore, type TestStore } from './storeTestUtils';
|
|
|
|
// Mock the renderer api module
|
|
vi.mock('../../../src/renderer/api', () => ({
|
|
api: {
|
|
plugins: {
|
|
getAll: vi.fn(),
|
|
getReadme: vi.fn(),
|
|
install: vi.fn(),
|
|
uninstall: vi.fn(),
|
|
},
|
|
mcpRegistry: {
|
|
search: vi.fn(),
|
|
browse: vi.fn(),
|
|
getById: vi.fn(),
|
|
getInstalled: vi.fn(),
|
|
diagnose: vi.fn(),
|
|
install: vi.fn(),
|
|
installCustom: vi.fn(),
|
|
uninstall: vi.fn(),
|
|
},
|
|
skills: {
|
|
list: vi.fn(),
|
|
getDetail: vi.fn(),
|
|
previewUpsert: vi.fn(),
|
|
applyUpsert: vi.fn(),
|
|
previewImport: vi.fn(),
|
|
applyImport: vi.fn(),
|
|
deleteSkill: vi.fn(),
|
|
startWatching: vi.fn(),
|
|
stopWatching: vi.fn(),
|
|
onChanged: vi.fn(),
|
|
},
|
|
apiKeys: {
|
|
list: vi.fn(),
|
|
save: vi.fn(),
|
|
delete: vi.fn(),
|
|
lookup: vi.fn(),
|
|
getStorageStatus: vi.fn(),
|
|
},
|
|
cliInstaller: {
|
|
getStatus: vi.fn(),
|
|
getProviderStatus: vi.fn(),
|
|
verifyProviderModels: vi.fn(),
|
|
invalidateStatus: vi.fn(),
|
|
onProgress: vi.fn(),
|
|
},
|
|
},
|
|
}));
|
|
|
|
import { api } from '../../../src/renderer/api';
|
|
import {
|
|
getMcpDiagnosticKey,
|
|
getMcpOperationKey,
|
|
getMcpProjectStateKey,
|
|
getPluginOperationKey,
|
|
} from '../../../src/shared/utils/extensionNormalizers';
|
|
import { createDefaultCliExtensionCapabilities } from '../../../src/shared/utils/providerExtensionCapabilities';
|
|
|
|
import type { AppConfig, CliInstallationStatus } from '../../../src/shared/types';
|
|
import type {
|
|
EnrichedPlugin,
|
|
McpCatalogItem,
|
|
SkillCatalogItem,
|
|
SkillDetail,
|
|
} from '../../../src/shared/types/extensions';
|
|
|
|
const makePlugin = (overrides: Partial<EnrichedPlugin>): EnrichedPlugin => ({
|
|
pluginId: 'test@marketplace',
|
|
marketplaceId: 'test@marketplace',
|
|
qualifiedName: 'test@marketplace',
|
|
name: 'Test Plugin',
|
|
source: 'official',
|
|
description: 'A test plugin',
|
|
category: 'testing',
|
|
hasLspServers: false,
|
|
hasMcpServers: false,
|
|
hasAgents: false,
|
|
hasCommands: false,
|
|
hasHooks: false,
|
|
isExternal: false,
|
|
installCount: 100,
|
|
isInstalled: false,
|
|
installations: [],
|
|
...overrides,
|
|
});
|
|
|
|
const makeMcpServer = (overrides: Partial<McpCatalogItem>): McpCatalogItem => ({
|
|
id: 'test-server',
|
|
name: 'Test Server',
|
|
description: 'A test MCP server',
|
|
source: 'official',
|
|
installSpec: null,
|
|
envVars: [],
|
|
tools: [],
|
|
requiresAuth: false,
|
|
...overrides,
|
|
});
|
|
|
|
const makeSkill = (overrides: Partial<SkillCatalogItem>): SkillCatalogItem => ({
|
|
id: '/tmp/skills/demo',
|
|
sourceType: 'filesystem',
|
|
name: 'Demo Skill',
|
|
description: 'Helps with demo work',
|
|
folderName: 'demo',
|
|
scope: 'user',
|
|
rootKind: 'claude',
|
|
projectRoot: null,
|
|
discoveryRoot: '/tmp/skills',
|
|
skillDir: '/tmp/skills/demo',
|
|
skillFile: '/tmp/skills/demo/SKILL.md',
|
|
metadata: {},
|
|
invocationMode: 'auto',
|
|
flags: {
|
|
hasScripts: false,
|
|
hasReferences: false,
|
|
hasAssets: false,
|
|
},
|
|
isValid: true,
|
|
issues: [],
|
|
modifiedAt: 1,
|
|
...overrides,
|
|
});
|
|
|
|
const makeSkillDetail = (overrides: Partial<SkillDetail> = {}): SkillDetail => ({
|
|
item: makeSkill({ id: '/tmp/skills/demo', skillDir: '/tmp/skills/demo' }),
|
|
body: 'body',
|
|
rawContent: '# Demo',
|
|
rawFrontmatter: null,
|
|
referencesFiles: [],
|
|
scriptFiles: [],
|
|
assetFiles: [],
|
|
...overrides,
|
|
});
|
|
|
|
const makeReadyCliStatus = (): CliInstallationStatus => ({
|
|
flavor: 'claude' as const,
|
|
displayName: 'Claude',
|
|
supportsSelfUpdate: true,
|
|
showVersionDetails: true,
|
|
showBinaryPath: true,
|
|
installed: true,
|
|
installedVersion: '1.0.0',
|
|
binaryPath: '/usr/local/bin/claude',
|
|
latestVersion: '1.0.0',
|
|
updateAvailable: false,
|
|
authLoggedIn: true,
|
|
authStatusChecking: false,
|
|
authMethod: 'oauth_token' as const,
|
|
providers: [],
|
|
});
|
|
|
|
const makeLimitedMultimodelCliStatus = (
|
|
section: 'plugins' | 'mcp',
|
|
reason: string
|
|
): CliInstallationStatus => ({
|
|
flavor: 'agent_teams_orchestrator' as const,
|
|
displayName: 'Claude Multimodel',
|
|
supportsSelfUpdate: false,
|
|
showVersionDetails: true,
|
|
showBinaryPath: true,
|
|
installed: true,
|
|
installedVersion: '1.0.0',
|
|
binaryPath: '/usr/local/bin/claude-multimodel',
|
|
latestVersion: '1.0.0',
|
|
updateAvailable: false,
|
|
authLoggedIn: true,
|
|
authStatusChecking: false,
|
|
authMethod: null,
|
|
providers: [
|
|
{
|
|
providerId: 'anthropic' as const,
|
|
displayName: 'Anthropic',
|
|
supported: true,
|
|
authenticated: true,
|
|
authMethod: 'oauth_token',
|
|
verificationState: 'verified' as const,
|
|
models: [],
|
|
canLoginFromUi: true,
|
|
capabilities: {
|
|
teamLaunch: true,
|
|
oneShot: true,
|
|
extensions: createDefaultCliExtensionCapabilities({
|
|
plugins: {
|
|
status: section === 'plugins' ? 'unsupported' : 'supported',
|
|
ownership: 'shared',
|
|
reason: section === 'plugins' ? reason : null,
|
|
},
|
|
mcp: {
|
|
status: section === 'mcp' ? 'read-only' : 'supported',
|
|
ownership: 'shared',
|
|
reason: section === 'mcp' ? reason : null,
|
|
},
|
|
}),
|
|
},
|
|
statusMessage: null,
|
|
connection: null,
|
|
backend: null,
|
|
},
|
|
],
|
|
});
|
|
|
|
function makeAppConfig(multimodelEnabled: boolean): AppConfig {
|
|
return {
|
|
notifications: {
|
|
enabled: true,
|
|
soundEnabled: false,
|
|
ignoredRegex: [],
|
|
ignoredRepositories: [],
|
|
snoozedUntil: null,
|
|
snoozeMinutes: 60,
|
|
includeSubagentErrors: true,
|
|
notifyOnLeadInbox: true,
|
|
notifyOnUserInbox: true,
|
|
notifyOnClarifications: true,
|
|
notifyOnStatusChange: true,
|
|
notifyOnTaskComments: true,
|
|
notifyOnTaskCreated: true,
|
|
notifyOnAllTasksCompleted: true,
|
|
notifyOnCrossTeamMessage: true,
|
|
notifyOnTeamLaunched: true,
|
|
notifyOnToolApproval: true,
|
|
autoResumeOnRateLimit: false,
|
|
statusChangeOnlySolo: false,
|
|
statusChangeStatuses: [],
|
|
triggers: [],
|
|
},
|
|
general: {
|
|
launchAtLogin: false,
|
|
showDockIcon: true,
|
|
theme: 'system',
|
|
defaultTab: 'dashboard',
|
|
multimodelEnabled,
|
|
claudeRootPath: null,
|
|
agentLanguage: 'system',
|
|
appLocale: 'system',
|
|
autoExpandAIGroups: true,
|
|
useNativeTitleBar: false,
|
|
telemetryEnabled: false,
|
|
},
|
|
providerConnections: {
|
|
anthropic: {
|
|
authMode: 'auto',
|
|
fastModeDefault: false,
|
|
compatibleEndpoint: {
|
|
enabled: false,
|
|
baseUrl: '',
|
|
},
|
|
},
|
|
codex: {
|
|
preferredAuthMode: 'auto',
|
|
},
|
|
},
|
|
runtime: {
|
|
providerBackends: {
|
|
gemini: 'auto',
|
|
codex: 'codex-native',
|
|
},
|
|
},
|
|
display: {
|
|
showTimestamps: true,
|
|
compactMode: false,
|
|
syntaxHighlighting: true,
|
|
},
|
|
sessions: {
|
|
pinnedSessions: {},
|
|
hiddenSessions: {},
|
|
},
|
|
};
|
|
}
|
|
|
|
const pluginOperationKey = (
|
|
pluginId: string,
|
|
scope: 'user' | 'project' | 'local' = 'user',
|
|
projectPath?: string
|
|
) => getPluginOperationKey(pluginId, scope, projectPath);
|
|
const mcpOperationKey = (
|
|
registryId: string,
|
|
scope: 'user' | 'project' | 'local' | 'global' = 'user',
|
|
projectPath?: string
|
|
) => getMcpOperationKey(registryId, scope, projectPath);
|
|
|
|
describe('extensionsSlice', () => {
|
|
let store: TestStore;
|
|
|
|
beforeEach(() => {
|
|
store = createTestStore();
|
|
vi.clearAllMocks();
|
|
(api.cliInstaller!.getStatus as ReturnType<typeof vi.fn>).mockResolvedValue(makeReadyCliStatus());
|
|
});
|
|
|
|
afterEach(() => {
|
|
vi.useRealTimers();
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
describe('fetchPluginCatalog', () => {
|
|
it('fetches and stores plugins', async () => {
|
|
const plugins = [makePlugin({ pluginId: 'a@m' }), makePlugin({ pluginId: 'b@m' })];
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue(plugins);
|
|
|
|
await store.getState().fetchPluginCatalog();
|
|
|
|
expect(store.getState().pluginCatalog).toHaveLength(2);
|
|
expect(store.getState().pluginCatalogLoading).toBe(false);
|
|
expect(store.getState().pluginCatalogError).toBeNull();
|
|
});
|
|
|
|
it('sets error on failure', async () => {
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('boom'));
|
|
|
|
await store.getState().fetchPluginCatalog();
|
|
|
|
expect(store.getState().pluginCatalog).toEqual([]);
|
|
expect(store.getState().pluginCatalogError).toBe('boom');
|
|
expect(store.getState().pluginCatalogLoading).toBe(false);
|
|
});
|
|
|
|
it('clears stale catalog when a different project fetch fails', async () => {
|
|
store.setState({
|
|
pluginCatalog: [makePlugin({ pluginId: 'project-a@m' })],
|
|
pluginCatalogProjectPath: '/tmp/project-a',
|
|
});
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('boom'));
|
|
|
|
await store.getState().fetchPluginCatalog('/tmp/project-b');
|
|
|
|
expect(store.getState().pluginCatalog).toEqual([]);
|
|
expect(store.getState().pluginCatalogProjectPath).toBe('/tmp/project-b');
|
|
expect(store.getState().pluginCatalogError).toBe('boom');
|
|
});
|
|
|
|
it('clears plugin operation state when switching project context', async () => {
|
|
store.setState({
|
|
pluginCatalog: [makePlugin({ pluginId: 'project-a@m' })],
|
|
pluginCatalogProjectPath: '/tmp/project-a',
|
|
pluginInstallProgress: {
|
|
[pluginOperationKey('project-a@m', 'project')]: 'error',
|
|
},
|
|
installErrors: {
|
|
[pluginOperationKey('project-a@m', 'project')]: 'Install failed',
|
|
'mcp-server': 'Keep me',
|
|
},
|
|
});
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue([
|
|
makePlugin({ pluginId: 'project-b@m' }),
|
|
]);
|
|
|
|
await store.getState().fetchPluginCatalog('/tmp/project-b');
|
|
|
|
expect(store.getState().pluginCatalogProjectPath).toBe('/tmp/project-b');
|
|
expect(
|
|
store.getState().pluginInstallProgress[pluginOperationKey('project-a@m', 'project')],
|
|
).toBeUndefined();
|
|
expect(store.getState().installErrors[pluginOperationKey('project-a@m', 'project')]).toBeUndefined();
|
|
expect(store.getState().installErrors['mcp-server']).toBe('Keep me');
|
|
});
|
|
|
|
it('dedups concurrent requests for the same project key', async () => {
|
|
let resolveFetch!: (plugins: EnrichedPlugin[]) => void;
|
|
const inFlight = new Promise<EnrichedPlugin[]>((resolve) => {
|
|
resolveFetch = resolve;
|
|
});
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockImplementation(() => inFlight);
|
|
|
|
const firstFetch = store.getState().fetchPluginCatalog('/tmp/project-a');
|
|
const secondFetch = store.getState().fetchPluginCatalog('/tmp/project-a');
|
|
|
|
expect(api.plugins!.getAll).toHaveBeenCalledTimes(1);
|
|
|
|
resolveFetch([makePlugin({ pluginId: 'same@m' })]);
|
|
await Promise.all([firstFetch, secondFetch]);
|
|
|
|
expect(store.getState().pluginCatalogProjectPath).toBe('/tmp/project-a');
|
|
expect(store.getState().pluginCatalog.map((plugin) => plugin.pluginId)).toEqual(['same@m']);
|
|
});
|
|
|
|
it('keeps the newest project catalog when project changes mid-flight', async () => {
|
|
let resolveProjectA!: (plugins: EnrichedPlugin[]) => void;
|
|
let resolveProjectB!: (plugins: EnrichedPlugin[]) => void;
|
|
const projectAFetch = new Promise<EnrichedPlugin[]>((resolve) => {
|
|
resolveProjectA = resolve;
|
|
});
|
|
const projectBFetch = new Promise<EnrichedPlugin[]>((resolve) => {
|
|
resolveProjectB = resolve;
|
|
});
|
|
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>)
|
|
.mockImplementationOnce(() => projectAFetch)
|
|
.mockImplementationOnce(() => projectBFetch);
|
|
|
|
const firstFetch = store.getState().fetchPluginCatalog('/tmp/project-a');
|
|
const secondFetch = store.getState().fetchPluginCatalog('/tmp/project-b');
|
|
|
|
expect(api.plugins!.getAll).toHaveBeenCalledTimes(2);
|
|
|
|
resolveProjectB([makePlugin({ pluginId: 'project-b@m' })]);
|
|
await secondFetch;
|
|
|
|
expect(store.getState().pluginCatalogProjectPath).toBe('/tmp/project-b');
|
|
expect(store.getState().pluginCatalog.map((plugin) => plugin.pluginId)).toEqual([
|
|
'project-b@m',
|
|
]);
|
|
|
|
resolveProjectA([makePlugin({ pluginId: 'project-a@m' })]);
|
|
await firstFetch;
|
|
|
|
expect(store.getState().pluginCatalogProjectPath).toBe('/tmp/project-b');
|
|
expect(store.getState().pluginCatalog.map((plugin) => plugin.pluginId)).toEqual([
|
|
'project-b@m',
|
|
]);
|
|
});
|
|
|
|
it('clears plugin operation state when a different project fetch fails', async () => {
|
|
store.setState({
|
|
pluginCatalog: [makePlugin({ pluginId: 'project-a@m' })],
|
|
pluginCatalogProjectPath: '/tmp/project-a',
|
|
pluginInstallProgress: {
|
|
[pluginOperationKey('project-a@m', 'project')]: 'error',
|
|
},
|
|
installErrors: {
|
|
[pluginOperationKey('project-a@m', 'project')]: 'Install failed',
|
|
'mcp-server': 'Keep me',
|
|
},
|
|
});
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('boom'));
|
|
|
|
await store.getState().fetchPluginCatalog('/tmp/project-b');
|
|
|
|
expect(store.getState().pluginCatalog).toEqual([]);
|
|
expect(
|
|
store.getState().pluginInstallProgress[pluginOperationKey('project-a@m', 'project')],
|
|
).toBeUndefined();
|
|
expect(store.getState().installErrors[pluginOperationKey('project-a@m', 'project')]).toBeUndefined();
|
|
expect(store.getState().installErrors['mcp-server']).toBe('Keep me');
|
|
});
|
|
});
|
|
|
|
describe('fetchPluginReadme', () => {
|
|
it('fetches and caches README', async () => {
|
|
(api.plugins!.getReadme as ReturnType<typeof vi.fn>).mockResolvedValue('# Hello');
|
|
|
|
store.getState().fetchPluginReadme('test@m');
|
|
|
|
// Wait for the async to resolve
|
|
await vi.waitFor(() => {
|
|
expect(store.getState().pluginReadmes['test@m']).toBe('# Hello');
|
|
});
|
|
expect(store.getState().pluginReadmeLoading['test@m']).toBe(false);
|
|
});
|
|
|
|
it('does not re-fetch cached README', () => {
|
|
store.setState({ pluginReadmes: { 'test@m': 'cached' } });
|
|
|
|
store.getState().fetchPluginReadme('test@m');
|
|
|
|
expect(api.plugins!.getReadme).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('retries README fetch when the cached value is null', () => {
|
|
store.setState({ pluginReadmes: { 'test@m': null } });
|
|
(api.plugins!.getReadme as ReturnType<typeof vi.fn>).mockResolvedValue(null);
|
|
|
|
store.getState().fetchPluginReadme('test@m');
|
|
|
|
expect(api.plugins!.getReadme).toHaveBeenCalledWith('test@m');
|
|
});
|
|
});
|
|
|
|
describe('mcpBrowse', () => {
|
|
it('fetches initial browse results', async () => {
|
|
const servers = [makeMcpServer({ id: 's1' }), makeMcpServer({ id: 's2' })];
|
|
(api.mcpRegistry!.browse as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
servers,
|
|
nextCursor: 'cursor-abc',
|
|
});
|
|
|
|
await store.getState().mcpBrowse();
|
|
|
|
expect(store.getState().mcpBrowseCatalog).toHaveLength(2);
|
|
expect(store.getState().mcpBrowseNextCursor).toBe('cursor-abc');
|
|
expect(store.getState().mcpBrowseLoading).toBe(false);
|
|
});
|
|
|
|
it('appends on cursor-based pagination', async () => {
|
|
store.setState({ mcpBrowseCatalog: [makeMcpServer({ id: 'existing' })] });
|
|
const newServers = [makeMcpServer({ id: 'new1' })];
|
|
(api.mcpRegistry!.browse as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
servers: newServers,
|
|
nextCursor: undefined,
|
|
});
|
|
|
|
await store.getState().mcpBrowse('cursor-1');
|
|
|
|
expect(store.getState().mcpBrowseCatalog).toHaveLength(2);
|
|
expect(store.getState().mcpBrowseNextCursor).toBeUndefined();
|
|
});
|
|
|
|
it('sets error on failure', async () => {
|
|
(api.mcpRegistry!.browse as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('fail'));
|
|
|
|
await store.getState().mcpBrowse();
|
|
|
|
expect(store.getState().mcpBrowseError).toBe('fail');
|
|
expect(store.getState().mcpBrowseLoading).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('mcpFetchInstalled', () => {
|
|
it('fetches installed MCP servers', async () => {
|
|
const installed = [{ name: 'server-a', scope: 'user' as const }];
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue(installed);
|
|
|
|
await store.getState().mcpFetchInstalled();
|
|
|
|
expect(store.getState().mcpInstalledServers).toEqual(installed);
|
|
});
|
|
|
|
it('stores installed MCP servers independently per project context', async () => {
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>)
|
|
.mockResolvedValueOnce([{ name: 'global-server', scope: 'global' as const }])
|
|
.mockResolvedValueOnce([{ name: 'project-server', scope: 'project' as const }]);
|
|
|
|
await store.getState().mcpFetchInstalled();
|
|
await store.getState().mcpFetchInstalled('/tmp/project-a');
|
|
|
|
expect(store.getState().mcpInstalledServersByProjectPath).toMatchObject({
|
|
[getMcpProjectStateKey()]: [{ name: 'global-server', scope: 'global' }],
|
|
[getMcpProjectStateKey('/tmp/project-a')]: [{ name: 'project-server', scope: 'project' }],
|
|
});
|
|
});
|
|
|
|
it('clears stale project- and local-scoped MCP operation state when project changes', async () => {
|
|
store.setState({
|
|
mcpInstalledProjectPath: '/tmp/project-a',
|
|
mcpInstallProgress: {
|
|
[mcpOperationKey('project-server', 'project', '/tmp/project-a')]: 'error',
|
|
[mcpOperationKey('local-server', 'local', '/tmp/project-a')]: 'success',
|
|
[mcpOperationKey('user-server', 'user')]: 'pending',
|
|
},
|
|
installErrors: {
|
|
[mcpOperationKey('project-server', 'project', '/tmp/project-a')]: 'Project failed',
|
|
[mcpOperationKey('local-server', 'local', '/tmp/project-a')]: 'Local failed',
|
|
[mcpOperationKey('user-server', 'user')]: 'Keep user state',
|
|
'plugin:test@marketplace:user': 'Keep plugin state',
|
|
'mcp-custom:custom-server:project:/tmp/project-a': 'Clear custom project state',
|
|
},
|
|
});
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
await store.getState().mcpFetchInstalled('/tmp/project-b');
|
|
|
|
expect(store.getState().mcpInstalledProjectPath).toBe('/tmp/project-b');
|
|
expect(
|
|
store.getState().mcpInstallProgress[mcpOperationKey('project-server', 'project', '/tmp/project-a')]
|
|
).toBeUndefined();
|
|
expect(
|
|
store.getState().mcpInstallProgress[mcpOperationKey('local-server', 'local', '/tmp/project-a')]
|
|
).toBeUndefined();
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('user-server', 'user')]).toBe(
|
|
'pending',
|
|
);
|
|
expect(
|
|
store.getState().installErrors[mcpOperationKey('project-server', 'project', '/tmp/project-a')]
|
|
).toBeUndefined();
|
|
expect(
|
|
store.getState().installErrors[mcpOperationKey('local-server', 'local', '/tmp/project-a')]
|
|
).toBeUndefined();
|
|
expect(store.getState().installErrors[mcpOperationKey('user-server', 'user')]).toBe(
|
|
'Keep user state',
|
|
);
|
|
expect(store.getState().installErrors['mcp-custom:custom-server:project']).toBeUndefined();
|
|
expect(store.getState().installErrors['plugin:test@marketplace:user']).toBe(
|
|
'Keep plugin state',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('openExtensionsTab', () => {
|
|
it('opens a new extensions tab', () => {
|
|
// Ensure we have a focused pane
|
|
expect(store.getState().paneLayout.panes.length).toBeGreaterThan(0);
|
|
|
|
store.getState().openExtensionsTab();
|
|
|
|
const tabs = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const extTab = tabs.find((t) => t.type === 'extensions');
|
|
expect(extTab).toBeDefined();
|
|
expect(extTab!.label).toBe('Extensions');
|
|
});
|
|
|
|
it('seeds projectId from activeProjectId when selectedProjectId is null', () => {
|
|
store.setState({ selectedProjectId: null, activeProjectId: 'project-active' });
|
|
|
|
store.getState().openExtensionsTab();
|
|
|
|
const tabs = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const extTab = tabs.find((t) => t.type === 'extensions');
|
|
expect(extTab?.projectId).toBe('project-active');
|
|
});
|
|
|
|
it('activates existing extensions tab instead of creating new', () => {
|
|
store.getState().openExtensionsTab();
|
|
const tabs1 = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const count1 = tabs1.filter((t) => t.type === 'extensions').length;
|
|
|
|
store.getState().openExtensionsTab();
|
|
const tabs2 = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const count2 = tabs2.filter((t) => t.type === 'extensions').length;
|
|
|
|
expect(count1).toBe(1);
|
|
expect(count2).toBe(1); // no duplicate
|
|
});
|
|
|
|
it('updates projectId on existing tab when selected project changes', () => {
|
|
// Open Extensions with project-A
|
|
store.setState({ selectedProjectId: 'project-A', activeProjectId: null });
|
|
store.getState().openExtensionsTab();
|
|
|
|
const tabsBefore = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const extTabBefore = tabsBefore.find((t) => t.type === 'extensions');
|
|
expect(extTabBefore?.projectId).toBe('project-A');
|
|
|
|
// Switch to project-B and reopen Extensions
|
|
store.setState({ selectedProjectId: 'project-B' });
|
|
store.getState().openExtensionsTab();
|
|
|
|
const tabsAfter = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const extTabAfter = tabsAfter.find((t) => t.type === 'extensions');
|
|
expect(extTabAfter?.projectId).toBe('project-B');
|
|
// Still only one extensions tab
|
|
expect(tabsAfter.filter((t) => t.type === 'extensions')).toHaveLength(1);
|
|
});
|
|
|
|
it('does not update projectId when it already matches', () => {
|
|
store.setState({ selectedProjectId: 'project-A', activeProjectId: null });
|
|
store.getState().openExtensionsTab();
|
|
|
|
const layoutBefore = store.getState().paneLayout;
|
|
|
|
// Reopen with same project — layout should be referentially stable (no set() call)
|
|
store.getState().openExtensionsTab();
|
|
|
|
const tabsBefore = layoutBefore.panes.flatMap((p) => p.tabs);
|
|
const tabsAfter = store.getState().paneLayout.panes.flatMap((p) => p.tabs);
|
|
const extBefore = tabsBefore.find((t) => t.type === 'extensions');
|
|
const extAfter = tabsAfter.find((t) => t.type === 'extensions');
|
|
expect(extAfter?.projectId).toBe(extBefore?.projectId);
|
|
});
|
|
});
|
|
|
|
describe('installPlugin', () => {
|
|
it('sets progress to pending then success', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus() });
|
|
const plugins = [makePlugin({ pluginId: 'a@m' })];
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue(plugins);
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
const promise = store.getState().installPlugin({ pluginId: 'test@m', scope: 'user' });
|
|
|
|
// During execution, should be pending
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('pending');
|
|
|
|
await promise;
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('success');
|
|
});
|
|
|
|
it('does not block plugin install when a usable runtime status already exists during background refresh', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus(), cliStatusLoading: true });
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'test@m', scope: 'user' });
|
|
|
|
expect(api.plugins!.install).toHaveBeenCalledWith({ pluginId: 'test@m', scope: 'user' });
|
|
expect(api.cliInstaller!.getStatus).not.toHaveBeenCalled();
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('success');
|
|
});
|
|
|
|
it('sets progress to error on failure', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus() });
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
state: 'error',
|
|
error: 'Not found',
|
|
});
|
|
|
|
await store.getState().installPlugin({ pluginId: 'fail@m', scope: 'user' });
|
|
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('fail@m')]).toBe('error');
|
|
});
|
|
|
|
it('fills missing projectPath from the active Extensions project context', async () => {
|
|
store.setState({
|
|
cliStatus: makeReadyCliStatus(),
|
|
pluginCatalogProjectPath: '/tmp/project-a',
|
|
});
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'project@m', scope: 'project' });
|
|
|
|
expect(api.plugins!.install).toHaveBeenCalledWith({
|
|
pluginId: 'project@m',
|
|
scope: 'project',
|
|
projectPath: '/tmp/project-a',
|
|
});
|
|
});
|
|
|
|
it('keys project-scope install state by project path and refreshes that same project context', async () => {
|
|
store.setState({
|
|
cliStatus: makeReadyCliStatus(),
|
|
pluginCatalogProjectPath: '/tmp/project-b',
|
|
});
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().installPlugin({
|
|
pluginId: 'project@m',
|
|
scope: 'project',
|
|
projectPath: '/tmp/project-a',
|
|
});
|
|
|
|
expect(
|
|
store.getState().pluginInstallProgress[
|
|
pluginOperationKey('project@m', 'project', '/tmp/project-a')
|
|
]
|
|
).toBe('success');
|
|
expect(
|
|
store.getState().pluginInstallProgress[
|
|
pluginOperationKey('project@m', 'project', '/tmp/project-b')
|
|
]
|
|
).toBeUndefined();
|
|
expect(api.plugins!.getAll).toHaveBeenLastCalledWith('/tmp/project-a', true);
|
|
});
|
|
|
|
it('fails fast for project scope when there is no active project path', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus(), pluginCatalogProjectPath: null });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'project@m', scope: 'project' });
|
|
|
|
expect(api.plugins!.install).not.toHaveBeenCalled();
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('project@m', 'project')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[pluginOperationKey('project@m', 'project')]).toContain(
|
|
'active project',
|
|
);
|
|
});
|
|
|
|
it('fails fast when multimodel runtime declares plugin installs unsupported', async () => {
|
|
store.setState({
|
|
cliStatus: makeLimitedMultimodelCliStatus('plugins', 'Plugin writes unavailable'),
|
|
});
|
|
|
|
await store.getState().installPlugin({ pluginId: 'unsupported@m', scope: 'user' });
|
|
|
|
expect(api.plugins!.install).not.toHaveBeenCalled();
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('unsupported@m')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[pluginOperationKey('unsupported@m')]).toContain(
|
|
'Plugin writes unavailable',
|
|
);
|
|
});
|
|
|
|
it('fills missing projectPath for local scope from the active Extensions project context', async () => {
|
|
store.setState({
|
|
cliStatus: makeReadyCliStatus(),
|
|
pluginCatalogProjectPath: '/tmp/project-a',
|
|
});
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'local@m', scope: 'local' });
|
|
|
|
expect(api.plugins!.install).toHaveBeenCalledWith({
|
|
pluginId: 'local@m',
|
|
scope: 'local',
|
|
projectPath: '/tmp/project-a',
|
|
});
|
|
});
|
|
|
|
it('fails fast for local scope when there is no active project path', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus(), pluginCatalogProjectPath: null });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'local@m', scope: 'local' });
|
|
|
|
expect(api.plugins!.install).not.toHaveBeenCalled();
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('local@m', 'local')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[pluginOperationKey('local@m', 'local')]).toContain(
|
|
'active project',
|
|
);
|
|
});
|
|
|
|
it('keeps user-scope state isolated from local-scope failures', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus(), pluginCatalogProjectPath: null });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'shared@m', scope: 'local' });
|
|
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('shared@m', 'local')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('shared@m', 'user')]).toBeUndefined();
|
|
expect(store.getState().installErrors[pluginOperationKey('shared@m', 'user')]).toBeUndefined();
|
|
});
|
|
|
|
it('clears older success reset timers before a new operation on the same plugin', async () => {
|
|
vi.useFakeTimers();
|
|
store.setState({ cliStatus: makeReadyCliStatus() });
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.plugins!.install as ReturnType<typeof vi.fn>)
|
|
.mockResolvedValueOnce({ state: 'success' })
|
|
.mockResolvedValueOnce({ state: 'error', error: 'second failure' });
|
|
|
|
await store.getState().installPlugin({ pluginId: 'test@m', scope: 'user' });
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('success');
|
|
|
|
await store.getState().installPlugin({ pluginId: 'test@m', scope: 'user' });
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('error');
|
|
|
|
await vi.advanceTimersByTimeAsync(2_000);
|
|
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('error');
|
|
});
|
|
});
|
|
|
|
describe('uninstallPlugin', () => {
|
|
it('sets progress to pending then success', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus() });
|
|
const plugins = [makePlugin({ pluginId: 'a@m', isInstalled: false })];
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue(plugins);
|
|
(api.plugins!.uninstall as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
const promise = store.getState().uninstallPlugin('test@m', 'user');
|
|
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('pending');
|
|
|
|
await promise;
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('success');
|
|
});
|
|
|
|
it('fills missing projectPath from the active Extensions project context', async () => {
|
|
store.setState({ pluginCatalogProjectPath: '/tmp/project-a' });
|
|
(api.plugins!.uninstall as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().uninstallPlugin('project@m', 'project');
|
|
|
|
expect(api.plugins!.uninstall).toHaveBeenCalledWith('project@m', 'project', '/tmp/project-a');
|
|
});
|
|
|
|
it('keys project-scope uninstall state by project path and refreshes that same project context', async () => {
|
|
store.setState({ pluginCatalogProjectPath: '/tmp/project-b' });
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.plugins!.uninstall as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().uninstallPlugin('project@m', 'project', '/tmp/project-a');
|
|
|
|
expect(
|
|
store.getState().pluginInstallProgress[
|
|
pluginOperationKey('project@m', 'project', '/tmp/project-a')
|
|
]
|
|
).toBe('success');
|
|
expect(
|
|
store.getState().pluginInstallProgress[
|
|
pluginOperationKey('project@m', 'project', '/tmp/project-b')
|
|
]
|
|
).toBeUndefined();
|
|
expect(api.plugins!.getAll).toHaveBeenLastCalledWith('/tmp/project-a', true);
|
|
});
|
|
|
|
it('fails fast for project uninstall when there is no active project path', async () => {
|
|
store.setState({ pluginCatalogProjectPath: null });
|
|
|
|
await store.getState().uninstallPlugin('project@m', 'project');
|
|
|
|
expect(api.plugins!.uninstall).not.toHaveBeenCalled();
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('project@m', 'project')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[pluginOperationKey('project@m', 'project')]).toContain(
|
|
'active project',
|
|
);
|
|
});
|
|
|
|
it('fills missing projectPath for local uninstall from the active Extensions project context', async () => {
|
|
store.setState({ pluginCatalogProjectPath: '/tmp/project-a' });
|
|
(api.plugins!.uninstall as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().uninstallPlugin('local@m', 'local');
|
|
|
|
expect(api.plugins!.uninstall).toHaveBeenCalledWith('local@m', 'local', '/tmp/project-a');
|
|
});
|
|
|
|
it('fails fast for local uninstall when there is no active project path', async () => {
|
|
store.setState({ pluginCatalogProjectPath: null });
|
|
|
|
await store.getState().uninstallPlugin('local@m', 'local');
|
|
|
|
expect(api.plugins!.uninstall).not.toHaveBeenCalled();
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('local@m', 'local')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[pluginOperationKey('local@m', 'local')]).toContain(
|
|
'active project',
|
|
);
|
|
});
|
|
|
|
it('does not restore idle state after project switch clears a pending success timer', async () => {
|
|
vi.useFakeTimers();
|
|
store.setState({
|
|
pluginCatalogProjectPath: '/tmp/project-a',
|
|
pluginCatalog: [makePlugin({ pluginId: 'test@m' })],
|
|
});
|
|
(api.plugins!.getAll as ReturnType<typeof vi.fn>)
|
|
.mockResolvedValueOnce([makePlugin({ pluginId: 'test@m' })])
|
|
.mockResolvedValueOnce([makePlugin({ pluginId: 'other@m' })]);
|
|
(api.plugins!.uninstall as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
|
|
await store.getState().uninstallPlugin('test@m', 'user');
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBe('success');
|
|
|
|
await store.getState().fetchPluginCatalog('/tmp/project-b');
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBeUndefined();
|
|
|
|
await vi.advanceTimersByTimeAsync(2_000);
|
|
|
|
expect(store.getState().pluginInstallProgress[pluginOperationKey('test@m')]).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe('installMcpServer', () => {
|
|
it('sets progress to pending then success', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus() });
|
|
(api.mcpRegistry!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
const promise = store.getState().installMcpServer({
|
|
registryId: 'test-id',
|
|
serverName: 'test-server',
|
|
scope: 'user',
|
|
envValues: {},
|
|
headers: [],
|
|
});
|
|
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'user')]).toBe(
|
|
'pending',
|
|
);
|
|
|
|
await promise;
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'user')]).toBe(
|
|
'success',
|
|
);
|
|
});
|
|
|
|
it('does not block MCP install when a usable runtime status already exists during background refresh', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus(), cliStatusLoading: true });
|
|
(api.mcpRegistry!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
await store.getState().installMcpServer({
|
|
registryId: 'test-id',
|
|
serverName: 'test-server',
|
|
scope: 'user',
|
|
envValues: {},
|
|
headers: [],
|
|
});
|
|
|
|
expect(api.mcpRegistry!.install).toHaveBeenCalledWith({
|
|
registryId: 'test-id',
|
|
serverName: 'test-server',
|
|
scope: 'user',
|
|
envValues: {},
|
|
headers: [],
|
|
});
|
|
expect(api.cliInstaller!.getStatus).not.toHaveBeenCalled();
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'user')]).toBe(
|
|
'success',
|
|
);
|
|
});
|
|
|
|
it('does not restore idle state after project switch clears a pending project-scope success timer', async () => {
|
|
vi.useFakeTimers();
|
|
store.setState({
|
|
mcpInstalledProjectPath: '/tmp/project-a',
|
|
});
|
|
(api.mcpRegistry!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
await store.getState().installMcpServer({
|
|
registryId: 'test-id',
|
|
serverName: 'test-server',
|
|
scope: 'project',
|
|
projectPath: '/tmp/project-a',
|
|
envValues: {},
|
|
headers: [],
|
|
});
|
|
|
|
expect(
|
|
store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'project', '/tmp/project-a')]
|
|
).toBe('success');
|
|
|
|
await store.getState().mcpFetchInstalled('/tmp/project-b');
|
|
expect(
|
|
store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'project', '/tmp/project-a')]
|
|
).toBeUndefined();
|
|
|
|
await vi.advanceTimersByTimeAsync(2_000);
|
|
|
|
expect(
|
|
store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'project', '/tmp/project-a')]
|
|
).toBeUndefined();
|
|
});
|
|
|
|
it('fails fast when multimodel runtime exposes MCP as read-only', async () => {
|
|
store.setState({
|
|
cliStatus: makeLimitedMultimodelCliStatus('mcp', 'MCP writes unavailable'),
|
|
});
|
|
|
|
await store.getState().installMcpServer({
|
|
registryId: 'test-id',
|
|
serverName: 'test-server',
|
|
scope: 'global',
|
|
envValues: {},
|
|
headers: [],
|
|
});
|
|
|
|
expect(api.mcpRegistry!.install).not.toHaveBeenCalled();
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'global')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[mcpOperationKey('test-id', 'global')]).toContain(
|
|
'MCP writes unavailable',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('installCustomMcpServer', () => {
|
|
it('rejects and records an error when MCP writes are unavailable', async () => {
|
|
store.setState({
|
|
cliStatus: makeLimitedMultimodelCliStatus('mcp', 'MCP writes unavailable'),
|
|
});
|
|
|
|
await expect(
|
|
store.getState().installCustomMcpServer({
|
|
serverName: 'custom-server',
|
|
scope: 'global',
|
|
installSpec: {
|
|
type: 'stdio',
|
|
npmPackage: '@example/custom-mcp',
|
|
},
|
|
envValues: {},
|
|
headers: [],
|
|
}),
|
|
).rejects.toThrow('MCP writes unavailable');
|
|
|
|
expect(api.mcpRegistry!.installCustom).not.toHaveBeenCalled();
|
|
expect(store.getState().mcpInstallProgress['mcp-custom:custom-server:global']).toBe('error');
|
|
expect(store.getState().installErrors['mcp-custom:custom-server:global']).toContain(
|
|
'MCP writes unavailable',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('uninstallMcpServer', () => {
|
|
it('sets progress to pending then success', async () => {
|
|
store.setState({ cliStatus: makeReadyCliStatus() });
|
|
(api.mcpRegistry!.uninstall as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
const promise = store.getState().uninstallMcpServer('test-id', 'test-server', 'user');
|
|
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'user')]).toBe(
|
|
'pending',
|
|
);
|
|
|
|
await promise;
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'user')]).toBe(
|
|
'success',
|
|
);
|
|
});
|
|
|
|
it('fails fast when multimodel runtime exposes MCP as read-only', async () => {
|
|
store.setState({
|
|
cliStatus: makeLimitedMultimodelCliStatus('mcp', 'MCP writes unavailable'),
|
|
});
|
|
|
|
await store.getState().uninstallMcpServer('test-id', 'test-server', 'global');
|
|
|
|
expect(api.mcpRegistry!.uninstall).not.toHaveBeenCalled();
|
|
expect(store.getState().mcpInstallProgress[mcpOperationKey('test-id', 'global')]).toBe(
|
|
'error',
|
|
);
|
|
expect(store.getState().installErrors[mcpOperationKey('test-id', 'global')]).toContain(
|
|
'MCP writes unavailable',
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('provider-aware runtime refresh', () => {
|
|
it('passes projectPath through MCP diagnostics', async () => {
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
await store.getState().runMcpDiagnostics('/tmp/project-a');
|
|
|
|
expect(api.mcpRegistry!.diagnose).toHaveBeenCalledWith('/tmp/project-a');
|
|
});
|
|
|
|
it('refreshes CLI status after saving an API key', async () => {
|
|
(api.apiKeys!.save as ReturnType<typeof vi.fn>).mockResolvedValue({ id: 'k1' });
|
|
(api.apiKeys!.list as ReturnType<typeof vi.fn>).mockResolvedValue([
|
|
{
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
},
|
|
]);
|
|
|
|
await store.getState().saveApiKey({
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
value: 'secret',
|
|
scope: 'user',
|
|
});
|
|
|
|
expect(api.cliInstaller!.getStatus).toHaveBeenCalled();
|
|
expect(store.getState().apiKeys).toHaveLength(1);
|
|
});
|
|
|
|
it('keeps saved API keys updated when provider status refresh fails', async () => {
|
|
store.setState({
|
|
appConfig: makeAppConfig(false),
|
|
});
|
|
(api.apiKeys!.save as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
});
|
|
(api.apiKeys!.list as ReturnType<typeof vi.fn>).mockResolvedValue([
|
|
{
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
},
|
|
]);
|
|
(api.cliInstaller!.getStatus as ReturnType<typeof vi.fn>).mockRejectedValue(
|
|
new Error('refresh boom')
|
|
);
|
|
|
|
await store.getState().saveApiKey({
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
value: 'secret',
|
|
scope: 'user',
|
|
});
|
|
|
|
expect(store.getState().apiKeys).toHaveLength(1);
|
|
expect(store.getState().apiKeysError).toContain('API key saved, but failed to refresh provider status.');
|
|
});
|
|
|
|
it('keeps local API key state updated when key list refresh fails after save', async () => {
|
|
(api.apiKeys!.save as ReturnType<typeof vi.fn>).mockResolvedValue({
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
});
|
|
(api.apiKeys!.list as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('list boom'));
|
|
|
|
await store.getState().saveApiKey({
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
value: 'secret',
|
|
scope: 'user',
|
|
});
|
|
|
|
expect(store.getState().apiKeys).toEqual([
|
|
{
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
},
|
|
]);
|
|
expect(store.getState().apiKeysError).toContain('API key saved, but failed to refresh key list.');
|
|
});
|
|
|
|
it('refreshes CLI status after deleting an API key', async () => {
|
|
store.setState({
|
|
apiKeys: [
|
|
{
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
},
|
|
],
|
|
});
|
|
(api.apiKeys!.delete as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
|
|
|
|
await store.getState().deleteApiKey('k1');
|
|
|
|
expect(api.cliInstaller!.getStatus).toHaveBeenCalled();
|
|
expect(store.getState().apiKeys).toEqual([]);
|
|
});
|
|
|
|
it('keeps local API key state updated when provider status refresh fails after delete', async () => {
|
|
store.setState({
|
|
appConfig: makeAppConfig(false),
|
|
});
|
|
store.setState({
|
|
apiKeys: [
|
|
{
|
|
id: 'k1',
|
|
name: 'Codex key',
|
|
envVarName: 'OPENAI_API_KEY',
|
|
maskedValue: '***',
|
|
scope: 'user',
|
|
createdAt: '2026-04-17T10:00:00.000Z',
|
|
},
|
|
],
|
|
});
|
|
(api.apiKeys!.delete as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
|
|
(api.cliInstaller!.getStatus as ReturnType<typeof vi.fn>).mockRejectedValue(
|
|
new Error('refresh boom')
|
|
);
|
|
|
|
await store.getState().deleteApiKey('k1');
|
|
|
|
expect(store.getState().apiKeys).toEqual([]);
|
|
expect(store.getState().apiKeysError).toContain(
|
|
'API key deleted, but failed to refresh provider status.'
|
|
);
|
|
});
|
|
|
|
it('keys MCP diagnostics by scope when the same server exists in multiple scopes', async () => {
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([
|
|
{
|
|
name: 'context7',
|
|
scope: 'global',
|
|
target: 'npx -y @upstash/context7-mcp',
|
|
status: 'connected',
|
|
statusLabel: 'Connected',
|
|
rawLine: 'context7: npx -y @upstash/context7-mcp - Connected',
|
|
checkedAt: 1,
|
|
},
|
|
{
|
|
name: 'context7',
|
|
scope: 'project',
|
|
target: 'uvx context7-project',
|
|
status: 'failed',
|
|
statusLabel: 'Failed to connect',
|
|
rawLine: 'context7: uvx context7-project - Failed to connect',
|
|
checkedAt: 1,
|
|
},
|
|
]);
|
|
|
|
await store.getState().runMcpDiagnostics('/tmp/project-a');
|
|
|
|
expect(store.getState().mcpDiagnostics).toMatchObject({
|
|
[getMcpDiagnosticKey('context7', 'global')]: expect.objectContaining({
|
|
target: 'npx -y @upstash/context7-mcp',
|
|
}),
|
|
[getMcpDiagnosticKey('context7', 'project')]: expect.objectContaining({
|
|
target: 'uvx context7-project',
|
|
}),
|
|
});
|
|
});
|
|
|
|
it('stores MCP diagnostics independently per project context', async () => {
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>)
|
|
.mockResolvedValueOnce([
|
|
{
|
|
name: 'global-server',
|
|
scope: 'global',
|
|
target: 'npx global-server',
|
|
status: 'connected',
|
|
statusLabel: 'Connected',
|
|
rawLine: 'global-server: npx global-server - Connected',
|
|
checkedAt: 1,
|
|
},
|
|
])
|
|
.mockResolvedValueOnce([
|
|
{
|
|
name: 'project-server',
|
|
scope: 'project',
|
|
target: 'uvx project-server',
|
|
status: 'failed',
|
|
statusLabel: 'Failed to connect',
|
|
rawLine: 'project-server: uvx project-server - Failed to connect',
|
|
checkedAt: 2,
|
|
},
|
|
]);
|
|
|
|
await store.getState().runMcpDiagnostics();
|
|
await store.getState().runMcpDiagnostics('/tmp/project-a');
|
|
|
|
expect(store.getState().mcpDiagnosticsByProjectPath).toMatchObject({
|
|
[getMcpProjectStateKey()]: {
|
|
[getMcpDiagnosticKey('global-server', 'global')]: expect.objectContaining({
|
|
target: 'npx global-server',
|
|
}),
|
|
},
|
|
[getMcpProjectStateKey('/tmp/project-a')]: {
|
|
[getMcpDiagnosticKey('project-server', 'project')]: expect.objectContaining({
|
|
target: 'uvx project-server',
|
|
}),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('refreshes MCP install state using the operation project context instead of the last viewed tab', async () => {
|
|
store.setState({
|
|
mcpInstalledProjectPath: '/tmp/project-b',
|
|
});
|
|
(api.mcpRegistry!.install as ReturnType<typeof vi.fn>).mockResolvedValue({ state: 'success' });
|
|
(api.mcpRegistry!.getInstalled as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
(api.mcpRegistry!.diagnose as ReturnType<typeof vi.fn>).mockResolvedValue([]);
|
|
|
|
await store.getState().installMcpServer({
|
|
registryId: 'test-id',
|
|
serverName: 'test-server',
|
|
scope: 'project',
|
|
projectPath: '/tmp/project-a',
|
|
envValues: {},
|
|
headers: [],
|
|
});
|
|
|
|
expect(api.mcpRegistry!.getInstalled).toHaveBeenLastCalledWith('/tmp/project-a');
|
|
expect(api.mcpRegistry!.diagnose).toHaveBeenLastCalledWith('/tmp/project-a');
|
|
});
|
|
});
|
|
|
|
describe('skills state hardening', () => {
|
|
it('ignores stale catalog responses for the same project key', async () => {
|
|
let resolveFirst!: (value: SkillCatalogItem[]) => void;
|
|
const firstPromise = new Promise<SkillCatalogItem[]>((resolve) => {
|
|
resolveFirst = resolve;
|
|
});
|
|
const secondResult = [
|
|
makeSkill({
|
|
id: '/tmp/project/.claude/skills/newer',
|
|
skillDir: '/tmp/project/.claude/skills/newer',
|
|
skillFile: '/tmp/project/.claude/skills/newer/SKILL.md',
|
|
scope: 'project',
|
|
projectRoot: '/tmp/project',
|
|
discoveryRoot: '/tmp/project/.claude/skills',
|
|
name: 'Newer Skill',
|
|
}),
|
|
];
|
|
|
|
(api.skills!.list as ReturnType<typeof vi.fn>)
|
|
.mockImplementationOnce(() => firstPromise)
|
|
.mockResolvedValueOnce(secondResult);
|
|
|
|
const firstFetch = store.getState().fetchSkillsCatalog('/tmp/project');
|
|
const secondFetch = store.getState().fetchSkillsCatalog('/tmp/project');
|
|
|
|
await secondFetch;
|
|
resolveFirst([
|
|
makeSkill({
|
|
id: '/tmp/project/.claude/skills/older',
|
|
skillDir: '/tmp/project/.claude/skills/older',
|
|
skillFile: '/tmp/project/.claude/skills/older/SKILL.md',
|
|
scope: 'project',
|
|
projectRoot: '/tmp/project',
|
|
discoveryRoot: '/tmp/project/.claude/skills',
|
|
name: 'Older Skill',
|
|
}),
|
|
]);
|
|
await firstFetch;
|
|
|
|
expect(store.getState().skillsProjectCatalogByProjectPath['/tmp/project']).toEqual(
|
|
secondResult
|
|
);
|
|
});
|
|
|
|
it('keeps the previous detail cache when a detail fetch fails', async () => {
|
|
const cachedDetail = makeSkillDetail();
|
|
store.setState({
|
|
skillsDetailsById: { [cachedDetail.item.id]: cachedDetail },
|
|
});
|
|
(api.skills!.getDetail as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('detail fail'));
|
|
|
|
await expect(
|
|
store.getState().fetchSkillDetail(cachedDetail.item.id, '/tmp/project')
|
|
).rejects.toThrow('detail fail');
|
|
|
|
expect(store.getState().skillsDetailsById[cachedDetail.item.id]).toEqual(cachedDetail);
|
|
expect(store.getState().skillsDetailErrorById[cachedDetail.item.id]).toBe('detail fail');
|
|
});
|
|
});
|
|
});
|