eigen-skills 2.0.3 → 2.1.0

package/README.md

@@ -1,22 +1,73 @@
 # eigen-skills
 
-**EigenCompute Agent Skill — Deploy and manage apps in Trusted Execution Environments (TEE) with one command**
+**EigenCompute MCP Server & Agent Skill — Deploy and manage apps in Trusted Execution Environments (TEE)**
 
 ---
 
 ## What is this?
 
-**eigen-skills** gives AI agents (Claude Code, OpenClaw, etc.) the ability to deploy and manage apps on [EigenCompute](https://eigencloud.xyz) — hardware-isolated TEEs powered by Intel TDX with encrypted secrets and cryptographic attestation.
+**eigen-skills** gives AI agents the ability to deploy and manage apps on [EigenCompute](https://eigencloud.xyz) — hardware-isolated TEEs powered by Intel TDX with encrypted secrets and cryptographic attestation.
+
+Works with:
+- **MCP Clients** — Cursor, Claude Desktop, Antigravity, Cline, etc.
+- **Claude Code** — via SKILL.md standard
 
 ```bash
 npm install -g eigen-skills@latest
 ```
 
-> Install once, then any compatible AI agent can deploy to EigenCompute automatically via the `SKILL.md` standard.
+---
+
+## MCP Server Setup (Cursor, Claude Desktop, etc.)
+
+### 1. Install
+
+```bash
+npm install -g eigen-skills
+```
+
+### 2. Configure your MCP client
+
+**Cursor** (`~/.cursor/mcp.json`):
+```json
+{
+  "mcpServers": {
+    "eigencompute": {
+      "command": "eigen-mcp"
+    }
+  }
+}
+```
+
+**Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "eigencompute": {
+      "command": "eigen-mcp"
+    }
+  }
+}
+```
+
+### 3. Available MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `eigencompute_deploy` | Deploy Docker image to TEE |
+| `eigencompute_list` | List all deployed apps |
+| `eigencompute_info` | Get app status, IP, details |
+| `eigencompute_logs` | View app logs |
+| `eigencompute_start` | Start stopped app |
+| `eigencompute_stop` | Stop running app |
+| `eigencompute_terminate` | Destroy app permanently |
+| `eigencompute_whoami` | Check CLI auth status |
+| `eigencompute_env_set` | Set sealed secrets |
+| `eigencompute_upgrade` | Upgrade running app |
 
 ---
 
-## Setup
+## Prerequisites
 
 ```bash
 npm install -g @layr-labs/ecloud-cli@latest   # minimum v0.4.3

package/bin/eigen-mcp.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../src/mcp-server.js');

package/index.js

@@ -1,23 +1,14 @@
 /**
- * eigen-skills — EigenLayer data & infra skills for AI agents
+ * eigen-skills — EigenCompute TEE deployment for AI agents
  *
- * Install:  npx skills add zeeshan8281/eigen-skills
- * Usage:    Agents discover SKILL.md files in skills/ automatically.
- *           For programmatic use, require this module.
+ * MCP Server:  eigen-mcp (for Cursor, Claude Desktop, etc.)
+ * Claude Code: Discovers SKILL.md automatically
+ * Programmatic: require('eigen-skills')
  */
 
-const EigenAPI = require('./skills/eigen-restaking/scripts/eigen-api');
-const AVSAPI = require('./skills/eigen-avs/scripts/avs-api');
-const RewardsAPI = require('./skills/eigen-rewards/scripts/rewards-api');
-const DelegationAPI = require('./skills/eigen-delegation/scripts/delegation-api');
 const EigenCompute = require('./skills/eigen-compute/scripts/compute-api');
-const EigenDA = require('./skills/eigen-da/scripts/da-api');
 
 module.exports = {
-    EigenAPI,
-    AVSAPI,
-    RewardsAPI,
-    DelegationAPI,
     EigenCompute,
-    EigenDA,
+    default: EigenCompute,
 };

package/package.json

