@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/components/UpdateToast.test.ts

@@ -0,0 +1,344 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+
+/**
+ * UpdateToast Component Tests  
+ * Tests for Desktop-only update notification toast
+ */
+
+describe('UpdateToast Logic', () => {
+  describe('Skip Version Logic', () => {
+    it('should show toast when version > skipped desktop version', () => {
+      // Pure version comparison logic (no mocks needed)
+      const latest = '0.1.14';
+      const skipped = '0.1.13';
+      const shouldShow = latest > skipped;
+      expect(shouldShow).toBe(true);
+    });
+
+    it('should NOT show toast when version = skipped version', () => {
+      const latest = '0.1.14';
+      const skipped = '0.1.14';
+      const shouldShow = latest > skipped;
+      expect(shouldShow).toBe(false);
+    });
+
+    it('should NOT show toast when version < skipped version (older)', () => {
+      const latest = '0.1.13';
+      const skipped = '0.1.14';
+      const shouldShow = latest > skipped;
+      expect(shouldShow).toBe(false);
+    });
+
+    it('should show toast when no skipped version stored', () => {
+      const latest = '0.1.14';
+      const skipped: string | null = null;
+      const shouldShow = !skipped || latest > skipped;
+      expect(shouldShow).toBe(true);
+    });
+
+    it('should handle semantic versioning string comparison', () => {
+      // Test actual lexicographic string comparison behavior
+      // which is what we use for version comparison
+      expect('0.2.0' > '0.1.99').toBe(true);   // Works correctly
+      expect('1.0.0' > '0.9.9').toBe(true);    // Works correctly
+      expect('0.1.10' > '0.1.9').toBe(false);  // String comparison quirk, but OK for our use case
+    });
+  });
+
+  describe('Combined Update Detection', () => {
+    it('should detect single desktop update', () => {
+      const updates = {
+        desktop: { type: 'desktop' as const, version: '0.1.14' },
+        core: undefined,
+      };
+
+      const hasDesktop = !!updates.desktop;
+      const hasCore = !!updates.core;
+      const hasBoth = !!(updates.desktop && updates.core);
+
+      expect(hasDesktop).toBe(true);
+      expect(hasCore).toBe(false);
+      expect(hasBoth).toBe(false);
+    });
+
+    it('should detect single core update', () => {
+      const updates = {
+        desktop: undefined,
+        core: { type: 'core' as const, version: '0.6.28' },
+      };
+
+      const hasDesktop = !!updates.desktop;
+      const hasCore = !!updates.core;
+      const hasBoth = !!(updates.desktop && updates.core);
+
+      expect(hasDesktop).toBe(false);
+      expect(hasCore).toBe(true);
+      expect(hasBoth).toBe(false);
+    });
+
+    it('should detect both updates available', () => {
+      const updates = {
+        desktop: { type: 'desktop' as const, version: '0.1.14' },
+        core: { type: 'core' as const, version: '0.6.28' },
+      };
+
+      const hasBoth = !!(updates.desktop && updates.core);
+      expect(hasBoth).toBe(true);
+    });
+  });
+
+  describe('LocalStorage Key Management', () => {
+    it('should use correct key names', () => {
+      const SKIP_DESKTOP_KEY = 'mindos_update_skip_desktop';
+      const SKIP_CORE_KEY = 'mindos_update_skip_core';
+
+      expect(SKIP_DESKTOP_KEY).toBe('mindos_update_skip_desktop');
+      expect(SKIP_CORE_KEY).toBe('mindos_update_skip_core');
+    });
+
+    it('should handle separate skip storage for desktop and core', () => {
+      // Test the storage model
+      const storage: Record<string, string> = {};
+
+      // Desktop update
+      storage['mindos_update_skip_desktop'] = '0.1.14';
+
+      // Core update
+      storage['mindos_update_skip_core'] = '0.6.28';
+
+      expect(storage['mindos_update_skip_desktop']).toBe('0.1.14');
+      expect(storage['mindos_update_skip_core']).toBe('0.6.28');
+    });
+  });
+
+  describe('Desktop Bridge Detection', () => {
+    it('should return null when bridge unavailable', () => {
+      const bridge = undefined;
+      expect(bridge).toBeUndefined();
+    });
+
+    it('should return truthy when bridge exists', () => {
+      const bridge = { checkUpdate: () => {} };
+      expect(bridge).toBeDefined();
+      expect(bridge.checkUpdate).toBeDefined();
+    });
+  });
+
+  describe('Event Dispatching', () => {
+    it('should have correct event type', () => {
+      const eventType = 'mindos:open-settings';
+      expect(eventType).toBe('mindos:open-settings');
+    });
+
+    it('should include correct tab in event detail', () => {
+      const detail = { tab: 'update' };
+      expect(detail.tab).toBe('update');
+    });
+
+    it('should support both "Skip Version" and "Skip All" labels', () => {
+      const hasBoth = true;
+      const label = hasBoth ? 'Skip All' : 'Skip Version';
+      expect(label).toBe('Skip All');
+
+      const single = false;
+      const label2 = single ? 'Skip All' : 'Skip Version';
+      expect(label2).toBe('Skip Version');
+    });
+  });
+
+  describe('UI Display Logic', () => {
+    it('should generate correct title for single desktop update', () => {
+      const type = 'Desktop';
+      const version = '0.1.14';
+      const title = `${type} v${version} available`;
+      expect(title).toBe('Desktop v0.1.14 available');
+    });
+
+    it('should generate correct title for single core update', () => {
+      const type = 'Core';
+      const version = '0.6.28';
+      const title = `${type} v${version} available`;
+      expect(title).toBe('Core v0.6.28 available');
+    });
+
+    it('should generate correct title for both updates', () => {
+      const title = 'Updates available';
+      expect(title).toBe('Updates available');
+    });
+
+    it('should generate correct subtitle for both updates', () => {
+      const desktopVersion = '0.1.14';
+      const coreVersion = '0.6.28';
+      const subtitle = `Desktop v${desktopVersion} · Core v${coreVersion}`;
+      expect(subtitle).toBe('Desktop v0.1.14 · Core v0.6.28');
+    });
+  });
+
+  describe('Dismiss & Skip Behavior', () => {
+    it('should treat close button same as skip', () => {
+      // Both should:
+      // 1. Store skip version
+      // 2. Hide toast
+      // 3. Return same result
+      const version = '0.1.14';
+
+      const closeAction = { storeSkip: version, hide: true };
+      const skipAction = { storeSkip: version, hide: true };
+
+      expect(closeAction).toEqual(skipAction);
+    });
+
+    it('should not block manual checks in Settings after dismiss', () => {
+      // User can still click "Check" button in Settings tab
+      // even after dismissing toast
+      const toastDismissed = true;
+      const manualCheckAllowed = true;
+
+      expect(toastDismissed && manualCheckAllowed).toBe(true);
+    });
+  });
+
+  describe('Component Render Conditions', () => {
+    it('should render null when bridge is unavailable', () => {
+      const bridge = null;
+      const shouldRender = !!bridge;
+      expect(shouldRender).toBe(false);
+    });
+
+    it('should render null when state is hidden', () => {
+      const state = 'hidden';
+      const shouldRender = state !== 'hidden';
+      expect(shouldRender).toBe(false);
+    });
+
+    it('should render when bridge exists and state is visible', () => {
+      const bridge = { checkUpdate: () => {} };
+      const state = 'visible';
+      const shouldRender = !!bridge && state === 'visible';
+      expect(shouldRender).toBe(true);
+    });
+  });
+
+  describe('Semantic Version Comparison', () => {
+    // Helper function matching component implementation
+    function isVersionNewer(latest: string, skipped: string): boolean {
+      const latestParts = latest.split('.').map(Number);
+      const skippedParts = skipped.split('.').map(Number);
+      
+      for (let i = 0; i < Math.max(latestParts.length, skippedParts.length); i++) {
+        const l = latestParts[i] ?? 0;
+        const s = skippedParts[i] ?? 0;
+        if (l > s) return true;
+        if (l < s) return false;
+      }
+      return false;
+    }
+
+    it('should correctly compare 0.1.10 > 0.1.9', () => {
+      expect(isVersionNewer('0.1.10', '0.1.9')).toBe(true);
+    });
+
+    it('should correctly compare 0.1.9 is not > 0.1.10', () => {
+      expect(isVersionNewer('0.1.9', '0.1.10')).toBe(false);
+    });
+
+    it('should handle major version bumps', () => {
+      expect(isVersionNewer('1.0.0', '0.9.99')).toBe(true);
+    });
+
+    it('should handle minor version bumps', () => {
+      expect(isVersionNewer('0.2.0', '0.1.99')).toBe(true);
+    });
+
+    it('should return false for equal versions', () => {
+      expect(isVersionNewer('0.1.14', '0.1.14')).toBe(false);
+    });
+
+    it('should handle extra version parts', () => {
+      expect(isVersionNewer('0.1.14.1', '0.1.14')).toBe(true);
+    });
+  });
+
+  describe('i18n Keys', () => {
+    it('should include all updateToast translation keys', () => {
+      const keys = [
+        'titleSingle',
+        'titleMultiple',
+        'desktopLabel',
+        'coreLabel',
+        'viewDetails',
+        'skipVersion',
+        'skipAll',
+      ];
+
+      expect(keys).toContain('titleSingle');
+      expect(keys).toContain('viewDetails');
+      expect(keys).toContain('skipAll');
+      expect(keys.length).toBeGreaterThanOrEqual(7);
+    });
+  });
+
+  describe('Timing', () => {
+    it('should use 10 second delay before showing toast', () => {
+      const SHOW_DELAY_MS = 10_000;
+      expect(SHOW_DELAY_MS).toBe(10000);
+    });
+
+    it('should use 200ms dismiss animation', () => {
+      const DISMISS_MS = 200;
+      expect(DISMISS_MS).toBe(200);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should not show toast when core update is already ready', () => {
+      // If info.ready is true, the update is already downloaded
+      // UpdateTab handles that state, so toast should NOT show
+      const info = { current: '0.6.27', latest: '0.6.28', ready: true };
+      const shouldShowToast = info.latest && !info.ready;
+      expect(shouldShowToast).toBe(false);
+    });
+
+    it('should show toast when core update is available but not ready', () => {
+      const info = { current: '0.6.27', latest: '0.6.28', ready: false };
+      const shouldShowToast = info.latest && !info.ready;
+      expect(shouldShowToast).toBeTruthy();
+    });
+
+    it('should dedup: same version should not re-queue', () => {
+      const queued: Record<string, string | undefined> = {};
+      const version = '0.1.14';
+
+      // First call
+      queued['desktop'] = version;
+      expect(queued['desktop']).toBe('0.1.14');
+
+      // Second call with same version — should skip
+      const shouldSkip = queued['desktop'] === version;
+      expect(shouldSkip).toBe(true);
+    });
+
+    it('should dedup: different version should re-queue', () => {
+      const queued: Record<string, string | undefined> = {};
+      queued['desktop'] = '0.1.14';
+
+      const shouldSkip = queued['desktop'] === '0.1.15';
+      expect(shouldSkip).toBe(false);
+    });
+
+    it('should use translate-y animation instead of scale for subtlety', () => {
+      // Verify our animation approach: translate-y-2 → translate-y-0
+      // is more subtle and natural than scale-95 → scale-100
+      const showClass = 'translate-y-0';
+      const hideClass = 'translate-y-2';
+      expect(showClass).not.toBe(hideClass);
+    });
+
+    it('should position above regular toasts (bottom-14 vs bottom-4)', () => {
+      // UpdateToast uses bottom-14 to avoid overlapping Toaster (bottom-4)
+      const updateToastBottom = 14; // tailwind bottom-14 = 3.5rem
+      const toasterBottom = 4;      // tailwind bottom-4 = 1rem
+      expect(updateToastBottom).toBeGreaterThan(toasterBottom);
+    });
+  });
+});

