@zy_zhou/vps-mcp-server 1.0.0

package/README.md

@@ -0,0 +1,131 @@
+# VPS MCP Server 🚀
+
+[English](#english) | [中文说明](#chinese)
+
+<a name="english"></a>
+## English Description
+
+An advanced Model Context Protocol (MCP) server designed to turn your VPS into a powerful AI-driven remote workstation. It provides a comprehensive set of tools for command execution, file management, system monitoring, and persistent session handling.
+
+### 🌟 Key Features
+
+- **Command Execution**: Run shell commands and scripts (Python/Node/Bash) in a sandboxed environment.
+- **Advanced File Management**: Read, write, patch, search, and visualize directory trees.
+- **Persistent Sessions**: Based on `tmux`, allowing AI to handle long-running or interactive tasks.
+- **System Monitoring**: Real-time process listing and system resource tracking.
+- **Network Capabilities**: Make HTTP requests or download large files directly to the VPS.
+- **Flexible Transport**: Supports both `stdio` and `SSE` (HTTP) modes.
+
+### ⚡️ Quick Run with npx
+
+You can run the server directly without cloning the repository:
+
+```bash
+# stdio mode (for local use)
+npx github:zhy1369800/vps-mcp-server
+
+# SSE mode (for remote VPS deployment)
+MODE=sse PORT=8080 MCP_TOKEN=your-token npx github:zhy1369800/vps-mcp-server
+```
+
+### 🛠 Tools Reference
+
+| Tool | Description |
+|------|-------------|
+| `run_command` | Execute a one-off shell command. |
+| `run_script` | Run Python, Bash, or Node.js code blocks. |
+| `list_files` | List directory contents or generate a recursive tree. |
+| `file_read/write` | Read from or write to files. |
+| `file_patch` | Edit specific parts of a file (Token-efficient). |
+| `file_search` | Search for files by name or content (grep). |
+| `get_system_status` | Get OS info, memory, disk, or process list. |
+| `http_request` | Fetch web content or download files to disk. |
+| `session_*` | Start, exec, read, or stop persistent `tmux` sessions. |
+
+### 🚀 Manual Installation
+
+1. **Clone & Install**:
+   ```bash
+   git clone https://github.com/zhy1369800/vps-mcp-server.git
+   cd vps-mcp-server
+   npm install
+   ```
+2. **Build**:
+   ```bash
+   npm run build
+   ```
+3. **Configure**:
+   Copy `.env.example` to `.env` and set your `MCP_TOKEN`.
+4. **Run** (SSE Mode):
+   ```bash
+   MODE=sse PORT=8080 npm start
+   ```
+
+---
+
+<a name="chinese"></a>
+## 中文说明
+
+这是一个先进的 **Model Context Protocol (MCP)** 服务端，旨在将您的 VPS 变成一个强大的 AI 驱动远程工作站。它为 AI Agent 提供了完整的指令执行、文件管理、系统监控和持久化会话处理工具集。
+
+### 🌟 核心特性
+
+- **指令执行**：在沙箱环境中运行 Shell 命令和脚本（Python/Node/Bash）。
+- **高级文件管理**：支持读取、写入、增量补丁（Patch）、全文搜索及目录树可视化。
+- **持久化会话**：基于 `tmux` 实现，允许 AI 处理耗时较长或需要交互的任务。
+- **系统监控**：实时查看进程列表、CPU、内存及磁盘占用情况。
+- **网络增强**：直接从 VPS 发起 HTTP 请求或下载大文件到磁盘。
+- **双模式支持**：支持 `stdio` 本地调用和 `SSE` (HTTP) 远程调用模式。
+
+### ⚡️ 使用 npx 快速运行
+
+无需克隆代码即可直接启动服务：
+
+```bash
+# stdio 模式 (本地使用)
+npx github:zhy1369800/vps-mcp-server
+
+# SSE 模式 (远程 VPS 部署)
+MODE=sse PORT=8080 MCP_TOKEN=your-token npx github:zhy1369800/vps-mcp-server
+```
+
+### 🛠 工具列表
+
+| 工具名称 | 功能描述 |
+|----------|----------|
+| `run_command` | 执行一次性 Shell 命令。 |
+| `run_script` | 运行 Python、Bash 或 Node.js 代码块。 |
+| `list_files` | 列出目录内容或生成递归目录树（支持排除目录）。 |
+| `file_read/write` | 读取或写入文件。 |
+| `file_patch` | 增量编辑文件特定部分（极度节省 Token）。 |
+| `file_search` | 按名称或内容搜索文件（基于 grep）。 |
+| `get_system_status` | 获取系统概览、内存、磁盘或进程列表。 |
+| `http_request` | 发起 HTTP 请求或下载文件到 VPS 磁盘。 |
+| `session_*` | 启动、执行、读取或停止持久化的 `tmux` 会话。 |
+
+### 🚀 手动安装步骤
+
+1. **克隆与安装**：
+   ```bash
+   git clone https://github.com/zhy1369800/vps-mcp-server.git
+   cd vps-mcp-server
+   npm install
+   ```
+2. **编译**：
+   ```bash
+   npm run build
+   ```
+3. **配置环境**：
+   将 `.env.example` 复制为 `.env` 并设置您的 `MCP_TOKEN`。
+4. **启动服务** (SSE 模式)：
+   ```bash
+   MODE=sse PORT=8080 npm start
+   ```
+
+### 🛡 安全建议
+
+建议在 Docker 容器中运行此服务，并配合 Nginx 反向代理（配置 SSL 证书）以确保通信安全。
+
+### 📄 开源协议
+
+MIT

package/dist/sandbox/executor.js

@@ -0,0 +1,59 @@
+import { spawn } from 'child_process';
+import { DEFAULT_TIMEOUT, MAX_BUFFER } from '../utils.js';
+export function executeCommand(command, options) {
+    return new Promise((resolve) => {
+        const timeoutMs = options?.timeout ?? DEFAULT_TIMEOUT;
+        const cwd = options?.cwd ?? process.cwd();
+        const env = { ...process.env, ...options?.env };
+        const child = spawn('sh', ['-c', command], {
+            cwd,
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: false,
+            detached: false,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGKILL');
+        }, timeoutMs);
+        child.stdout.on('data', (data) => {
+            const chunk = data.toString();
+            stdout += chunk;
+            if (stdout.length > MAX_BUFFER)
+                stdout = stdout.slice(-MAX_BUFFER);
+            options?.onStdout?.(chunk);
+        });
+        child.stderr.on('data', (data) => {
+            const chunk = data.toString();
+            stderr += chunk;
+            if (stderr.length > MAX_BUFFER)
+                stderr = stderr.slice(-MAX_BUFFER);
+            options?.onStderr?.(chunk);
+        });
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({
+                success: code === 0 && !timedOut,
+                timedOut,
+                exitCode: code,
+                stdout,
+                stderr,
+                error: timedOut ? 'Command timed out' : code !== 0 ? `Exit code ${code}` : undefined,
+            });
+        });
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({
+                success: false,
+                timedOut: false,
+                exitCode: null,
+                stdout,
+                stderr,
+                error: err.message,
+            });
+        });
+    });
+}

