@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/settings/update-tab-availability-sync.test.tsx

@@ -0,0 +1,115 @@
+// @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();
+const mockDispatchEvent = vi.spyOn(window, 'dispatchEvent');
+
+vi.mock('@/lib/api', () => ({
+  apiFetch: mockApiFetch,
+}));
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en' as const,
+    t: {
+      settings: {
+        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...',
+        },
+      },
+    },
+  }),
+}));
+
+describe('Browser UpdateTab availability synchronization', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+    (globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  it('persists the latest available version when a manual check finds an update', async () => {
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    mockApiFetch.mockResolvedValue({
+      current: '1.0.0',
+      latest: '2.0.0',
+      hasUpdate: true,
+    });
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<UpdateTab />);
+    });
+
+    const checkButton = Array.from(host.querySelectorAll('button')).find((btn) =>
+      btn.textContent?.includes('Check for Updates'),
+    ) as HTMLButtonElement | undefined;
+    expect(checkButton).toBeTruthy();
+
+    await act(async () => {
+      checkButton?.click();
+      await Promise.resolve();
+    });
+
+    expect(localStorage.getItem('mindos_update_latest')).toBe('2.0.0');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+
+  it('dispatches an availability event so existing UI badges can react immediately', async () => {
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    mockApiFetch.mockResolvedValue({
+      current: '1.0.0',
+      latest: '2.0.0',
+      hasUpdate: true,
+    });
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<UpdateTab />);
+    });
+
+    const checkButton = Array.from(host.querySelectorAll('button')).find((btn) =>
+      btn.textContent?.includes('Check for Updates'),
+    ) as HTMLButtonElement | undefined;
+    expect(checkButton).toBeTruthy();
+
+    await act(async () => {
+      checkButton?.click();
+      await Promise.resolve();
+    });
+
+    expect(mockDispatchEvent).toHaveBeenCalledWith(expect.objectContaining({ type: 'mindos:update-available' }));
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});

package/_standalone/__tests__/settings/update-tab-browser.test.tsx

