@kirosnn/mosaic 0.71.0 → 0.74.0

package/src/mcp/servers/navigation/browser.ts

@@ -0,0 +1,151 @@
+import { chromium, firefox, webkit, type Browser, type BrowserContext, type Page } from 'playwright';
+import { LaunchConfig, ContextConfig } from './types.js';
+
+const browserTypes = { chromium, firefox, webkit };
+
+let browser: Browser | null = null;
+let context: BrowserContext | null = null;
+
+export const launchConfig: LaunchConfig = {
+    browserType: 'chromium',
+    headless: true,
+    args: [
+        '--disable-blink-features=AutomationControlled',
+        '--disable-infobars',
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--ignore-certificate-errors',
+        '--disable-features=IsolateOrigins,site-per-process',
+    ],
+};
+
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+const DEFAULT_VIEWPORT = { width: 1280, height: 720 };
+const DEFAULT_PAGE_TIMEOUT = 30000;
+const DEFAULT_NAV_TIMEOUT = 60000;
+
+export const contextConfig: ContextConfig = {
+    userAgent: DEFAULT_USER_AGENT,
+    viewport: DEFAULT_VIEWPORT,
+};
+
+const tabs = new Map<string, Page>();
+const tabOrder: string[] = [];
+const pageToId = new WeakMap<Page, string>();
+let currentTabId: string | null = null;
+let tabSeq = 0;
+
+function configurePage(page: Page): void {
+    page.setDefaultTimeout(DEFAULT_PAGE_TIMEOUT);
+    page.setDefaultNavigationTimeout(DEFAULT_NAV_TIMEOUT);
+}
+
+export function registerPage(page: Page): string {
+    const existing = pageToId.get(page);
+    if (existing) return existing;
+    configurePage(page);
+    const id = `tab_${++tabSeq}`;
+    pageToId.set(page, id);
+    tabs.set(id, page);
+    tabOrder.push(id);
+    currentTabId = id;
+    page.on('close', () => {
+        tabs.delete(id);
+        const index = tabOrder.indexOf(id);
+        if (index >= 0) tabOrder.splice(index, 1);
+        if (currentTabId === id) {
+            currentTabId = tabOrder.length > 0 ? tabOrder[tabOrder.length - 1]! : null;
+        }
+    });
+    return id;
+}
+
+export async function ensureBrowser(): Promise<Browser> {
+    if (browser) return browser;
+    const launcher = browserTypes[launchConfig.browserType];
+    browser = await launcher.launch({
+        headless: launchConfig.headless,
+        channel: launchConfig.channel,
+        executablePath: launchConfig.executablePath,
+        args: [
+            ...launchConfig.args,
+            ...(launchConfig.args.length > 0 ? [] : [])
+        ],
+    });
+    return browser;
+}
+
+export async function ensureContext(): Promise<BrowserContext> {
+    if (context) return context;
+    const b = await ensureBrowser();
+    context = await b.newContext({
+        userAgent: contextConfig.userAgent,
+        viewport: contextConfig.viewport === null ? null : contextConfig.viewport,
+        extraHTTPHeaders: contextConfig.extraHTTPHeaders,
+        locale: 'en-US',
+        timezoneId: contextConfig.timezoneId,
+        deviceScaleFactor: 1,
+        isMobile: false,
+        hasTouch: false,
+        javaScriptEnabled: true,
+    });
+
+    await context.addInitScript(() => {
+        Object.defineProperty(navigator, 'webdriver', {
+            get: () => undefined,
+        });
+
+        if (!(window as any).chrome) {
+            (window as any).chrome = {
+                runtime: {},
+                loadTimes: function () { },
+                csi: function () { },
+                app: {},
+            };
+        }
+
+        if (navigator.plugins.length === 0) {
+            Object.defineProperty(navigator, 'plugins', {
+                get: () => {
+                    return [
+                        { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+                        { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: 'Portable Document Format' },
+                        { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' }
+                    ];
+                },
+            });
+        }
+
+        Object.defineProperty(navigator, 'languages', {
+            get: () => ['en-US', 'en'],
+        });
+    });
+
+    context.on('page', page => {
+        registerPage(page);
+    });
+    return context;
+}
+
+export async function ensurePage(tabId?: string): Promise<{ page: Page; tabId: string }> {
+    const ctx = await ensureContext();
+    if (tabId) {
+        const existing = tabs.get(tabId);
+        if (!existing) {
+            throw new Error(`Tab not found: ${tabId}`);
+        }
+        currentTabId = tabId;
+        return { page: existing, tabId };
+    }
+    if (currentTabId) {
+        const current = tabs.get(currentTabId);
+        if (current) return { page: current, tabId: currentTabId };
+    }
+    const page = await ctx.newPage();
+    const id = registerPage(page);
+    return { page, tabId: id };
+}
+
+export function getTabs() {
+    return tabs;
+}

package/src/mcp/servers/navigation/index.ts

@@ -0,0 +1,23 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ensureContext } from './browser.js';
+import { registerTools } from './tools.js';
+
+const server = new McpServer({ name: 'navigation', version: '1.0.0' });
+
+registerTools(server);
+
+async function main(): Promise<void> {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    try {
+        await ensureContext();
+    } catch {
+        // Browser will be launched on first tool call if pre-launch fails
+    }
+}
+
+main().catch(error => {
+    console.error(error);
+    process.exit(1);
+});

package/src/mcp/servers/navigation/tools.ts

@@ -0,0 +1,263 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { Page } from 'playwright';
+import { ensureContext, ensurePage, registerPage } from './browser.js';
+import { randomDelay } from './utils.js';
+
+type SearchEngine = 'duckduckgo' | 'google' | 'bing';
+
+interface SearchResult {
+    text: string;
+    href: string;
+    snippet: string;
+}
+
+interface EngineConfig {
+    buildUrl: (query: string) => string;
+    extract: (page: Page, limit: number) => Promise<SearchResult[]>;
+}
+
+async function resolveRedirects(page: Page, results: SearchResult[]): Promise<SearchResult[]> {
+    return page.evaluate((results) => {
+        return results.map(r => {
+            try {
+                const url = new URL(r.href);
+                if (url.hostname.includes('bing.com') && url.pathname === '/ck/a') {
+                    const u = url.searchParams.get('u');
+                    if (u) {
+                        const decoded = atob(u.replace(/^a1/, ''));
+                        if (decoded.startsWith('http')) return { ...r, href: decoded };
+                    }
+                }
+            } catch {}
+            return r;
+        });
+    }, results);
+}
+
+const engines: Record<SearchEngine, EngineConfig> = {
+    bing: {
+        buildUrl: (q) => `https://www.bing.com/search?q=${encodeURIComponent(q)}`,
+        extract: async (page, limit) => {
+            const raw = await page.evaluate((limit) => {
+                const items: { text: string; href: string; snippet: string }[] = [];
+                const results = document.querySelectorAll('.b_algo');
+
+                for (const el of Array.from(results)) {
+                    if (items.length >= limit) break;
+
+                    const linkEl = el.querySelector('h2 a');
+                    const snippetEl = el.querySelector('.b_caption p, p');
+
+                    const text = linkEl?.textContent?.trim();
+                    const href = linkEl?.getAttribute('href');
+                    const snippet = snippetEl?.textContent?.trim() || '';
+
+                    if (text && href && href.startsWith('http')) {
+                        items.push({ text, href, snippet });
+                    }
+                }
+                return items;
+            }, limit);
+            return resolveRedirects(page, raw);
+        },
+    },
+    duckduckgo: {
+        buildUrl: (q) => `https://duckduckgo.com/?q=${encodeURIComponent(q)}`,
+        extract: async (page, limit) => {
+            return page.evaluate((limit) => {
+                const items: { text: string; href: string; snippet: string }[] = [];
+                const selectors = ['article[data-testid="result"]', '.result', '.web-result', '.results .result__body'];
+
+                for (const selector of selectors) {
+                    const elements = document.querySelectorAll(selector);
+                    if (elements.length === 0) continue;
+
+                    for (const el of Array.from(elements)) {
+                        if (items.length >= limit) break;
+
+                        const titleEl = el.querySelector('h2 a, a[data-testid="result-title-a"], .result__a');
+                        const snippetEl = el.querySelector('[data-result="snippet"], .result__snippet, span');
+
+                        const text = titleEl?.textContent?.trim();
+                        const href = titleEl?.getAttribute('href');
+                        const snippet = snippetEl?.textContent?.trim() || '';
+
+                        if (text && href && href.startsWith('http')) {
+                            items.push({ text, href, snippet });
+                        }
+                    }
+                    if (items.length > 0) break;
+                }
+                return items;
+            }, limit);
+        },
+    },
+    google: {
+        buildUrl: (q) => `https://www.google.com/search?q=${encodeURIComponent(q)}&udm=14`,
+        extract: async (page, limit) => {
+            return page.evaluate((limit) => {
+                const items: { text: string; href: string; snippet: string }[] = [];
+                const results = document.querySelectorAll('#search .g');
+
+                for (const el of Array.from(results)) {
+                    if (items.length >= limit) break;
+
+                    const titleEl = el.querySelector('h3');
+                    const linkEl = el.querySelector('a');
+                    const snippetEl = el.querySelector('[style*="-webkit-line-clamp"], .VwiC3b, div[style*="line-height"]');
+
+                    const text = titleEl?.textContent?.trim();
+                    const href = linkEl?.getAttribute('href');
+                    const snippet = snippetEl?.textContent?.trim() || '';
+
+                    if (text && href && href.startsWith('http')) {
+                        items.push({ text, href, snippet });
+                    }
+                }
+                return items;
+            }, limit);
+        },
+    },
+};
+
+async function extractFallbackResults(page: Page, limit: number): Promise<SearchResult[]> {
+    return page.evaluate((limit) => {
+        const items: { text: string; href: string; snippet: string }[] = [];
+        const seen = new Set<string>();
+        const links = document.querySelectorAll('a[href^="http"]');
+
+        for (const link of Array.from(links)) {
+            if (items.length >= limit) break;
+
+            const href = link.getAttribute('href');
+            if (!href || seen.has(href)) continue;
+
+            try {
+                const host = new URL(href).hostname;
+                if (['google.', 'bing.', 'duckduckgo.', 'yahoo.'].some(d => host.includes(d))) continue;
+            } catch { continue; }
+
+            const text = link.textContent?.trim();
+            if (!text || text.length < 3) continue;
+
+            seen.add(href);
+            const parent = link.closest('div, li, article, section');
+            const snippet = parent?.textContent?.trim().slice(0, 200) || '';
+
+            items.push({ text, href, snippet });
+        }
+        return items;
+    }, limit);
+}
+
+async function dismissConsentDialogs(page: Page): Promise<void> {
+    try {
+        const consentButton = page.locator(
+            'button:has-text("Tout refuser"), button:has-text("Reject all"), ' +
+            'button:has-text("Alle ablehnen"), button:has-text("Accept"), ' +
+            'button:has-text("I agree"), button:has-text("Accepter")'
+        ).first();
+        if (await consentButton.isVisible({ timeout: 1500 })) {
+            await consentButton.click();
+            await page.waitForLoadState('domcontentloaded', { timeout: 3000 }).catch(() => {});
+        }
+    } catch {
+        // No consent dialog
+    }
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+    return Promise.race([
+        promise,
+        new Promise<never>((_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)),
+    ]);
+}
+
+export function registerTools(server: McpServer) {
+    server.registerTool('navigation_search', {
+        description: 'Search the web and return top results (titles, links, snippets). Defaults to Bing. Supports bing, duckduckgo, and google engines.',
+        inputSchema: {
+            query: z.string(),
+            limit: z.number().optional(),
+            engine: z.enum(['bing', 'duckduckgo', 'google']).optional(),
+            newTab: z.boolean().optional(),
+        },
+    }, async (args) => {
+        const engineName: SearchEngine = args.engine ?? 'bing';
+        const engine = engines[engineName];
+        const limit = args.limit ?? 8;
+
+        const doSearch = async () => {
+            const target = args.newTab ? await ensureContext().then(async ctx => {
+                const page = await ctx.newPage();
+                const tabId = registerPage(page);
+                return { page, tabId };
+            }) : await ensurePage();
+
+            const page = target.page;
+            const url = engine.buildUrl(args.query);
+
+            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 10000 });
+
+            await dismissConsentDialogs(page);
+
+            await randomDelay(300, 600);
+
+            let results = await engine.extract(page, limit);
+
+            if (results.length === 0) {
+                results = await extractFallbackResults(page, limit);
+            }
+
+            const currentUrl = page.url();
+            const pageTitle = await page.title();
+
+            if (results.length === 0) {
+                return {
+                    content: [{
+                        type: 'text' as const,
+                        text: JSON.stringify({
+                            tabId: target.tabId,
+                            engine: engineName,
+                            url: currentUrl,
+                            pageTitle,
+                            resultCount: 0,
+                            results: [],
+                            note: 'No results extracted. The page may have shown a CAPTCHA, consent wall, or unexpected layout. Check pageTitle and url for clues.',
+                        }, null, 2),
+                    }],
+                };
+            }
+
+            return {
+                content: [{
+                    type: 'text' as const,
+                    text: JSON.stringify({
+                        tabId: target.tabId,
+                        engine: engineName,
+                        url: currentUrl,
+                        resultCount: results.length,
+                        results,
+                    }, null, 2),
+                }],
+            };
+        };
+
+        try {
+            return await withTimeout(doSearch(), 45000, 'navigation_search');
+        } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        engine: engineName,
+                        error: `Search failed: ${msg}`,
+                    }, null, 2),
+                }],
+                isError: true,
+            };
+        }
+    });
+}