@@ -1,8 +1,12 @@
 {
     "name": "eigen-skills",
-    "version": "2.0.3",
-    "description": "Deploy and manage apps on EigenCompute TEE — trusted execution environments with hardware-level isolation, encrypted secrets, and attestation",
+    "version": "2.1.0",
+    "description": "Deploy and manage apps on EigenCompute TEE — trusted execution environments with hardware-level isolation, encrypted secrets, and attestation. Works as MCP server for Cursor/Claude Desktop or as Claude Code skill.",
     "main": "index.js",
+    "bin": {
+        "eigen-mcp": "./bin/eigen-mcp.js",
+        "eigencompute": "./bin/eigen-mcp.js"
+    },
     "agents": {
         "skills": "skills/"
     },
@@ -10,22 +14,26 @@
         "postinstall": "node scripts/postinstall.js",
         "test": "node scripts/test-all.js",
         "demo": "node scripts/demo.js",
-        "ui": "node server.js"
+        "ui": "node server.js",
+        "mcp": "node src/mcp-server.js"
     },
     "keywords": [
+        "mcp",
+        "mcp-server",
+        "model-context-protocol",
         "eigenlayer",
-        "eigen",
-        "restaking",
-        "avs",
+        "eigencompute",
+        "tee",
         "agent-skills",
         "ai-agent",
         "claude",
-        "openclaw",
-        "eigenexplorer"
+        "cursor",
+        "antigravity"
     ],
     "author": "zeeshan8281",
     "license": "MIT",
     "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.29.0",
         "axios": "^1.7.0",
         "dotenv": "^17.3.1",
         "express": "^5.2.1",

package/src/mcp-server.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+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 { execSync, exec } = require('child_process');
+
+const INSTANCE_TYPES = [
+    'g1-micro-1v',
+    'g1-medium-1v',
+    'g1-custom-2-4096s',
+    'g1-standard-2s',
+    'g1-standard-4t',
+    'g1-standard-8t'
+];
+
+function checkCLI() {
+    try {
+        execSync('ecloud --version', { stdio: 'pipe' });
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function runCommand(cmd, timeout = 60000) {
+    return new Promise((resolve, reject) => {
+        exec(`ecloud ${cmd}`, { encoding: 'utf-8', timeout }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(stderr || error.message));
+            } else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+}
+
+async function runDeploy(args) {
+    const { name, image, instanceType = 'g1-standard-4t', envFile } = args;
+
+    let cmd = `compute app deploy --name "${name}" --image-ref "${image}" --skip-profile --instance-type ${instanceType} --log-visibility public --resource-usage-monitoring enable --verbose`;
+
+    if (envFile) {
+        cmd += ` --env-file "${envFile}"`;
+    }
+
+    return new Promise((resolve, reject) => {
+        exec(`echo "n" | ecloud ${cmd}`, { encoding: 'utf-8', timeout: 300000 }, (error, stdout, stderr) => {
+            if (error) {
+                reject(new Error(stderr || error.message));
+            } else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+}
+
+const TOOLS = [
+    {
+        name: 'eigencompute_whoami',
+        description: 'Check which address the ecloud CLI is authenticated as',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'eigencompute_list',
+        description: 'List all deployed EigenCompute apps',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+    {
+        name: 'eigencompute_info',
+        description: 'Get detailed info for a specific app including status and IP',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to get info for'
+                }
+            },
+            required: ['appId']
+        }
+    },
+    {
+        name: 'eigencompute_logs',
+        description: 'View logs for a specific app',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to get logs for'
+                }
+            },
+            required: ['appId']
+        }
+    },
+    {
+        name: 'eigencompute_start',
+        description: 'Start a stopped app',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to start'
+                }
+            },
+            required: ['appId']
+        }
+    },
+    {
+        name: 'eigencompute_stop',
+        description: 'Stop a running app',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to stop'
+                }
+            },
+            required: ['appId']
+        }
+    },
+    {
+        name: 'eigencompute_terminate',
+        description: 'Permanently terminate and destroy an app. This cannot be undone.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to terminate'
+                }
+            },
+            required: ['appId']
+        }
+    },
+    {
+        name: 'eigencompute_deploy',
+        description: 'Deploy a Docker image to EigenCompute TEE. Image must be linux/amd64 and pushed to a public registry.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'App name for the deployment'
+                },
+                image: {
+                    type: 'string',
+                    description: 'Docker image reference (e.g., user/app:latest)'
+                },
+                instanceType: {
+                    type: 'string',
+                    description: 'Instance type. Recommended: g1-standard-4t',
+                    enum: INSTANCE_TYPES,
+                    default: 'g1-standard-4t'
+                },
+                envFile: {
+                    type: 'string',
+                    description: 'Path to .env file for sealed secrets (optional)'
+                }
+            },
+            required: ['name', 'image']
+        }
+    },
+    {
+        name: 'eigencompute_env_set',
+        description: 'Set sealed environment variables for an app. Secrets are encrypted and only decryptable inside the TEE.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to set env vars for'
+                },
+                secrets: {
+                    type: 'object',
+                    description: 'Key-value pairs of secrets to set',
+                    additionalProperties: { type: 'string' }
+                }
+            },
+            required: ['appId', 'secrets']
+        }
+    },
+    {
+        name: 'eigencompute_upgrade',
+        description: 'Upgrade a running app to a new image version',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                appId: {
+                    type: 'string',
+                    description: 'The app ID to upgrade'
+                }
+            },
+            required: ['appId']
+        }
+    }
+];
+
+async function handleToolCall(name, args) {
+    if (!checkCLI()) {
+        return {
+            content: [{
+                type: 'text',
+                text: 'Error: ecloud CLI not installed. Run: npm install -g @layr-labs/ecloud-cli@latest'
+            }],
+            isError: true
+        };
+    }
+
+    try {
+        let result;
+
+        switch (name) {
+            case 'eigencompute_whoami':
+                result = await runCommand('auth whoami');
+                break;
+
+            case 'eigencompute_list':
+                result = await runCommand('compute app list');
+                break;
+
+            case 'eigencompute_info':
+                result = await runCommand(`compute app info ${args.appId}`);
+                break;
+
+            case 'eigencompute_logs':
+                result = await runCommand(`compute app logs ${args.appId}`, 120000);
+                break;
+
+            case 'eigencompute_start':
+                result = await runCommand(`compute app start ${args.appId}`);
+                break;
+
+            case 'eigencompute_stop':
+                result = await runCommand(`compute app stop ${args.appId}`);
+                break;
+
+            case 'eigencompute_terminate':
+                result = await new Promise((resolve, reject) => {
+                    exec(`echo "y" | ecloud compute app terminate ${args.appId}`,
+                        { encoding: 'utf-8', timeout: 60000 },
+                        (error, stdout, stderr) => {
+                            if (error) reject(new Error(stderr || error.message));
+                            else resolve(stdout.trim());
+                        });
+                });
+                break;
+
+            case 'eigencompute_deploy':
+                result = await runDeploy(args);
+                break;
+
+            case 'eigencompute_env_set':
+                const secretPairs = Object.entries(args.secrets)
+                    .map(([k, v]) => `${k}="${v}"`)
+                    .join(' ');
+                result = await runCommand(`compute app env set ${secretPairs}`, 120000);
+                break;
+
+            case 'eigencompute_upgrade':
+                result = await runCommand(`compute app upgrade ${args.appId}`, 300000);
+                break;
+
+            default:
+                return {
+                    content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                    isError: true
+                };
+        }
+
+        return {
+            content: [{ type: 'text', text: result || 'Command completed successfully' }]
+        };
+
+    } catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+
+async function main() {
+    const server = new Server(
+        {
+            name: 'eigencompute',
+            version: '2.1.0'
+        },
+        {
+            capabilities: {
+                tools: {}
+            }
+        }
+    );
+
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: TOOLS };
+    });
+
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return handleToolCall(name, args || {});
+    });
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('EigenCompute MCP server running on stdio');
+}
+
+main().catch(console.error);