@@ -0,0 +1,159 @@
+// @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();
+
+class MockApiError extends Error {
+  status: number;
+  constructor(message: string, status: number) {
+    super(message);
+    this.name = 'ApiError';
+    this.status = status;
+  }
+}
+
+vi.mock('@/lib/api', () => ({
+  apiFetch: mockApiFetch,
+  ApiError: MockApiError,
+}));
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en' as const,
+    t: {
+      settings: {
+        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...',
+        },
+      },
+    },
+  }),
+}));
+
+describe('Browser UpdateTab immediate failure handling', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  it('surfaces an immediate /api/update failure as an error instead of staying in updating state', async () => {
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    mockApiFetch.mockImplementation((url: string) => {
+      if (url === '/api/update-check') {
+        return Promise.resolve({
+          current: '1.0.0',
+          latest: '2.0.0',
+          hasUpdate: true,
+        });
+      }
+      if (url === '/api/update') {
+        return Promise.reject(new MockApiError('spawn failed', 500));
+      }
+      if (url === '/api/update-status') {
+        return Promise.resolve({
+          stage: 'idle',
+          stages: [],
+          error: null,
+          version: null,
+          startedAt: null,
+        });
+      }
+      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(<UpdateTab />);
+    });
+
+    const updateButton = Array.from(host.querySelectorAll('button')).find((btn) =>
+      btn.textContent?.includes('Update to v2.0.0'),
+    ) as HTMLButtonElement | undefined;
+    expect(updateButton).toBeTruthy();
+
+    await act(async () => {
+      updateButton?.click();
+      await Promise.resolve();
+    });
+
+    expect(host.textContent).toContain('Retry Update');
+    expect(host.textContent).not.toContain('This may take 1–3 minutes. Do not close this page.');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+
+  it('clears persisted update-in-progress state when /api/update fails immediately', async () => {
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    mockApiFetch.mockImplementation((url: string) => {
+      if (url === '/api/update-check') {
+        return Promise.resolve({
+          current: '1.0.0',
+          latest: '2.0.0',
+          hasUpdate: true,
+        });
+      }
+      if (url === '/api/update') {
+        return Promise.reject(new MockApiError('spawn failed', 500));
+      }
+      if (url === '/api/update-status') {
+        return Promise.resolve({
+          stage: 'idle',
+          stages: [],
+          error: null,
+          version: null,
+          startedAt: null,
+        });
+      }
+      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(<UpdateTab />);
+    });
+
+    const updateButton = Array.from(host.querySelectorAll('button')).find((btn) =>
+      btn.textContent?.includes('Update to v2.0.0'),
+    ) as HTMLButtonElement | undefined;
+    expect(updateButton).toBeTruthy();
+
+    await act(async () => {
+      updateButton?.click();
+      await Promise.resolve();
+    });
+
+    expect(localStorage.getItem('mindos_update_in_progress')).toBeNull();
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});

package/_standalone/__tests__/settings/update-tab-desktop.test.tsx

@@ -0,0 +1,169 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot, Root } from 'react-dom/client';
+
+const mockBridge = {
+  checkUpdate: vi.fn(),
+  installUpdate: vi.fn(),
+  getAppInfo: vi.fn(),
+  onUpdateProgress: vi.fn(),
+  onUpdateReady: vi.fn(),
+};
+
+vi.mock('@/lib/api', () => ({
+  apiFetch: vi.fn(),
+  ApiError: class extends Error {},
+}));
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en' as const,
+    t: {
+      settings: {
+        update: {
+          checking: 'Checking for updates...',
+          error: 'Failed to check for updates.',
+          upToDate: "You're up to date",
+          desktopDownloading: 'Downloading update...',
+          desktopReady: 'Update downloaded. Restart to apply.',
+          desktopRestart: 'Restart Now',
+          checkButton: 'Check for Updates',
+          releaseNotes: 'View release notes',
+          desktopHint: 'Updates are delivered through the Desktop app auto-updater.',
+        },
+      },
+    },
+  }),
+}));
+
+describe('Desktop UpdateTab error handling', () => {
+  let host: HTMLDivElement;
+  let root: Root;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    localStorage.clear();
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+
+    mockBridge.getAppInfo.mockResolvedValue({ version: '0.1.0' });
+    mockBridge.onUpdateProgress.mockReturnValue(() => {});
+    mockBridge.onUpdateReady.mockReturnValue(() => {});
+
+    (window as any).mindos = mockBridge;
+
+    host = document.createElement('div');
+    document.body.appendChild(host);
+    root = createRoot(host);
+  });
+
+  afterEach(async () => {
+    await act(async () => { root.unmount(); });
+    host.remove();
+    delete (window as any).mindos;
+  });
+
+  it('shows error state when installUpdate fails during download', async () => {
+    mockBridge.checkUpdate.mockResolvedValue({ available: true, version: '0.2.0' });
+    mockBridge.installUpdate.mockRejectedValue(new Error('Download failed'));
+
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    await act(async () => { root.render(<UpdateTab />); });
+
+    const updateBtn = Array.from(host.querySelectorAll('button'))
+      .find(b => b.textContent?.includes('Update to v0.2.0'));
+    expect(updateBtn).toBeTruthy();
+
+    await act(async () => { updateBtn!.click(); });
+    await act(async () => { await Promise.resolve(); });
+
+    expect(host.textContent).toContain('Update failed');
+  });
+
+  it('shows error state when "Restart Now" fails', async () => {
+    mockBridge.checkUpdate.mockResolvedValue({ available: true, version: '0.2.0' });
+    mockBridge.installUpdate.mockRejectedValue(new Error('quitAndInstall failed'));
+
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    await act(async () => { root.render(<UpdateTab />); });
+
+    // Simulate reaching 'ready' state via onUpdateReady callback
+    const readyCb = mockBridge.onUpdateReady.mock.calls[0]?.[0];
+    expect(readyCb).toBeDefined();
+
+    // First trigger download (to get to a state where 'ready' makes sense)
+    mockBridge.installUpdate.mockResolvedValueOnce(undefined);
+    const updateBtn = Array.from(host.querySelectorAll('button'))
+      .find(b => b.textContent?.includes('Update to v0.2.0'));
+    expect(updateBtn).toBeTruthy();
+
+    await act(async () => { updateBtn!.click(); });
+
+    // Simulate update-ready event
+    await act(async () => { readyCb(); });
+
+    const restartBtn = Array.from(host.querySelectorAll('button'))
+      .find(b => b.textContent?.includes('Restart Now'));
+    expect(restartBtn).toBeTruthy();
+
+    // Now make installUpdate fail on the second call (Restart Now click)
+    mockBridge.installUpdate.mockRejectedValue(new Error('quitAndInstall failed'));
+
+    await act(async () => { restartBtn!.click(); });
+    await act(async () => { await Promise.resolve(); });
+
+    expect(host.textContent).toContain('Failed to');
+  });
+
+  it('shows "up to date" when no update is available', async () => {
+    mockBridge.checkUpdate.mockResolvedValue({ available: false });
+
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    await act(async () => { root.render(<UpdateTab />); });
+
+    expect(host.textContent).toContain("You're up to date");
+  });
+
+  it('resets state to idle on mount to clear stale state after app restart', async () => {
+    // This test verifies the fix for: restart → 'state' still 'downloading' → button disabled
+    mockBridge.checkUpdate.mockResolvedValue({ available: true, version: '0.2.0' });
+
+    const { UpdateTab } = await import('@/components/settings/UpdateTab');
+
+    // First render (before restart)
+    await act(async () => { root.render(<UpdateTab />); });
+
+    const updateBtn = Array.from(host.querySelectorAll('button'))
+      .find(b => b.textContent?.includes('Update to v0.2.0'));
+    expect(updateBtn).toBeTruthy();
+    expect((updateBtn as HTMLButtonElement).disabled).toBe(false);
+
+    // User clicks update, state becomes 'downloading'
+    await act(async () => { updateBtn!.click(); });
+    await act(async () => { await Promise.resolve(); });
+
+    // In real scenario, app restarts here and component remounts
+    // Unmount and create new root to simulate fresh load
+    await act(async () => { root.unmount(); });
+    host.remove();
+
+    const newHost = document.createElement('div');
+    document.body.appendChild(newHost);
+    const newRoot = createRoot(newHost);
+
+    await act(async () => { newRoot.render(<UpdateTab />); });
+
+    // CRITICAL: After remount, the "Check for Updates" button should be ENABLED
+    // (not disabled like before the fix)
+    const checkBtn = Array.from(newHost.querySelectorAll('button'))
+      .find(b => b.textContent?.includes('Check for Updates'));
+    expect(checkBtn).toBeTruthy();
+    expect((checkBtn as HTMLButtonElement).disabled).toBe(false); // Must be enabled!
+
+    await act(async () => { newRoot.unmount(); });
+    newHost.remove();
+  });
+});

