@darbotlabs/darbot-browser-mcp 0.2.0 → 1.3.0

package/lib/health.js

@@ -0,0 +1,178 @@
+/**
+ * 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 { packageJSON } from './package.js';
+/**
+ * Health check service for monitoring system status
+ */
+export class HealthCheckService {
+    checks = new Map();
+    constructor() {
+        this.registerDefaultChecks();
+    }
+    /**
+     * Registers a health check function
+     */
+    registerCheck(name, checkFn) {
+        this.checks.set(name, checkFn);
+    }
+    /**
+     * Runs all registered health checks
+     */
+    async runChecks() {
+        const timestamp = new Date().toISOString();
+        const checks = [];
+        for (const [name, checkFn] of this.checks) {
+            try {
+                const startTime = Date.now();
+                const result = await checkFn();
+                result.duration = Date.now() - startTime;
+                checks.push(result);
+            }
+            catch (error) {
+                checks.push({
+                    name,
+                    status: 'fail',
+                    duration: 0,
+                    details: { error: error instanceof Error ? error.message : 'Unknown error' }
+                });
+            }
+        }
+        const overallStatus = this.determineOverallStatus(checks);
+        return {
+            status: overallStatus,
+            timestamp,
+            version: packageJSON.version,
+            checks
+        };
+    }
+    /**
+     * HTTP handler for health check endpoint
+     */
+    async handleHealthCheck(req, res) {
+        try {
+            const health = await this.runChecks();
+            const statusCode = health.status === 'healthy' ? 200 :
+                health.status === 'degraded' ? 200 : 503;
+            res.statusCode = statusCode;
+            res.setHeader('Content-Type', 'application/json');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.end(JSON.stringify(health, null, 2));
+        }
+        catch (error) {
+            res.statusCode = 500;
+            res.setHeader('Content-Type', 'application/json');
+            res.end(JSON.stringify({
+                status: 'unhealthy',
+                timestamp: new Date().toISOString(),
+                error: error instanceof Error ? error.message : 'Health check failed'
+            }));
+        }
+    }
+    /**
+     * Lightweight readiness probe for Kubernetes/Azure
+     */
+    async handleReadinessCheck(req, res) {
+        try {
+            // Quick check - just verify service is responding
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end('OK');
+        }
+        catch (error) {
+            res.statusCode = 503;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end('Service Unavailable');
+        }
+    }
+    /**
+     * Liveness probe for Kubernetes/Azure
+     */
+    async handleLivenessCheck(req, res) {
+        try {
+            // Basic liveness check
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end('Alive');
+        }
+        catch (error) {
+            res.statusCode = 503;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end('Dead');
+        }
+    }
+    registerDefaultChecks() {
+        // Memory usage check
+        this.registerCheck('memory', async () => {
+            const memUsage = process.memoryUsage();
+            const heapUsedMB = Math.round(memUsage.heapUsed / 1024 / 1024);
+            const heapTotalMB = Math.round(memUsage.heapTotal / 1024 / 1024);
+            // Warn if heap usage > 95%, fail if > 98% (relaxed for Playwright workloads)
+            const usagePercent = (heapUsedMB / heapTotalMB) * 100;
+            const status = usagePercent > 98 ? 'fail' : usagePercent > 95 ? 'warn' : 'pass';
+            return {
+                name: 'memory',
+                status,
+                duration: 0,
+                details: {
+                    heapUsedMB,
+                    heapTotalMB,
+                    usagePercent: Math.round(usagePercent)
+                }
+            };
+        });
+        // Process uptime check
+        this.registerCheck('uptime', async () => {
+            const uptimeSeconds = process.uptime();
+            return {
+                name: 'uptime',
+                status: 'pass',
+                duration: 0,
+                details: {
+                    uptimeSeconds: Math.round(uptimeSeconds),
+                    uptimeHours: Math.round(uptimeSeconds / 3600 * 100) / 100
+                }
+            };
+        });
+        // Node.js version check
+        this.registerCheck('runtime', async () => {
+            return {
+                name: 'runtime',
+                status: 'pass',
+                duration: 0,
+                details: {
+                    nodeVersion: process.version,
+                    platform: process.platform,
+                    arch: process.arch
+                }
+            };
+        });
+    }
+    determineOverallStatus(checks) {
+        const hasFailures = checks.some(check => check.status === 'fail');
+        const hasWarnings = checks.some(check => check.status === 'warn');
+        if (hasFailures)
+            return 'unhealthy';
+        if (hasWarnings)
+            return 'degraded';
+        return 'healthy';
+    }
+}
+/**
+ * Creates a health check service with default checks
+ */
+export function createHealthCheckService() {
+    return new HealthCheckService();
+}

