@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/__tests__/hooks/useMention.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+/**
+ * Unit tests for useMention behavior.
+ * Since @testing-library/react is not available, we test the core logic
+ * by directly importing and calling the pure functions extracted from useMention.
+ * For the hook integration, we rely on the existing ask-content tests.
+ */
+
+describe('useMention logic', () => {
+  describe('mention query parsing', () => {
+    function parseMentionQuery(val: string): { atIdx: number; query: string } | null {
+      const atIdx = val.lastIndexOf('@');
+      if (atIdx === -1) return null;
+      const before = val[atIdx - 1];
+      if (atIdx > 0 && before !== ' ') return null;
+      return { atIdx, query: val.slice(atIdx + 1).toLowerCase() };
+    }
+
+    it('detects @ at start of input', () => {
+      expect(parseMentionQuery('@readme')).toEqual({ atIdx: 0, query: 'readme' });
+    });
+
+    it('detects @ after space', () => {
+      expect(parseMentionQuery('hello @file')).toEqual({ atIdx: 6, query: 'file' });
+    });
+
+    it('rejects @ in middle of word (email-like)', () => {
+      expect(parseMentionQuery('user@host')).toBeNull();
+    });
+
+    it('returns null when no @', () => {
+      expect(parseMentionQuery('hello world')).toBeNull();
+    });
+  });
+
+  describe('zero-result behavior', () => {
+    it('should auto-reset mention when filter yields zero results', () => {
+      const allFiles = ['README.md', 'TODO.md'];
+      const query = 'nonexistentfile';
+      const filtered = allFiles.filter(f => f.toLowerCase().includes(query)).slice(0, 30);
+
+      expect(filtered.length).toBe(0);
+    });
+  });
+
+  describe('navigate bounds', () => {
+    it('navigateDown does not go below 0 when results empty', () => {
+      const resultsLength = 0;
+      const index = 0;
+      const next = resultsLength > 0 ? Math.min(index + 1, resultsLength - 1) : 0;
+      expect(next).toBeGreaterThanOrEqual(0);
+    });
+
+    it('navigateDown stays in bounds with results', () => {
+      const resultsLength = 3;
+      let index = 0;
+      index = Math.min(index + 1, resultsLength - 1);
+      expect(index).toBe(1);
+      index = Math.min(index + 1, resultsLength - 1);
+      expect(index).toBe(2);
+      index = Math.min(index + 1, resultsLength - 1);
+      expect(index).toBe(2);
+    });
+
+    it('navigateUp stays at 0', () => {
+      const index = 0;
+      const next = Math.max(index - 1, 0);
+      expect(next).toBe(0);
+    });
+  });
+
+  describe('API response defense', () => {
+    it('rejects non-array response', () => {
+      const data = { error: 'Internal error' };
+      const safe = Array.isArray(data) ? data : [];
+      expect(safe).toEqual([]);
+    });
+
+    it('accepts valid array response', () => {
+      const data = ['README.md', 'TODO.md'];
+      const safe = Array.isArray(data) ? data : [];
+      expect(safe).toEqual(['README.md', 'TODO.md']);
+    });
+
+    it('rejects null response', () => {
+      const data = null;
+      const safe = Array.isArray(data) ? data : [];
+      expect(safe).toEqual([]);
+    });
+  });
+});

