@darbotlabs/darbot-browser-mcp 0.2.0 → 1.3.0

package/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/config.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -80,6 +80,82 @@ export type Config = {
      * The host to bind the server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.
      */
     host?: string;
+
+    /**
+     * Base URL for the server, used in OpenAPI specification generation.
+     */
+    baseUrl?: string;
+
+    /**
+     * Enable HTTPS with SSL certificates.
+     */
+    https?: {
+      enabled: boolean;
+      keyPath?: string;
+      certPath?: string;
+    };
+
+    /**
+     * Rate limiting configuration for enterprise use.
+     */
+    rateLimit?: {
+      enabled: boolean;
+      windowMs?: number;
+      maxRequests?: number;
+    };
+  },
+
+  /**
+   * Microsoft Copilot Studio integration settings.
+   */
+  copilotStudio?: {
+    /**
+     * Enable Copilot Studio specific features.
+     */
+    enabled?: boolean;
+
+    /**
+     * Callback URL for OAuth authentication flow.
+     */
+    callbackUrl?: string;
+
+    /**
+     * Maximum number of concurrent browser sessions for enterprise workloads.
+     */
+    maxConcurrentSessions?: number;
+
+    /**
+     * Session timeout in milliseconds.
+     */
+    sessionTimeoutMs?: number;
+
+    /**
+     * Enable audit logging for compliance.
+     */
+    auditLogging?: boolean;
+  },
+
+  /**
+   * Authentication configuration.
+   */
+  auth?: {
+    /**
+     * Microsoft Entra ID authentication settings.
+     */
+    entraId?: {
+      enabled?: boolean;
+      tenantId?: string;
+      clientId?: string;
+      clientSecret?: string;
+    };
+
+    /**
+     * API key authentication settings.
+     */
+    apiKey?: {
+      enabled?: boolean;
+      keys?: string[];
+    };
   },
 
   /**

package/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Copyright (c) Microsoft Corporation.
+ * Copyright (c) DarbotLabs
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

package/lib/ai/context.js

@@ -0,0 +1,150 @@
+/**
+ * Copyright (c) DarbotLabs.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * AI-native context manager for tracking user intent and session state
+ */
+export class AIContextManager {
+    contexts = new Map();
+    maxHistorySize = 50;
+    /**
+     * Create or get session context for a browser session
+     */
+    getOrCreateContext(sessionId) {
+        if (!this.contexts.has(sessionId)) {
+            this.contexts.set(sessionId, {
+                currentTask: '',
+                pageIntent: '',
+                userGoals: [],
+                navigationHistory: [],
+                failurePatterns: [],
+                successfulActions: [],
+                contextId: sessionId,
+                startTime: Date.now(),
+                lastActivity: Date.now(),
+            });
+        }
+        return this.contexts.get(sessionId);
+    }
+    /**
+     * Update current task description
+     */
+    updateTask(sessionId, task) {
+        const context = this.getOrCreateContext(sessionId);
+        context.currentTask = task;
+        context.lastActivity = Date.now();
+    }
+    /**
+     * Set page intent based on analysis
+     */
+    setPageIntent(sessionId, intent) {
+        const context = this.getOrCreateContext(sessionId);
+        context.pageIntent = intent;
+        context.lastActivity = Date.now();
+    }
+    /**
+     * Record successful action for learning
+     */
+    recordSuccess(sessionId, action) {
+        const context = this.getOrCreateContext(sessionId);
+        context.successfulActions.push(action);
+        context.lastActivity = Date.now();
+        // Keep only recent successes
+        if (context.successfulActions.length > this.maxHistorySize)
+            context.successfulActions = context.successfulActions.slice(-this.maxHistorySize);
+    }
+    /**
+     * Record page state for navigation tracking
+     */
+    recordPageState(sessionId, pageState) {
+        const context = this.getOrCreateContext(sessionId);
+        context.navigationHistory.push(pageState);
+        context.lastActivity = Date.now();
+        // Keep only recent navigation history
+        if (context.navigationHistory.length > this.maxHistorySize)
+            context.navigationHistory = context.navigationHistory.slice(-this.maxHistorySize);
+    }
+    /**
+     * Record error pattern for learning
+     */
+    recordError(sessionId, error) {
+        const context = this.getOrCreateContext(sessionId);
+        // Find existing pattern or create new
+        const existing = context.failurePatterns.find(p => p.errorType === error.errorType &&
+            p.elementSelector === error.elementSelector &&
+            p.pageUrl === error.pageUrl);
+        if (existing) {
+            existing.frequency++;
+            existing.lastOccurrence = Date.now();
+        }
+        else {
+            context.failurePatterns.push({
+                ...error,
+                frequency: 1,
+                lastOccurrence: Date.now(),
+            });
+        }
+        context.lastActivity = Date.now();
+    }
+    /**
+     * Get context for AI decision making
+     */
+    getContext(sessionId) {
+        return this.getOrCreateContext(sessionId);
+    }
+    /**
+     * Analyze patterns to suggest next actions
+     */
+    suggestNextActions(sessionId, currentPage) {
+        const context = this.getOrCreateContext(sessionId);
+        const suggestions = [];
+        // Analyze successful patterns
+        const recentSuccesses = context.successfulActions
+            .filter(action => Date.now() - action.timestamp < 300000) // Last 5 minutes
+            .slice(-10);
+        // Look for common action patterns
+        const actionCounts = new Map();
+        recentSuccesses.forEach(action => {
+            actionCounts.set(action.action, (actionCounts.get(action.action) || 0) + 1);
+        });
+        // Suggest most common recent actions
+        const sortedActions = Array.from(actionCounts.entries())
+            .sort(([, a], [, b]) => b - a)
+            .slice(0, 3);
+        sortedActions.forEach(([action]) => {
+            suggestions.push(`Continue with ${action} action based on recent pattern`);
+        });
+        return suggestions;
+    }
+    /**
+     * Clean up old contexts
+     */
+    cleanup() {
+        const now = Date.now();
+        const maxAge = 24 * 60 * 60 * 1000; // 24 hours
+        for (const [sessionId, context] of this.contexts.entries()) {
+            if (now - context.lastActivity > maxAge)
+                this.contexts.delete(sessionId);
+        }
+    }
+    /**
+     * Clear context for session
+     */
+    clearContext(sessionId) {
+        this.contexts.delete(sessionId);
+    }
+}
+// Global instance for session management
+export const aiContextManager = new AIContextManager();