package/_standalone/__tests__/setup.ts

@@ -0,0 +1,100 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { vi, beforeEach, afterEach } from 'vitest';
+
+// --- JSDOM polyfills ---
+
+// JSDOM doesn't implement scrollIntoView
+if (typeof Element !== 'undefined' && !Element.prototype.scrollIntoView) {
+  Element.prototype.scrollIntoView = function () {};
+}
+
+// JSDOM doesn't implement DataTransfer
+if (typeof globalThis.DataTransfer === 'undefined') {
+  class DataTransferPolyfill {
+    private _data: Record<string, string> = {};
+    dropEffect = 'none';
+    effectAllowed = 'uninitialized';
+    files: FileList = [] as unknown as FileList;
+    items: DataTransferItemList = [] as unknown as DataTransferItemList;
+    types: string[] = [];
+    setData(format: string, data: string) {
+      this._data[format] = data;
+      if (!this.types.includes(format)) this.types.push(format);
+    }
+    getData(format: string) {
+      return this._data[format] ?? '';
+    }
+    clearData(format?: string) {
+      if (format) {
+        delete this._data[format];
+        this.types = this.types.filter(t => t !== format);
+      } else {
+        this._data = {};
+        this.types = [];
+      }
+    }
+    setDragImage() {}
+  }
+  (globalThis as any).DataTransfer = DataTransferPolyfill;
+}
+
+// JSDOM doesn't implement DragEvent
+if (typeof globalThis.DragEvent === 'undefined' && typeof globalThis.MouseEvent !== 'undefined') {
+  class DragEventPolyfill extends MouseEvent {
+    readonly dataTransfer: DataTransfer | null;
+    constructor(type: string, init?: DragEventInit & { dataTransfer?: DataTransfer | null }) {
+      super(type, init);
+      this.dataTransfer = init?.dataTransfer ?? null;
+    }
+  }
+  (globalThis as any).DragEvent = DragEventPolyfill;
+}
+
+// Temp MIND_ROOT for each test
+export let testMindRoot: string;
+
+// Helper to seed files into the temp dir
+export function seedFile(relativePath: string, content: string): void {
+  const abs = path.join(testMindRoot, relativePath);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf-8');
+}
+
+// We need to expose testMindRoot via a getter since it changes per test
+const state = { root: '' };
+export function getTestMindRoot() {
+  return state.root;
+}
+
+// Mock the settings module so effectiveSopRoot() returns our temp dir
+vi.mock('@/lib/settings', () => ({
+  readSettings: () => ({
+    ai: {
+      activeProvider: 'p_anthro01',
+      providers: [
+        { id: 'p_anthro01', name: 'Anthropic', protocol: 'anthropic', apiKey: '', model: 'claude-sonnet-4-6', baseUrl: '' },
+        { id: 'p_openai01', name: 'OpenAI', protocol: 'openai', apiKey: '', model: 'gpt-5.4', baseUrl: '' },
+      ],
+    },
+    mindRoot: '',
+  }),
+  writeSettings: vi.fn(),
+  effectiveSopRoot: () => state.root,
+  effectiveAiConfig: () => ({
+    provider: 'anthropic',
+    apiKey: '',
+    model: 'claude-sonnet-4-6',
+    baseUrl: '',
+  }),
+}));
+
+beforeEach(() => {
+  state.root = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-app-test-'));
+  testMindRoot = state.root;
+});
+
+afterEach(() => {
+  fs.rmSync(state.root, { recursive: true, force: true });
+});