package/_standalone/__tests__/hooks/useSlashCommand.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest';
+
+/**
+ * Unit tests for useSlashCommand behavior.
+ * Since @testing-library/react is not available, we test the core logic
+ * by directly replicating the pure parsing functions from useSlashCommand.
+ */
+
+function parseSlashQuery(val: string, cursorPos: number): { slashIdx: number; query: string } | null {
+  const before = val.slice(0, cursorPos);
+  const slashIdx = before.lastIndexOf('/');
+  if (slashIdx === -1) return null;
+  if (slashIdx > 0 && before[slashIdx - 1] !== ' ' && before[slashIdx - 1] !== '\n') return null;
+  const query = before.slice(slashIdx + 1);
+  if (query.includes(' ')) return null;
+  return { slashIdx, query };
+}
+
+function filterSkills(
+  allSkills: Array<{ name: string; description: string; enabled: boolean }>,
+  query: string,
+) {
+  const q = query.toLowerCase();
+  return allSkills
+    .filter((s) => s.enabled)
+    .filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q))
+    .slice(0, 20)
+    .map((s) => ({ type: 'skill' as const, name: s.name, description: s.description }));
+}
+
+const mockSkills = [
+  { name: 'mindos', description: 'Operate MindOS knowledge base', enabled: true },
+  { name: 'ui-design', description: 'UI/UX design intelligence', enabled: true },
+  { name: 'disabled-skill', description: 'This is disabled', enabled: false },
+];
+
+describe('useSlashCommand logic', () => {
+  describe('slash query parsing', () => {
+    it('detects / at start of input', () => {
+      expect(parseSlashQuery('/', 1)).toEqual({ slashIdx: 0, query: '' });
+    });
+
+    it('detects / with query', () => {
+      expect(parseSlashQuery('/mind', 5)).toEqual({ slashIdx: 0, query: 'mind' });
+    });
+
+    it('detects / after space', () => {
+      expect(parseSlashQuery('hello /ui', 9)).toEqual({ slashIdx: 6, query: 'ui' });
+    });
+
+    it('rejects / in middle of word (path-like)', () => {
+      expect(parseSlashQuery('path/to/file', 12)).toBeNull();
+    });
+
+    it('returns null when no /', () => {
+      expect(parseSlashQuery('hello world', 11)).toBeNull();
+    });
+
+    it('rejects when query contains space', () => {
+      expect(parseSlashQuery('/mind os', 8)).toBeNull();
+    });
+
+    it('detects / after newline', () => {
+      expect(parseSlashQuery('line1\n/skill', 12)).toEqual({ slashIdx: 6, query: 'skill' });
+    });
+  });
+
+  describe('skill filtering', () => {
+    it('shows all enabled skills on empty query', () => {
+      const results = filterSkills(mockSkills, '');
+      expect(results).toHaveLength(2);
+      expect(results[0].name).toBe('mindos');
+      expect(results[1].name).toBe('ui-design');
+    });
+
+    it('excludes disabled skills', () => {
+      const results = filterSkills(mockSkills, 'disabled');
+      expect(results).toHaveLength(0);
+    });
+
+    it('filters by name', () => {
+      const results = filterSkills(mockSkills, 'ui');
+      expect(results).toHaveLength(1);
+      expect(results[0].name).toBe('ui-design');
+    });
+
+    it('filters by description', () => {
+      const results = filterSkills(mockSkills, 'knowledge');
+      expect(results).toHaveLength(1);
+      expect(results[0].name).toBe('mindos');
+    });
+
+    it('caps at 20 results', () => {
+      const many = Array.from({ length: 30 }, (_, i) => ({
+        name: `skill-${i}`,
+        description: 'test',
+        enabled: true,
+      }));
+      const results = filterSkills(many, '');
+      expect(results).toHaveLength(20);
+    });
+  });
+
+  describe('navigate bounds', () => {
+    it('navigateDown stays in bounds', () => {
+      const len = 3;
+      let i = 0;
+      i = Math.min(i + 1, len - 1);
+      expect(i).toBe(1);
+      i = Math.min(i + 1, len - 1);
+      expect(i).toBe(2);
+      i = Math.min(i + 1, len - 1);
+      expect(i).toBe(2);
+    });
+
+    it('navigateUp stays at 0', () => {
+      const i = 0;
+      expect(Math.max(i - 1, 0)).toBe(0);
+    });
+  });
+
+  describe('zero-result does not block submit', () => {
+    it('returns null query when no skills match', () => {
+      const results = filterSkills(mockSkills, 'zzz-nonexistent');
+      expect(results).toHaveLength(0);
+    });
+
+    it('returns null query with empty skills list and empty query', () => {
+      const results = filterSkills([], '');
+      expect(results).toHaveLength(0);
+    });
+
+    it('returns null query with empty skills list and non-empty query', () => {
+      const results = filterSkills([], 'mind');
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe('API response defense', () => {
+    it('handles missing skills key', () => {
+      const data = { error: 'fail' };
+      const skills = Array.isArray((data as Record<string, unknown>)?.skills) ? (data as Record<string, unknown>).skills : [];
+      expect(skills).toEqual([]);
+    });
+
+    it('handles null response', () => {
+      const data = null;
+      const skills = Array.isArray((data as Record<string, unknown> | null)?.skills) ? [] : [];
+      expect(skills).toEqual([]);
+    });
+  });
+});

package/_standalone/__tests__/im/activity.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fs from 'fs';
+
+vi.mock('fs');
+const mockFs = vi.mocked(fs);
+
+describe('IM activity store', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.resetModules();
+    mockFs.existsSync.mockReturnValue(false);
+    mockFs.mkdirSync.mockImplementation(() => undefined as unknown as string);
+    mockFs.writeFileSync.mockImplementation(() => undefined);
+    mockFs.renameSync.mockImplementation(() => undefined);
+    mockFs.unlinkSync.mockImplementation(() => undefined);
+  });
+
+  it('records a new activity and truncates long message summaries', async () => {
+    let fileContent = '';
+    mockFs.existsSync.mockImplementation(() => Boolean(fileContent));
+    mockFs.readFileSync.mockImplementation(() => fileContent as never);
+    mockFs.writeFileSync.mockImplementation((_, content) => {
+      fileContent = String(content).trim();
+      return undefined;
+    });
+    mockFs.renameSync.mockImplementation(() => undefined);
+
+    const { recordActivity, getActivities } = await import('@/lib/im/activity');
+
+    recordActivity({
+      platform: 'feishu',
+      type: 'test',
+      status: 'success',
+      recipient: 'ou_123',
+      message: 'x'.repeat(80),
+    });
+
+    const activities = getActivities('feishu');
+    expect(activities).toHaveLength(1);
+    expect(activities[0].type).toBe('test');
+    expect(activities[0].status).toBe('success');
+    expect(activities[0].messageSummary.length).toBeLessThanOrEqual(50);
+    expect(mockFs.writeFileSync).toHaveBeenCalled();
+  });
+
+  it('returns newest-first activities and respects limit', async () => {
+    let fileContent = '';
+    mockFs.existsSync.mockImplementation(() => Boolean(fileContent));
+    mockFs.readFileSync.mockImplementation(() => fileContent as never);
+    mockFs.writeFileSync.mockImplementation((_, content) => {
+      fileContent = String(content).trim();
+      return undefined;
+    });
+    mockFs.renameSync.mockImplementation(() => undefined);
+
+    const { recordActivity, getActivities } = await import('@/lib/im/activity');
+
+    recordActivity({ platform: 'telegram', type: 'manual', status: 'success', recipient: '123', message: 'first' });
+    recordActivity({ platform: 'telegram', type: 'manual', status: 'failed', recipient: '123', message: 'second', error: 'oops' });
+
+    const activities = getActivities('telegram', 1);
+    expect(activities).toHaveLength(1);
+    expect(activities[0].messageSummary).toBe('second');
+    expect(activities[0].status).toBe('failed');
+  });
+
+  it('resets corrupt store data to empty', async () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.readFileSync.mockReturnValue('{bad json}' as never);
+
+    const { getActivities } = await import('@/lib/im/activity');
+    expect(getActivities('slack')).toEqual([]);
+  });
+});