package/_standalone/__tests__/components/breadcrumb-header-ux.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('Breadcrumb header UX', () => {
+  it('keeps breadcrumb on a single row and truncates long labels', () => {
+    const filePath = path.resolve(process.cwd(), 'components/Breadcrumb.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('flex-nowrap overflow-hidden');
+    expect(source).toContain('truncate max-w-[180px] sm:max-w-[260px] md:max-w-[360px]');
+    expect(source).not.toContain('flex-wrap');
+  });
+});

package/_standalone/__tests__/components/channel-detail-redesign.test.tsx

@@ -0,0 +1,222 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React, { act } from 'react';
+import { createRoot } from 'react-dom/client';
+import AgentsContentChannelDetail from '@/components/agents/AgentsContentChannelDetail';
+
+vi.mock('next/link', () => ({
+  default: ({ children, href, ...props }: any) => <a href={href} {...props}>{children}</a>,
+}));
+
+vi.mock('@/lib/stores/locale-store', () => ({
+  useLocale: () => ({
+    locale: 'en',
+    t: {
+      panels: {
+        im: {
+          emptyDesc: 'Connect messaging platforms to let MindOS send messages on your behalf.',
+          backToChannels: 'Back to Channels',
+          statusConnected: 'Connected',
+          notConfigured: 'Set up',
+          fetchError: 'Failed to load channel status.',
+          thisIsNotChat: 'This is a delivery channel, not a chat inbox.',
+          retry: 'Retry',
+          howItWorks: 'How it works',
+          currentMode: 'Current mode',
+          notificationsOnly: 'Notifications only',
+          twoWayConversation: 'Two-way conversation',
+          conversationTitle: 'Conversation',
+          conversationEnable: 'Allow messages from Feishu',
+          conversationWaiting: 'Waiting for verification',
+          conversationReady: 'Ready for replies',
+          conversationDisabled: 'Disabled',
+          conversationNeedsPublicUrl: 'Public URL required',
+          conversationNeedsEncryptKey: 'Encrypt Key required',
+          conversationHint: 'Users can DM the bot, and group messages only trigger when the bot is mentioned.',
+          conversationConfigHint: 'Turn this on after you have a reachable public URL and your Feishu Encrypt Key ready.',
+          conversationWebhookUrl: 'Webhook URL',
+          conversationCopyUrl: 'Copy URL',
+          conversationStatus: 'Webhook status',
+          conversationReachability: 'Reachability',
+          conversationReachabilityHint: 'Feishu must be able to reach this URL from the public internet.',
+          conversationOpenPlatform: 'Open Feishu console',
+          conversationPublicBaseUrl: 'Public base URL',
+          conversationEncryptKey: 'Encrypt Key',
+          conversationVerificationToken: 'Verification Token',
+          conversationVerificationTokenHint: 'Used for Feishu webhook challenge verification. Leave blank to keep the saved value.',
+          conversationSecretPlaceholder: 'Leave blank to keep saved value',
+          conversationGroupMentions: 'Only reply when mentioned in groups',
+          conversationSaved: 'Conversation settings saved',
+          conversationSave: 'Save conversation settings',
+          workInMindosHint: 'Use Ask in MindOS to work with the agent. Use this channel to receive updates, alerts, and sample messages.',
+          useCasesTitle: 'What you can receive',
+          guideLink: 'Open setup guide',
+          statusSummaryTitle: 'Status summary',
+          lastActivity: 'Last activity',
+          lastRecipient: 'Last recipient',
+          tabStatus: 'Status',
+          notAvailable: 'Not available',
+          latestSuccess: 'Latest success',
+          latestFailure: 'Latest failure',
+          noRecentActivity: 'No recent activity',
+          activityTypeTest: 'Sample message',
+          activityTypeAgent: 'Agent update',
+          activityTypeManual: 'Manual send',
+          recentActivity: 'Recent activity',
+          noActivityYet: 'No messages sent yet',
+          noActivityHint: 'Send a sample message to verify this channel is working.',
+          sendSample: 'Send sample notification',
+          sampleHint: 'This sends a real outbound message through the selected channel.',
+          recipientPlaceholder: 'Recipient ID',
+          recipientHint: 'Use the platform-specific recipient ID.',
+          messagePlaceholder: 'Hello from MindOS',
+          sentOk: 'Sent successfully',
+          settingsTitle: 'Settings',
+          settingsHint: 'Maintain credentials and channel settings here.',
+          editCredentials: 'Update credentials',
+          editCredentialsHint: 'Need to rotate tokens or fix a broken connection? Update and save here.',
+          savedValuesHint: 'Saved values stay hidden. To update credentials, paste the full replacement values and save.',
+          required: 'required',
+          hideSecret: 'Hide value',
+          showSecret: 'Show value',
+          saving: 'Saving...',
+          saveConfig: 'Save',
+          saved: 'Saved — reconnecting...',
+          disconnect: 'Disconnect',
+          disconnectHint: 'Remove credentials and disconnect this platform.',
+          confirmDisconnect: 'Confirm?',
+          setupGuide: 'Setup Guide',
+          tabConfigure: 'Configure',
+        },
+      },
+    },
+  }),
+}));
+
+describe('AgentsContentChannelDetail redesign', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (globalThis as any).IS_REACT_ACT_ENVIRONMENT = true;
+  });
+
+  it('renders a connected channel as a management page with activity and settings', async () => {
+    vi.stubGlobal('fetch', vi.fn((url: string) => {
+      if (url.includes('/api/im/status')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => ({
+            platforms: [{ platform: 'feishu', connected: true, botName: 'MindOS Bot', capabilities: ['text', 'markdown'], webhook: { state: 'ready', webhookUrl: 'https://mindos.example.com/api/im/webhook/feishu', publicBaseUrl: 'https://mindos.example.com' } }],
+          }),
+        });
+      }
+      if (url.includes('/api/im/activity')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => ({
+            activities: [{
+              id: 'a1',
+              platform: 'feishu',
+              type: 'test',
+              status: 'success',
+              recipient: 'ou_123456',
+              messageSummary: 'Hello from MindOS',
+              timestamp: '2026-04-10T10:00:00.000Z',
+            }],
+          }),
+        });
+      }
+      return Promise.resolve({ ok: true, json: async () => ({}) });
+    }));
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<AgentsContentChannelDetail platformId="feishu" />);
+    });
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(host.textContent).toContain('How it works');
+    expect(host.textContent).toContain('Conversation');
+    expect(host.textContent).toContain('Ready for replies');
+    expect(host.textContent).toContain('Two-way conversation');
+    expect(host.textContent).toContain('Recent activity');
+    expect(host.textContent).toContain('Send sample notification');
+    expect(host.textContent).toContain('Settings');
+    expect(host.textContent).toContain('This is a delivery channel, not a chat inbox.');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+
+  it('renders a verification token field for Feishu conversation setup', async () => {
+    vi.stubGlobal('fetch', vi.fn((url: string) => {
+      if (url.includes('/api/im/status')) {
+        return Promise.resolve({
+          ok: true,
+          json: async () => ({
+            platforms: [{ platform: 'feishu', connected: true, botName: 'MindOS Bot', capabilities: ['text', 'markdown'], webhook: { state: 'ready', webhookUrl: 'https://mindos.example.com/api/im/webhook/feishu', publicBaseUrl: 'https://mindos.example.com' } }],
+          }),
+        });
+      }
+      if (url.includes('/api/im/activity')) {
+        return Promise.resolve({ ok: true, json: async () => ({ activities: [] }) });
+      }
+      return Promise.resolve({ ok: true, json: async () => ({}) });
+    }));
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<AgentsContentChannelDetail platformId="feishu" />);
+    });
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(host.textContent).toContain('Verification Token');
+    expect(host.textContent).toContain('Leave blank to keep the saved value');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+
+  it('renders an unconfigured channel as setup flow instead of activity page', async () => {
+    vi.stubGlobal('fetch', vi.fn((url: string) => {
+      if (url.includes('/api/im/status')) {
+        return Promise.resolve({ ok: true, json: async () => ({ platforms: [] }) });
+      }
+      if (url.includes('/api/im/activity')) {
+        return Promise.resolve({ ok: true, json: async () => ({ activities: [] }) });
+      }
+      return Promise.resolve({ ok: true, json: async () => ({}) });
+    }));
+
+    const host = document.createElement('div');
+    document.body.appendChild(host);
+    const root = createRoot(host);
+
+    await act(async () => {
+      root.render(<AgentsContentChannelDetail platformId="telegram" />);
+    });
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(host.textContent).toContain('Setup Guide');
+    expect(host.textContent).toContain('Configure');
+    expect(host.textContent).not.toContain('Recent activity');
+    expect(host.textContent).not.toContain('Send sample notification');
+
+    await act(async () => {
+      root.unmount();
+    });
+  });
+});

