@geminilight/mindos 0.6.73 → 0.6.74

package/_standalone/__tests__/obsidian-compat/integration.test.ts

@@ -1,160 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { PluginLoader } from '@/lib/obsidian-compat/loader';
-
-let mindRoot: string;
-
-const writePlugin = (pluginId: string, mainJs: string) => {
-  const pluginDir = path.join(mindRoot, '.plugins', pluginId);
-  fs.mkdirSync(pluginDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(pluginDir, 'manifest.json'),
-    JSON.stringify({ id: pluginId, name: pluginId, version: '1.0.0' }, null, 2),
-    'utf-8',
-  );
-  fs.writeFileSync(path.join(pluginDir, 'main.js'), mainJs, 'utf-8');
-};
-
-describe('obsidian compat integration', () => {
-  beforeEach(() => {
-    mindRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-integration-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(mindRoot, { recursive: true, force: true });
-  });
-
-  it('awaits async plugin onload before returning from loadPlugin', async () => {
-    writePlugin(
-      'async-plugin',
-      `
-        const { Plugin } = require('obsidian');
-        module.exports = class AsyncPlugin extends Plugin {
-          async onload() {
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            await this.saveData({ ready: true });
-          }
-        };
-      `,
-    );
-
-    const loader = new PluginLoader(mindRoot);
-    const loaded = await loader.loadPlugin('async-plugin');
-    const data = await loaded.instance.loadData();
-
-    expect(data).toEqual({ ready: true });
-  });
-
-  it('injects the expected obsidian exports into plugin modules', async () => {
-    writePlugin(
-      'exports-plugin',
-      `
-        const obsidian = require('obsidian');
-        module.exports = class ExportsPlugin extends obsidian.Plugin {
-          onload() {
-            this.exportCheck = {
-              hasPlugin: typeof obsidian.Plugin === 'function',
-              hasComponent: typeof obsidian.Component === 'function',
-              hasEvents: typeof obsidian.Events === 'function',
-              hasNotice: typeof obsidian.Notice === 'function',
-              hasModal: typeof obsidian.Modal === 'function',
-              hasPluginSettingTab: typeof obsidian.PluginSettingTab === 'function',
-              hasSetting: typeof obsidian.Setting === 'function',
-              hasTFile: typeof obsidian.TFile === 'function'
-            };
-          }
-        };
-      `,
-    );
-
-    const loader = new PluginLoader(mindRoot);
-    const loaded = await loader.loadPlugin('exports-plugin');
-
-    expect((loaded.instance as any).exportCheck).toEqual({
-      hasPlugin: true,
-      hasComponent: true,
-      hasEvents: true,
-      hasNotice: true,
-      hasModal: true,
-      hasPluginSettingTab: true,
-      hasSetting: true,
-      hasTFile: true,
-    });
-  });
-
-  it('extracts frontmatter tags and links through metadata cache', async () => {
-    fs.mkdirSync(path.join(mindRoot, 'notes'), { recursive: true });
-    fs.writeFileSync(
-      path.join(mindRoot, 'notes', 'sample.md'),
-      `---\ntitle: Sample\ncategory: docs\n---\n\n# Hello\nA #tag with a [[Target Note]] link and [external](https://example.com).\n`,
-      'utf-8',
-    );
-    fs.writeFileSync(path.join(mindRoot, 'notes', 'Target Note.md'), '# Target', 'utf-8');
-
-    const loader = new PluginLoader(mindRoot);
-    const app = loader.getApp();
-    const file = app.vault.getFileByPath('notes/sample.md');
-
-    const cache = app.metadataCache.getFileCache(file!);
-
-    expect(cache?.frontmatter).toEqual({ title: 'Sample', category: 'docs' });
-    expect(cache?.tags?.map((item) => item.tag)).toContain('#tag');
-    expect(cache?.links?.map((item) => item.link)).toContain('Target Note');
-  });
-
-  it('resolves link targets and strips md extension when requested', async () => {
-    fs.mkdirSync(path.join(mindRoot, 'notes'), { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, 'notes', 'Target Note.md'), '# Target', 'utf-8');
-
-    const loader = new PluginLoader(mindRoot);
-    const app = loader.getApp();
-    const file = app.vault.getFileByPath('notes/Target Note.md');
-
-    const resolved = app.metadataCache.getFirstLinkpathDest('Target Note', 'notes/source.md');
-
-    expect(resolved?.path).toBe('notes/Target Note.md');
-    expect(app.metadataCache.fileToLinktext(file!, 'notes/source.md', true)).toBe('notes/Target Note');
-  });
-
-  it('lets plugins register setting tabs with collected setting items', async () => {
-    writePlugin(
-      'settings-plugin',
-      `
-        const { Plugin, PluginSettingTab, Setting } = require('obsidian');
-        class ExampleTab extends PluginSettingTab {
-          constructor(app, plugin) {
-            super(app);
-            this.plugin = plugin;
-          }
-          display() {
-            new Setting(this)
-              .setName('API Key')
-              .setDesc('Stored locally')
-              .addText((text) => text.setValue('token').onChange(() => {}));
-          }
-        }
-        module.exports = class SettingsPlugin extends Plugin {
-          onload() {
-            const tab = new ExampleTab(this.app, this);
-            tab.display();
-            this.addSettingTab(tab);
-          }
-        };
-      `,
-    );
-
-    const loader = new PluginLoader(mindRoot);
-    const loaded = await loader.loadPlugin('settings-plugin');
-    const tabs = (loaded.instance as any).settingTabs;
-
-    expect(tabs).toHaveLength(1);
-    expect(tabs[0].items[0]).toMatchObject({
-      name: 'API Key',
-      desc: 'Stored locally',
-      kind: 'text',
-      value: 'token',
-    });
-  });
-});