package/src/mcp/servers/navigation/types.ts

@@ -0,0 +1,17 @@
+export type BrowserTypeName = 'chromium' | 'firefox' | 'webkit';
+
+export type LaunchConfig = {
+    browserType: BrowserTypeName;
+    headless: boolean;
+    channel?: string;
+    executablePath?: string;
+    args: string[];
+};
+
+export type ContextConfig = {
+    userAgent?: string;
+    viewport?: { width: number; height: number } | null;
+    extraHTTPHeaders?: Record<string, string>;
+    locale?: string;
+    timezoneId?: string;
+};

package/src/mcp/servers/navigation/utils.ts

@@ -0,0 +1,20 @@
+import type { Page } from 'playwright';
+
+export const randomDelay = (min: number, max: number) => new Promise(resolve => setTimeout(resolve, Math.floor(Math.random() * (max - min + 1)) + min));
+
+export async function humanType(page: any, selector: string, text: string) {
+    const element = page.locator(selector);
+    await element.click();
+    for (const char of text) {
+        await page.keyboard.type(char, { delay: Math.random() * 100 + 50 });
+    }
+}
+
+export async function waitForStability(page: Page, timeout = 10000): Promise<void> {
+    try {
+        await page.waitForLoadState('networkidle', { timeout });
+    } catch {
+        await page.waitForLoadState('domcontentloaded', { timeout: 5000 }).catch(() => {});
+        await randomDelay(300, 600);
+    }
+}