package/_standalone/__tests__/components/header-toc-vertical-alignment.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+describe('Page header and TOC vertical alignment', () => {
+  it('TOC toggle button top aligns with header height (46px)', () => {
+    const filePath = path.resolve(process.cwd(), 'components/TableOfContents.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('const TOPBAR_H = 46;');
+    expect(source).toContain('top-[46px]');
+    expect(source).not.toContain('top-[52px]');
+    expect(source).not.toContain('top-[50px]');
+  });
+
+  it('FindInPage sticky top aligns with header height on desktop', () => {
+    const filePath = path.resolve(process.cwd(), 'components/FindInPage.tsx');
+    const source = fs.readFileSync(filePath, 'utf8');
+
+    expect(source).toContain('md:top-[46px]');
+    expect(source).not.toContain('md:top-[44px]');
+  });
+});

package/_standalone/__tests__/components/line-diff.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { buildLineDiff } from '@/components/changes/line-diff';
+
+describe('buildLineDiff (LCS-based diff)', () => {
+  it('handles empty files', () => {
+    // ''.split('\n') returns [''] — one empty line, so diff shows one equal empty line
+    expect(buildLineDiff('', '')).toEqual([{ type: 'equal', text: '' }]);
+    expect(buildLineDiff('line1', '')).toContainEqual({ type: 'delete', text: 'line1' });
+    expect(buildLineDiff('', 'line1')).toContainEqual({ type: 'insert', text: 'line1' });
+  });
+
+  it('detects unchanged lines', () => {
+    const result = buildLineDiff('line1\nline2', 'line1\nline2');
+    expect(result).toEqual([
+      { type: 'equal', text: 'line1' },
+      { type: 'equal', text: 'line2' },
+    ]);
+  });
+
+  it('detects insertions', () => {
+    const result = buildLineDiff('line1', 'line1\nline2');
+    expect(result).toContainEqual({ type: 'insert', text: 'line2' });
+  });
+
+  it('detects deletions', () => {
+    const result = buildLineDiff('line1\nline2', 'line1');
+    expect(result).toContainEqual({ type: 'delete', text: 'line2' });
+  });
+
+  it('handles large diffs correctly', () => {
+    const lines = Array.from({ length: 100 }, (_, i) => `line ${i}`);
+    const before = lines.join('\n');
+    const after = [...lines.slice(0, 50), 'INSERTED', ...lines.slice(50)].join('\n');
+    const result = buildLineDiff(before, after);
+    expect(result).toContainEqual({ type: 'insert', text: 'INSERTED' });
+  });
+});