package/_standalone/__tests__/skills/mindos-skill-copy-alignment.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+const root = '/data/home/geminitwang/code/sop_note';
+const read = (relativePath: string) => readFileSync(path.join(root, relativePath), 'utf8');
+
+describe('MindOS skill copy alignment', () => {
+  it('keeps source and app skill copies aligned for default skill', () => {
+    expect(read('skills/mindos/SKILL.md')).toBe(read('app/data/skills/mindos/SKILL.md'));
+    expect(read('skills/mindos-zh/SKILL.md')).toBe(read('app/data/skills/mindos-zh/SKILL.md'));
+  });
+
+  it('keeps source and app skill copies aligned for max skill', () => {
+    expect(read('skills/mindos-max/SKILL.md')).toBe(read('app/data/skills/mindos-max/SKILL.md'));
+    expect(read('skills/mindos-max-zh/SKILL.md')).toBe(read('app/data/skills/mindos-max-zh/SKILL.md'));
+  });
+
+  it('removes second-brain wording from aligned skill descriptions', () => {
+    const en = read('skills/mindos-max/SKILL.md').toLowerCase();
+    const zh = read('skills/mindos-max-zh/SKILL.md');
+    expect(en).not.toContain('second brain');
+    expect(zh).not.toContain('第二大脑');
+    expect(en).toContain('local knowledge assistant');
+    expect(zh).toContain('本地知识助手');
+  });
+});