@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/renderers/workflow-yaml-parser.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect } from 'vitest';
+import { parseWorkflowYaml, validateWorkflowSchema } from '@/components/renderers/workflow-yaml/parser';
+
+describe('Workflow YAML Parser', () => {
+  it('should parse valid workflow', () => {
+    const yaml = `
+title: Test Workflow
+description: A test workflow
+steps:
+  - id: step1
+    name: First step
+    prompt: Execute this step
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors).toHaveLength(0);
+    expect(result.workflow).toBeDefined();
+    expect(result.workflow?.title).toBe('Test Workflow');
+    expect(result.workflow?.steps).toHaveLength(1);
+  });
+
+  it('should detect missing title', () => {
+    const yaml = `
+description: Missing title
+steps:
+  - id: step1
+    name: Step
+    prompt: Execute
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('title');
+  });
+
+  it('should detect missing steps', () => {
+    const yaml = `
+title: No Steps Workflow
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('steps');
+  });
+
+  it('should detect empty steps', () => {
+    const yaml = `
+title: Empty Steps
+steps: []
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('at least 1 step');
+  });
+
+  it('should parse workflow with skills and tools', () => {
+    const yaml = `
+title: Advanced Workflow
+skills:
+  - code-review-quality
+  - document-release
+tools:
+  - git
+  - npm
+steps:
+  - id: review
+    name: Code Review
+    skill: code-review-quality
+    agent: claude-code
+    prompt: Review the code
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors).toHaveLength(0);
+    expect(result.workflow?.skills).toContain('code-review-quality');
+    expect(result.workflow?.tools).toContain('git');
+    expect(result.workflow?.steps[0].skill).toBe('code-review-quality');
+    expect(result.workflow?.steps[0].agent).toBe('claude-code');
+  });
+
+  it('should validate step requires id', () => {
+    const yaml = `
+title: Missing ID
+steps:
+  - name: Step
+    prompt: Execute
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('steps[0]');
+    expect(result.errors[0]).toContain('id');
+  });
+
+  it('should validate step requires name', () => {
+    const yaml = `
+title: Missing Name
+steps:
+  - id: step1
+    prompt: Execute
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('steps[0]');
+    expect(result.errors[0]).toContain('name');
+  });
+
+  it('should validate step requires prompt', () => {
+    const yaml = `
+title: Missing Prompt
+steps:
+  - id: step1
+    name: Step
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('steps[0]');
+    expect(result.errors[0]).toContain('prompt');
+  });
+
+  it('should reject invalid id format', () => {
+    const yaml = `
+title: Invalid ID Format
+steps:
+  - id: "Step-1 Invalid"
+    name: Step
+    prompt: Execute
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toContain('invalid');
+  });
+
+  it('should handle YAML parse errors', () => {
+    const yaml = `
+title: Test
+steps:
+  - id: step1
+    name: Step
+    prompt: |
+      Multiline
+      with: invalid: yaml:
+`;
+    const result = parseWorkflowYaml(yaml);
+    // Should handle gracefully (may or may not error depending on YAML parser)
+    expect(typeof result.errors).toBe('object');
+    expect(Array.isArray(result.errors)).toBe(true);
+  });
+
+  it('should allow optional fields', () => {
+    const yaml = `
+title: Minimal Workflow
+steps:
+  - id: step1
+    name: Step
+    prompt: Execute
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors).toHaveLength(0);
+    expect(result.workflow?.description).toBeUndefined();
+    expect(result.workflow?.steps[0].agent).toBeUndefined();
+    expect(result.workflow?.steps[0].skill).toBeUndefined();
+  });
+
+  it('should detect duplicate step IDs', () => {
+    const yaml = `
+title: Duplicate IDs
+steps:
+  - id: same
+    name: Step A
+    prompt: Do A
+  - id: same
+    name: Step B
+    prompt: Do B
+`;
+    const result = parseWorkflowYaml(yaml);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors.some(e => e.includes('duplicate'))).toBe(true);
+  });
+
+  it('should handle empty file', () => {
+    const result = parseWorkflowYaml('');
+    expect(result.workflow).toBeNull();
+    expect(result.errors.length).toBeGreaterThan(0);
+  });
+});