package/_standalone/__tests__/obsidian-compat/loader.test.ts

@@ -1,130 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { PluginLoader } from '@/lib/obsidian-compat/loader';
-import { CompatError } from '@/lib/obsidian-compat/errors';
-
-let mindRoot: string;
-
-const writePlugin = (pluginId: string, manifest: object, mainJs: string) => {
-  const pluginDir = path.join(mindRoot, '.plugins', pluginId);
-  fs.mkdirSync(pluginDir, { recursive: true });
-  fs.writeFileSync(path.join(pluginDir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
-  fs.writeFileSync(path.join(pluginDir, 'main.js'), mainJs, 'utf-8');
-  return pluginDir;
-};
-
-describe('PluginLoader', () => {
-  beforeEach(() => {
-    mindRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-loader-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(mindRoot, { recursive: true, force: true });
-  });
-
-  it('discovers only plugins with valid manifests', () => {
-    writePlugin(
-      'valid-plugin',
-      { id: 'valid-plugin', name: 'Valid Plugin', version: '1.0.0' },
-      "module.exports = class {}",
-    );
-
-    writePlugin(
-      'invalid-plugin',
-      { id: 'invalid plugin', name: 'Invalid Plugin', version: '1.0.0' },
-      "module.exports = class {}",
-    );
-
-    const loader = new PluginLoader(mindRoot);
-    const plugins = loader.discoverPlugins();
-
-    expect(plugins).toHaveLength(1);
-    expect(plugins[0]?.id).toBe('valid-plugin');
-  });
-
-  it('loads a valid plugin and registers its command during onload', async () => {
-    writePlugin(
-      'hello-plugin',
-      { id: 'hello-plugin', name: 'Hello Plugin', version: '1.0.0' },
-      `
-        const { Plugin } = require('obsidian');
-        module.exports = class HelloPlugin extends Plugin {
-          onload() {
-            this.addCommand({ id: 'hello', name: 'Hello', callback: () => {} });
-          }
-        };
-      `,
-    );
-
-    const loader = new PluginLoader(mindRoot);
-    const loaded = await loader.loadPlugin('hello-plugin');
-    const commands = loader.getApp().getCommands();
-
-    expect(loaded.manifest.id).toBe('hello-plugin');
-    expect(commands).toHaveLength(1);
-    expect(commands[0]?.fullId).toBe('obsidian:hello-plugin:hello');
-  });
-
-  it('unloads a plugin and removes all its registered commands', async () => {
-    writePlugin(
-      'cleanup-plugin',
-      { id: 'cleanup-plugin', name: 'Cleanup Plugin', version: '1.0.0' },
-      `
-        const { Plugin } = require('obsidian');
-        module.exports = class CleanupPlugin extends Plugin {
-          onload() {
-            this.addCommand({ id: 'first', name: 'First', callback: () => {} });
-            this.addCommand({ id: 'second', name: 'Second', callback: () => {} });
-          }
-        };
-      `,
-    );
-
-    const loader = new PluginLoader(mindRoot);
-    await loader.loadPlugin('cleanup-plugin');
-    expect(loader.getApp().getCommands()).toHaveLength(2);
-
-    await loader.unloadPlugin('cleanup-plugin');
-
-    expect(loader.getApp().getCommands()).toHaveLength(0);
-    expect(loader.getLoadedPlugins()).toHaveLength(0);
-  });
-
-  it('rejects plugins that require unsupported modules', async () => {
-    writePlugin(
-      'bad-plugin',
-      { id: 'bad-plugin', name: 'Bad Plugin', version: '1.0.0' },
-      `
-        require('fs');
-        const { Plugin } = require('obsidian');
-        module.exports = class BadPlugin extends Plugin {};
-      `,
-    );
-
-    const loader = new PluginLoader(mindRoot);
-
-    await expect(loader.loadPlugin('bad-plugin')).rejects.toThrow(CompatError);
-    await expect(loader.loadPlugin('bad-plugin')).rejects.toThrow(/Unsupported module: fs/);
-  });
-
-  it('rejects plugin ids that traverse outside the .plugins directory', async () => {
-    const escapedDir = path.join(mindRoot, 'escaped-plugin');
-    fs.mkdirSync(escapedDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(escapedDir, 'manifest.json'),
-      JSON.stringify({ id: 'escaped-plugin', name: 'Escaped Plugin', version: '1.0.0' }),
-      'utf-8',
-    );
-    fs.writeFileSync(
-      path.join(escapedDir, 'main.js'),
-      `const { Plugin } = require('obsidian'); module.exports = class EscapedPlugin extends Plugin {};`,
-      'utf-8',
-    );
-
-    const loader = new PluginLoader(mindRoot);
-
-    await expect(loader.loadPlugin('../escaped-plugin')).rejects.toThrow();
-  });
-});

package/_standalone/__tests__/obsidian-compat/manifest.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateManifest, ManifestError } from '@/lib/obsidian-compat/manifest';
-
-describe('validateManifest', () => {
-  it('accepts valid manifest', () => {
-    const manifest = validateManifest({
-      id: 'test-plugin',
-      name: 'Test Plugin',
-      version: '1.0.0',
-    });
-    expect(manifest.id).toBe('test-plugin');
-    expect(manifest.name).toBe('Test Plugin');
-    expect(manifest.version).toBe('1.0.0');
-  });
-
-  it('throws on missing id', () => {
-    expect(() =>
-      validateManifest({
-        name: 'Test Plugin',
-        version: '1.0.0',
-      }),
-    ).toThrow(ManifestError);
-  });
-
-  it('throws on invalid id (contains spaces)', () => {
-    expect(() =>
-      validateManifest({
-        id: 'test plugin',
-        name: 'Test Plugin',
-        version: '1.0.0',
-      }),
-    ).toThrow(ManifestError);
-  });
-
-  it('throws on invalid version', () => {
-    expect(() =>
-      validateManifest({
-        id: 'test-plugin',
-        name: 'Test Plugin',
-        version: '1.0',
-      }),
-    ).toThrow(ManifestError);
-  });
-
-  it('accepts optional fields', () => {
-    const manifest = validateManifest({
-      id: 'test-plugin',
-      name: 'Test Plugin',
-      version: '1.0.0',
-      description: 'A test plugin',
-      author: 'Test Author',
-      isDesktopOnly: true,
-    });
-    expect(manifest.description).toBe('A test plugin');
-    expect(manifest.author).toBe('Test Author');
-    expect(manifest.isDesktopOnly).toBe(true);
-  });
-});

package/_standalone/__tests__/obsidian-compat/plugin-manager.test.ts

@@ -1,112 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { PluginManager } from '@/lib/obsidian-compat/plugin-manager';
-
-let mindRoot: string;
-
-const writePlugin = (pluginId: string, mainJs: string) => {
-  const pluginDir = path.join(mindRoot, '.plugins', pluginId);
-  fs.mkdirSync(pluginDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(pluginDir, 'manifest.json'),
-    JSON.stringify({ id: pluginId, name: pluginId, version: '1.0.0' }, null, 2),
-    'utf-8',
-  );
-  fs.writeFileSync(path.join(pluginDir, 'main.js'), mainJs, 'utf-8');
-};
-
-describe('PluginManager', () => {
-  beforeEach(() => {
-    mindRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-manager-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(mindRoot, { recursive: true, force: true });
-  });
-
-  it('discovers plugins and marks them disabled by default', async () => {
-    writePlugin('alpha-plugin', `const { Plugin } = require('obsidian'); module.exports = class AlphaPlugin extends Plugin {};`);
-
-    const manager = new PluginManager(mindRoot);
-    const plugins = await manager.discover();
-
-    expect(plugins).toHaveLength(1);
-    expect(plugins[0]).toMatchObject({ id: 'alpha-plugin', enabled: false, loaded: false });
-  });
-
-  it('persists enabled state across manager instances', async () => {
-    writePlugin('persist-plugin', `const { Plugin } = require('obsidian'); module.exports = class PersistPlugin extends Plugin {};`);
-
-    const first = new PluginManager(mindRoot);
-    await first.discover();
-    await first.enable('persist-plugin');
-
-    const second = new PluginManager(mindRoot);
-    const plugins = await second.discover();
-
-    expect(plugins[0]).toMatchObject({ id: 'persist-plugin', enabled: true });
-  });
-
-  it('loads only enabled plugins', async () => {
-    writePlugin('enabled-plugin', `
-      const { Plugin } = require('obsidian');
-      module.exports = class EnabledPlugin extends Plugin {
-        onload() {
-          this.addCommand({ id: 'enabled', name: 'Enabled', callback: () => {} });
-        }
-      };
-    `);
-    writePlugin('disabled-plugin', `const { Plugin } = require('obsidian'); module.exports = class DisabledPlugin extends Plugin {};`);
-
-    const manager = new PluginManager(mindRoot);
-    await manager.discover();
-    await manager.enable('enabled-plugin');
-    const result = await manager.loadEnabledPlugins();
-
-    expect(result.loaded).toEqual(['enabled-plugin']);
-    expect(result.failed).toEqual([]);
-
-    const plugins = manager.list();
-    expect(plugins.find((item) => item.id === 'enabled-plugin')).toMatchObject({ enabled: true, loaded: true });
-    expect(plugins.find((item) => item.id === 'disabled-plugin')).toMatchObject({ enabled: false, loaded: false });
-  });
-
-  it('captures plugin load errors without aborting the whole load pass', async () => {
-    writePlugin('good-plugin', `const { Plugin } = require('obsidian'); module.exports = class GoodPlugin extends Plugin {};`);
-    writePlugin('bad-plugin', `
-      const { Plugin } = require('obsidian');
-      module.exports = class BadPlugin extends Plugin {
-        onload() {
-          throw new Error('boom');
-        }
-      };
-    `);
-
-    const manager = new PluginManager(mindRoot);
-    await manager.discover();
-    await manager.enable('good-plugin');
-    await manager.enable('bad-plugin');
-    const result = await manager.loadEnabledPlugins();
-
-    expect(result.loaded).toContain('good-plugin');
-    expect(result.failed).toContain('bad-plugin');
-
-    const bad = manager.list().find((item) => item.id === 'bad-plugin');
-    expect(bad?.lastError).toMatch(/boom/);
-  });
-
-  it('disables and unloads a loaded plugin', async () => {
-    writePlugin('toggle-plugin', `const { Plugin } = require('obsidian'); module.exports = class TogglePlugin extends Plugin {};`);
-
-    const manager = new PluginManager(mindRoot);
-    await manager.discover();
-    await manager.enable('toggle-plugin');
-    await manager.loadEnabledPlugins();
-    await manager.disable('toggle-plugin');
-
-    const plugin = manager.list().find((item) => item.id === 'toggle-plugin');
-    expect(plugin).toMatchObject({ enabled: false, loaded: false });
-  });
-});

package/_standalone/__tests__/obsidian-compat/ui.test.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Notice, Modal } from '@/lib/obsidian-compat/shims/ui';
-import { PluginSettingTab, Setting } from '@/lib/obsidian-compat/shims/settings';
-import type { App } from '@/lib/obsidian-compat/types';
-
-const appStub: App = {
-  vault: {} as App['vault'],
-  metadataCache: {} as App['metadataCache'],
-  workspace: {} as App['workspace'],
-  isDarkMode: () => false,
-  loadLocalStorage: () => null,
-  saveLocalStorage: () => {},
-  registerCommand: () => ({ id: 'noop', name: 'noop' }),
-  unregisterCommand: () => {},
-};
-
-describe('UI shims', () => {
-  it('stores notice message and timeout', () => {
-    const notice = new Notice('Saved', 1500);
-    expect(notice.message).toBe('Saved');
-    expect(notice.timeout).toBe(1500);
-  });
-
-  it('opens and closes modal while preserving title and content in non-browser environments', () => {
-    const modal = new Modal(appStub);
-    modal.setTitle('Settings');
-    modal.setContent('Body');
-    modal.open();
-    expect(modal.isOpen).toBe(true);
-    expect(modal.titleEl.textContent).toBe('Settings');
-    expect(modal.contentEl.textContent).toBe('Body');
-    modal.close();
-    expect(modal.isOpen).toBe(false);
-  });
-
-  it('collects setting items through the Setting DSL', () => {
-    const tab = new PluginSettingTab(appStub);
-    new Setting(tab)
-      .setName('API Key')
-      .setDesc('Used for requests')
-      .addText((text) => text.setValue('abc').onChange(() => {}));
-
-    expect(tab.items).toHaveLength(1);
-    expect(tab.items[0]).toMatchObject({
-      name: 'API Key',
-      desc: 'Used for requests',
-      kind: 'text',
-      value: 'abc',
-    });
-  });
-
-  it('supports toggle dropdown and button settings', () => {
-    const tab = new PluginSettingTab(appStub);
-
-    new Setting(tab)
-      .setName('Enabled')
-      .addToggle((toggle) => toggle.setValue(true).onChange(() => {}));
-
-    new Setting(tab)
-      .setName('Mode')
-      .addDropdown((dropdown) => dropdown.addOption('fast', 'Fast').setValue('fast').onChange(() => {}));
-
-    new Setting(tab)
-      .setName('Run')
-      .addButton((button) => button.setButtonText('Run now').onClick(() => {}));
-
-    expect(tab.items.map((item) => item.kind)).toEqual(['toggle', 'dropdown', 'button']);
-    expect(tab.items[1]).toMatchObject({ kind: 'dropdown', value: 'fast' });
-    expect(tab.items[2]).toMatchObject({ kind: 'button', buttonText: 'Run now' });
-  });
-});