package/dist/sandbox/tmux-manager.js

@@ -0,0 +1,48 @@
+import { execAsync } from '../utils.js';
+export class TmuxManager {
+    static SESSION_PREFIX = 'mcp-';
+    static async startSession(sessionId, command, cwd) {
+        const fullId = this.SESSION_PREFIX + sessionId;
+        const cdCmd = cwd ? `cd ${cwd} &&` : '';
+        await execAsync(`tmux new-session -d -s ${fullId} "${cdCmd} ${command}"`);
+    }
+    static async execInSession(sessionId, command) {
+        const fullId = this.SESSION_PREFIX + sessionId;
+        const { stdout } = await execAsync(`tmux send-keys -t ${fullId} "${command}" Enter`);
+        return stdout;
+    }
+    static async readSession(sessionId) {
+        const fullId = this.SESSION_PREFIX + sessionId;
+        try {
+            const { stdout } = await execAsync(`tmux capture-pane -p -t ${fullId}`);
+            return stdout;
+        }
+        catch {
+            return '';
+        }
+    }
+    static async stopSession(sessionId) {
+        const fullId = this.SESSION_PREFIX + sessionId;
+        try {
+            await execAsync(`tmux kill-session -t ${fullId}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async sessionExists(sessionId) {
+        const fullId = this.SESSION_PREFIX + sessionId;
+        try {
+            await execAsync(`tmux has-session -t ${fullId}`);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static async listSessions() {
+        const { stdout } = await execAsync(`tmux list-sessions -F "#{session_name}"`);
+        return stdout.split('\n').filter(s => s.startsWith(this.SESSION_PREFIX)).map(s => s.slice(this.SESSION_PREFIX.length));
+    }
+}

package/dist/server.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import 'dotenv/config';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import express from 'express';
+import { handleRunCommand, handleRunScript, handleFileRead, handleFileWrite, handleListFiles, handleFileDelete, handleFileSearch, handleFilePatch, handleSessionStart, handleSessionExec, handleSessionRead, handleSessionStop, handleGetSystemStatus, handleKillProcess, handleHttpRequest, } from './tools/index.js';
+const TOKEN = process.env.MCP_TOKEN || 'change-me';
+const server = new Server({
+    name: 'vps-sandbox',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'run_command',
+            description: '在 VPS 沙盒中执行 Shell 命令（一次性）',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: '要执行的命令' },
+                    cwd: { type: 'string', description: '工作目录，默认 /tmp' },
+                    timeout: { type: 'number', description: '超时(ms)，默认 30000' },
+                },
+                required: ['command'],
+            },
+        },
+        {
+            name: 'run_script',
+            description: '执行脚本代码 (python/bash/node)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    language: { type: 'string', enum: ['python', 'bash', 'node', 'sh'] },
+                    code: { type: 'string', description: '脚本源码' },
+                    timeout: { type: 'number', description: '超时(ms)' },
+                },
+                required: ['language', 'code'],
+            },
+        },
+        {
+            name: 'file_read',
+            description: '读取文件内容',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filepath: { type: 'string' },
+                },
+                required: ['filepath'],
+            },
+        },
+        {
+            name: 'file_write',
+            description: '写入文件',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filepath: { type: 'string' },
+                    content: { type: 'string' },
+                },
+                required: ['filepath', 'content'],
+            },
+        },
+        {
+            name: 'file_patch',
+            description: '增量编辑文件（搜索并替换）',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filepath: { type: 'string' },
+                    search: { type: 'string', description: '要搜索的原始文本' },
+                    replace: { type: 'string', description: '要替换成的新文本' },
+                },
+                required: ['filepath', 'search', 'replace'],
+            },
+        },
+        {
+            name: 'list_files',
+            description: '列出目录内容或递归获取目录树',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    dirpath: { type: 'string', description: '目录路径' },
+                    recursive: { type: 'boolean', description: '是否递归列出 (树状结构)' },
+                    depth: { type: 'number', description: '递归深度' },
+                    exclude: { type: 'array', items: { type: 'string' }, description: '排除的目录' },
+                },
+            },
+        },
+        {
+            name: 'file_delete',
+            description: '删除文件或目录',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filepath: { type: 'string' },
+                },
+                required: ['filepath'],
+            },
+        },
+        {
+            name: 'file_search',
+            description: '搜索文件名或文件内容',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    dirpath: { type: 'string', description: '起始目录' },
+                    query: { type: 'string', description: '搜索关键词' },
+                    type: { type: 'string', enum: ['name', 'content'], description: '搜索类型' },
+                    recursive: { type: 'boolean', description: '是否递归搜索' },
+                },
+                required: ['query'],
+            },
+        },
+        {
+            name: 'get_system_status',
+            description: '获取 VPS 系统状态或进程列表',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: ['summary', 'processes'], description: 'summary: 系统概览, processes: 进程列表' },
+                    sort: { type: 'string', enum: ['cpu', 'mem'], description: '进程排序方式' },
+                },
+            },
+        },
+        {
+            name: 'kill_process',
+            description: '终止指定 PID 的进程',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    pid: { type: 'number' },
+                    force: { type: 'boolean' },
+                },
+                required: ['pid'],
+            },
+        },
+        {
+            name: 'http_request',
+            description: '发起 HTTP 请求或下载文件',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string' },
+                    method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'DELETE'] },
+                    headers: { type: 'object' },
+                    body: { type: 'any' },
+                    savePath: { type: 'string', description: '如果提供，则将响应保存到此文件路径' },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'session_start',
+            description: '启动一个持久 tmux 会话',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    sessionId: { type: 'string' },
+                    command: { type: 'string' },
+                    cwd: { type: 'string' },
+                },
+                required: ['sessionId'],
+            },
+        },
+        {
+            name: 'session_exec',
+            description: '向已有会话发送命令',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    sessionId: { type: 'string' },
+                    command: { type: 'string' },
+                },
+                required: ['sessionId', 'command'],
+            },
+        },
+        {
+            name: 'session_read',
+            description: '读取会话的最近输出',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    sessionId: { type: 'string' },
+                    maxChars: { type: 'number' },
+                },
+                required: ['sessionId'],
+            },
+        },
+        {
+            name: 'session_stop',
+            description: '停止并销毁会话',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    sessionId: { type: 'string' },
+                },
+                required: ['sessionId'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        let result;
+        switch (name) {
+            case 'run_command':
+                result = await handleRunCommand(args);
+                break;
+            case 'run_script':
+                result = await handleRunScript(args);
+                break;
+            case 'file_read':
+                result = await handleFileRead(args);
+                break;
+            case 'file_write':
+                result = await handleFileWrite(args);
+                break;
+            case 'file_patch':
+                result = await handleFilePatch(args);
+                break;
+            case 'list_files':
+                result = await handleListFiles(args);
+                break;
+            case 'file_delete':
+                result = await handleFileDelete(args);
+                break;
+            case 'file_search':
+                result = await handleFileSearch(args);
+                break;
+            case 'get_system_status':
+                result = await handleGetSystemStatus(args);
+                break;
+            case 'kill_process':
+                result = await handleKillProcess(args);
+                break;
+            case 'http_request':
+                result = await handleHttpRequest(args);
+                break;
+            case 'session_start':
+                result = await handleSessionStart(args);
+                break;
+            case 'session_exec':
+                result = await handleSessionExec(args);
+                break;
+            case 'session_read':
+                result = await handleSessionRead(args);
+                break;
+            case 'session_stop':
+                result = await handleSessionStop(args);
+                break;
+            default: throw new Error(`Unknown tool: ${name}`);
+        }
+        return result;
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+const mode = process.env.MODE || 'stdio';
+if (mode === 'sse') {
+    const app = express();
+    app.use(express.json());
+    let transport = null;
+    app.get('/sse', async (req, res) => {
+        const auth = (req.headers.authorization?.replace('Bearer ', '') || req.query.token);
+        if (auth !== TOKEN) {
+            res.status(401).json({ error: 'Unauthorized' });
+            return;
+        }
+        transport = new SSEServerTransport('/messages', res);
+        await server.connect(transport);
+    });
+    app.post('/messages', async (req, res) => {
+        const auth = req.headers.authorization?.replace('Bearer ', '');
+        if (auth !== TOKEN) {
+            res.status(401).json({ error: 'Unauthorized' });
+            return;
+        }
+        if (transport) {
+            await transport.handlePostMessage(req, res, req.body);
+        }
+        else {
+            res.status(400).json({ error: 'No active SSE transport' });
+        }
+    });
+    app.listen(process.env.PORT || 8080, () => {
+        console.error(`MCP SSE server running on port ${process.env.PORT || 8080}`);
+    });
+}
+else {
+    const transport = new StdioServerTransport();
+    server.connect(transport);
+    console.error('MCP stdio server running');
+}

package/dist/tools/command.js

@@ -0,0 +1,25 @@
+import { executeCommand } from '../sandbox/executor.js';
+export async function handleRunCommand(args) {
+    const { command, cwd, timeout = 30000 } = args;
+    if (!command)
+        throw new Error('command is required');
+    let output = '';
+    const result = await executeCommand(command, {
+        cwd: cwd || '/tmp',
+        timeout,
+        onStdout: (chunk) => { output += chunk; },
+        onStderr: (chunk) => { output += chunk; },
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: result.success,
+                    exitCode: result.exitCode,
+                    output: output.slice(-20000),
+                    timedOut: result.timedOut,
+                    error: result.error,
+                }, null, 2),
+            }],
+    };
+}

package/dist/tools/files.js

@@ -0,0 +1,70 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { executeCommand } from '../sandbox/executor.js';
+export async function handleFileRead(args) {
+    const { filepath } = args;
+    if (!filepath)
+        throw new Error('filepath required');
+    const content = await fs.readFile(filepath, 'utf-8');
+    return { content: [{ type: 'text', text: content }] };
+}
+export async function handleFileWrite(args) {
+    const { filepath, content } = args;
+    if (!filepath)
+        throw new Error('filepath required');
+    await fs.mkdir(path.dirname(filepath), { recursive: true });
+    await fs.writeFile(filepath, content);
+    return { content: [{ type: 'text', text: `Written to ${filepath}` }] };
+}
+export async function handleFileDelete(args) {
+    const { filepath } = args;
+    if (!filepath)
+        throw new Error('filepath required');
+    await fs.rm(filepath, { recursive: true, force: true });
+    return { content: [{ type: 'text', text: `Deleted ${filepath}` }] };
+}
+export async function handleFileSearch(args) {
+    const { dirpath = '.', query, type = 'name', recursive = true } = args;
+    if (!query)
+        throw new Error('query required');
+    let command = '';
+    if (type === 'name') {
+        command = `find ${dirpath} ${recursive ? '' : '-maxdepth 1'} -name "*${query}*"`;
+    }
+    else {
+        command = `grep -rnE "${query}" ${dirpath} ${recursive ? '' : '--maxdepth=0'}`;
+    }
+    const result = await executeCommand(command, { timeout: 15000 });
+    const output = result.stdout || result.stderr || (result.success ? '(no matches)' : 'Search failed');
+    return {
+        content: [{ type: 'text', text: output.slice(0, 20000) }]
+    };
+}
+export async function handleFilePatch(args) {
+    const { filepath, search, replace } = args;
+    if (!filepath || search === undefined || replace === undefined)
+        throw new Error('filepath, search, and replace required');
+    const content = await fs.readFile(filepath, 'utf-8');
+    if (!content.includes(search)) {
+        throw new Error(`Search string not found in ${filepath}`);
+    }
+    const newContent = content.replace(search, replace);
+    await fs.writeFile(filepath, newContent);
+    return {
+        content: [{ type: 'text', text: `Successfully patched ${filepath}` }]
+    };
+}
+export async function handleListFiles(args) {
+    const { dirpath = '.', recursive = false, depth = 3, exclude = [] } = args;
+    if (recursive) {
+        let excludePart = exclude.map((item) => `-not -path "*/${item}/*"`).join(' ');
+        const command = `find ${dirpath} -maxdepth ${depth} -not -path "*/.*" ${excludePart} | sed -e "s/[^-][^\/]*\//  |/g" -e "s/| / |-/g"`;
+        const result = await executeCommand(command, { timeout: 10000 });
+        return { content: [{ type: 'text', text: result.stdout || '(no results)' }] };
+    }
+    else {
+        const entries = await fs.readdir(dirpath, { withFileTypes: true });
+        const list = entries.map(e => `${e.isDirectory() ? '📁' : '📄'} ${e.name}`).join('\n');
+        return { content: [{ type: 'text', text: list || '(empty)' }] };
+    }
+}

package/dist/tools/index.js

@@ -0,0 +1,6 @@
+export * from './command.js';
+export * from './script.js';
+export * from './files.js';
+export * from './session.js';
+export * from './system.js';
+export * from './network.js';

package/dist/tools/network.js

@@ -0,0 +1,42 @@
+import { executeCommand } from '../sandbox/executor.js';
+import path from 'path';
+import fs from 'fs/promises';
+export async function handleHttpRequest(args) {
+    const { url, method = 'GET', body, headers = {}, savePath } = args;
+    if (!url)
+        throw new Error('url required');
+    let command = `curl -sL -X ${method} "${url}"`;
+    if (savePath) {
+        const dir = path.dirname(savePath);
+        await fs.mkdir(dir, { recursive: true });
+        command = `curl -L -o "${savePath}" "${url}"`;
+    }
+    else {
+        Object.entries(headers).forEach(([key, value]) => {
+            command += ` -H "${key}: ${value}"`;
+        });
+        if (body) {
+            const bodyStr = typeof body === 'string' ? body : JSON.stringify(body);
+            command += ` -d '${bodyStr.replace(/'/g, "'\\''")}'`;
+            if (!headers['Content-Type']) {
+                command += ` -H "Content-Type: application/json"`;
+            }
+        }
+    }
+    const result = await executeCommand(command, { timeout: savePath ? 60000 : 20000 });
+    if (savePath) {
+        if (result.success) {
+            return { content: [{ type: 'text', text: `Successfully downloaded to ${savePath}` }] };
+        }
+        else {
+            throw new Error(`Download failed: ${result.stderr || result.error}`);
+        }
+    }
+    const output = result.stdout || result.stderr || (result.success ? '(empty response)' : 'Request failed');
+    return {
+        content: [{
+                type: 'text',
+                text: output.slice(0, 30000)
+            }]
+    };
+}