package/_standalone/__tests__/renderers/workflow-yaml-serializer.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from 'vitest';
+import { serializeWorkflowYaml, generateStepId } from '@/components/renderers/workflow-yaml/serializer';
+import { parseWorkflowYaml } from '@/components/renderers/workflow-yaml/parser';
+import type { WorkflowYaml } from '@/components/renderers/workflow-yaml/types';
+
+describe('Workflow Serializer', () => {
+  it('round-trips a basic workflow (normal path)', () => {
+    const workflow: WorkflowYaml = {
+      title: 'Test Workflow',
+      description: 'A test',
+      steps: [
+        { id: 'step-1', name: 'First', prompt: 'Do something' },
+      ],
+    };
+    const yaml = serializeWorkflowYaml(workflow);
+    const parsed = parseWorkflowYaml(yaml);
+    expect(parsed.errors).toHaveLength(0);
+    expect(parsed.workflow?.title).toBe('Test Workflow');
+    expect(parsed.workflow?.steps[0].name).toBe('First');
+  });
+
+  it('strips empty optional fields (boundary)', () => {
+    const workflow: WorkflowYaml = {
+      title: 'Minimal',
+      steps: [{ id: 's1', name: 'Step', prompt: 'Go' }],
+    };
+    const yaml = serializeWorkflowYaml(workflow);
+    expect(yaml).not.toContain('description');
+    expect(yaml).not.toContain('skills');
+    expect(yaml).not.toContain('agent');
+  });
+
+  it('preserves agent and skill fields (normal path)', () => {
+    const workflow: WorkflowYaml = {
+      title: 'Full',
+      skills: ['code-review'],
+      steps: [{
+        id: 's1', name: 'Review', prompt: 'Review code',
+        agent: 'cursor', skill: 'code-review-quality', timeout: 120,
+      }],
+    };
+    const yaml = serializeWorkflowYaml(workflow);
+    const parsed = parseWorkflowYaml(yaml);
+    expect(parsed.workflow?.skills).toContain('code-review');
+    expect(parsed.workflow?.steps[0].agent).toBe('cursor');
+    expect(parsed.workflow?.steps[0].skill).toBe('code-review-quality');
+    expect(parsed.workflow?.steps[0].timeout).toBe(120);
+  });
+});
+
+describe('generateStepId', () => {
+  it('converts name to kebab-case', () => {
+    expect(generateStepId('Run Tests', [])).toBe('run-tests');
+  });
+
+  it('avoids duplicates', () => {
+    expect(generateStepId('step', ['step'])).toBe('step-2');
+    expect(generateStepId('step', ['step', 'step-2'])).toBe('step-3');
+  });
+
+  it('handles empty name', () => {
+    expect(generateStepId('', [])).toBe('step');
+  });
+});

package/_standalone/__tests__/settings/activity-bar-rail-navigation.test.tsx

