@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/types/semver.d.ts

@@ -0,0 +1,8 @@
+declare module 'semver' {
+  export function gt(v1: string, v2: string): boolean;
+  export function lt(v1: string, v2: string): boolean;
+  export function gte(v1: string, v2: string): boolean;
+  export function lte(v1: string, v2: string): boolean;
+  export function eq(v1: string, v2: string): boolean;
+  export function valid(v: string | null): string | null;
+}

package/_standalone/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    include: ['__tests__/**/*.test.ts', '__tests__/**/*.test.tsx', '__tests__/**/*.test.js'],
+    setupFiles: ['__tests__/setup.ts'],
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname),
+    },
+  },
+});

package/app/__tests__/agent/provider-presets.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { PROVIDER_PRESETS, getDefaultBaseUrl, groupedProviders } from '@/lib/agent/providers';
+
+
+describe('provider presets', () => {
+  it('includes LM Studio as an explicit local preset', () => {
+    const preset = PROVIDER_PRESETS['lm-studio'];
+    expect(preset.name).toBe('LM Studio');
+    expect(preset.fixedBaseUrl).toBe('http://localhost:1234/v1');
+    expect(preset.apiKeyFallback).toBe('lm-studio');
+    expect(preset.supportsListModels).toBe(true);
+  });
+
+  it('resolves LM Studio default base URL from its fixed preset URL', () => {
+    expect(getDefaultBaseUrl('lm-studio')).toBe('http://localhost:1234/v1');
+  });
+
+  it('includes vLLM as an explicit local preset', () => {
+    const preset = PROVIDER_PRESETS.vllm;
+    expect(preset.name).toBe('vLLM');
+    expect(preset.fixedBaseUrl).toBe('http://localhost:8000/v1');
+    expect(preset.apiKeyFallback).toBe('vllm');
+    expect(preset.supportsListModels).toBe(true);
+  });
+
+  it('groups Ollama, LM Studio, and vLLM under local providers', () => {
+    const groups = groupedProviders();
+    expect(groups.local).toContain('ollama');
+    expect(groups.local).toContain('lm-studio');
+    expect(groups.local).toContain('vllm');
+  });
+});

package/app/__tests__/api/im-config-feishu-conversation.test.ts

@@ -100,4 +100,43 @@ describe('/api/im/config Feishu conversation', () => {
       }),
     }));
   });
+
+  it('stores transport mode for Feishu conversation settings', async () => {
+    readIMConfig.mockReturnValue({
+      providers: {
+        feishu: {
+          app_id: 'cli_xxx',
+          app_secret: 'secret',
+          conversation: {
+            enabled: true,
+            transport: 'webhook',
+            allow_group_mentions: true,
+          },
+        },
+      },
+    });
+    const { PUT } = await importRoute();
+    const req = new NextRequest('http://localhost/api/im/config', {
+      method: 'PUT',
+      body: JSON.stringify({
+        platform: 'feishu',
+        conversation: {
+          enabled: true,
+          transport: 'long_connection',
+        },
+      }),
+    });
+
+    const res = await PUT(req);
+    expect(res.status).toBe(200);
+    expect(writeIMConfig).toHaveBeenCalledWith(expect.objectContaining({
+      providers: expect.objectContaining({
+        feishu: expect.objectContaining({
+          conversation: expect.objectContaining({
+            transport: 'long_connection',
+          }),
+        }),
+      }),
+    }));
+  });
 });

package/app/__tests__/api/im-webhook-feishu.test.ts

@@ -2,14 +2,14 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { NextRequest } from 'next/server';
 
 const getPlatformConfig = vi.fn();
-const handleFeishuWebhook = vi.fn();
+const dispatchFeishuWebhook = vi.fn();
 
 vi.mock('@/lib/im/config', () => ({
   getPlatformConfig,
 }));
 