package/dist/tools/script.js

@@ -0,0 +1,43 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { executeCommand } from '../sandbox/executor.js';
+const RUNNERS = {
+    python: 'python3',
+    bash: 'bash',
+    node: 'node',
+    sh: 'sh',
+};
+export async function handleRunScript(args) {
+    const { language, code, timeout = 30000 } = args;
+    if (!language || !code)
+        throw new Error('language and code required');
+    const runner = RUNNERS[language];
+    if (!runner)
+        throw new Error(`Unsupported language: ${language}`);
+    const tmpDir = '/tmp/mcp-scripts';
+    await fs.mkdir(tmpDir, { recursive: true });
+    const extMap = { python: 'py', bash: 'sh', node: 'js', sh: 'sh' };
+    const fileName = `script_${Date.now()}.${extMap[language] || 'txt'}`;
+    const filePath = path.join(tmpDir, fileName);
+    await fs.writeFile(filePath, code, { mode: 0o644 });
+    let output = '';
+    const result = await executeCommand(`${runner} ${filePath}`, {
+        cwd: tmpDir,
+        timeout,
+        onStdout: (chunk) => { output += chunk; },
+        onStderr: (chunk) => { output += chunk; },
+    });
+    await fs.unlink(filePath).catch(() => { });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: result.success,
+                    exitCode: result.exitCode,
+                    output: output.slice(-20000),
+                    timedOut: result.timedOut,
+                    error: result.error,
+                }, null, 2),
+            }],
+    };
+}