@@ -0,0 +1,178 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+
+const mockRouterPush = vi.fn();
+let mockPathname = '/';
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en' as const,
+    t: {
+      sidebar: {
+        files: 'Files',
+        searchTitle: 'Search',
+        echo: 'Echo',
+        agents: 'Agents',
+        discover: 'Discover',
+        workflows: 'Flows',
+        help: 'Help',
+        settingsTitle: 'Settings',
+        syncLabel: 'Sync',
+      },
+    },
+  }),
+}));
+
+vi.mock('next/link', () => ({
+  default: ({ children, ...props }: any) => <a {...props}>{children}</a>,
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ push: mockRouterPush, replace: vi.fn(), prefetch: vi.fn(), back: vi.fn() }),
+  usePathname: () => mockPathname,
+  useSearchParams: () => new URLSearchParams(),
+}));
+
+vi.mock('@/components/SyncStatusBar', () => ({
+  DOT_COLORS: {
+    synced: 'bg-success',
+    syncing: 'bg-[var(--amber)]',
+    error: 'bg-error',
+    conflicts: 'bg-error',
+    off: 'bg-muted',
+  },
+  getStatusLevel: () => 'synced',
+}));
+
+describe('ActivityBar rail navigation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+    mockPathname = '/';
+    (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ hasUpdate: false, current: '1.0.0', latest: '1.0.0' }),
+    }));
+  });
+
+  it('clicking Files on homepage navigates to /wiki instead of toggling sidebar', async () => {
+    mockPathname = '/';
+    const mockPanelChange = vi.fn();
+
+    const ActivityBar = (await import('@/components/ActivityBar')).default;
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(
+        <ActivityBar
+          activePanel="files"
+          onPanelChange={mockPanelChange}
+          syncStatus={null}
+          expanded
+          onExpandedChange={vi.fn()}
+          onSettingsClick={vi.fn()}
+          onSyncClick={vi.fn()}
+          onSpacesClick={() => {
+            // Simulate the SidebarLayout onSpacesClick logic with the fix
+            const pathname = mockPathname;
+            const isHome = pathname === '/';
+            const activePanel = 'files';
+            const wasActive = activePanel === 'files';
+            const onFilesRoute = pathname === '/wiki' || pathname?.startsWith('/view/') || pathname?.startsWith('/wiki/');
+            if (isHome || !wasActive) {
+              mockPanelChange('files');
+              mockRouterPush('/wiki');
+            } else if (!onFilesRoute) {
+              mockRouterPush('/wiki');
+            } else {
+              mockPanelChange(null);
+            }
+          }}
+        />,
+      );
+    });
+
+    // Find and click the Files button
+    const filesButton = host.querySelector('[data-walkthrough="files-panel"]');
+    expect(filesButton).not.toBeNull();
+
+    await act(async () => {
+      filesButton?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+      // Wait for debounce
+      await new Promise(r => setTimeout(r, 200));
+    });
+
+    // Should navigate to /wiki, not toggle off
+    expect(mockRouterPush).toHaveBeenCalledWith('/wiki');
+    // Should set activePanel to 'files', not null
+    expect(mockPanelChange).toHaveBeenCalledWith('files');
+    expect(mockPanelChange).not.toHaveBeenCalledWith(null);
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+
+  it('clicking Files on /wiki page toggles sidebar off', async () => {
+    mockPathname = '/wiki';
+    const mockPanelChange = vi.fn();
+
+    const ActivityBar = (await import('@/components/ActivityBar')).default;
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(
+        <ActivityBar
+          activePanel="files"
+          onPanelChange={mockPanelChange}
+          syncStatus={null}
+          expanded
+          onExpandedChange={vi.fn()}
+          onSettingsClick={vi.fn()}
+          onSyncClick={vi.fn()}
+          onSpacesClick={() => {
+            // Simulate the SidebarLayout onSpacesClick logic with the fix
+            const pathname = mockPathname;
+            const isHome = pathname === '/';
+            const activePanel = 'files';
+            const wasActive = activePanel === 'files';
+            const onFilesRoute = pathname === '/wiki' || pathname?.startsWith('/view/') || pathname?.startsWith('/wiki/');
+            if (isHome || !wasActive) {
+              mockPanelChange('files');
+              mockRouterPush('/wiki');
+            } else if (!onFilesRoute) {
+              mockRouterPush('/wiki');
+            } else {
+              mockPanelChange(null);
+            }
+          }}
+        />,
+      );
+    });
+
+    const filesButton = host.querySelector('[data-walkthrough="files-panel"]');
+    expect(filesButton).not.toBeNull();
+
+    await act(async () => {
+      filesButton?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+      await new Promise(r => setTimeout(r, 200));
+    });
+
+    // On /wiki with files already active, should toggle off
+    expect(mockPanelChange).toHaveBeenCalledWith(null);
+    expect(mockRouterPush).not.toHaveBeenCalled();
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});