package/lib/httpServer.js

@@ -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.

package/lib/index.js

@@ -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.

package/lib/javascript.js

@@ -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.

package/lib/manualPromise.js

@@ -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.

package/lib/memory.js

@@ -0,0 +1,273 @@
+/**
+ * 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 crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import debug from 'debug';
+const log = debug('darbot:memory');
+/**
+ * Local file-based memory storage implementation
+ */
+export class LocalMemoryStorage {
+    storagePath;
+    maxStates;
+    constructor(config = {}) {
+        this.storagePath = config.storagePath || path.join(process.cwd(), '.darbot', 'memory');
+        this.maxStates = config.maxStates || 1000;
+        this.ensureStorageDirectory();
+    }
+    ensureStorageDirectory() {
+        if (!fs.existsSync(this.storagePath))
+            fs.mkdirSync(this.storagePath, { recursive: true });
+    }
+    getStatePath(stateHash) {
+        return path.join(this.storagePath, `${stateHash}.json`);
+    }
+    async storeState(state) {
+        try {
+            const statePath = this.getStatePath(state.stateHash);
+            await fs.promises.writeFile(statePath, JSON.stringify(state, null, 2));
+            log('Stored state:', state.stateHash, state.url);
+            // Clean up old states if we exceed the limit
+            await this.cleanupOldStates();
+        }
+        catch (error) {
+            log('Error storing state:', error);
+            throw error;
+        }
+    }
+    async getState(stateHash) {
+        try {
+            const statePath = this.getStatePath(stateHash);
+            if (!fs.existsSync(statePath))
+                return null;
+            const data = await fs.promises.readFile(statePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            log('Error reading state:', error);
+            return null;
+        }
+    }
+    async hasState(stateHash) {
+        const statePath = this.getStatePath(stateHash);
+        return fs.existsSync(statePath);
+    }
+    async getAllStates() {
+        try {
+            const files = await fs.promises.readdir(this.storagePath);
+            const states = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = path.join(this.storagePath, file);
+                    try {
+                        const data = await fs.promises.readFile(filePath, 'utf-8');
+                        states.push(JSON.parse(data));
+                    }
+                    catch (error) {
+                        log('Error reading state file:', file, error);
+                    }
+                }
+            }
+            return states.sort((a, b) => a.timestamp - b.timestamp);
+        }
+        catch (error) {
+            log('Error reading states:', error);
+            return [];
+        }
+    }
+    async getUnvisitedLinks() {
+        const states = await this.getAllStates();
+        const visited = new Set(states.filter(s => s.visited).map(s => s.url));
+        const allLinks = new Set();
+        states.forEach(state => {
+            state.links.forEach(link => {
+                if (!visited.has(link))
+                    allLinks.add(link);
+            });
+        });
+        return Array.from(allLinks);
+    }
+    async clear() {
+        try {
+            const files = await fs.promises.readdir(this.storagePath);
+            await Promise.all(files.map(file => fs.promises.unlink(path.join(this.storagePath, file))));
+            log('Cleared memory storage');
+        }
+        catch (error) {
+            log('Error clearing storage:', error);
+            throw error;
+        }
+    }
+    async cleanupOldStates() {
+        const states = await this.getAllStates();
+        if (states.length <= this.maxStates)
+            return;
+        // Remove oldest states
+        const toRemove = states.slice(0, states.length - this.maxStates);
+        await Promise.all(toRemove.map(state => fs.promises.unlink(this.getStatePath(state.stateHash)).catch(() => { })));
+        log(`Cleaned up ${toRemove.length} old states`);
+    }
+}
+/**
+ * Darbot Memory MCP connector (placeholder for future implementation)
+ */
+export class DarbotMemoryStorage {
+    constructor(config = {}) {
+        // TODO: Implement darbot-memory-mcp integration
+        log('Darbot Memory MCP connector not yet implemented, falling back to local storage');
+    }
+    async storeState(state) {
+        // TODO: Send to darbot-memory-mcp server
+        throw new Error('Darbot Memory MCP connector not yet implemented');
+    }
+    async getState(stateHash) {
+        // TODO: Query darbot-memory-mcp server
+        throw new Error('Darbot Memory MCP connector not yet implemented');
+    }
+    async hasState(stateHash) {
+        // TODO: Check darbot-memory-mcp server
+        throw new Error('Darbot Memory MCP connector not yet implemented');
+    }
+    async getAllStates() {
+        // TODO: Fetch from darbot-memory-mcp server
+        throw new Error('Darbot Memory MCP connector not yet implemented');
+    }
+    async getUnvisitedLinks() {
+        // TODO: Query darbot-memory-mcp server
+        throw new Error('Darbot Memory MCP connector not yet implemented');
+    }
+    async clear() {
+        // TODO: Clear darbot-memory-mcp storage
+        throw new Error('Darbot Memory MCP connector not yet implemented');
+    }
+}
+/**
+ * Memory manager with optional darbot-memory-mcp integration
+ */
+export class MemoryManager {
+    storage;
+    config;
+    constructor(config = { enabled: true }) {
+        this.config = config;
+        if (!config.enabled) {
+            this.storage = new LocalMemoryStorage(); // Dummy storage that won't be used
+            return;
+        }
+        switch (config.connector) {
+            case 'darbot-memory-mcp':
+                try {
+                    this.storage = new DarbotMemoryStorage();
+                }
+                catch (error) {
+                    log('Failed to initialize darbot-memory-mcp connector, falling back to local storage:', error);
+                    this.storage = new LocalMemoryStorage({
+                        storagePath: config.storagePath,
+                        maxStates: config.maxStates
+                    });
+                }
+                break;
+            case 'local':
+            default:
+                this.storage = new LocalMemoryStorage({
+                    storagePath: config.storagePath,
+                    maxStates: config.maxStates
+                });
+                break;
+        }
+    }
+    /**
+     * Generate a hash for the current page state
+     */
+    static stateHash(domSnapshot) {
+        return crypto.createHash('sha256').update(domSnapshot).digest('hex').substring(0, 16);
+    }
+    /**
+     * Store a crawl state with screenshot
+     */
+    async storeState(url, title, domSnapshot, screenshot, links = []) {
+        if (!this.config.enabled)
+            return '';
+        const stateHash = MemoryManager.stateHash(domSnapshot);
+        let screenshotPath;
+        // Save screenshot if provided
+        if (screenshot) {
+            const screenshotDir = path.join(process.cwd(), '.darbot', 'screenshots');
+            if (!fs.existsSync(screenshotDir))
+                fs.mkdirSync(screenshotDir, { recursive: true });
+            screenshotPath = path.join(screenshotDir, `${stateHash}.png`);
+            await fs.promises.writeFile(screenshotPath, screenshot);
+        }
+        const state = {
+            url,
+            title,
+            stateHash,
+            timestamp: Date.now(),
+            screenshot: screenshotPath,
+            links,
+            visited: true
+        };
+        await this.storage.storeState(state);
+        return stateHash;
+    }
+    /**
+     * Check if we've seen this state before
+     */
+    async hasState(domSnapshot) {
+        if (!this.config.enabled)
+            return false;
+        const stateHash = MemoryManager.stateHash(domSnapshot);
+        return await this.storage.hasState(stateHash);
+    }
+    /**
+     * Get a stored state by hash
+     */
+    async getState(stateHash) {
+        if (!this.config.enabled)
+            return null;
+        return await this.storage.getState(stateHash);
+    }
+    /**
+     * Get all stored states
+     */
+    async getAllStates() {
+        if (!this.config.enabled)
+            return [];
+        return await this.storage.getAllStates();
+    }
+    /**
+     * Get unvisited links for BFS crawling
+     */
+    async getUnvisitedLinks() {
+        if (!this.config.enabled)
+            return [];
+        return await this.storage.getUnvisitedLinks();
+    }
+    /**
+     * Clear all stored states
+     */
+    async clear() {
+        if (!this.config.enabled)
+            return;
+        await this.storage.clear();
+    }
+    /**
+     * Check if memory is enabled
+     */
+    get enabled() {
+        return this.config.enabled;
+    }
+}