@legionai/mcp 1.0.0

package/README.md

@@ -0,0 +1,52 @@
+# Legion MCP Server
+
+Access deployment logs directly from AI agents like Claude Code, Cursor, or Windsurf.
+
+## Installation
+
+```bash
+npm install -g @legion/mcp
+```
+
+## Configuration
+
+Add to your MCP config (e.g., `~/.config/claude/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "legion": {
+      "command": "legion-mcp",
+      "env": {
+        "LEGION_AUTH_SERVER_URL": "https://auth.legion-ai.org",
+        "LEGION_ACCESS_TOKEN": "<your_token>"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `legion_list_projects` | List your connected projects |
+| `legion_connect_project` | Connect a new project |
+| `legion_get_logs` | Fetch logs with filters (level, limit) |
+| `legion_get_errors` | Fetch error-level logs |
+| `legion_disconnect_project` | Remove a project connection |
+
+## Usage Example
+
+Once configured, ask your AI agent:
+
+- "Check my logs for errors"
+- "What's the latest error in my-api?"
+- "Connect my project for debugging"
+
+## Security
+
+- All log access is authenticated via your Legion account
+- You can only access logs for projects you've connected
+- Tokens are encrypted at rest
+- Access is rate-limited (30 requests/minute)

package/package.json

@@ -0,0 +1,23 @@
+{
+    "name": "@legionai/mcp",
+    "version": "1.0.0",
+    "description": "Legion MCP Server - Railway logs access for AI agents",
+    "main": "src/index.js",
+    "bin": {
+        "legion-mcp": "./src/cli.js"
+    },
+    "scripts": {
+        "start": "node src/index.js"
+    },
+    "keywords": [
+        "mcp",
+        "legion",
+        "railway",
+        "ai",
+        "agents"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0"
+    }
+}

package/src/cli.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+/**
+ * Legion CLI Login
+ * 
+ * Opens browser for OAuth login, receives token via local callback.
+ * 
+ * Usage: legion-mcp login
+ */
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execSync } = require('child_process');
+
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.legion');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const LEGION_URL = process.env.LEGION_URL || 'https://legion-ai.org';
+
+/**
+ * Get a random available port
+ */
+function getRandomPort() {
+    return Math.floor(Math.random() * (65535 - 49152) + 49152);
+}
+
+/**
+ * Open URL in default browser
+ */
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+
+    if (platform === 'darwin') {
+        command = `open "${url}"`;
+    } else if (platform === 'win32') {
+        command = `start "${url}"`;
+    } else {
+        command = `xdg-open "${url}"`;
+    }
+
+    try {
+        execSync(command);
+    } catch (err) {
+        console.error('Failed to open browser. Please open this URL manually:');
+        console.error(url);
+    }
+}
+
+/**
+ * Save config to ~/.legion/config.json
+ */
+function saveConfig(config) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+
+    const existing = fs.existsSync(CONFIG_FILE)
+        ? JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'))
+        : {};
+
+    const merged = { ...existing, ...config };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+}
+
+/**
+ * Load config from ~/.legion/config.json
+ */
+function loadConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return {};
+    }
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+}
+
+/**
+ * Start local callback server and wait for token
+ */
+function startCallbackServer(port, state) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            server.close();
+            reject(new Error('Login timed out after 5 minutes'));
+        }, 5 * 60 * 1000);
+
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost:${port}`);
+
+            if (url.pathname === '/callback') {
+                const token = url.searchParams.get('token');
+                const returnedState = url.searchParams.get('state');
+                const error = url.searchParams.get('error');
+
+                if (error) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center;">
+                <h1 style="color: #ef4444;">Login Failed</h1>
+                <p>${error}</p>
+                <p>You can close this window.</p>
+              </body>
+            </html>
+          `);
+                    clearTimeout(timeout);
+                    server.close();
+                    reject(new Error(error));
+                    return;
+                }
+
+                if (returnedState !== state) {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end('<html><body>Invalid state token</body></html>');
+                    return;
+                }
+
+                if (token) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; padding: 40px; text-align: center; background: #0a0a0a; color: white;">
+                <h1 style="color: #22c55e;">✓ Logged in to Legion</h1>
+                <p style="color: #a1a1aa;">You can close this window and return to your terminal.</p>
+              </body>
+            </html>
+          `);
+                    clearTimeout(timeout);
+                    server.close();
+                    resolve(token);
+                } else {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end('<html><body>No token received</body></html>');
+                }
+            } else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+
+        server.listen(port, () => {
+            console.log(`Waiting for login callback on port ${port}...`);
+        });
+
+        server.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}
+
+/**
+ * Main login flow
+ */
+async function login() {
+    console.log('🔐 Logging in to Legion...\n');
+
+    const port = getRandomPort();
+    const state = crypto.randomBytes(16).toString('hex');
+    const callback = `http://localhost:${port}/callback`;
+
+    const loginUrl = `${LEGION_URL}/cli-login?callback=${encodeURIComponent(callback)}&state=${state}`;
+
+    console.log('Opening browser for login...');
+    openBrowser(loginUrl);
+
+    try {
+        const token = await startCallbackServer(port, state);
+
+        // Save token to config
+        saveConfig({
+            access_token: token,
+            auth_server_url: LEGION_URL.replace('legion-ai.org', 'auth.legion-ai.org'),
+        });
+
+        console.log('\n✓ Logged in successfully!');
+        console.log(`  Token saved to ${CONFIG_FILE}`);
+        console.log('\n  You can now use Legion MCP tools.');
+
+    } catch (err) {
+        console.error('\n✗ Login failed:', err.message);
+        process.exit(1);
+    }
+}
+
+/**
+ * Logout: remove saved token
+ */
+function logout() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        const config = loadConfig();
+        delete config.access_token;
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+        console.log('✓ Logged out of Legion');
+    } else {
+        console.log('Not logged in');
+    }
+}
+
+/**
+ * Show current status
+ */
+function status() {
+    const config = loadConfig();
+    if (config.access_token) {
+        console.log('✓ Logged in to Legion');
+        console.log(`  Token: ${config.access_token.substring(0, 10)}...`);
+        console.log(`  Config: ${CONFIG_FILE}`);
+    } else {
+        console.log('✗ Not logged in');
+        console.log('  Run: legion-mcp login');
+    }
+}
+
+// CLI handler
+const command = process.argv[2];
+
+switch (command) {
+    case 'login':
+        login();
+        break;
+    case 'logout':
+        logout();
+        break;
+    case 'status':
+        status();
+        break;
+    default:
+        // If no command, run the MCP server (imported from index.js)
+        require('./index.js');
+}