package/src/mcp/toolCatalog.ts

@@ -0,0 +1,182 @@
+import { tool, type CoreTool } from 'ai';
+import type { McpToolInfo, McpServerConfig } from './types';
+import { parseSafeId, isNativeMcpServer } from './types';
+import { McpProcessManager } from './processManager';
+import { McpApprovalPolicy } from './approvalPolicy';
+import { jsonSchemaObjectToZodObject } from './schemaConverter';
+
+function matchGlobList(name: string, patterns: string[]): boolean {
+  for (const pattern of patterns) {
+    if (pattern === '*') return true;
+    if (pattern === name) return true;
+
+    const regex = new RegExp(
+      '^' + pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+    );
+    if (regex.test(name)) return true;
+  }
+  return false;
+}
+
+export class McpToolCatalog {
+  private processManager: McpProcessManager;
+  private approvalPolicy: McpApprovalPolicy;
+  private configs: McpServerConfig[];
+  private exposedTools = new Map<string, CoreTool>();
+  private toolInfoMap = new Map<string, McpToolInfo>();
+  private safeToCanonical = new Map<string, string>();
+  private canonicalToSafe = new Map<string, string>();
+
+  constructor(processManager: McpProcessManager, approvalPolicy: McpApprovalPolicy, configs: McpServerConfig[]) {
+    this.processManager = processManager;
+    this.approvalPolicy = approvalPolicy;
+    this.configs = configs;
+  }
+
+  refreshTools(serverId?: string): void {
+    if (serverId) {
+      this.refreshServerTools(serverId);
+    } else {
+      for (const config of this.configs) {
+        if (config.enabled) {
+          this.refreshServerTools(config.id);
+        }
+      }
+    }
+  }
+
+  private refreshServerTools(serverId: string): void {
+    for (const [safeId, info] of this.toolInfoMap) {
+      if (info.serverId === serverId) {
+        this.exposedTools.delete(safeId);
+        this.toolInfoMap.delete(safeId);
+        this.safeToCanonical.delete(safeId);
+        this.canonicalToSafe.delete(info.canonicalId);
+      }
+    }
+
+    const config = this.configs.find(c => c.id === serverId);
+    if (!config || !config.enabled) return;
+
+    const rawTools = this.processManager.listTools(serverId);
+
+    for (const toolInfo of rawTools) {
+      if (config.tools.deny && config.tools.deny.length > 0) {
+        if (matchGlobList(toolInfo.name, config.tools.deny)) continue;
+      }
+
+      if (config.tools.allow && config.tools.allow.length > 0) {
+        if (!matchGlobList(toolInfo.name, config.tools.allow)) continue;
+      }
+
+      const coreTool = this.convertToCoreToolDef(toolInfo, config);
+      this.exposedTools.set(toolInfo.safeId, coreTool);
+      this.toolInfoMap.set(toolInfo.safeId, toolInfo);
+      this.safeToCanonical.set(toolInfo.safeId, toolInfo.canonicalId);
+      this.canonicalToSafe.set(toolInfo.canonicalId, toolInfo.safeId);
+    }
+  }
+
+  private convertToCoreToolDef(toolInfo: McpToolInfo, config: McpServerConfig): CoreTool {
+    const schema = toolInfo.inputSchema || { type: 'object', properties: {} };
+    const zodParams = jsonSchemaObjectToZodObject(schema as Record<string, unknown>);
+
+    const pm = this.processManager;
+    const ap = this.approvalPolicy;
+    const serverConfig = config;
+
+    return tool({
+      description: toolInfo.description || `MCP tool: ${toolInfo.name} (${config.name})`,
+      parameters: zodParams,
+      execute: async (args: Record<string, unknown>) => {
+        try {
+          const effectiveApproval = serverConfig.toolApproval?.[toolInfo.name] ?? serverConfig.approval;
+          const approvalResult = await ap.requestMcpApproval({
+            serverId: serverConfig.id,
+            serverName: serverConfig.name,
+            toolName: toolInfo.name,
+            canonicalId: toolInfo.canonicalId,
+            args,
+            approvalMode: effectiveApproval,
+          });
+
+          if (!approvalResult.approved) {
+            if (approvalResult.customResponse) {
+              return {
+                error: `OPERATION REJECTED BY USER with custom instructions: "${approvalResult.customResponse}"`,
+                userMessage: 'Operation cancelled by user',
+              };
+            }
+            return {
+              error: `OPERATION REJECTED BY USER: calling MCP tool ${toolInfo.canonicalId}`,
+              userMessage: 'Operation cancelled by user',
+            };
+          }
+
+          const result = await pm.callTool(serverConfig.id, toolInfo.name, args);
+
+          if (result.isError) {
+            return { error: result.content };
+          }
+
+          return result.content;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { error: `MCP tool call failed: ${message}` };
+        }
+      },
+    });
+  }
+
+  getExposedTools(): Record<string, CoreTool> {
+    const result: Record<string, CoreTool> = {};
+    for (const [safeId, coreTool] of this.exposedTools) {
+      result[safeId] = coreTool;
+    }
+    return result;
+  }
+
+  getMcpToolInfos(): McpToolInfo[] {
+    return Array.from(this.toolInfoMap.values());
+  }
+
+  getToolInfo(safeId: string): McpToolInfo | null {
+    return this.toolInfoMap.get(safeId) || null;
+  }
+
+  getSafeIdFromCanonical(canonicalId: string): string | null {
+    return this.canonicalToSafe.get(canonicalId) || null;
+  }
+
+  getCanonicalFromSafeId(safeId: string): string | null {
+    return this.safeToCanonical.get(safeId) || null;
+  }
+
+  isMcpTool(toolName: string): boolean {
+    return toolName.startsWith('mcp__');
+  }
+
+  parseMcpToolName(safeId: string): { serverId: string; toolName: string } | null {
+    return parseSafeId(safeId);
+  }
+
+  isNative(safeId: string): boolean {
+    const parsed = parseSafeId(safeId);
+    if (!parsed) return false;
+    const config = this.configs.find(c => c.id === parsed.serverId);
+    if (config?.native) return true;
+    return isNativeMcpServer(parsed.serverId);
+  }
+
+  getServerConfig(serverId: string): McpServerConfig | null {
+    return this.configs.find(c => c.id === serverId) || null;
+  }
+
+  updateConfigs(configs: McpServerConfig[]): void {
+    this.configs = configs;
+  }
+
+  static mergeTools(internal: Record<string, CoreTool>, mcp: Record<string, CoreTool>): Record<string, CoreTool> {
+    return { ...internal, ...mcp };
+  }
+}