package/_standalone/__tests__/settings/activity-bar-update-badge.test.tsx

@@ -0,0 +1,91 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en' as const,
+    t: {
+      sidebar: {
+        files: 'Files',
+        searchTitle: 'Search',
+        echo: 'Echo',
+        agents: 'Agents',
+        discover: 'Discover',
+        help: 'Help',
+        settingsTitle: 'Settings',
+        syncLabel: 'Sync',
+      },
+    },
+  }),
+}));
+
+vi.mock('next/link', () => ({
+  default: ({ children, ...props }: any) => <a {...props}>{children}</a>,
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ push: vi.fn(), replace: vi.fn(), prefetch: vi.fn(), back: vi.fn() }),
+  usePathname: () => '/',
+  useSearchParams: () => new URLSearchParams(),
+}));
+
+vi.mock('@/components/SyncStatusBar', () => ({
+  DOT_COLORS: {
+    synced: 'bg-success',
+    syncing: 'bg-[var(--amber)]',
+    error: 'bg-error',
+    conflicts: 'bg-error',
+    off: 'bg-muted',
+  },
+  getStatusLevel: () => 'synced',
+}));
+
+describe('ActivityBar update badge synchronization', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+    (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ hasUpdate: false, current: '1.0.0', latest: '1.0.0' }),
+    }));
+  });
+
+  it('reacts immediately to update-available events from the current tab', async () => {
+    const ActivityBar = (await import('@/components/ActivityBar')).default;
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(
+        <ActivityBar
+          activePanel={null}
+          onPanelChange={vi.fn()}
+          syncStatus={null}
+          expanded
+          onExpandedChange={vi.fn()}
+          onSettingsClick={vi.fn()}
+          onSyncClick={vi.fn()}
+        />,
+      );
+    });
+
+    expect(host.querySelectorAll('.bg-error').length).toBe(0);
+
+    await act(async () => {
+      localStorage.setItem('mindos_update_latest', '2.0.0');
+      window.dispatchEvent(new Event('mindos:update-available'));
+      await Promise.resolve();
+    });
+
+    expect(host.querySelectorAll('.bg-error').length).toBeGreaterThanOrEqual(1);
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});

package/_standalone/__tests__/settings/custom-provider-form.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { buildDefaultProviderName } from '@/components/settings/useCustomProviderForm';
+
+
+describe('buildDefaultProviderName', () => {
+  it('uses the protocol display name by default', () => {
+    expect(buildDefaultProviderName('openai', [], undefined, 'en')).toBe('OpenAI');
+  });
+
+  it('appends numeric suffixes when the default name already exists', () => {
+    expect(buildDefaultProviderName('openai', ['OpenAI'], undefined, 'en')).toBe('OpenAI 2');
+    expect(buildDefaultProviderName('openai', ['OpenAI', 'OpenAI 2'], undefined, 'en')).toBe('OpenAI 3');
+  });
+
+  it('ignores the currently edited provider name when computing duplicates', () => {
+    expect(buildDefaultProviderName('openai', ['OpenAI'], 'OpenAI', 'en')).toBe('OpenAI');
+  });
+
+  it('uses localized protocol name in Chinese', () => {
+    expect(buildDefaultProviderName('minimax-cn', [], undefined, 'zh')).toBe('MiniMax (国内版)');
+  });
+
+  it('uses LM Studio as the default generated name', () => {
+    expect(buildDefaultProviderName('lm-studio', [], undefined, 'en')).toBe('LM Studio');
+  });
+
+  it('uses vLLM as the default generated name', () => {
+    expect(buildDefaultProviderName('vllm', [], undefined, 'en')).toBe('vLLM');
+  });
+});

package/_standalone/__tests__/settings/settings-update-badge.test.tsx