package/src/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+/**
+ * Legion MCP Server
+ * 
+ * Provides AI agents with access to deployment logs
+ * for iterative debugging and self-healing applications.
+ * 
+ * Usage:
+ *   legion-mcp --auth-server-url https://auth.yourlegion.com --token <legion_token>
+ * 
+ * Or set environment variables:
+ *   LEGION_AUTH_SERVER_URL
+ *   LEGION_ACCESS_TOKEN
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const fs = require('fs');
+const path = require('path');
+
+// Load config from ~/.legion/config.json
+function loadConfig() {
+    const configPath = path.join(process.env.HOME || process.env.USERPROFILE, '.legion', 'config.json');
+    try {
+        if (fs.existsSync(configPath)) {
+            return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+    } catch (err) {
+        console.error('[LEGION MCP] Failed to load config:', err.message);
+    }
+    return {};
+}
+
+const config = loadConfig();
+
+// Configuration (env vars take precedence over config file)
+const AUTH_SERVER_URL = process.env.LEGION_AUTH_SERVER_URL || config.auth_server_url || 'https://auth.legion-ai.org';
+const ACCESS_TOKEN = process.env.LEGION_ACCESS_TOKEN || config.access_token;
+
+// --- API Client ---
+
+async function legionRequest(path, options = {}) {
+    if (!ACCESS_TOKEN) {
+        throw new Error('LEGION_ACCESS_TOKEN not set. Please authenticate first.');
+    }
+
+    const url = `${AUTH_SERVER_URL}${path}`;
+    const response = await fetch(url, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${ACCESS_TOKEN}`,
+            ...options.headers,
+        },
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: response.statusText }));
+        throw new Error(`Legion API error: ${error.message || response.statusText}`);
+    }
+
+    return response.json();
+}
+
+// --- Tool Implementations ---
+
+async function listProjects() {
+    const data = await legionRequest('/v1/railway/projects');
+    return data.projects;
+}
+
+async function connectProject(projectName, projectId, environmentId, projectToken, serviceId) {
+    const data = await legionRequest('/v1/railway/connect', {
+        method: 'POST',
+        body: JSON.stringify({
+            project_name: projectName,
+            project_id: projectId,
+            environment_id: environmentId,
+            project_token: projectToken,
+            service_id: serviceId,
+        }),
+    });
+    return data.connection;
+}
+
+async function getLogs(connectionId, level, limit, filter) {
+    const params = new URLSearchParams();
+    if (level) params.set('level', level);
+    if (limit) params.set('limit', limit.toString());
+    if (filter) params.set('filter', filter);
+
+    const queryString = params.toString();
+    const path = `/v1/railway/logs/${connectionId}${queryString ? '?' + queryString : ''}`;
+
+    return legionRequest(path);
+}
+
+async function disconnectProject(connectionId) {
+    return legionRequest(`/v1/railway/disconnect/${connectionId}`, {
+        method: 'DELETE',
+    });
+}
+
+// --- MCP Server ---
+
+const server = new Server(
+    {
+        name: 'legion',
+        version: '1.0.0',
+    },
+    {
+        capabilities: {
+            tools: {},
+        },
+    }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'legion_list_projects',
+                description: 'List all projects connected to your Legion account for log access',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: [],
+                },
+            },
+            {
+                name: 'legion_connect_project',
+                description: 'Connect a project to your Legion account for deployment log access',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        project_name: {
+                            type: 'string',
+                            description: 'A friendly name for this project (e.g., "my-api")',
+                        },
+                        project_id: {
+                            type: 'string',
+                            description: 'Project ID from your hosting platform',
+                        },
+                        environment_id: {
+                            type: 'string',
+                            description: 'Environment ID (e.g., production, staging)',
+                        },
+                        project_token: {
+                            type: 'string',
+                            description: 'Project access token from your hosting platform settings',
+                        },
+                        service_id: {
+                            type: 'string',
+                            description: 'Optional: Service ID for multi-service projects',
+                        },
+                    },
+                    required: ['project_name', 'project_id', 'environment_id', 'project_token'],
+                },
+            },
+            {
+                name: 'legion_get_logs',
+                description: 'Fetch deployment logs from a connected project. Use this to debug errors and monitor your application.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        connection_id: {
+                            type: 'string',
+                            description: 'The connection ID returned when you connected the project',
+                        },
+                        level: {
+                            type: 'string',
+                            enum: ['error', 'warn', 'info'],
+                            description: 'Filter logs by level. Use "error" to see only errors.',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of log lines to return (default: 100, max: 500)',
+                        },
+                        filter: {
+                            type: 'string',
+                            description: 'Advanced filter syntax (e.g., "@level:error")',
+                        },
+                    },
+                    required: ['connection_id'],
+                },
+            },
+            {
+                name: 'legion_get_errors',
+                description: 'Shortcut to fetch only error-level logs. Use this to quickly identify issues in your deployment.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        connection_id: {
+                            type: 'string',
+                            description: 'The connection ID returned when you connected the project',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of error lines to return (default: 50)',
+                        },
+                    },
+                    required: ['connection_id'],
+                },
+            },
+            {
+                name: 'legion_disconnect_project',
+                description: 'Disconnect a project from your Legion account',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        connection_id: {
+                            type: 'string',
+                            description: 'The connection ID to disconnect',
+                        },
+                    },
+                    required: ['connection_id'],
+                },
+            },
+        ],
+    };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        let result;
+
+        switch (name) {
+            case 'legion_list_projects':
+                result = await listProjects();
+                break;
+
+            case 'legion_connect_project':
+                result = await connectProject(
+                    args.project_name,
+                    args.project_id,
+                    args.environment_id,
+                    args.project_token,
+                    args.service_id
+                );
+                break;
+
+            case 'legion_get_logs':
+                result = await getLogs(
+                    args.connection_id,
+                    args.level,
+                    args.limit,
+                    args.filter
+                );
+                break;
+
+            case 'legion_get_errors':
+                result = await getLogs(
+                    args.connection_id,
+                    'error',
+                    args.limit || 50,
+                    null
+                );
+                break;
+
+            case 'legion_disconnect_project':
+                result = await disconnectProject(args.connection_id);
+                break;
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[LEGION MCP] Server started');
+}
+
+main().catch((error) => {
+    console.error('[LEGION MCP] Fatal error:', error);
+    process.exit(1);
+});