Expertise Gallery

/**
 * MCP Server - Terminal Tool (No Installation Required)
 * 
 * Enables execution of terminal commands directly via Swipeer AI.
 * Security Note: Only read-only commands (ls, cat, pwd, etc.)
 * and git commands are allowed by default. For full shell control,
 * use the "execute_command" tool.
 * 
 * Created for Swipeer AI
 */
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 } = require("child_process");
const path = require("path");
const fs = require("fs");

const server = new Server(
  { name: "terminal-tool", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

/**
 * Security check: Allows only specific commands
 */
function isAllowedCommand(command) {
  // Read-only commands (safe)
  const readCommands = [
    "ls", "cat", "pwd", "echo", "which", "whoami", "date",
    "head", "tail", "wc", "sort", "uniq", "grep", "find",
    "df", "du", "free", "uptime", "uname", "id", "env",
    "stat", "file", "type", "printenv", "realpath", "readlink",
    "tree", "diff", "cmp", "od", "xxd", "hexdump",
    "node", "npm", "npx", "python", "python3", "pip", "pip3",
  ];
  
  // Extra: git, docker (read-only-like commands)
  const extraCommands = ["git", "docker"];
  
  const allowedCommands = [...readCommands, ...extraCommands];
  
  const cmdBase = command.trim().split(/\s+/)[0];
  const cmdName = path.basename(cmdBase);
  
  return allowedCommands.includes(cmdName);
}

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "list_directory",
      description: "Lists the contents of a directory (like `ls -la`). Parameter: directory (path)",
      inputSchema: {
        type: "object",
        properties: {
          directory: {
            type: "string",
            description: "Directory path (defaults to current directory)",
          },
          all: {
            type: "boolean",
            description: "Show hidden files (-a)",
          },
          long: {
            type: "boolean",
            description: "Detailed view (-l)",
          },
        },
      },
    },
    {
      name: "read_file",
      description: "Displays the contents of a file (like `cat`). Parameter: path",
      inputSchema: {
        type: "object",
        properties: {
          path: {
            type: "string",
            description: "Path to the file",
          },
          lines: {
            type: "number",
            description: "Only show the first N lines",
          },
        },
      },
      required: ["path"],
    },
    {
      name: "current_directory",
      description: "Displays the current working directory (like `pwd`)",
      inputSchema: {
        type: "object",
        properties: {},
      },
    },
    {
      name: "disk_usage",
      description: "Displays disk space usage (like `df -h`). Optional: check a specific path with `du -sh`",
      inputSchema: {
        type: "object",
        properties: {
          path: {
            type: "string",
            description: "Optional: path for detailed disk usage analysis",
          },
        },
      },
    },
    {
      name: "system_info",
      description: "Displays system information (uptime, free -h, uname -a)",
      inputSchema: {
        type: "object",
        properties: {},
      },
    },
    {
      name: "search_files",
      description: "Searches files and directories (like `find` and `grep` combined)",
      inputSchema: {
        type: "object",
        properties: {
          pattern: {
            type: "string",
            description: "Search pattern (filename or text)",
          },
          path: {
            type: "string",
            description: "Starting directory for the search",
          },
          name: {
            type: "boolean",
            description: "Only search by filename (like find -name)",
          },
        },
      },
      required: ["pattern"],
    },
    {
      name: "process_info",
      description: "Displays running processes (like `ps aux`). Optional: filter by name",
      inputSchema: {
        type: "object",
        properties: {
          filter: {
            type: "string",
            description: "Filter by process name (e.g., 'node', 'python')",
          },
        },
      },
    },
    {
      name: "run_command",
      description: "Executes a terminal command. ACCEPTS ONLY READ-ONLY COMMANDS + git + docker for security reasons.",
      inputSchema: {
        type: "object",
        properties: {
          command: {
            type: "string",
            description: "The command to execute",
          },
          cwd: {
            type: "string",
            description: "Working directory (optional)",
          },
        },
      },
      required: ["command"],
    },
    {
      name: "execute_command",
      description: "Executes ANY terminal command (FULL ACCESS). WARNING: Can modify the system! For experienced users only.",
      inputSchema: {
        type: "object",
        properties: {
          command: {
            type: "string",
            description: "The command to execute",
          },
          cwd: {
            type: "string",
            description: "Working directory (optional)",
          },
        },
      },
      required: ["command"],
    },
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  
  try {
    switch (name) {
      case "list_directory": {
        const dir = args?.directory || ".";
        const all = args?.all ? "-a" : "";
        const long = args?.long ? "-l" : "";
        const flags = `${long} ${all}`.trim() || "";
        const cmd = `ls ${flags} "${dir}" 2>&1`;
        const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
        return { content: [{ type: "text", text: output }] };
      }
      
      case "read_file": {
        const filePath = args?.path;
        if (!fs.existsSync(filePath)) {
          throw new Error(`File not found: ${filePath}`);
        }
        if (args?.lines) {
          const cmd = `head -n ${args.lines} "${filePath}"`;
          const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
          return { content: [{ type: "text", text: output }] };
        }
        const cmd = `cat "${filePath}"`;
        const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
        return { content: [{ type: "text", text: output }] };
      }
      
      case "current_directory": {
        const output = execSync("pwd", { encoding: "utf-8" });
        return { content: [{ type: "text", text: `📁 Current directory: ${output.trim()}` }] };
      }
      
      case "disk_usage": {
        if (args?.path) {
          const cmd = `du -sh "${args.path}" 2>&1`;
          const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
          return { content: [{ type: "text", text: `💾 Disk usage:\n${output}` }] };
        }
        const output = execSync("df -h 2>&1", { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
        return { content: [{ type: "text", text: `💾 Disk usage:\n${output}` }] };
      }
      
      case "system_info": {
        const uptime = execSync("uptime", { encoding: "utf-8" });
        const memory = execSync("free -h", { encoding: "utf-8" });
        const uname = execSync("uname -a", { encoding: "utf-8" });
        return {
          content: [
            { type: "text", text: `🖥️ System Information:\n\n⏱️ Uptime:\n${uptime}\n\n🧠 Memory:\n${memory}\n\n🔧 Kernel:\n${uname}` },
          ],
        };
      }
      
      case "search_files": {
        const searchPath = args?.path || ".";
        if (args?.name) {
          const cmd = `find "${searchPath}" -name "${args.pattern}" 2>/dev/null`;
          const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
          return { content: [{ type: "text", text: output || "No results found." }] };
        }
        const cmd = `grep -r "${args.pattern}" "${searchPath}" --include="*" -l 2>/dev/null | head -50`;
        const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
        return { content: [{ type: "text", text: output || "No results found." }] };
      }
      
      case "process_info": {
        let cmd = "ps aux 2>&1";
        if (args?.filter) {
          cmd = `ps aux 2>&1 | grep -i "${args.filter}" | grep -v grep`;
        }
        const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
        return { content: [{ type: "text", text: `📋 Processes:\n${output}` }] };
      }
      
      case "run_command": {
        const cmd = args?.command;
        if (!isAllowedCommand(cmd)) {
          return {
            content: [{
              type: "text",
              text: `❌ Command not allowed: "${cmd.split(/\s+/)[0]}"\n\nAllowed commands: ls, cat, pwd, echo, which, whoami, date, head, tail, wc, grep, find, df, du, free, uptime, uname, id, stat, file, tree, diff, node, npm, python, git, docker\n\n💡 Use "execute_command" for full shell control.`,
            }],
          };
        }
        const options = { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 };
        if (args?.cwd) options.cwd = args.cwd;
        const output = execSync(cmd, options);
        return { content: [{ type: "text", text: `$ ${cmd}\n${output}` }] };
      }
      
      case "execute_command": {
        const cmd = args?.command;
        const options = { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 };
        if (args?.cwd) options.cwd = args.cwd;
        const output = execSync(cmd, options);
        return { content: [{ type: "text", text: `$ ${cmd}\n${output}` }] };
      }
      
      default:
        throw new Error(`Tool "${name}" not found`);
    }
  } catch (error) {
    return {
      content: [{ type: "text", text: `❌ Error: ${error.message}` }],
    };
  }
});

// Start server
const transport = new StdioServerTransport();
server.connect(transport);
console.error("✅ Terminal-Tool MCP Server started!");

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");
const { exec } = require("child_process");

const PROJECTS_DIR = path.join(process.cwd(), "hyperframes_projects");
if (!fs.existsSync(PROJECTS_DIR)) fs.mkdirSync(PROJECTS_DIR, { recursive: true });

const server = new Server(
  { name: "hyperframes-mcp", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

function runCommand(command, cwd) {
  return new Promise((resolve, reject) => {
    exec(command, { cwd }, (error, stdout, stderr) => {
      if (error) reject(new Error(stderr || error.message));
      else resolve(stdout || stderr);
    });
  });
}

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "hyperframes_list_projects",
      description: "List all existing HyperFrames video projects.",
      inputSchema: { type: "object", properties: {} },
    },
    {
      name: "hyperframes_init_project",
      description: "Initialize a new HyperFrames video project with a default template.",
      inputSchema: {
        type: "object",
        properties: { projectName: { type: "string" } },
        required: ["projectName"],
      },
    },
    {
      name: "hyperframes_write_file",
      description: "Write or update an HTML, CSS, or JS file in a HyperFrames project.",
      inputSchema: {
        type: "object",
        properties: {
          projectName: { type: "string" },
          filePath: { type: "string" },
          content: { type: "string" },
        },
        required: ["projectName", "filePath", "content"],
      },
    },
    {
      name: "hyperframes_render_project",
      description: "Render the HyperFrames HTML composition into an MP4/WebM video file.",
      inputSchema: {
        type: "object",
        properties: { projectName: { type: "string" } },
        required: ["projectName"],
      },
    }
  ],
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  try {
    const projName = args.projectName ? args.projectName.replace(/[^a-zA-Z0-9\-_]/g, "") : "";
    const projectPath = path.join(PROJECTS_DIR, projName);

    switch (name) {
      case "hyperframes_list_projects":
        const dirs = fs.readdirSync(PROJECTS_DIR).filter(f => fs.statSync(path.join(PROJECTS_DIR, f)).isDirectory());
        return { content: [{ type: "text", text: `Projects:\n${dirs.join("\n") || "None"}` }] };

      case "hyperframes_init_project":
        fs.mkdirSync(projectPath, { recursive: true });
        await runCommand("npx -y hyperframes init .", projectPath);
        return { content: [{ type: "text", text: `Project '${projName}' initialized.` }] };

      case "hyperframes_write_file":
        const target = path.join(projectPath, args.filePath);
        fs.mkdirSync(path.dirname(target), { recursive: true });
        fs.writeFileSync(target, args.content, "utf8");
        return { content: [{ type: "text", text: `Wrote ${args.filePath}` }] };

      case "hyperframes_render_project":
        const output = await runCommand("npx hyperframes render --format mp4", projectPath);
        return { content: [{ type: "text", text: `Render complete:\n${output}` }] };

      default:
        throw new Error("Tool not found");
    }
  } catch (err) {
    return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
  }
});

server.connect(new StdioServerTransport());