@@ -0,0 +1,134 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+
+const mockApiFetch = vi.fn();
+
+vi.mock('@/lib/api', () => ({
+  apiFetch: mockApiFetch,
+}));
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en' as const,
+    setLocale: vi.fn(),
+    t: {
+      settings: {
+        title: 'Settings',
+        saved: 'Saved',
+        saveFailed: 'Save failed',
+        save: 'Save',
+        reconfigure: 'Reconfigure',
+        tabs: {
+          ai: 'AI',
+          mcp: 'MCP',
+          knowledge: 'Knowledge',
+          appearance: 'Appearance',
+          sync: 'Sync',
+          update: 'Update',
+        },
+        update: {
+          checking: 'Checking for updates...',
+          error: 'Failed to check for updates.',
+          upToDate: "You're up to date",
+          available: (current: string, latest: string) => `Update available: v${current} → v${latest}`,
+          timeout: 'Update may still be in progress.',
+          timeoutHint: 'The server may need more time to rebuild. Try refreshing.',
+          refreshButton: 'Refresh Page',
+          retryButton: 'Retry Update',
+          releaseNotes: 'View release notes',
+          hint: 'Updates are installed via npm. Equivalent to running',
+          inTerminal: 'in your terminal.',
+          checkButton: 'Check for Updates',
+          updateButton: (latest: string) => `Update to v${latest}`,
+          serverRestarting: 'Server is restarting, please wait...',
+          updatingHint: 'This may take 1–3 minutes. Do not close this page.',
+          updated: 'Updated successfully! Reloading...',
+        },
+      },
+    },
+  }),
+}));
+
+vi.mock('@/components/settings/AiTab', () => ({ AiTab: () => null }));
+vi.mock('@/components/settings/AppearanceTab', () => ({ AppearanceTab: () => null }));
+vi.mock('@/components/settings/KnowledgeTab', () => ({ KnowledgeTab: () => null }));
+vi.mock('@/components/settings/SyncTab', () => ({ SyncTab: () => null }));
+vi.mock('@/components/settings/McpTab', () => ({ McpTab: () => null }));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ push: vi.fn(), replace: vi.fn(), prefetch: vi.fn(), back: vi.fn() }),
+  usePathname: () => '/',
+  useSearchParams: () => new URLSearchParams(),
+}));
+
+describe('Settings update badge synchronization', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+    (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockReturnValue({
+        matches: false,
+        media: '(prefers-color-scheme: dark)',
+        onchange: null,
+        addListener: vi.fn(),
+        removeListener: vi.fn(),
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+      }),
+    });
+  });
+
+  it('shows the Update tab badge after the embedded UpdateTab finds an update', async () => {
+    const SettingsContent = (await import('@/components/settings/SettingsContent')).default;
+
+    mockApiFetch.mockImplementation((url: string) => {
+      if (url === '/api/settings') {
+        return Promise.resolve({
+          ai: {
+            provider: 'anthropic',
+            providers: {
+              anthropic: { apiKey: '', model: 'claude-sonnet-4-6' },
+              openai: { apiKey: '', model: 'gpt-5.4', baseUrl: '' },
+            },
+          },
+          mindRoot: '/tmp/mind',
+          envOverrides: {},
+        });
+      }
+      if (url === '/api/update-check') {
+        return Promise.resolve({
+          current: '1.0.0',
+          latest: '2.0.0',
+          hasUpdate: true,
+        });
+      }
+      if (url === '/api/settings' || url === '/api/update') {
+        return Promise.resolve({});
+      }
+      throw new Error(`Unexpected apiFetch call: ${url}`);
+    });
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<SettingsContent visible initialTab="update" variant="panel" />);
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    const badges = host.querySelectorAll('.bg-error');
+    expect(badges.length).toBeGreaterThanOrEqual(1);
+    expect(localStorage.getItem('mindos_update_latest')).toBe('2.0.0');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});