ScriptFlow MCP Server: Persistent Multi-Language Script Management

Overview

ScriptFlow MCP Server provides a small persistent service for managing, searching, editing, and executing multi-language scripts. It is designed to act as a script registry and execution engine that integrates with Model Context Protocol (MCP) clients and other developer workflows. Scripts (Bash, Python, Node.js, TypeScript, etc.) are stored persistently, indexed for fast search, and can be executed on demand with configurable runtime controls.

The server is useful when you want to codify repetitive developer or operator tasks as reusable script artifacts and expose them to human users, automation pipelines, or LLM-driven agents. By combining persistent storage, text search, and runtime sandboxing controls, ScriptFlow helps centralize operational scripts while enabling programmatic access and auditability.

Features

• Persistent script storage (filesystem-backed or configurable storage directory).
• Multi-language support: Bash, Python, Node.js, TypeScript.
• Full-text search across script names, tags, and contents.
• REST API and MCP-compatible endpoints for integration with LLM tools and agents.
• Script versioning and metadata (name, description, language, tags).
• Script execution with timeout, environment control, and resource limits.
• CLI/web-friendly endpoints for CRUD operations on scripts.
• Optional access control and audit logging hooks.

Installation / Configuration

Prerequisites:

• Node.js (>=14)
• Python 3 (for Python script execution)
• Bash shell
• Node.js runtime and optionally ts-node for TypeScript execution

Basic install and run:

# Clone repo
git clone https://github.com/yanmxa/scriptflow-mcp.git
cd scriptflow-mcp

# Install dependencies
npm install

# Copy example env and edit if needed
cp .env.example .env

# Start the server (development)
npm run dev

# Or build & run production
npm run build
npm start

Example .env (key options):

PORT=3000
STORAGE_DIR=./data/scripts
SEARCH_INDEX=./data/index
MAX_RUNTIME_SECONDS=10
ALLOW_EXECUTION=true
MCP_PORT=3500

Notes:

• Ensure required runtimes are available on the host (python3, node, bash).
• For TypeScript execution, have ts-node installed globally or as a dependency.
• Configure MAX_RUNTIME_SECONDS and other limits to control resource use in production.

Available Resources

The server exposes HTTP endpoints and an MCP-compatible interface for programmatic access. Typical REST endpoints include:

• GET /scripts — list scripts
• POST /scripts — create a new script
• GET /scripts/:id — fetch a script
• PUT /scripts/:id — update a script
• DELETE /scripts/:id — remove a script
• POST /scripts/:id/run — execute a script (payload may include input, env overrides)
• GET /search?q=… — search across scripts

Script metadata fields:

• id, name, description, language, tags, code, createdAt, updatedAt

Execution options (sent with run request):

• timeoutSeconds, input (stdin), env (map of environment variables), cwd

Repository and examples:

• GitHub: https://github.com/yanmxa/scriptflow-mcp

Use Cases

1. Centralized devops snippets

   • Store common maintenance commands (backup, rotate logs, deploy tasks) as auditable scripts. Use POST /scripts/:id/run from a CI server to execute deployment steps.

   Example create payload:

   {
     "name": "backup-db",
     "language": "bash",
     "description": "Dump and compress the PostgreSQL DB",
     "code": "pg_dump $DB_NAME | gzip > /backups/db-$(date +%F).sql.gz",
     "tags": ["backup", "db"]
   }
   

2. LLM-driven automation

   • Connect an MCP-capable LLM agent to the server so the model can search available scripts and run them as tools. This lets AI assistants execute verified scripts instead of generating ad-hoc shell commands.

3. Developer productivity toolkit

   • Save frequently used local scripts (lint, test-run, scaffolders) and call them from IDE tasks or a web UI. Search by tag or code snippet to quickly find the right helper.

4. Safe experimentation sandbox

   • Run short experiments (data munging, quick Python transforms) with timeouts and environment isolation. Limit MAX_RUNTIME_SECONDS and control which scripts are executable to reduce risk.

5. Integration with pipelines

   • Use the server as a script catalog for CI/CD workflows. Reference script IDs in pipeline definitions to ensure consistent behavior across environments.

Notes and Best Practices

• Always configure execution limits and use layered access control when enabling script execution in multi-tenant environments.
• Keep sensitive data out of script bodies; prefer passing secrets via environment variables managed by your orchestration layer.
• Install and lock interpreter versions on the host to ensure reproducible execution (e.g., Node, Python).
• Use tags and good descriptions to make scripts discoverable via search.

This server is targeted at teams that want a small, searchable repository of executable scripts combined with MCP integration so models and tools can discover and run verified script artifacts.