package/_standalone/__tests__/obsidian-compat/vault.test.ts

@@ -1,93 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { Vault } from '@/lib/obsidian-compat/shims/vault';
-
-let mindRoot: string;
-let vault: Vault;
-
-describe('Vault', () => {
-  beforeEach(() => {
-    mindRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-obsidian-vault-'));
-    vault = new Vault(mindRoot);
-  });
-
-  afterEach(() => {
-    fs.rmSync(mindRoot, { recursive: true, force: true });
-  });
-
-  it('creates, reads, modifies, appends and deletes a file', async () => {
-    const created = await vault.create('notes/today.md', 'hello');
-    expect(created.path).toBe('notes/today.md');
-    expect(await vault.read(created)).toBe('hello');
-
-    await vault.modify(created, 'updated');
-    expect(await vault.read(created)).toBe('updated');
-
-    await vault.append(created, ' world');
-    expect(await vault.read(created)).toBe('updated world');
-
-    await vault.delete(created);
-    expect(vault.getFileByPath('notes/today.md')).toBeNull();
-  });
-
-  it('renames and copies files', async () => {
-    const created = await vault.create('notes/source.md', 'copy me');
-
-    await vault.rename(created, 'notes/renamed.md');
-    const renamed = vault.getFileByPath('notes/renamed.md');
-    expect(renamed?.path).toBe('notes/renamed.md');
-
-    const copied = await vault.copy(renamed!, 'notes/copied.md');
-    expect(copied.path).toBe('notes/copied.md');
-    expect(await vault.read(copied)).toBe('copy me');
-  });
-
-  it('returns markdown files only from getMarkdownFiles', async () => {
-    await vault.create('notes/one.md', 'one');
-    await vault.create('notes/two.txt', 'two');
-
-    const markdownFiles = vault.getMarkdownFiles();
-
-    expect(markdownFiles).toHaveLength(1);
-    expect(markdownFiles[0]?.path).toBe('notes/one.md');
-  });
-
-  it('skips plugin private files under .plugins when listing vault files', async () => {
-    await vault.create('notes/one.md', 'one');
-    fs.mkdirSync(path.join(mindRoot, '.plugins', 'sample-plugin'), { recursive: true });
-    fs.writeFileSync(path.join(mindRoot, '.plugins', 'sample-plugin', 'data.json'), '{}', 'utf-8');
-
-    const files = vault.getFiles().map((file) => file.path);
-
-    expect(files).toContain('notes/one.md');
-    expect(files).not.toContain(path.join('.plugins', 'sample-plugin', 'data.json'));
-  });
-
-  it('emits create and modify events', async () => {
-    const onCreate = vi.fn();
-    const onModify = vi.fn();
-
-    vault.on('create', onCreate);
-    vault.on('modify', onModify);
-
-    const created = await vault.create('notes/events.md', 'hello');
-    await vault.modify(created, 'updated');
-
-    expect(onCreate).toHaveBeenCalledTimes(1);
-    expect(onModify).toHaveBeenCalledTimes(1);
-    expect(onCreate.mock.calls[0]?.[0]?.path).toBe('notes/events.md');
-  });
-
-  it('blocks path traversal when creating files outside mindRoot', async () => {
-    await expect(vault.create('../escaped.md', 'nope')).rejects.toThrow();
-  });
-
-  it('blocks path traversal when reading files outside mindRoot', () => {
-    const escapedPath = path.join(mindRoot, '..', 'escaped.md');
-    fs.writeFileSync(escapedPath, 'secret', 'utf-8');
-
-    expect(vault.getFileByPath('../escaped.md')).toBeNull();
-  });
-});