package/skills/eigen-avs/SKILL.md

@@ -1,92 +0,0 @@
----
-name: eigen-avs
-description: "Query EigenLayer AVS (Actively Validated Services) — list services, operators per AVS, stakers per AVS, registration events, and operator-sets"
-version: 1.0.0
-metadata:
-  emoji: "🛡️"
-  tags: ["eigenlayer", "avs", "services", "operators", "security"]
-user-invocable: true
----
-
-# EigenLayer AVS Skill
-
-Query live data about Actively Validated Services (AVS) on EigenLayer: service listings, operators securing each AVS, staker delegations, registration events, and operator-sets.
-
-## Data Source
-
-**EigenExplorer API** — `https://api.eigenexplorer.com`
-- Auth: `x-api-token` header (free key at https://developer.eigenexplorer.com)
-
-## When to use this skill
-
-Use when the user asks about:
-- AVS (Actively Validated Services) on EigenLayer
-- Which operators are securing a specific AVS
-- Stakers delegated to a specific AVS
-- AVS registration/deregistration events
-- Operator-sets for an AVS
-- Comparing AVS by TVL, staker count, or APY
-
-## How to query
-
-### Get all AVS (sorted by TVL)
-```bash
-curl -s "https://api.eigenexplorer.com/avs?withTvl=true&sortByTvl=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Search AVS by name
-```bash
-curl -s "https://api.eigenexplorer.com/avs?searchByText=eigenda&withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get a specific AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS?withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get operators registered to an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operators?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get stakers for an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/stakers?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get registration events for an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/events/registration?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get operator-sets for an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operator-sets?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get all AVS addresses (lightweight)
-```bash
-curl -s "https://api.eigenexplorer.com/avs/addresses" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-## Response Format
-
-Format results for the user with:
-- **Bold AVS names** and abbreviated addresses
-- TVL in human-readable form (e.g., "$500M")
-- Number of operators securing the AVS
-- Number of stakers
-- APY if available
-- Active/inactive status for operator registrations
-- Use bullet points, never tables in chat
-
-## Programmatic Usage
-
-```javascript
-const AVSAPI = require('eigen-agent-skills/skills/eigen-avs/scripts/avs-api');
-const api = new AVSAPI('YOUR_API_KEY');
-
-const allAVS = await api.getAllAVS({ sortByTvl: 'desc', take: 10 });
-const operators = await api.getAVSOperators('0xAVS_ADDRESS');
-const stakers = await api.getAVSStakers('0xAVS_ADDRESS');
-```

package/skills/eigen-avs/scripts/avs-api.js

@@ -1,117 +0,0 @@
-/**
- * EigenLayer AVS (Actively Validated Services) API Client
- *
- * Data source: EigenExplorer REST API
- * Covers: AVS listing, detail, operators per AVS, stakers per AVS, registration events
- */
-
-const axios = require('axios');
-
-const MAINNET = 'https://api.eigenexplorer.com';
-const HOLESKY = 'https://api-holesky.eigenexplorer.com';
-
-class AVSAPI {
-    constructor(apiKey, { network = 'mainnet' } = {}) {
-        if (!apiKey) throw new Error('EigenExplorer API key required. Get one free at https://developer.eigenexplorer.com');
-        this.client = axios.create({
-            baseURL: network === 'holesky' ? HOLESKY : MAINNET,
-            headers: {
-                'x-api-token': apiKey,
-                'Content-Type': 'application/json',
-            },
-            timeout: 30000,
-        });
-    }
-
-    // ─── AVS Listing ──────────────────────────────────────
-
-    /**
-     * Get all AVS with optional filtering and sorting.
-     * @param {object} opts
-     * @param {boolean} [opts.withTvl=true]
-     * @param {string}  [opts.searchByText] - search AVS by name
-     * @param {'asc'|'desc'} [opts.sortByTvl]
-     * @param {'asc'|'desc'} [opts.sortByApy]
-     * @param {'asc'|'desc'} [opts.sortByTotalStakers]
-     * @param {number} [opts.skip=0]
-     * @param {number} [opts.take=12]
-     */
-    async getAllAVS(opts = {}) {
-        const params = {
-            withTvl: opts.withTvl !== false ? 'true' : 'false',
-            skip: opts.skip || 0,
-            take: opts.take || 12,
-        };
-        if (opts.searchByText) params.searchByText = opts.searchByText;
-        if (opts.sortByTvl) params.sortByTvl = opts.sortByTvl;
-        if (opts.sortByApy) params.sortByApy = opts.sortByApy;
-        if (opts.sortByTotalStakers) params.sortByTotalStakers = opts.sortByTotalStakers;
-
-        const { data } = await this.client.get('/avs', { params });
-        return data;
-    }
-
-    /**
-     * Get AVS addresses only (lightweight).
-     */
-    async getAVSAddresses() {
-        const { data } = await this.client.get('/avs/addresses');
-        return data;
-    }
-
-    /**
-     * Get detailed info for a single AVS.
-     * @param {string} address - AVS contract address
-     * @param {boolean} [withTvl=true]
-     */
-    async getAVS(address, withTvl = true) {
-        const { data } = await this.client.get(`/avs/${address}`, {
-            params: { withTvl: withTvl ? 'true' : 'false' },
-        });
-        return data;
-    }
-
-    // ─── AVS ↔ Operators ─────────────────────────────────
-
-    /**
-     * Get operators registered to a specific AVS.
-     * @param {string} avsAddress
-     * @param {object} opts
-     */
-    async getAVSOperators(avsAddress, opts = {}) {
-        const { data } = await this.client.get(`/avs/${avsAddress}/operators`, {
-            params: { skip: opts.skip || 0, take: opts.take || 12 },
-        });
-        return data;
-    }
-
-    // ─── AVS ↔ Stakers ───────────────────────────────────
-
-    /**
-     * Get stakers delegated to a specific AVS.
-     * @param {string} avsAddress
-     * @param {object} opts
-     */
-    async getAVSStakers(avsAddress, opts = {}) {
-        const { data } = await this.client.get(`/avs/${avsAddress}/stakers`, {
-            params: { skip: opts.skip || 0, take: opts.take || 12 },
-        });
-        return data;
-    }
-
-    // ─── AVS Registration Events ──────────────────────────
-
-    /**
-     * Get registration/deregistration events for a specific AVS.
-     * @param {string} avsAddress
-     * @param {object} opts
-     */
-    async getAVSRegistrationEvents(avsAddress, opts = {}) {
-        const { data } = await this.client.get(`/avs/${avsAddress}/events/registration-status`, {
-            params: { skip: opts.skip || 0, take: opts.take || 12 },
-        });
-        return data;
-    }
-}
-
-module.exports = AVSAPI;