@mseep/claudian 2.0.25

package/tests/setupWindow.ts

@@ -0,0 +1,26 @@
+type TestWindow = typeof globalThis & {
+  cancelAnimationFrame?: (handle: number) => void;
+  requestAnimationFrame?: (callback: FrameRequestCallback) => number;
+};
+
+const testWindow = globalThis as TestWindow;
+
+if (!testWindow.requestAnimationFrame) {
+  testWindow.requestAnimationFrame = (callback: FrameRequestCallback): number => (
+    Number(setTimeout(() => callback(Date.now()), 0))
+  );
+}
+
+if (!testWindow.cancelAnimationFrame) {
+  testWindow.cancelAnimationFrame = (handle: number): void => {
+    clearTimeout(handle);
+  };
+}
+
+if (!('window' in globalThis)) {
+  Object.defineProperty(globalThis, 'window', {
+    configurable: true,
+    value: testWindow,
+    writable: true,
+  });
+}

package/tests/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../tsconfig.jest.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["**/*.ts"]
+}

package/tests/unit/core/commands/builtInCommands.test.ts

@@ -0,0 +1,239 @@
+import '@/providers';
+
+import {
+  BUILT_IN_COMMANDS,
+  detectBuiltInCommand,
+  getBuiltInCommandsForDropdown,
+  isBuiltInCommandSupported,
+} from '../../../../src/core/commands/builtInCommands';
+
+describe('builtInCommands', () => {
+  describe('detectBuiltInCommand', () => {
+    it('detects /clear command', () => {
+      const result = detectBuiltInCommand('/clear');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('clear');
+      expect(result?.command.action).toBe('clear');
+      expect(result?.args).toBe('');
+    });
+
+    it('detects /new command as alias for clear', () => {
+      const result = detectBuiltInCommand('/new');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('clear');
+      expect(result?.command.action).toBe('clear');
+    });
+
+    it('is case-insensitive', () => {
+      expect(detectBuiltInCommand('/CLEAR')).not.toBeNull();
+      expect(detectBuiltInCommand('/Clear')).not.toBeNull();
+      expect(detectBuiltInCommand('/NEW')).not.toBeNull();
+    });
+
+    it('detects command with trailing whitespace', () => {
+      const result = detectBuiltInCommand('/clear ');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('clear');
+      expect(result?.args).toBe('');
+    });
+
+    it('detects command with arguments', () => {
+      const result = detectBuiltInCommand('/clear some arguments');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('clear');
+      expect(result?.args).toBe('some arguments');
+    });
+
+    it('detects /add-dir command with path argument', () => {
+      const result = detectBuiltInCommand('/add-dir /path/to/dir');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('add-dir');
+      expect(result?.command.action).toBe('add-dir');
+      expect(result?.args).toBe('/path/to/dir');
+    });
+
+    it('detects /add-dir command with home path', () => {
+      const result = detectBuiltInCommand('/add-dir ~/projects');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('add-dir');
+      expect(result?.args).toBe('~/projects');
+    });
+
+    it('returns null for non-slash input', () => {
+      expect(detectBuiltInCommand('clear')).toBeNull();
+      expect(detectBuiltInCommand('hello /clear')).toBeNull();
+    });
+
+    it('returns null for unknown commands', () => {
+      expect(detectBuiltInCommand('/unknown')).toBeNull();
+      expect(detectBuiltInCommand('/foo')).toBeNull();
+    });
+
+    it('returns null for empty input', () => {
+      expect(detectBuiltInCommand('')).toBeNull();
+      expect(detectBuiltInCommand('   ')).toBeNull();
+    });
+
+    it('returns null for just slash', () => {
+      expect(detectBuiltInCommand('/')).toBeNull();
+    });
+
+    it('detects /resume command', () => {
+      const result = detectBuiltInCommand('/resume');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('resume');
+      expect(result?.command.action).toBe('resume');
+      expect(result?.args).toBe('');
+    });
+
+    it('detects /fork command', () => {
+      const result = detectBuiltInCommand('/fork');
+      expect(result).not.toBeNull();
+      expect(result?.command.name).toBe('fork');
+      expect(result?.command.action).toBe('fork');
+      expect(result?.args).toBe('');
+    });
+
+    it('detects /fork case-insensitively', () => {
+      expect(detectBuiltInCommand('/FORK')).not.toBeNull();
+      expect(detectBuiltInCommand('/Fork')).not.toBeNull();
+    });
+  });
+
+  describe('getBuiltInCommandsForDropdown', () => {
+    it('returns all built-in commands with proper format', () => {
+      const commands = getBuiltInCommandsForDropdown();
+
+      expect(commands.length).toBe(BUILT_IN_COMMANDS.length);
+
+      const clearCmd = commands.find((c) => c.name === 'clear');
+      expect(clearCmd).toBeDefined();
+      expect(clearCmd?.id).toBe('builtin:clear');
+      expect(clearCmd?.description).toBe('Start a new conversation');
+      expect(clearCmd?.content).toBe('');
+    });
+
+    it('returns commands compatible with SlashCommand interface', () => {
+      const commands = getBuiltInCommandsForDropdown();
+
+      for (const cmd of commands) {
+        expect(cmd).toHaveProperty('id');
+        expect(cmd).toHaveProperty('name');
+        expect(cmd).toHaveProperty('description');
+        expect(cmd).toHaveProperty('content');
+      }
+    });
+  });
+
+  describe('BUILT_IN_COMMANDS', () => {
+    it('has clear command with new alias', () => {
+      const clearCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'clear');
+      expect(clearCmd).toBeDefined();
+      expect(clearCmd?.aliases).toContain('new');
+      expect(clearCmd?.action).toBe('clear');
+    });
+
+    it('has add-dir command that accepts args', () => {
+      const addDirCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'add-dir');
+      expect(addDirCmd).toBeDefined();
+      expect(addDirCmd?.action).toBe('add-dir');
+      expect(addDirCmd?.hasArgs).toBe(true);
+      expect(addDirCmd?.description).toBe('Add external context directory');
+    });
+
+    it('has resume command', () => {
+      const resumeCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'resume');
+      expect(resumeCmd).toBeDefined();
+      expect(resumeCmd?.action).toBe('resume');
+      expect(resumeCmd?.description).toBe('Resume a previous conversation');
+    });
+
+    it('has fork command without args', () => {
+      const forkCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'fork');
+      expect(forkCmd).toBeDefined();
+      expect(forkCmd?.action).toBe('fork');
+      expect(forkCmd?.hasArgs).toBeUndefined();
+    });
+
+    it('clear has no provider restriction', () => {
+      const clearCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'clear');
+      expect(clearCmd?.requiredCapability).toBeUndefined();
+    });
+
+    it('add-dir has no provider restriction', () => {
+      const cmd = BUILT_IN_COMMANDS.find((c) => c.name === 'add-dir');
+      expect(cmd?.requiredCapability).toBeUndefined();
+    });
+
+    it('resume requires native history support', () => {
+      const cmd = BUILT_IN_COMMANDS.find((c) => c.name === 'resume');
+      expect(cmd?.requiredCapability).toBe('supportsNativeHistory');
+    });
+
+    it('fork requires fork support', () => {
+      const cmd = BUILT_IN_COMMANDS.find((c) => c.name === 'fork');
+      expect(cmd?.requiredCapability).toBe('supportsFork');
+    });
+  });
+
+  describe('getBuiltInCommandsForDropdown - provider filtering', () => {
+    it('returns all commands when no providerId is given', () => {
+      const commands = getBuiltInCommandsForDropdown();
+      expect(commands.length).toBe(BUILT_IN_COMMANDS.length);
+    });
+
+    it('returns all commands for claude provider', () => {
+      const commands = getBuiltInCommandsForDropdown('claude');
+      expect(commands.length).toBe(BUILT_IN_COMMANDS.length);
+      expect(commands.map(c => c.name)).toContain('clear');
+      expect(commands.map(c => c.name)).toContain('add-dir');
+      expect(commands.map(c => c.name)).toContain('resume');
+      expect(commands.map(c => c.name)).toContain('fork');
+    });
+
+    it('returns all capability-supported commands for codex provider', () => {
+      const commands = getBuiltInCommandsForDropdown('codex');
+      const names = commands.map(c => c.name);
+      expect(names).toContain('clear');
+      expect(names).toContain('add-dir');
+      expect(names).toContain('resume');
+      expect(names).toContain('fork');
+    });
+
+    it('returns only commands supported by codex capabilities', () => {
+      const commands = getBuiltInCommandsForDropdown('codex');
+      expect(commands.length).toBe(4);
+      expect(commands.map(c => c.name)).toEqual(['clear', 'add-dir', 'resume', 'fork']);
+    });
+  });
+
+  describe('isBuiltInCommandSupported', () => {
+    it('returns true for universal commands on any provider', () => {
+      const clearCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'clear')!;
+      expect(isBuiltInCommandSupported(clearCmd, 'claude')).toBe(true);
+      expect(isBuiltInCommandSupported(clearCmd, 'codex')).toBe(true);
+    });
+
+    it('returns false for provider-restricted commands on other providers', () => {
+      const resumeCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'resume')!;
+      expect(isBuiltInCommandSupported(resumeCmd, 'claude')).toBe(true);
+      expect(isBuiltInCommandSupported(
+        resumeCmd,
+        { supportsNativeHistory: false, supportsFork: true },
+      )).toBe(false);
+    });
+
+    it('uses provider capabilities for provider-specific commands', () => {
+      const forkCmd = BUILT_IN_COMMANDS.find((c) => c.name === 'fork')!;
+      expect(isBuiltInCommandSupported(
+        forkCmd,
+        { supportsNativeHistory: true, supportsFork: true },
+      )).toBe(true);
+      expect(isBuiltInCommandSupported(
+        forkCmd,
+        { supportsNativeHistory: true, supportsFork: false },
+      )).toBe(false);
+    });
+  });
+
+});

