@geminilight/mindos 0.6.74 → 0.6.75

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

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

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

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

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

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

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

@@ -0,0 +1,66 @@
+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');
+  });
+});