package/dist/tools/session.js

@@ -0,0 +1,52 @@
+import { TmuxManager } from '../sandbox/tmux-manager.js';
+export async function handleSessionStart(args) {
+    const { sessionId, command, cwd } = args;
+    if (!sessionId)
+        throw new Error('sessionId required');
+    const exists = await TmuxManager.sessionExists(sessionId);
+    if (exists) {
+        return { content: [{
+                    type: 'text',
+                    text: `Session ${sessionId} already exists`
+                }] };
+    }
+    await TmuxManager.startSession(sessionId, command || 'bash', cwd);
+    return { content: [{
+                type: 'text',
+                text: `Session ${sessionId} started`
+            }] };
+}
+export async function handleSessionExec(args) {
+    const { sessionId, command } = args;
+    if (!sessionId || !command)
+        throw new Error('sessionId and command required');
+    const exists = await TmuxManager.sessionExists(sessionId);
+    if (!exists)
+        throw new Error(`Session ${sessionId} not found`);
+    await TmuxManager.execInSession(sessionId, command);
+    return { content: [{
+                type: 'text',
+                text: `Command sent to session ${sessionId}`
+            }] };
+}
+export async function handleSessionRead(args) {
+    const { sessionId, maxChars = 20000 } = args;
+    if (!sessionId)
+        throw new Error('sessionId required');
+    const transcript = await TmuxManager.readSession(sessionId);
+    const truncated = transcript.length > maxChars ? transcript.slice(-maxChars) : transcript;
+    return { content: [{
+                type: 'text',
+                text: truncated
+            }] };
+}
+export async function handleSessionStop(args) {
+    const { sessionId } = args;
+    if (!sessionId)
+        throw new Error('sessionId required');
+    await TmuxManager.stopSession(sessionId);
+    return { content: [{
+                type: 'text',
+                text: `Session ${sessionId} stopped`
+            }] };
+}