package/_standalone/__tests__/panels/agents-panel-hub.test.tsx

@@ -1,66 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { renderToStaticMarkup } from 'react-dom/server';
-import AgentsPanel from '@/components/panels/AgentsPanel';
-import { messages } from '@/lib/i18n';
-
-vi.mock('next/navigation', () => ({
-  useRouter: () => ({ push: () => {} }),
-  usePathname: () => '/agents',
-  useSearchParams: () => new URLSearchParams('tab=mcp'),
-}));
-
-vi.mock('@/lib/stores/mcp-store', () => ({
-  useMcpData: () => ({
-    status: {
-      running: true,
-      port: 8781,
-      toolCount: 3,
-      transport: 'stdio',
-      endpoint: 'http://127.0.0.1:8781/mcp',
-      authConfigured: true,
-      connectionMode: { cli: true, mcp: true },
-    },
-    agents: [
-      {
-        key: 'test-agent',
-        name: 'Test Agent',
-        present: true,
-        installed: true,
-        hasProjectScope: false,
-        hasGlobalScope: true,
-        preferredTransport: 'stdio' as const,
-        format: 'json' as const,
-        configKey: 'mcpServers',
-        globalPath: '/home/user/.config/claude.json',
-        transport: 'stdio',
-      },
-    ],
-    skills: [],
-    loading: false,
-    refresh: async () => {},
-    toggleSkill: async () => true,
-    installAgent: async () => true,
-  }),
-}));
-
-vi.mock('@/lib/stores/locale-store', () => ({
-  useLocale: () => ({ locale: 'en' as const, setLocale: () => {}, t: messages.en }),
-}));
-
-describe('AgentsPanel hub layout', () => {
-  it('renders four hub nav rows (Overview, MCP, Skills, Network) and agent name', () => {
-    const html = renderToStaticMarkup(<AgentsPanel active maximized={false} />);
-    const a = messages.en.panels.agents;
-    expect(html).toContain(a.navOverview);
-    expect(html).toContain(a.navMcp);
-    expect(html).toContain(a.navSkills);
-    expect(html).toContain(a.navNetwork);
-    expect(html).toContain('href="/agents"');
-    expect(html).toContain('href="/agents?tab=mcp"');
-    expect(html).toContain('href="/agents?tab=skills"');
-    expect(html).toContain('href="/agents?tab=a2a"');
-    expect(html).toContain('href="/agents/test-agent"');
-    expect(html).toContain('Test Agent');
-    expect(html).not.toContain('/help');
-  });
-});