package/lib/ai/guardrails.js

@@ -0,0 +1,382 @@
+/**
+ * Copyright (c) DarbotLabs.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import debug from 'debug';
+const log = debug('darbot:guardrails');
+/**
+ * Guardrail system for safe autonomous operation
+ */
+export class GuardrailSystem {
+    config;
+    domainCounts = new Map();
+    actionHistory = [];
+    rateLimiter;
+    constructor(config = {}) {
+        this.config = {
+            maxPagesPerDomain: 50,
+            maxDepth: 5,
+            timeoutMs: 300000, // 5 minutes
+            allowedDomains: [],
+            blockedDomains: [
+                'facebook.com', 'twitter.com', 'linkedin.com', 'instagram.com',
+                'tiktok.com', 'youtube.com', 'gmail.com', 'outlook.com'
+            ],
+            blockedPatterns: [
+                /\/login\/?$/i,
+                /\/register\/?$/i,
+                /\/signup\/?$/i,
+                /\/logout\/?$/i,
+                /\/admin\/?/i,
+                /\/api\//i,
+                /\.exe$/i,
+                /\.dmg$/i,
+                /\.zip$/i,
+                /malware/i,
+                /virus/i,
+                /hack/i,
+                /illegal/i
+            ],
+            rateLimit: {
+                requestsPerSecond: 2,
+                burstSize: 5
+            },
+            safetyChecks: {
+                preventInfiniteLoops: true,
+                preventDestructiveActions: true,
+                requireUserConfirmation: false
+            },
+            ...config
+        };
+        this.rateLimiter = new RateLimiter(this.config.rateLimit.requestsPerSecond, this.config.rateLimit.burstSize);
+    }
+    /**
+     * Validate a crawl action before execution
+     */
+    async validateAction(action, context) {
+        log('Validating action:', action.type, action.target || action.url);
+        // Check rate limiting
+        if (!this.rateLimiter.allowRequest()) {
+            return {
+                allowed: false,
+                reason: 'Rate limit exceeded. Please slow down requests.'
+            };
+        }
+        // Check timeout
+        if (this.isSessionTimedOut(context.sessionStartTime)) {
+            return {
+                allowed: false,
+                reason: `Session timeout exceeded (${this.config.timeoutMs}ms)`
+            };
+        }
+        // Check depth limit
+        if (context.currentDepth > this.config.maxDepth) {
+            return {
+                allowed: false,
+                reason: `Maximum crawl depth exceeded (${this.config.maxDepth})`
+            };
+        }
+        // Validate specific action types
+        switch (action.type) {
+            case 'navigate':
+                return this.validateNavigation(action, context);
+            case 'click':
+                return this.validateClick(action, context);
+            case 'type':
+                return this.validateType(action, context);
+            case 'finish':
+                return { allowed: true };
+            default:
+                return { allowed: true };
+        }
+    }
+    /**
+     * Validate navigation actions
+     */
+    validateNavigation(action, context) {
+        if (!action.url)
+            return { allowed: false, reason: 'Navigation action missing URL' };
+        // URL safety checks
+        const urlCheck = this.validateUrl(action.url);
+        if (!urlCheck.allowed)
+            return urlCheck;
+        // Domain count check
+        const domain = this.extractDomain(action.url);
+        const domainCount = this.domainCounts.get(domain) || 0;
+        if (domainCount >= this.config.maxPagesPerDomain) {
+            return {
+                allowed: false,
+                reason: `Maximum pages per domain exceeded for ${domain} (${this.config.maxPagesPerDomain})`
+            };
+        }
+        // Infinite loop prevention
+        if (this.config.safetyChecks.preventInfiniteLoops) {
+            const loopCheck = this.detectInfiniteLoop(action, context);
+            if (!loopCheck.allowed)
+                return loopCheck;
+        }
+        // Update domain count
+        this.domainCounts.set(domain, domainCount + 1);
+        return { allowed: true };
+    }
+    /**
+     * Validate click actions
+     */
+    validateClick(action, context) {
+        if (!action.target)
+            return { allowed: false, reason: 'Click action missing target selector' };
+        // Check for potentially destructive actions
+        if (this.config.safetyChecks.preventDestructiveActions) {
+            const destructiveCheck = this.checkDestructiveClick(action);
+            if (!destructiveCheck.allowed)
+                return destructiveCheck;
+        }
+        return { allowed: true };
+    }
+    /**
+     * Validate type actions
+     */
+    validateType(action, context) {
+        if (!action.text)
+            return { allowed: false, reason: 'Type action missing text' };
+        // Prevent sensitive data input
+        const sensitivePatterns = [
+            /password/i,
+            /ssn/i,
+            /social.security/i,
+            /credit.card/i,
+            /bank.account/i,
+            /api.key/i,
+            /secret/i,
+            /token/i
+        ];
+        const containsSensitive = sensitivePatterns.some(pattern => pattern.test(action.text) || pattern.test(action.target || ''));
+        if (containsSensitive) {
+            return {
+                allowed: false,
+                reason: 'Type action appears to contain sensitive information'
+            };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Validate URL safety
+     */
+    validateUrl(url) {
+        try {
+            const urlObj = new URL(url);
+            // Protocol check
+            if (!['http:', 'https:'].includes(urlObj.protocol)) {
+                return {
+                    allowed: false,
+                    reason: `Unsafe protocol: ${urlObj.protocol}`
+                };
+            }
+            // Domain whitelist check
+            if (this.config.allowedDomains && this.config.allowedDomains.length > 0) {
+                const isAllowed = this.config.allowedDomains.some(domain => urlObj.hostname === domain || urlObj.hostname.endsWith('.' + domain));
+                if (!isAllowed) {
+                    return {
+                        allowed: false,
+                        reason: `Domain not in allowlist: ${urlObj.hostname}`
+                    };
+                }
+            }
+            // Domain blocklist check
+            if (this.config.blockedDomains) {
+                const isBlocked = this.config.blockedDomains.some(domain => urlObj.hostname === domain || urlObj.hostname.endsWith('.' + domain));
+                if (isBlocked) {
+                    return {
+                        allowed: false,
+                        reason: `Domain is blocked: ${urlObj.hostname}`
+                    };
+                }
+            }
+            // Pattern check
+            if (this.config.blockedPatterns) {
+                const matchedPattern = this.config.blockedPatterns.find(pattern => pattern.test(url));
+                if (matchedPattern) {
+                    return {
+                        allowed: false,
+                        reason: `URL matches blocked pattern: ${matchedPattern.source}`
+                    };
+                }
+            }
+            return { allowed: true };
+        }
+        catch (error) {
+            return {
+                allowed: false,
+                reason: `Invalid URL: ${error}`
+            };
+        }
+    }
+    /**
+     * Detect infinite loop patterns
+     */
+    detectInfiniteLoop(action, context) {
+        if (action.type !== 'navigate' || !action.url)
+            return { allowed: true };
+        // Check if we've visited this URL recently
+        const recentActions = this.actionHistory
+            .filter(h => Date.now() - h.timestamp < 60000) // Last minute
+            .filter(h => h.action.type === 'navigate' && h.action.url === action.url);
+        if (recentActions.length >= 3) {
+            return {
+                allowed: false,
+                reason: `Potential infinite loop detected: visited ${action.url} ${recentActions.length} times in the last minute`
+            };
+        }
+        // Check for back-and-forth patterns
+        const lastFewActions = this.actionHistory.slice(-6)
+            .filter(h => h.action.type === 'navigate')
+            .map(h => h.action.url);
+        if (lastFewActions.length >= 4) {
+            const pattern = [lastFewActions[0], lastFewActions[1]];
+            let patternCount = 0;
+            for (let i = 0; i < lastFewActions.length - 1; i += 2) {
+                if (lastFewActions[i] === pattern[0] && lastFewActions[i + 1] === pattern[1])
+                    patternCount++;
+            }
+            if (patternCount >= 2) {
+                return {
+                    allowed: false,
+                    reason: 'Infinite navigation loop detected between two URLs'
+                };
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check for potentially destructive click actions
+     */
+    checkDestructiveClick(action) {
+        if (!action.target)
+            return { allowed: true };
+        const destructivePatterns = [
+            /delete/i,
+            /remove/i,
+            /cancel/i,
+            /logout/i,
+            /sign.?out/i,
+            /unsubscribe/i,
+            /deactivate/i,
+            /close.account/i,
+            /purchase/i,
+            /buy.now/i,
+            /order.now/i,
+            /submit.payment/i
+        ];
+        const isDestructive = destructivePatterns.some(pattern => pattern.test(action.target) || pattern.test(action.reason || ''));
+        if (isDestructive) {
+            return {
+                allowed: false,
+                reason: 'Click action appears to be potentially destructive'
+            };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Record an action in history
+     */
+    recordAction(action, url) {
+        this.actionHistory.push({
+            action,
+            timestamp: Date.now(),
+            url
+        });
+        // Keep only recent history
+        const cutoff = Date.now() - 3600000; // 1 hour
+        while (this.actionHistory.length > 0 && this.actionHistory[0].timestamp < cutoff)
+            this.actionHistory.shift();
+    }
+    /**
+     * Check if session has timed out
+     */
+    isSessionTimedOut(sessionStartTime) {
+        return Date.now() - sessionStartTime > this.config.timeoutMs;
+    }
+    /**
+     * Extract domain from URL
+     */
+    extractDomain(url) {
+        try {
+            return new URL(url).hostname;
+        }
+        catch {
+            return url;
+        }
+    }
+    /**
+     * Get guardrail statistics
+     */
+    getStats() {
+        return {
+            domainCounts: Object.fromEntries(this.domainCounts),
+            actionsRecorded: this.actionHistory.length,
+            rateLimiterStatus: this.rateLimiter.getStatus(),
+            config: this.config
+        };
+    }
+    /**
+     * Reset guardrail state
+     */
+    reset() {
+        this.domainCounts.clear();
+        this.actionHistory.length = 0;
+        this.rateLimiter.reset();
+    }
+}
+/**
+ * Simple rate limiter implementation
+ */
+class RateLimiter {
+    tokens;
+    lastRefill;
+    maxTokens;
+    refillRate; // tokens per second
+    constructor(tokensPerSecond, burstSize) {
+        this.maxTokens = burstSize;
+        this.refillRate = tokensPerSecond;
+        this.tokens = burstSize;
+        this.lastRefill = Date.now();
+    }
+    allowRequest() {
+        this.refillTokens();
+        if (this.tokens >= 1) {
+            this.tokens -= 1;
+            return true;
+        }
+        return false;
+    }
+    refillTokens() {
+        const now = Date.now();
+        const timePassed = (now - this.lastRefill) / 1000;
+        const tokensToAdd = timePassed * this.refillRate;
+        this.tokens = Math.min(this.maxTokens, this.tokens + tokensToAdd);
+        this.lastRefill = now;
+    }
+    getStatus() {
+        this.refillTokens();
+        return {
+            tokens: Math.floor(this.tokens),
+            maxTokens: this.maxTokens,
+            refillRate: this.refillRate
+        };
+    }
+    reset() {
+        this.tokens = this.maxTokens;
+        this.lastRefill = Date.now();
+    }
+}