package/dist/tools/system.js

@@ -0,0 +1,34 @@
+import { executeCommand } from '../sandbox/executor.js';
+export async function handleGetSystemStatus(args) {
+    const { type = 'summary', sort = 'cpu' } = args;
+    if (type === 'summary') {
+        const command = 'echo "OS Info:"; uname -a; echo "\nUptime:"; uptime; echo "\nMemory Usage:"; free -h; echo "\nDisk Usage:"; df -h /';
+        const result = await executeCommand(command);
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }]
+        };
+    }
+    else {
+        let command = 'ps aux --sort=-%cpu | head -n 31';
+        if (sort === 'mem') {
+            command = 'ps aux --sort=-%mem | head -n 31';
+        }
+        const result = await executeCommand(command);
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }]
+        };
+    }
+}
+export async function handleKillProcess(args) {
+    const { pid, force = false } = args;
+    if (!pid)
+        throw new Error('pid required');
+    const command = `kill ${force ? '-9' : ''} ${pid}`;
+    const result = await executeCommand(command);
+    if (result.success) {
+        return { content: [{ type: 'text', text: `Successfully sent kill signal to process ${pid}` }] };
+    }
+    else {
+        throw new Error(`Failed to kill process: ${result.stderr || result.error}`);
+    }
+}

package/dist/utils.js

@@ -0,0 +1,21 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+export const execAsync = promisify(exec);
+export const DEFAULT_TIMEOUT = 30000;
+export const MAX_BUFFER = 10 * 1024 * 1024;
+export function quoteShell(arg) {
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+export function truncateOutput(output, maxLen = 20000) {
+    if (output.length <= maxLen)
+        return output;
+    return output.slice(0, maxLen) + '\n... [truncated]';
+}
+export function safeJsonStringify(obj) {
+    try {
+        return JSON.stringify(obj, null, 2);
+    }
+    catch {
+        return String(obj);
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@zy_zhou/vps-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP Server for VPS sandbox execution — run commands, scripts, and manage sessions remotely via MCP protocol. Supports stdio and SSE transports.",
+  "type": "module",
+  "main": "dist/server.js",
+  "bin": {
+    "vps-mcp-server": "dist/server.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "start": "node dist/server.js",
+    "dev": "tsx src/server.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "dotenv": "^16.4.5",
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/express": "^4.17.21",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.3"
+  }
+}