mortgram-bridge 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# Mortgram Bridge
+
+A lightweight log forwarder that streams your OpenClaw agent logs to the Mortgram Dashboard for real-time observability.
+
+## Installation
+
+```bash
+npx @mortgram/bridge --token YOUR_SECRET_TOKEN
+```
+
+Or install globally:
+
+```bash
+npm install -g @mortgram/bridge
+mortgram-bridge --token YOUR_SECRET_TOKEN
+```
+
+## Usage
+
+```bash
+# Basic usage
+npx @mortgram/bridge --token abc123-def456-789
+
+# With custom URL (for self-hosted)
+npx @mortgram/bridge --token YOUR_TOKEN --url https://your-dashboard.com
+
+# With custom log path
+npx @mortgram/bridge --token YOUR_TOKEN --log-path ./my-agent.log
+
+# Verbose mode
+npx @mortgram/bridge --token YOUR_TOKEN --verbose
+```
+
+## Environment Variables
+
+You can also configure via environment variables:
+
+```bash
+export MORTGRAM_TOKEN=your-secret-token
+export MORTGRAM_URL=https://mortgram.vercel.app
+
+npx @mortgram/bridge
+```
+
+## How It Works
+
+1. **Watches** your OpenClaw log file (`~/.openclaw/logs/agent.log`)
+2. **Parses** each new log line to identify:
+   - 🧠 **Thoughts** - Agent reasoning and analysis
+   - ⚡ **Actions** - Tool calls and function executions
+   - ✅ **Results** - Outputs and completions
+   - ❌ **Errors** - Failures and exceptions
+3. **Forwards** structured data to the Mortgram Dashboard
+4. **Updates** your agent's heartbeat for live status
+
+## Log File Locations
+
+The bridge automatically searches for logs in:
+
+- `~/.openclaw/logs/agent.log` (default)
+- `~/.openclaw/agent.log`
+- `~/.config/openclaw/agent.log`
+- `./agent.log`
+- `./logs/agent.log`
+
+## Requirements
+
+- Node.js 18+
+- A Mortgram account with an agent token
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,374 @@
+#!/usr/bin/env node
+
+/**
+ * Mortgram Bridge
+ * 
+ * A lightweight agent that tails your OpenClaw logs and forwards them
+ * to the Mortgram Dashboard for real-time observability.
+ * 
+ * Usage:
+ *   npx @mortgram/bridge --token YOUR_SECRET_TOKEN
+ *   
+ * Environment Variables:
+ *   MORTGRAM_TOKEN - Your agent's secret token
+ *   MORTGRAM_URL   - Dashboard URL (default: https://mortgram.vercel.app)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// ANSI colors for terminal output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    red: '\x1b[31m',
+};
+
+// Parse command line arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {
+        token: process.env.MORTGRAM_TOKEN || null,
+        url: process.env.MORTGRAM_URL || 'https://mortgram.vercel.app',
+        logPath: null,
+        verbose: false,
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--token' && args[i + 1]) {
+            config.token = args[++i];
+        } else if (arg === '--url' && args[i + 1]) {
+            config.url = args[++i];
+        } else if (arg === '--log-path' && args[i + 1]) {
+            config.logPath = args[++i];
+        } else if (arg === '--verbose' || arg === '-v') {
+            config.verbose = true;
+        } else if (arg === '--help' || arg === '-h') {
+            printHelp();
+            process.exit(0);
+        }
+    }
+
+    return config;
+}
+
+function printHelp() {
+    console.log(`
+${colors.bright}${colors.cyan}Mortgram Bridge${colors.reset} - OpenClaw Log Forwarder
+
+${colors.bright}Usage:${colors.reset}
+  npx @mortgram/bridge --token YOUR_TOKEN
+
+${colors.bright}Options:${colors.reset}
+  --token <token>     Your Mortgram secret token (required)
+  --url <url>         Dashboard URL (default: https://mortgram.vercel.app)
+  --log-path <path>   Custom log file path
+  --verbose, -v       Show detailed output
+  --help, -h          Show this help message
+
+${colors.bright}Environment Variables:${colors.reset}
+  MORTGRAM_TOKEN      Your secret token
+  MORTGRAM_URL        Dashboard URL
+
+${colors.bright}Example:${colors.reset}
+  npx @mortgram/bridge --token abc123-def456-789
+`);
+}
+
+// Find the OpenClaw log file
+function findLogFile(customPath) {
+    if (customPath && fs.existsSync(customPath)) {
+        return customPath;
+    }
+
+    const possiblePaths = [
+        path.join(os.homedir(), '.openclaw', 'logs', 'agent.log'),
+        path.join(os.homedir(), '.openclaw', 'agent.log'),
+        path.join(os.homedir(), '.config', 'openclaw', 'agent.log'),
+        './agent.log',
+        './logs/agent.log',
+    ];
+
+    for (const logPath of possiblePaths) {
+        if (fs.existsSync(logPath)) {
+            return logPath;
+        }
+    }
+
+    return null;
+}
+
+// Parse log line to determine type
+function parseLogLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+
+    let stepType = 'log';
+    let level = 'info';
+    let message = trimmed;
+    const metadata = {};
+
+    // Detect log type from common patterns
+    const lowerLine = trimmed.toLowerCase();
+
+    // Thought patterns
+    if (
+        lowerLine.includes('thinking') ||
+        lowerLine.includes('reasoning') ||
+        lowerLine.includes('analyzing') ||
+        lowerLine.includes('[thought]') ||
+        lowerLine.includes('considering')
+    ) {
+        stepType = 'thought';
+        level = 'info';
+    }
+    // Tool/Action patterns
+    else if (
+        lowerLine.includes('calling') ||
+        lowerLine.includes('executing') ||
+        lowerLine.includes('tool:') ||
+        lowerLine.includes('[action]') ||
+        lowerLine.includes('[tool]') ||
+        lowerLine.includes('function:') ||
+        lowerLine.includes('running')
+    ) {
+        stepType = 'action';
+        level = 'info';
+
+        // Try to extract tool name
+        const toolMatch = trimmed.match(/(?:tool|function|calling|executing)[:\s]+([a-zA-Z_]+)/i);
+        if (toolMatch) {
+            metadata.tool_name = toolMatch[1];
+        }
+    }
+    // Result patterns
+    else if (
+        lowerLine.includes('result:') ||
+        lowerLine.includes('[result]') ||
+        lowerLine.includes('response:') ||
+        lowerLine.includes('output:') ||
+        lowerLine.includes('completed') ||
+        lowerLine.includes('success')
+    ) {
+        stepType = 'result';
+        level = 'success';
+    }
+    // Error patterns
+    else if (
+        lowerLine.includes('error') ||
+        lowerLine.includes('failed') ||
+        lowerLine.includes('exception') ||
+        lowerLine.includes('[error]')
+    ) {
+        stepType = 'error';
+        level = 'error';
+    }
+    // Warning patterns
+    else if (
+        lowerLine.includes('warning') ||
+        lowerLine.includes('warn') ||
+        lowerLine.includes('[warn]')
+    ) {
+        level = 'warning';
+    }
+    // Debug patterns
+    else if (
+        lowerLine.includes('[debug]') ||
+        lowerLine.includes('debug:')
+    ) {
+        level = 'debug';
+    }
+
+    // Try to parse JSON if present
+    const jsonMatch = trimmed.match(/\{[\s\S]*\}$/);
+    if (jsonMatch) {
+        try {
+            const jsonData = JSON.parse(jsonMatch[0]);
+            Object.assign(metadata, jsonData);
+            message = trimmed.replace(jsonMatch[0], '').trim() || message;
+        } catch {
+            // Not valid JSON, keep original message
+        }
+    }
+
+    return {
+        type: stepType,
+        level,
+        message,
+        metadata,
+        timestamp: new Date().toISOString(),
+    };
+}
+
+// Send log to Mortgram API
+async function sendToMortgram(config, logData) {
+    const endpoint = `${config.url}/api/ingest`;
+
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-mortgram-token': config.token,
+            },
+            body: JSON.stringify({
+                type: logData.type === 'thought' || logData.type === 'action' || logData.type === 'result' || logData.type === 'error'
+                    ? 'step'
+                    : 'log',
+                level: logData.level,
+                message: logData.message,
+                metadata: logData.metadata,
+                step_type: logData.type,
+            }),
+        });
+
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+
+        return true;
+    } catch (error) {
+        if (config.verbose) {
+            console.error(`${colors.red}[ERROR]${colors.reset} Failed to send: ${error.message}`);
+        }
+        return false;
+    }
+}
+
+// Main bridge function
+async function startBridge(config) {
+    console.log(`
+${colors.cyan}${colors.bright}╔═══════════════════════════════════════╗
+║         MORTGRAM BRIDGE v1.0.0        ║
+╚═══════════════════════════════════════╝${colors.reset}
+`);
+
+    // Validate token
+    if (!config.token) {
+        console.error(`${colors.red}[ERROR]${colors.reset} No token provided. Use --token or set MORTGRAM_TOKEN`);
+        process.exit(1);
+    }
+
+    // Find log file
+    const logPath = findLogFile(config.logPath);
+    if (!logPath) {
+        console.log(`${colors.yellow}[WARN]${colors.reset} Log file not found. Creating watcher for default path...`);
+        const defaultPath = path.join(os.homedir(), '.openclaw', 'logs', 'agent.log');
+
+        // Create directory structure
+        const logDir = path.dirname(defaultPath);
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+
+        // Create empty file
+        if (!fs.existsSync(defaultPath)) {
+            fs.writeFileSync(defaultPath, '');
+        }
+
+        config.logPath = defaultPath;
+    } else {
+        config.logPath = logPath;
+    }
+
+    console.log(`${colors.green}[✓]${colors.reset} Token: ${config.token.slice(0, 8)}...`);
+    console.log(`${colors.green}[✓]${colors.reset} URL: ${config.url}`);
+    console.log(`${colors.green}[✓]${colors.reset} Watching: ${config.logPath}`);
+    console.log(`\n${colors.dim}Waiting for logs...${colors.reset}\n`);
+
+    // Send initial connection log
+    await sendToMortgram(config, {
+        type: 'log',
+        level: 'success',
+        message: 'Mortgram Bridge connected',
+        metadata: {
+            bridge_version: '1.0.0',
+            log_path: config.logPath,
+            platform: process.platform,
+        },
+    });
+
+    console.log(`${colors.green}[✓]${colors.reset} Connection established!\n`);
+
+    // Track file position
+    let fileSize = fs.existsSync(config.logPath) ? fs.statSync(config.logPath).size : 0;
+    let linesForwarded = 0;
+
+    // Watch for file changes
+    const watcher = fs.watch(config.logPath, async (eventType) => {
+        if (eventType !== 'change') return;
+
+        try {
+            const stats = fs.statSync(config.logPath);
+
+            // File was truncated/rotated
+            if (stats.size < fileSize) {
+                fileSize = 0;
+            }
+
+            // Read new content
+            if (stats.size > fileSize) {
+                const stream = fs.createReadStream(config.logPath, {
+                    start: fileSize,
+                    end: stats.size,
+                    encoding: 'utf8',
+                });
+
+                const rl = readline.createInterface({ input: stream });
+
+                for await (const line of rl) {
+                    const parsed = parseLogLine(line);
+                    if (parsed) {
+                        const success = await sendToMortgram(config, parsed);
+                        if (success) {
+                            linesForwarded++;
+                            const typeColors = {
+                                thought: colors.magenta,
+                                action: colors.blue,
+                                result: colors.green,
+                                error: colors.red,
+                                log: colors.dim,
+                            };
+                            const typeColor = typeColors[parsed.type] || colors.dim;
+                            console.log(`${typeColor}[${parsed.type.toUpperCase()}]${colors.reset} ${parsed.message.slice(0, 60)}${parsed.message.length > 60 ? '...' : ''}`);
+                        }
+                    }
+                }
+
+                fileSize = stats.size;
+            }
+        } catch (error) {
+            if (config.verbose) {
+                console.error(`${colors.red}[ERROR]${colors.reset} ${error.message}`);
+            }
+        }
+    });
+
+    // Handle graceful shutdown
+    const shutdown = () => {
+        console.log(`\n${colors.yellow}[INFO]${colors.reset} Shutting down bridge...`);
+        console.log(`${colors.dim}Forwarded ${linesForwarded} log entries${colors.reset}`);
+        watcher.close();
+        process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    // Keep process alive
+    process.stdin.resume();
+}
+
+// Run the bridge
+const config = parseArgs();
+startBridge(config);

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "mortgram-bridge",
+    "version": "1.0.0",
+    "description": "OpenClaw log bridge for Mortgram Dashboard - Real-time agent observability",
+    "main": "index.js",
+    "bin": {
+        "mortgram-bridge": "./index.js"
+    },
+    "scripts": {
+        "start": "node index.js"
+    },
+    "keywords": [
+        "mortgram",
+        "openclaw",
+        "ai-agent",
+        "observability",
+        "logging",
+        "monitoring",
+        "telemetry"
+    ],
+    "author": "Mortgram",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/yusef1975/agent-dashboard"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "files": [
+        "index.js",
+        "README.md"
+    ]
+}