-vi.mock('@/lib/im/webhook/feishu', () => ({
-  handleFeishuWebhook,
+vi.mock('@/lib/im/feishu-dispatcher', () => ({
+  dispatchFeishuWebhook,
 }));
 
 async function importRoute() {
@@ -36,15 +36,14 @@ describe('POST /api/im/webhook/feishu', () => {
     expect(await res.json()).toEqual({ error: 'Feishu is not configured' });
   });
 
-  it('returns challenge response when webhook helper resolves a challenge', async () => {
+  it('delegates webhook protocol handling to the SDK dispatcher wrapper', async () => {
     getPlatformConfig.mockReturnValue({
       app_id: 'cli_xxx',
       app_secret: 'secret',
       conversation: { enabled: true, encrypt_key: 'encrypt', public_base_url: 'https://mindos.example.com' },
     });
 
-    handleFeishuWebhook.mockResolvedValue({
-      kind: 'challenge',
+    dispatchFeishuWebhook.mockResolvedValue({
       body: { challenge: 'challenge-token' },
       status: 200,
     });
@@ -53,24 +52,34 @@ describe('POST /api/im/webhook/feishu', () => {
     const req = new NextRequest('http://localhost/api/im/webhook/feishu', {
       method: 'POST',
       body: JSON.stringify({ challenge: 'challenge-token' }),
-      headers: { 'content-type': 'application/json' },
+      headers: {
+        'content-type': 'application/json',
+        'x-lark-request-timestamp': '1',
+      },
     });
 
     const res = await POST(req);
+    expect(dispatchFeishuWebhook).toHaveBeenCalledWith({
+      config: expect.objectContaining({ app_id: 'cli_xxx' }),
+      body: { challenge: 'challenge-token' },
+      headers: expect.objectContaining({
+        'content-type': 'application/json',
+        'x-lark-request-timestamp': '1',
+      }),
+    });
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ challenge: 'challenge-token' });
   });
 
-  it('returns accepted when webhook helper accepts an inbound event for async processing', async () => {
+  it('returns accepted when dispatcher queues an inbound event', async () => {
     getPlatformConfig.mockReturnValue({
       app_id: 'cli_xxx',
       app_secret: 'secret',
       conversation: { enabled: true, encrypt_key: 'encrypt', public_base_url: 'https://mindos.example.com' },
     });
 
-    handleFeishuWebhook.mockResolvedValue({
-      kind: 'accepted',
-      body: { ok: true },
+    dispatchFeishuWebhook.mockResolvedValue({
+      body: { ok: true, queued: true },
       status: 202,
     });
 
@@ -83,6 +92,6 @@ describe('POST /api/im/webhook/feishu', () => {
 
     const res = await POST(req);
     expect(res.status).toBe(202);
-    expect(await res.json()).toEqual({ ok: true });
+    expect(await res.json()).toEqual({ ok: true, queued: true });
   });
 });

package/app/__tests__/api/pi-subagents.test.ts

@@ -0,0 +1,81 @@
+/**
+ * Tests for built-in pi-subagents extension support.
+ *
+ * Verifies that MindOS correctly bundles and loads pi-subagents as a default
+ * extension, providing subagent tools (subagent, subagent_status) to the Agent.
+ */
+
+import { describe, expect, it, beforeAll } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..');
+
+describe('pi-subagents built-in extension', () => {
+  describe('dependency installation', () => {
+    it('pi-subagents is listed in package.json dependencies', () => {
+      const pkgPath = path.join(PROJECT_ROOT, 'package.json');
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+      expect(pkg.dependencies).toHaveProperty('pi-subagents');
+      expect(pkg.dependencies['pi-subagents']).toMatch(/^\^?0\.\d+\.\d+$/);
+    });
+
+    it('pi-subagents is installed in node_modules', () => {
+      const indexPath = path.join(PROJECT_ROOT, 'node_modules', 'pi-subagents', 'index.ts');
+      expect(fs.existsSync(indexPath)).toBe(true);
+    });
+
+    it('pi-subagents has expected structure (agents directory)', () => {
+      const agentsDir = path.join(PROJECT_ROOT, 'node_modules', 'pi-subagents', 'agents');
+      expect(fs.existsSync(agentsDir)).toBe(true);
+
+      // Should have builtin agents like scout.md, planner.md
+      const agentFiles = fs.readdirSync(agentsDir);
+      expect(agentFiles.some((f) => f.endsWith('.md'))).toBe(true);
+    });
+  });
+
+  describe('extension path registration', () => {
+    let askRouteContent: string;
+
+    beforeAll(() => {
+      const routePath = path.join(PROJECT_ROOT, 'app', 'api', 'ask', 'route.ts');
+      askRouteContent = fs.readFileSync(routePath, 'utf-8');
+    });
+
+    it('ask/route.ts includes pi-subagents in additionalExtensionPaths', () => {
+      expect(askRouteContent).toContain('pi-subagents');
+      expect(askRouteContent).toContain("path.join(projectRoot, 'app', 'node_modules', 'pi-subagents', 'index.ts')");
+    });
+
+    it('pi-subagents path is after user extensions (scanExtensionPaths)', () => {
+      // User extensions should have priority, so scanExtensionPaths() comes first
+      const scanIndex = askRouteContent.indexOf('scanExtensionPaths()');
+      const subagentsIndex = askRouteContent.indexOf('pi-subagents');
+
+      expect(scanIndex).toBeGreaterThan(-1);
+      expect(subagentsIndex).toBeGreaterThan(scanIndex);
+    });
+  });
+
+  describe('extension exports', () => {
+    it('pi-subagents index.ts is valid TypeScript with default export', async () => {
+      const indexPath = path.join(PROJECT_ROOT, 'node_modules', 'pi-subagents', 'index.ts');
+      const content = fs.readFileSync(indexPath, 'utf-8');
+
+      // Extension should have a default export function
+      expect(content).toMatch(/export\s+default\s+function/);
+    });
+
+    it('pi-subagents registers subagent tool via pi.registerTool', async () => {
+      const indexPath = path.join(PROJECT_ROOT, 'node_modules', 'pi-subagents', 'index.ts');
+      const content = fs.readFileSync(indexPath, 'utf-8');
+
+      // Should call pi.registerTool with the subagent tool
+      expect(content).toContain('pi.registerTool');
+      // Should have tool definition for 'subagent'
+      expect(content).toMatch(/name:\s*['"]subagent['"]/);
+    });
+  });
+});

package/app/__tests__/ask/file-chip-variants.test.tsx

@@ -0,0 +1,18 @@
+// @vitest-environment jsdom
+import { describe, it, expect } from 'vitest';
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import FileChip from '@/components/ask/FileChip';
+
+describe('FileChip variants', () => {
+  it('renders ACP agent chips with an amber bot icon', () => {
+    const html = renderToStaticMarkup(
+      <FileChip path="Claude Code" variant="agent" onRemove={() => {}} />,
+    );
+
+    expect(html).toContain('Claude Code');
+    expect(html).toContain('lucide-bot');
+    expect(html).toContain('text-[var(--amber)]');
+    expect(html).not.toContain('lucide-zap');
+  });
+});

package/app/__tests__/ask/message-list-agent-attribution.test.tsx

@@ -46,6 +46,7 @@ describe('MessageList agent attribution', () => {
 
     expect(html).toContain('Claude Code');
     expect(html).toContain('Hello from Claude.');
+    expect(html).toContain('lucide-bot');
   });
 
   it('keeps the agent badge visible on assistant error bubbles', () => {
@@ -67,5 +68,6 @@ describe('MessageList agent attribution', () => {
 
     expect(html).toContain('Claude Code');
     expect(html).toContain('ACP Agent Error: timeout');
+    expect(html).toContain('lucide-bot');
   });
 });

package/app/__tests__/im/feishu-dispatcher.test.ts

@@ -0,0 +1,151 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { FeishuConfig } from '@/lib/im/types';
+
+const { dispatcherInvoke, dispatcherConstruct, generateChallenge } = vi.hoisted(() => {
+  const dispatcherInvoke = vi.fn();
+  const dispatcherConstruct = vi.fn();
+  const generateChallenge = vi.fn();
+  return { dispatcherInvoke, dispatcherConstruct, generateChallenge };
+});
+
+vi.mock('@larksuiteoapi/node-sdk', () => ({
+  EventDispatcher: class MockEventDispatcher {
+    constructor(params: unknown) {
+      dispatcherConstruct(params);
+    }
+
+    register() {
+      return this;
+    }
+
+    async invoke(data: unknown) {
+      return await dispatcherInvoke(data);
+    }
+  },
+  generateChallenge,
+}));
+
+describe('Feishu dispatcher', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    generateChallenge.mockReturnValue({ isChallenge: false, challenge: undefined });
+  });
+
+  it('returns ignored when webhook is not ready', async () => {
+    const { dispatchFeishuWebhook } = await import('@/lib/im/feishu-dispatcher');
+    const config: FeishuConfig = {
+      app_id: 'cli_xxx',
+      app_secret: 'secret',
+      conversation: {
+        enabled: true,
+        encrypt_key: 'encrypt',
+      },
+    };
+
+    const result = await dispatchFeishuWebhook({
+      config,
+      body: { event: { message: { content: '{"text":"hi"}' } } },
+      headers: {},
+    });
+
+    expect(result).toEqual({
+      status: 202,
+      body: { ok: false, ignored: true, reason: 'Public base URL is required for Feishu event callbacks.' },
+    });
+  });
+
+  it('returns challenge response using SDK helper', async () => {
+    const { dispatchFeishuWebhook } = await import('@/lib/im/feishu-dispatcher');
+    generateChallenge.mockReturnValue({
+      isChallenge: true,
+      challenge: { challenge: 'challenge-token' },
+    });
+
+    const result = await dispatchFeishuWebhook({
+      config: {
+        app_id: 'cli_xxx',
+        app_secret: 'secret',
+        conversation: {
+          enabled: true,
+          encrypt_key: 'encrypt',
+          public_base_url: 'https://mindos.example.com',
+          verification_token: 'verification-token',
+        },
+      },
+      body: { challenge: 'challenge-token' },
+      headers: { 'x-lark-request-timestamp': '1' },
+    });
+
+    expect(generateChallenge).toHaveBeenCalledWith(
+      expect.objectContaining({ challenge: 'challenge-token' }),
+      { encryptKey: 'encrypt' },
+    );
+    expect(dispatcherInvoke).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      status: 200,
+      body: { challenge: 'challenge-token' },
+    });
+  });
+
+  it('returns 401 when SDK verification fails', async () => {
+    const { dispatchFeishuWebhook } = await import('@/lib/im/feishu-dispatcher');
+    dispatcherInvoke.mockResolvedValue(undefined);
+
+    const result = await dispatchFeishuWebhook({
+      config: {
+        app_id: 'cli_xxx',
+        app_secret: 'secret',
+        conversation: {
+          enabled: true,
+          encrypt_key: 'encrypt',
+          public_base_url: 'https://mindos.example.com',
+          verification_token: 'verification-token',
+        },
+      },
+      body: { schema: '2.0', header: { event_type: 'im.message.receive_v1' } },
+      headers: {
+        'x-lark-request-timestamp': '1',
+        'x-lark-request-nonce': 'nonce',
+        'x-lark-signature': 'bad-signature',
+      },
+    });
+
+    expect(result).toEqual({
+      status: 401,
+      body: { ok: false, error: 'Invalid Feishu webhook signature or payload.' },
+    });
+  });
+
+  it('uses SDK dispatcher and returns the handler response for accepted events', async () => {
+    const { dispatchFeishuWebhook } = await import('@/lib/im/feishu-dispatcher');
+    dispatcherInvoke.mockResolvedValue({ ok: true, queued: true, reason: 'direct_message' });
+
+    const result = await dispatchFeishuWebhook({
+      config: {
+        app_id: 'cli_xxx',
+        app_secret: 'secret',
+        conversation: {
+          enabled: true,
+          encrypt_key: 'encrypt',
+          public_base_url: 'https://mindos.example.com',
+          verification_token: 'verification-token',
+        },
+      },
+      body: { schema: '2.0', header: { event_type: 'im.message.receive_v1' } },
+      headers: {
+        'x-lark-request-timestamp': '1',
+        'x-lark-request-nonce': 'nonce',
+        'x-lark-signature': 'signature',
+      },
+    });
+
+    expect(dispatcherInvoke).toHaveBeenCalledWith(expect.objectContaining({
+      schema: '2.0',
+      header: { event_type: 'im.message.receive_v1' },
+    }));
+    expect(result).toEqual({
+      status: 202,
+      body: { ok: true, queued: true, reason: 'direct_message' },
+    });
+  });
+});

package/app/__tests__/im/feishu-webhook.test.ts

@@ -1,14 +1,35 @@
-import { describe, it, expect } from 'vitest';
-import type { FeishuConfig, FeishuWebhookEventEnvelope } from '@/lib/im/types';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { FeishuConfig, FeishuSdkMessageEvent, FeishuWebhookEventEnvelope } from '@/lib/im/types';
 
-import {
-  buildFeishuWebhookStatus,
-  normalizeFeishuIncomingMessage,
-  shouldProcessFeishuEvent,
-} from '@/lib/im/webhook/feishu';
+vi.mock('@/lib/im/executor', () => ({
+  sendIMMessage: vi.fn().mockResolvedValue({ ok: true, messageId: 'msg_1', timestamp: '2026-04-10T00:00:00.000Z' }),
+}));
+
+vi.mock('@/lib/agent/headless', () => ({
+  runHeadlessAgent: vi.fn().mockResolvedValue({ text: 'Hello from MindOS', thinking: '', toolCalls: [] }),
+}));
+
+vi.mock('@/lib/im/conversation-store', () => ({
+  appendConversationTurn: vi.fn(),
+  getConversationHistory: vi.fn(() => ({ sessionId: 'session', messages: [] })),
+}));
+
+vi.mock('@/lib/im/activity', () => ({
+  recordActivity: vi.fn(),
+}));
+
+async function importModule() {
+  return await import('@/lib/im/webhook/feishu');
+}
 
 describe('Feishu webhook helpers', () => {
-  it('builds pending status when conversation is enabled but public url is missing', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  it('builds pending status when conversation is enabled but public url is missing', async () => {
+    const { buildFeishuWebhookStatus } = await importModule();
     const config: FeishuConfig = {
       app_id: 'cli_xxx',
       app_secret: 'secret',
@@ -27,7 +48,8 @@ describe('Feishu webhook helpers', () => {
     });
   });
 
-  it('builds ready status when conversation is enabled and callback URL is available', () => {
+  it('builds ready status when conversation is enabled and callback URL is available', async () => {
+    const { buildFeishuWebhookStatus } = await importModule();
     const config: FeishuConfig = {
       app_id: 'cli_xxx',
       app_secret: 'secret',
@@ -47,27 +69,8 @@ describe('Feishu webhook helpers', () => {
     });
   });
 
-  it('rejects challenge with wrong verification token', async () => {
-    const { handleFeishuWebhook } = await import('@/lib/im/webhook/feishu');
-    const result = await handleFeishuWebhook({
-      config: {
-        app_id: 'cli_xxx',
-        app_secret: 'secret',
-        conversation: {
-          enabled: true,
-          encrypt_key: 'encrypt',
-          public_base_url: 'https://mindos.example.com',
-          verification_token: 'expected-token',
-        },
-      },
-      body: { challenge: 'challenge-token', token: 'wrong-token' },
-    });
-
-    expect(result.status).toBe(401);
-    expect(result.body).toEqual({ ok: false, error: 'Invalid verification token' });
-  });
-
-  it('normalizes a dm text message into the shared incoming message shape', () => {
+  it('normalizes a dm text message into the shared incoming message shape', async () => {
+    const { normalizeFeishuIncomingMessage } = await importModule();
     const payload: FeishuWebhookEventEnvelope = {
       header: {
         event_type: 'im.message.receive_v1',
@@ -99,7 +102,8 @@ describe('Feishu webhook helpers', () => {
     });
   });
 
-  it('processes direct messages even without mentions', () => {
+  it('processes direct messages even without mentions', async () => {
+    const { shouldProcessFeishuEvent } = await importModule();
     const payload: FeishuWebhookEventEnvelope = {
       event: {
         message: {
@@ -112,7 +116,8 @@ describe('Feishu webhook helpers', () => {
     expect(shouldProcessFeishuEvent(payload)).toEqual({ ok: true, reason: 'direct_message' });
   });
 
-  it('ignores group messages without bot mentions', () => {
+  it('ignores group messages without bot mentions', async () => {
+    const { shouldProcessFeishuEvent } = await importModule();
     const payload: FeishuWebhookEventEnvelope = {
       event: {
         message: {
@@ -126,34 +131,57 @@ describe('Feishu webhook helpers', () => {
     expect(shouldProcessFeishuEvent(payload)).toEqual({ ok: false, reason: 'group_without_mention' });
   });
 
-  it('ignores events with empty text after normalization', async () => {
-    const { handleFeishuWebhook } = await import('@/lib/im/webhook/feishu');
-    const result = await handleFeishuWebhook({
-      config: {
-        app_id: 'cli_xxx',
-        app_secret: 'secret',
-        conversation: {
-          enabled: true,
-          encrypt_key: 'encrypt',
-          public_base_url: 'https://mindos.example.com',
-        },
+  it('queues processing for direct message sdk events', async () => {
+    const { handleFeishuMessageReceiveEvent } = await importModule();
+    const payload: FeishuSdkMessageEvent = {
+      event_type: 'im.message.receive_v1',
+      sender: {
+        sender_id: { open_id: 'ou_sender_1' },
       },
-      body: {
-        event: {
-          message: {
-            chat_type: 'p2p',
-            chat_id: 'oc_chat_001',
-            message_id: 'om_001',
-            content: JSON.stringify({ text: '   ' }),
-          },
-          sender: {
-            sender_id: { open_id: 'ou_sender_1' },
-          },
-        },
+      message: {
+        message_id: 'om_001',
+        chat_id: 'oc_chat_001',
+        chat_type: 'p2p',
+        content: JSON.stringify({ text: '你好' }),
+      },
+    };
+
+    const result = await handleFeishuMessageReceiveEvent(payload);
+
+    expect(result).toEqual(expect.objectContaining({ ok: true, queued: true, reason: 'direct_message' }));
+  });
+
+  it('ignores sdk events with empty text after normalization', async () => {
+    const { handleFeishuMessageReceiveEvent } = await importModule();
+    const result = await handleFeishuMessageReceiveEvent({
+      event_type: 'im.message.receive_v1',
+      sender: {
+        sender_id: { open_id: 'ou_sender_1' },
+      },
+      message: {
+        chat_type: 'p2p',
+        chat_id: 'oc_chat_001',
+        message_id: 'om_001',
+        content: JSON.stringify({ text: '   ' }),
+      },
+    });
+
+    expect(result).toEqual({ ok: true, ignored: true, reason: 'empty_text' });
+  });
+
+  it('ignores sdk events missing required message identifiers', async () => {
+    const { handleFeishuMessageReceiveEvent } = await importModule();
+    const result = await handleFeishuMessageReceiveEvent({
+      event_type: 'im.message.receive_v1',
+      sender: {
+        sender_id: { open_id: 'ou_sender_1' },
+      },
+      message: {
+        chat_type: 'p2p',
+        content: JSON.stringify({ text: 'hello' }),
       },
     });
 
-    expect(result.status).toBe(202);
-    expect(result.body).toEqual({ ok: true, ignored: true, reason: 'empty_text' });
+    expect(result).toEqual({ ok: true, ignored: true, reason: 'invalid_event_payload' });
   });
 });