package/_standalone/__tests__/im/config.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Mock fs for config tests
+vi.mock('fs');
+const mockFs = vi.mocked(fs);
+
+// We need to import after mocking
+const CONFIG_DIR = path.join(os.homedir(), '.mindos');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'im.json');
+
+describe('IM Config Manager', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Reset module cache to clear config cache
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('readIMConfig', () => {
+    it('returns empty config when file does not exist', async () => {
+      mockFs.existsSync.mockReturnValue(false);
+      mockFs.statSync.mockImplementation(() => { throw new Error('ENOENT'); });
+      const { readIMConfig, _resetConfigCache } = await import('@/lib/im/config');
+      _resetConfigCache();
+      const config = readIMConfig();
+      expect(config).toEqual({ providers: {} });
+    });
+
+    it('parses valid config correctly', async () => {
+      const validConfig = { providers: { telegram: { bot_token: '123:ABC' } } };
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.statSync.mockReturnValue({ mtimeMs: 1000 } as fs.Stats);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify(validConfig));
+      const { readIMConfig, _resetConfigCache } = await import('@/lib/im/config');
+      _resetConfigCache();
+      const config = readIMConfig();
+      expect(config.providers.telegram?.bot_token).toBe('123:ABC');
+    });
+
+    it('returns empty config for invalid JSON', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.statSync.mockReturnValue({ mtimeMs: 2000 } as fs.Stats);
+      mockFs.readFileSync.mockReturnValue('{not valid json}');
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const { readIMConfig, _resetConfigCache } = await import('@/lib/im/config');
+      _resetConfigCache();
+      const config = readIMConfig();
+      expect(config).toEqual({ providers: {} });
+      expect(warnSpy).toHaveBeenCalled();
+    });
+
+    it('returns empty config when providers is not an object', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.statSync.mockReturnValue({ mtimeMs: 3000 } as fs.Stats);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ providers: 'invalid' }));
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const { readIMConfig, _resetConfigCache } = await import('@/lib/im/config');
+      _resetConfigCache();
+      const config = readIMConfig();
+      expect(config).toEqual({ providers: {} });
+      expect(warnSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('validatePlatformConfig', () => {
+    it('validates telegram config (requires bot_token with colon)', async () => {
+      const { validatePlatformConfig } = await import('@/lib/im/config');
+      expect(validatePlatformConfig('telegram', { bot_token: '123:ABC' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('telegram', { bot_token: 'no-colon' }).valid).toBe(false);
+      expect(validatePlatformConfig('telegram', {}).valid).toBe(false);
+      expect(validatePlatformConfig('telegram', null).valid).toBe(false);
+    });
+
+    it('validates slack config (requires xoxb- prefix)', async () => {
+      const { validatePlatformConfig } = await import('@/lib/im/config');
+      expect(validatePlatformConfig('slack', { bot_token: 'xoxb-123' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('slack', { bot_token: 'invalid' }).valid).toBe(false);
+    });
+
+    it('validates wecom config (webhook_key OR corp_id+secret)', async () => {
+      const { validatePlatformConfig } = await import('@/lib/im/config');
+      expect(validatePlatformConfig('wecom', { webhook_key: 'abc' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('wecom', { corp_id: 'x', corp_secret: 'y' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('wecom', {}).valid).toBe(false);
+    });
+
+    it('validates dingtalk config (client_id+secret OR webhook_url)', async () => {
+      const { validatePlatformConfig } = await import('@/lib/im/config');
+      expect(validatePlatformConfig('dingtalk', { webhook_url: 'https://...' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('dingtalk', { client_id: 'x', client_secret: 'y' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('dingtalk', {}).valid).toBe(false);
+    });
+
+    it('validates wechat config (requires bot_token)', async () => {
+      const { validatePlatformConfig } = await import('@/lib/im/config');
+      expect(validatePlatformConfig('wechat', { bot_token: 'wx_abc123' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('wechat', {}).valid).toBe(false);
+      expect(validatePlatformConfig('wechat', null).valid).toBe(false);
+    });
+
+    it('validates qq config (requires app_id + app_secret)', async () => {
+      const { validatePlatformConfig } = await import('@/lib/im/config');
+      expect(validatePlatformConfig('qq', { app_id: '123', app_secret: 'abc' })).toEqual({ valid: true });
+      expect(validatePlatformConfig('qq', { app_id: '123' }).valid).toBe(false);
+      expect(validatePlatformConfig('qq', {}).valid).toBe(false);
+    });
+  });
+});

package/_standalone/__tests__/im/dingtalk.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { DingTalkAdapter } from '@/lib/im/adapters/dingtalk';
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe('DingTalkAdapter', () => {
+  it('verify returns false when token refresh times out', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Request timed out')));
+    const adapter = new DingTalkAdapter({ client_id: 'ding-app', client_secret: 'ding-secret' });
+    await expect(adapter.verify()).resolves.toBe(false);
+  });
+
+  it('send reports timeout error clearly', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Request timed out')));
+    const adapter = new DingTalkAdapter({ webhook_url: 'https://oapi.dingtalk.com/robot/send?access_token=abc' });
+    const result = await adapter.send({ platform: 'dingtalk', recipientId: 'chat1', text: 'hello' });
+    expect(result.ok).toBe(false);
+    expect(result.error).toContain('timed out');
+  });
+});

package/_standalone/__tests__/im/feishu-conversation-processing.test.ts

@@ -0,0 +1,96 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const runHeadlessAgent = vi.fn();
+const getConversationHistory = vi.fn();
+const appendConversationTurn = vi.fn();
+const recordActivity = vi.fn();
+const sendIMMessage = vi.fn();
+
+vi.mock('@/lib/agent/headless', () => ({
+  runHeadlessAgent,
+}));
+
+vi.mock('@/lib/im/conversation-store', () => ({
+  getConversationHistory,
+  appendConversationTurn,
+}));
+
+vi.mock('@/lib/im/activity', () => ({
+  recordActivity,
+}));
+
+vi.mock('@/lib/im/executor', () => ({
+  sendIMMessage,
+}));
+
+async function importModule() {
+  return await import('@/lib/im/webhook/feishu');
+}
+
+describe('Feishu conversation processing', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    getConversationHistory.mockReturnValue({
+      sessionId: 'feishu-oc_chat_001-1',
+      messages: [{ role: 'assistant', content: 'Previous reply', timestamp: 1 }],
+    });
+    sendIMMessage.mockResolvedValue({ ok: true, messageId: 'msg_1', timestamp: '2026-04-10T00:00:00.000Z' });
+  });
+
+  it('runs the agent, sends the reply, and appends conversation history', async () => {
+    runHeadlessAgent.mockResolvedValue({ text: 'Hello from MindOS', thinking: '', toolCalls: [] });
+    const { processFeishuIncomingMessage } = await importModule();
+
+    await processFeishuIncomingMessage({
+      platform: 'feishu',
+      senderId: 'ou_sender_1',
+      chatId: 'oc_chat_001',
+      chatType: 'dm',
+      text: '你好',
+      messageId: 'om_001',
+      rawEvent: {},
+    });
+
+    expect(recordActivity).toHaveBeenCalledWith(expect.objectContaining({
+      type: 'conversation_inbound',
+      recipient: 'ou_sender_1',
+      message: '你好',
+    }));
+    expect(runHeadlessAgent).toHaveBeenCalledWith(expect.objectContaining({
+      userMessage: '你好',
+      historyMessages: [{ role: 'assistant', content: 'Previous reply', timestamp: 1 }],
+      mode: 'agent',
+    }));
+    expect(sendIMMessage).toHaveBeenCalledWith(expect.objectContaining({
+      platform: 'feishu',
+      recipientId: 'oc_chat_001',
+      text: 'Hello from MindOS',
+    }), undefined, { activityType: 'conversation_reply' });
+    expect(appendConversationTurn).toHaveBeenCalledWith(expect.objectContaining({
+      platform: 'feishu',
+      chatId: 'oc_chat_001',
+      userMessage: expect.objectContaining({ role: 'user', content: '你好' }),
+      assistantMessage: expect.objectContaining({ role: 'assistant', content: 'Hello from MindOS' }),
+    }));
+  });
+
+  it('falls back when the agent run fails', async () => {
+    runHeadlessAgent.mockRejectedValue(new Error('model exploded'));
+    const { processFeishuIncomingMessage } = await importModule();
+
+    await processFeishuIncomingMessage({
+      platform: 'feishu',
+      senderId: 'ou_sender_1',
+      chatId: 'oc_chat_001',
+      chatType: 'dm',
+      text: '你好',
+      messageId: 'om_001',
+      rawEvent: {},
+    });
+
+    expect(sendIMMessage).toHaveBeenCalledWith(expect.objectContaining({
+      text: 'I received your message, but I could not generate a reply just now. Please try again from MindOS or send another message.',
+    }), undefined, { activityType: 'conversation_reply' });
+  });
+});