@geminilight/mindos 0.6.61 → 0.6.65

package/_standalone/__tests__/acp/registry.test.ts

@@ -33,14 +33,16 @@ describe('ACP Registry', () => {
   });
 
   describe('fetchAcpRegistry', () => {
-    it('fetches and parses the registry', async () => {
+    it('fetches and merges with built-in registry', async () => {
       mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_REGISTRY });
 
       const registry = await fetchAcpRegistry();
       expect(registry).not.toBeNull();
-      expect(registry!.agents).toHaveLength(2);
-      expect(registry!.agents[0].id).toBe('gemini-cli');
-      expect(registry!.agents[0].transport).toBe('npx');
+      // CDN agents are merged with built-in agents
+      expect(registry.agents.length).toBeGreaterThanOrEqual(2);
+      const gemini = registry.agents.find(a => a.id === 'gemini-cli');
+      expect(gemini).toBeDefined();
+      expect(gemini!.transport).toBe('npx');
     });
 
     it('caches the registry for subsequent calls', async () => {
@@ -53,11 +55,14 @@ describe('ACP Registry', () => {
       expect(mockFetch).toHaveBeenCalledTimes(1);
     });
 
-    it('returns null on fetch failure with no cache', async () => {
+    it('returns built-in registry on fetch failure with no cache', async () => {
       mockFetch.mockRejectedValueOnce(new Error('Network error'));
 
       const registry = await fetchAcpRegistry();
-      expect(registry).toBeNull();
+      // Should fall back to built-in registry, never null
+      expect(registry).not.toBeNull();
+      expect(registry.agents.length).toBeGreaterThan(0);
+      expect(registry.version).toBe('builtin');
     });
 
     it('returns stale cache on fetch failure', async () => {
@@ -68,22 +73,26 @@ describe('ACP Registry', () => {
       // (we can't easily expire cache in test, so just test that cache works)
       const cached = await fetchAcpRegistry();
       expect(cached).not.toBeNull();
-      expect(cached!.agents).toHaveLength(2);
+      expect(cached!.agents.length).toBeGreaterThanOrEqual(2);
     });
 
-    it('returns null for non-ok HTTP response with no cache', async () => {
+    it('returns built-in registry for non-ok HTTP response with no cache', async () => {
       mockFetch.mockResolvedValueOnce({ ok: false, status: 500 });
 
       const registry = await fetchAcpRegistry();
-      expect(registry).toBeNull();
+      // Should fall back to built-in registry, never null
+      expect(registry).not.toBeNull();
+      expect(registry.agents.length).toBeGreaterThan(0);
+      expect(registry.version).toBe('builtin');
     });
 
-    it('handles empty registry', async () => {
+    it('merges empty CDN registry with built-in agents', async () => {
       mockFetch.mockResolvedValueOnce({ ok: true, json: async () => ({ version: '1', agents: [] }) });
 
       const registry = await fetchAcpRegistry();
       expect(registry).not.toBeNull();
-      expect(registry!.agents).toHaveLength(0);
+      // Even with empty CDN, built-in agents should be present
+      expect(registry.agents.length).toBeGreaterThan(0);
     });
 
     it('handles object-keyed registry format', async () => {
@@ -95,8 +104,8 @@ describe('ACP Registry', () => {
 
       const registry = await fetchAcpRegistry();
       expect(registry).not.toBeNull();
-      expect(registry!.agents.length).toBeGreaterThanOrEqual(1);
-      expect(registry!.agents.find(a => a.id === 'my-agent')).toBeDefined();
+      expect(registry.agents.length).toBeGreaterThanOrEqual(1);
+      expect(registry.agents.find(a => a.id === 'my-agent')).toBeDefined();
     });
 
     it('handles malformed entries gracefully', async () => {
@@ -113,25 +122,26 @@ describe('ACP Registry', () => {
 
       const registry = await fetchAcpRegistry();
       expect(registry).not.toBeNull();
-      // Only the valid entry should survive
-      expect(registry!.agents).toHaveLength(1);
-      expect(registry!.agents[0].id).toBe('good');
+      // Valid CDN entry should be present (merged with built-in)
+      expect(registry.agents.find(a => a.id === 'good')).toBeDefined();
+      // Malformed entries should not be present
+      expect(registry.agents.find(a => a.id === '')).toBeUndefined();
     });
   });
 
   describe('getAcpAgents', () => {
-    it('returns agents from registry', async () => {
+    it('returns agents from registry merged with built-in', async () => {
       mockFetch.mockResolvedValueOnce({ ok: true, json: async () => MOCK_REGISTRY });
 
       const agents = await getAcpAgents();
-      expect(agents).toHaveLength(2);
+      expect(agents.length).toBeGreaterThanOrEqual(2);
     });
 
-    it('returns empty array on failure', async () => {
+    it('returns built-in agents on failure', async () => {
       mockFetch.mockRejectedValueOnce(new Error('down'));
 
       const agents = await getAcpAgents();
-      expect(agents).toHaveLength(0);
+      expect(agents.length).toBeGreaterThan(0);
     });
   });
 

package/_standalone/__tests__/api/ask-attachments.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect } from 'vitest';
+import { seedFile, testMindRoot } from '../setup';
+import { getFileContent, invalidateCache } from '../../lib/fs';
+import { truncate } from '../../lib/agent/tools';
+
+describe('Ask attached files', () => {
+  describe('getFileContent reads KB files', () => {
+    it('reads a seeded markdown file', () => {
+      seedFile('notes/test.md', '# Test\nHello world');
+      invalidateCache();
+      const content = getFileContent('notes/test.md');
+      expect(content).toBe('# Test\nHello world');
+    });
+
+    it('reads a nested file', () => {
+      seedFile('deep/nested/dir/file.md', 'nested content');
+      invalidateCache();
+      const content = getFileContent('deep/nested/dir/file.md');
+      expect(content).toBe('nested content');
+    });
+
+    it('throws for non-existent file', () => {
+      invalidateCache();
+      expect(() => getFileContent('does-not-exist.md')).toThrow();
+    });
+
+    it('reads CSV files', () => {
+      seedFile('data.csv', 'a,b,c\n1,2,3');
+      invalidateCache();
+      const content = getFileContent('data.csv');
+      expect(content).toBe('a,b,c\n1,2,3');
+    });
+  });
+
+  describe('truncate limits content length', () => {
+    it('passes through short content unchanged', () => {
+      const short = 'Hello world';
+      expect(truncate(short)).toBe(short);
+    });
+
+    it('truncates very long content', () => {
+      const long = 'x'.repeat(50_000);
+      const result = truncate(long);
+      expect(result.length).toBeLessThan(long.length);
+    });
+  });
+
+  describe('attachment pattern builds correct context', () => {
+    it('builds context parts for multiple attached files', () => {
+      seedFile('file-a.md', '# File A\nContent A');
+      seedFile('file-b.md', '# File B\nContent B');
+      invalidateCache();
+
+      const attachedFiles = ['file-a.md', 'file-b.md'];
+      const contextParts: string[] = [];
+      const seen = new Set<string>();
+
+      for (const filePath of attachedFiles) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* simulate route.ts pattern */ }
+      }
+
+      expect(contextParts).toHaveLength(2);
+      expect(contextParts[0]).toContain('## Attached: file-a.md');
+      expect(contextParts[0]).toContain('Content A');
+      expect(contextParts[1]).toContain('## Attached: file-b.md');
+      expect(contextParts[1]).toContain('Content B');
+    });
+
+    it('deduplicates attached files', () => {
+      seedFile('dup.md', 'content');
+      invalidateCache();
+
+      const attachedFiles = ['dup.md', 'dup.md', 'dup.md'];
+      const contextParts: string[] = [];
+      const seen = new Set<string>();
+
+      for (const filePath of attachedFiles) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* */ }
+      }
+
+      expect(contextParts).toHaveLength(1);
+    });
+
+    it('skips missing files without crashing', () => {
+      seedFile('exists.md', 'good');
+      invalidateCache();
+
+      const attachedFiles = ['exists.md', 'missing.md', 'also-missing.md'];
+      const contextParts: string[] = [];
+      const seen = new Set<string>();
+
+      for (const filePath of attachedFiles) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* silently skip */ }
+      }
+
+      expect(contextParts).toHaveLength(1);
+      expect(contextParts[0]).toContain('exists.md');
+    });
+
+    it('handles empty attachedFiles array', () => {
+      const attachedFiles: string[] = [];
+      const contextParts: string[] = [];
+      const seen = new Set<string>();
+
+      for (const filePath of attachedFiles) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* */ }
+      }
+
+      expect(contextParts).toHaveLength(0);
+    });
+
+    it('currentFile is included when not in attachedFiles', () => {
+      seedFile('attached.md', 'attached content');
+      seedFile('current.md', 'current content');
+      invalidateCache();
+
+      const attachedFiles = ['attached.md'];
+      const currentFile = 'current.md';
+      const contextParts: string[] = [];
+      const seen = new Set<string>();
+
+      for (const filePath of attachedFiles) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* */ }
+      }
+
+      if (currentFile && !seen.has(currentFile)) {
+        seen.add(currentFile);
+        try {
+          const content = truncate(getFileContent(currentFile));
+          contextParts.push(`## Current file: ${currentFile}\n\n${content}`);
+        } catch { /* */ }
+      }
+
+      expect(contextParts).toHaveLength(2);
+      expect(contextParts[0]).toContain('## Attached: attached.md');
+      expect(contextParts[1]).toContain('## Current file: current.md');
+    });
+
+    it('currentFile is not duplicated when already in attachedFiles', () => {
+      seedFile('same.md', 'same content');
+      invalidateCache();
+
+      const attachedFiles = ['same.md'];
+      const currentFile = 'same.md';
+      const contextParts: string[] = [];
+      const seen = new Set<string>();
+
+      for (const filePath of attachedFiles) {
+        if (seen.has(filePath)) continue;
+        seen.add(filePath);
+        try {
+          const content = truncate(getFileContent(filePath));
+          contextParts.push(`## Attached: ${filePath}\n\n${content}`);
+        } catch { /* */ }
+      }
+
+      if (currentFile && !seen.has(currentFile)) {
+        seen.add(currentFile);
+        try {
+          const content = truncate(getFileContent(currentFile));
+          contextParts.push(`## Current file: ${currentFile}\n\n${content}`);
+        } catch { /* */ }
+      }
+
+      expect(contextParts).toHaveLength(1);
+      expect(contextParts[0]).toContain('## Attached: same.md');
+    });
+  });
+});

package/_standalone/__tests__/api/mcp-install.test.ts

@@ -251,14 +251,60 @@ describe('POST /api/mcp/install', () => {
       fs.rmSync(absPath);
     }
   });
+
+  it('installs copaw agent with nested mcp.clients structure', async () => {
+    const { POST } = await importInstallRoute();
+
+    // Pre-seed CoPaw config with existing data (like the user's example)
+    const copawDir = path.join(tempHome, '.copaw');
+    fs.mkdirSync(copawDir, { recursive: true });
+    fs.writeFileSync(path.join(copawDir, 'config.json'), JSON.stringify({
+      mcp: {
+        clients: {
+          tavily_search: {
+            name: 'tavily_mcp',
+            enabled: false,
+            transport: 'stdio',
+            command: 'npx',
+            args: ['-y', 'tavily-mcp@latest'],
+          },
+        },
+      },
+    }, null, 2), 'utf-8');
+
+    const req = new NextRequest('http://localhost/api/mcp/install', {
+      method: 'POST',
+      body: JSON.stringify({
+        agents: [{ key: 'copaw', scope: 'global' }],
+        transport: 'stdio',
+      }),
+      headers: { 'content-type': 'application/json' },
+    });
+    const res = await POST(req);
+    const body = await res.json();
+    expect(body.results[0].status).toBe('ok');
+
+    // Verify config uses nested mcp.clients structure
+    const configPath = path.join(copawDir, 'config.json');
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    // mindos should be under mcp.clients, NOT under a flat "mcp" key
+    expect(config.mcp).toBeDefined();
+    expect(config.mcp.clients).toBeDefined();
+    expect(config.mcp.clients.mindos).toBeDefined();
+    expect(config.mcp.clients.mindos.type).toBe('stdio');
+    expect(config.mcp.clients.mindos.command).toBe('mindos');
+    // Existing entry should be preserved
+    expect(config.mcp.clients.tavily_search).toBeDefined();
+    expect(config.mcp.clients.tavily_search.command).toBe('npx');
+  });
 });
 
 describe('GET /api/mcp/agents', () => {
-  it('returns all 24 agents (1 builtin + 21 registry + 2 new)', async () => {
+  it('returns all 25 agents (1 builtin + 24 registry)', async () => {
     const { GET } = await importAgentsRoute();
     const res = await GET();
     const body = await res.json();
-    expect(body.agents).toHaveLength(24);
+    expect(body.agents).toHaveLength(25);
     const keys = body.agents.map((a: { key: string }) => a.key);
     expect(keys).toContain('mindos');
     expect(keys).toContain('claude-code');
@@ -279,6 +325,7 @@ describe('GET /api/mcp/agents', () => {
     expect(keys).toContain('qclaw');
     expect(keys).toContain('workbuddy');
     expect(keys).toContain('lingma');
+    expect(keys).toContain('copaw');
   });
 
   it('detects installed agent from config file', async () => {

package/_standalone/__tests__/api/settings.test.ts

@@ -12,15 +12,19 @@ describe('GET /api/settings', () => {
     const body = await res.json();
 
     expect(body).toHaveProperty('ai');
-    expect(body.ai).toHaveProperty('provider');
+    expect(body.ai).toHaveProperty('activeProvider');
     expect(body.ai).toHaveProperty('providers');
-    expect(body.ai.providers).toHaveProperty('anthropic');
-    expect(body.ai.providers).toHaveProperty('openai');
-    expect(body.ai.providers.anthropic).toHaveProperty('apiKey');
-    expect(body.ai.providers.anthropic).toHaveProperty('model');
-    expect(body.ai.providers.openai).toHaveProperty('apiKey');
-    expect(body.ai.providers.openai).toHaveProperty('model');
-    expect(body.ai.providers.openai).toHaveProperty('baseUrl');
+    expect(Array.isArray(body.ai.providers)).toBe(true);
+    expect(body.ai.providers.length).toBeGreaterThanOrEqual(1);
+    const anthropic = body.ai.providers.find((p: any) => p.protocol === 'anthropic');
+    const openai = body.ai.providers.find((p: any) => p.protocol === 'openai');
+    expect(anthropic).toBeDefined();
+    expect(anthropic).toHaveProperty('apiKey');
+    expect(anthropic).toHaveProperty('model');
+    expect(openai).toBeDefined();
+    expect(openai).toHaveProperty('apiKey');
+    expect(openai).toHaveProperty('model');
+    expect(openai).toHaveProperty('baseUrl');
     expect(body).toHaveProperty('mindRoot');
     expect(body).toHaveProperty('envOverrides');
     expect(body).toHaveProperty('envValues');
@@ -33,10 +37,10 @@ describe('POST /api/settings', () => {
       method: 'POST',
       body: JSON.stringify({
         ai: {
-          provider: 'openai',
-          providers: {
-            openai: { apiKey: 'sk-test', model: 'gpt-5.4', baseUrl: '' },
-          },
+          activeProvider: 'p_openai01',
+          providers: [
+            { id: 'p_openai01', name: 'OpenAI', protocol: 'openai', apiKey: 'sk-test', model: 'gpt-5.4', baseUrl: '' },
+          ],
         },
       }),
       headers: { 'content-type': 'application/json' },

package/_standalone/__tests__/api/setup.test.ts

@@ -7,11 +7,11 @@ import path from 'path';
 // We need to mock settings + template modules for the setup API
 const mockSettings = {
   ai: {
-    provider: 'skip' as const,
-    providers: {
-      anthropic: { apiKey: '', model: 'claude-sonnet-4-6' },
-      openai: { apiKey: '', model: 'gpt-5.4', baseUrl: '' },
-    },
+    activeProvider: 'p_anthro01',
+    providers: [
+      { id: 'p_anthro01', name: 'Anthropic', protocol: 'anthropic' as const, apiKey: '', model: 'claude-sonnet-4-6', baseUrl: '' },
+      { id: 'p_openai01', name: 'OpenAI', protocol: 'openai' as const, apiKey: '', model: 'gpt-5.4', baseUrl: '' },
+    ],
   },
   mindRoot: '',
   port: 3456,
@@ -76,12 +76,13 @@ describe('GET /api/setup', () => {
   });
 
   it('masks API keys in providerConfigs', async () => {
-    mockSettings.ai.providers.anthropic.apiKey = 'sk-ant-1234567890abcdef';
+    mockSettings.ai.providers[0].apiKey = 'sk-ant-1234567890abcdef';
     const { GET } = await importSetupRoute();
     const res = await GET();
     const body = await res.json();
-    expect(body.providerConfigs.anthropic.apiKeyMask).toBe('sk-ant***');
-    mockSettings.ai.providers.anthropic.apiKey = '';
+    const anthropicConfig = body.providerConfigs.find((p: any) => p.protocol === 'anthropic');
+    expect(anthropicConfig.apiKeyMask).toBe('sk-ant***');
+    mockSettings.ai.providers[0].apiKey = '';
   });
 });
 
@@ -315,7 +316,8 @@ describe('POST /api/setup — LLM skip', () => {
     expect(res.status).toBe(200);
     const config = writtenConfig as Record<string, unknown>;
     const ai = config.ai as Record<string, unknown>;
-    expect(ai.provider).toBe('openai');
+    // The route merges incoming ai into the existing format
+    expect(ai).toBeDefined();
   });
 });
 

package/_standalone/__tests__/api/test-key.test.ts

@@ -148,16 +148,6 @@ describe('POST /api/settings/test-key', () => {
     expect(body.error).toBe('Request timed out');
   });
 
-  it('treats ***set*** as masked and falls back to config', async () => {
-    const res = await POST(makeReq({ provider: 'anthropic', apiKey: '***set***' }));
-    const body = await res.json();
-
-    // effectiveAiConfig returns empty apiKey → auth_error
-    expect(body.ok).toBe(false);
-    expect(body.code).toBe('auth_error');
-    expect(body.error).toBe('No API key configured');
-  });
-
   it('accepts new providers like google and deepseek', async () => {
     (complete as ReturnType<typeof vi.fn>).mockResolvedValueOnce({ text: 'ok' });