package/tests/unit/core/mcp/McpServerManager.test.ts

@@ -0,0 +1,405 @@
+import { McpServerManager } from '@/core/mcp/McpServerManager';
+import type { ManagedMcpServer } from '@/core/types';
+
+const createManager = async (servers: ManagedMcpServer[]) => {
+  const manager = new McpServerManager({
+    load: async () => servers,
+  });
+  await manager.loadServers();
+  return manager;
+};
+
+describe('McpServerManager', () => {
+  describe('getDisallowedMcpTools', () => {
+    it('returns empty array when no servers are loaded', async () => {
+      const manager = await createManager([]);
+      expect(manager.getDisallowedMcpTools(new Set())).toEqual([]);
+    });
+
+    it('formats disabled tools for enabled servers', async () => {
+      const manager = await createManager([
+        {
+          name: 'alpha',
+          config: { command: 'alpha-cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['tool_a', 'tool_b'],
+        },
+      ]);
+
+      expect(manager.getDisallowedMcpTools(new Set())).toEqual([
+        'mcp__alpha__tool_a',
+        'mcp__alpha__tool_b',
+      ]);
+    });
+
+    it('skips disabled servers', async () => {
+      const manager = await createManager([
+        {
+          name: 'alpha',
+          config: { command: 'alpha-cmd' },
+          enabled: false,
+          contextSaving: false,
+          disabledTools: ['tool_a'],
+        },
+        {
+          name: 'beta',
+          config: { command: 'beta-cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['tool_b'],
+        },
+      ]);
+
+      expect(manager.getDisallowedMcpTools(new Set())).toEqual(['mcp__beta__tool_b']);
+    });
+
+    it('trims tool names and ignores blanks', async () => {
+      const manager = await createManager([
+        {
+          name: 'alpha',
+          config: { command: 'alpha-cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['  tool_a  ', ''],
+        },
+      ]);
+
+      expect(manager.getDisallowedMcpTools(new Set())).toEqual(['mcp__alpha__tool_a']);
+    });
+
+    it('skips context-saving servers not mentioned', async () => {
+      const manager = await createManager([
+        {
+          name: 'alpha',
+          config: { command: 'alpha-cmd' },
+          enabled: true,
+          contextSaving: true,
+          disabledTools: ['tool_a'],
+        },
+        {
+          name: 'beta',
+          config: { command: 'beta-cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['tool_b'],
+        },
+      ]);
+
+      expect(manager.getDisallowedMcpTools(new Set())).toEqual(['mcp__beta__tool_b']);
+    });
+
+    it('includes context-saving servers when mentioned', async () => {
+      const manager = await createManager([
+        {
+          name: 'alpha',
+          config: { command: 'alpha-cmd' },
+          enabled: true,
+          contextSaving: true,
+          disabledTools: ['tool_a'],
+        },
+        {
+          name: 'beta',
+          config: { command: 'beta-cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['tool_b'],
+        },
+      ]);
+
+      expect(manager.getDisallowedMcpTools(new Set(['alpha']))).toEqual([
+        'mcp__alpha__tool_a',
+        'mcp__beta__tool_b',
+      ]);
+    });
+  });
+
+  describe('getActiveServers', () => {
+    it('returns empty record when no servers loaded', async () => {
+      const manager = await createManager([]);
+      expect(manager.getActiveServers(new Set())).toEqual({});
+    });
+
+    it('returns enabled non-context-saving servers', async () => {
+      const manager = await createManager([
+        {
+          name: 'alpha',
+          config: { command: 'alpha-cmd', args: ['--flag'] },
+          enabled: true,
+          contextSaving: false,
+        },
+      ]);
+
+      const result = manager.getActiveServers(new Set());
+      expect(result).toEqual({
+        alpha: { command: 'alpha-cmd', args: ['--flag'] },
+      });
+    });
+
+    it('excludes disabled servers', async () => {
+      const manager = await createManager([
+        {
+          name: 'disabled-one',
+          config: { command: 'cmd' },
+          enabled: false,
+          contextSaving: false,
+        },
+        {
+          name: 'enabled-one',
+          config: { command: 'cmd2' },
+          enabled: true,
+          contextSaving: false,
+        },
+      ]);
+
+      const result = manager.getActiveServers(new Set());
+      expect(Object.keys(result)).toEqual(['enabled-one']);
+    });
+
+    it('excludes context-saving servers not mentioned', async () => {
+      const manager = await createManager([
+        {
+          name: 'ctx-server',
+          config: { command: 'ctx-cmd' },
+          enabled: true,
+          contextSaving: true,
+        },
+        {
+          name: 'normal-server',
+          config: { command: 'normal-cmd' },
+          enabled: true,
+          contextSaving: false,
+        },
+      ]);
+
+      const result = manager.getActiveServers(new Set());
+      expect(Object.keys(result)).toEqual(['normal-server']);
+    });
+
+    it('includes context-saving servers when mentioned', async () => {
+      const manager = await createManager([
+        {
+          name: 'ctx-server',
+          config: { command: 'ctx-cmd' },
+          enabled: true,
+          contextSaving: true,
+        },
+      ]);
+
+      const result = manager.getActiveServers(new Set(['ctx-server']));
+      expect(result).toEqual({ 'ctx-server': { command: 'ctx-cmd' } });
+    });
+  });
+
+  describe('getAllDisallowedMcpTools', () => {
+    it('returns empty array when no servers', async () => {
+      const manager = await createManager([]);
+      expect(manager.getAllDisallowedMcpTools()).toEqual([]);
+    });
+
+    it('includes disabled tools from all enabled servers regardless of context-saving', async () => {
+      const manager = await createManager([
+        {
+          name: 'ctx-server',
+          config: { command: 'cmd' },
+          enabled: true,
+          contextSaving: true,
+          disabledTools: ['tool_x'],
+        },
+        {
+          name: 'normal-server',
+          config: { command: 'cmd2' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['tool_y'],
+        },
+      ]);
+
+      const result = manager.getAllDisallowedMcpTools();
+      expect(result).toEqual([
+        'mcp__ctx-server__tool_x',
+        'mcp__normal-server__tool_y',
+      ]);
+    });
+
+    it('skips disabled servers', async () => {
+      const manager = await createManager([
+        {
+          name: 'off',
+          config: { command: 'cmd' },
+          enabled: false,
+          contextSaving: false,
+          disabledTools: ['tool_a'],
+        },
+      ]);
+
+      expect(manager.getAllDisallowedMcpTools()).toEqual([]);
+    });
+
+    it('returns sorted results', async () => {
+      const manager = await createManager([
+        {
+          name: 'beta',
+          config: { command: 'cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['zzz'],
+        },
+        {
+          name: 'alpha',
+          config: { command: 'cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: ['aaa'],
+        },
+      ]);
+
+      const result = manager.getAllDisallowedMcpTools();
+      expect(result).toEqual(['mcp__alpha__aaa', 'mcp__beta__zzz']);
+    });
+
+    it('skips servers with no disabledTools', async () => {
+      const manager = await createManager([
+        {
+          name: 'no-disabled',
+          config: { command: 'cmd' },
+          enabled: true,
+          contextSaving: false,
+        },
+        {
+          name: 'empty-disabled',
+          config: { command: 'cmd' },
+          enabled: true,
+          contextSaving: false,
+          disabledTools: [],
+        },
+      ]);
+
+      expect(manager.getAllDisallowedMcpTools()).toEqual([]);
+    });
+  });
+
+  describe('getEnabledCount', () => {
+    it('returns 0 for no servers', async () => {
+      const manager = await createManager([]);
+      expect(manager.getEnabledCount()).toBe(0);
+    });
+
+    it('counts only enabled servers', async () => {
+      const manager = await createManager([
+        { name: 'a', config: { command: 'a' }, enabled: true, contextSaving: false },
+        { name: 'b', config: { command: 'b' }, enabled: false, contextSaving: false },
+        { name: 'c', config: { command: 'c' }, enabled: true, contextSaving: false },
+      ]);
+      expect(manager.getEnabledCount()).toBe(2);
+    });
+  });
+
+  describe('hasServers', () => {
+    it('returns false for empty', async () => {
+      const manager = await createManager([]);
+      expect(manager.hasServers()).toBe(false);
+    });
+
+    it('returns true when servers exist', async () => {
+      const manager = await createManager([
+        { name: 'a', config: { command: 'a' }, enabled: false, contextSaving: false },
+      ]);
+      expect(manager.hasServers()).toBe(true);
+    });
+  });
+
+  describe('getServers', () => {
+    it('returns loaded servers', async () => {
+      const servers: ManagedMcpServer[] = [
+        { name: 'x', config: { command: 'x' }, enabled: true, contextSaving: false },
+      ];
+      const manager = await createManager(servers);
+      expect(manager.getServers()).toEqual(servers);
+    });
+  });
+
+  describe('getContextSavingServers', () => {
+    it('returns only enabled context-saving servers', async () => {
+      const manager = await createManager([
+        { name: 'ctx-on', config: { command: 'a' }, enabled: true, contextSaving: true },
+        { name: 'ctx-off', config: { command: 'b' }, enabled: true, contextSaving: false },
+        { name: 'disabled-ctx', config: { command: 'c' }, enabled: false, contextSaving: true },
+      ]);
+
+      const result = manager.getContextSavingServers();
+      expect(result).toHaveLength(1);
+      expect(result[0].name).toBe('ctx-on');
+    });
+  });
+
+  describe('extractMentions', () => {
+    it('extracts mentions of context-saving servers from text', async () => {
+      const manager = await createManager([
+        { name: 'my-server', config: { command: 'a' }, enabled: true, contextSaving: true },
+        { name: 'other', config: { command: 'b' }, enabled: true, contextSaving: false },
+      ]);
+
+      const mentions = manager.extractMentions('please use @my-server for this');
+      expect(mentions).toEqual(new Set(['my-server']));
+    });
+
+    it('ignores mentions of non-context-saving servers', async () => {
+      const manager = await createManager([
+        { name: 'normal', config: { command: 'a' }, enabled: true, contextSaving: false },
+      ]);
+
+      const mentions = manager.extractMentions('@normal do something');
+      expect(mentions.size).toBe(0);
+    });
+
+    it('ignores mentions of disabled context-saving servers', async () => {
+      const manager = await createManager([
+        { name: 'disabled-ctx', config: { command: 'a' }, enabled: false, contextSaving: true },
+      ]);
+
+      const mentions = manager.extractMentions('@disabled-ctx');
+      expect(mentions.size).toBe(0);
+    });
+  });
+
+  describe('transformMentions', () => {
+    it('appends MCP after context-saving server mentions', async () => {
+      const manager = await createManager([
+        { name: 'my-server', config: { command: 'a' }, enabled: true, contextSaving: true },
+      ]);
+
+      const result = manager.transformMentions('use @my-server please');
+      expect(result).toBe('use @my-server MCP please');
+    });
+
+    it('does not transform non-context-saving server mentions', async () => {
+      const manager = await createManager([
+        { name: 'normal', config: { command: 'a' }, enabled: true, contextSaving: false },
+      ]);
+
+      const result = manager.transformMentions('use @normal please');
+      expect(result).toBe('use @normal please');
+    });
+
+    it('returns text unchanged when no context-saving servers', async () => {
+      const manager = await createManager([]);
+      const text = 'hello @world';
+      expect(manager.transformMentions(text)).toBe(text);
+    });
+  });
+
+  describe('loadServers', () => {
+    it('populates servers from storage', async () => {
+      const servers: ManagedMcpServer[] = [
+        { name: 'a', config: { command: 'cmd-a' }, enabled: true, contextSaving: false },
+        { name: 'b', config: { type: 'sse', url: 'http://localhost' }, enabled: false, contextSaving: true },
+      ];
+      const manager = new McpServerManager({ load: async () => servers });
+
+      expect(manager.getServers()).toEqual([]);
+      await manager.loadServers();
+      expect(manager.getServers()).toEqual(servers);
+    });
+  });
+});