Power your agent
The publisher's own command. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
npx -y @ai-capabilities-suite/[email protected]Claude Code has no install link for a local command. Copy the command below and run it in a terminal.
claude mcp add io.github.digital-defiance-mcp-process -- npx -y @ai-capabilities-suite/mcp-process@0.1.1Run in a terminal.
{ "mcpServers": { "io.github.digital-defiance-mcp-process": { "command": "npx", "args": [ "-y", "@ai-capabilities-suite/[email protected]" ] } }}claude_desktop_config.json
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchFrom the publisher
We've built the most comprehensive suite of MCP servers that give AI agents superpowers they've never had before. This isn't just another tool collection—it's a paradigm shift that transforms AI assistants from code generators into intelligent development partners with , , and .
Process management and monitoring for AI agents with strict security boundaries
📝 Note: All packages have been split into individual Git submodules with their own repositories for better maintainability and independent versioning. Each package now has its own dedicated repository under the Digital-Defiance organization.
25+ debugging tools for AI agents | VS Code Extension | NPM | Docker
Visual UI capture and analysis | VS Code Extension | NPM | Docker
Enterprise-grade process management | VS Code Extension | NPM | Docker
Spec-driven development for GitHub Copilot | Repository
Our flagship MCP ACS Debugger is now available as a native VS Code extension, bringing professional-grade debugging capabilities directly to your editor with zero configuration required.
Why developers love it:
AI agents today are powerful but blind:
Result: You're stuck doing manual work that AI should handle.
The AI Capability Extension Suite provides 5 comprehensive MCP servers that give AI agents professional-grade capabilities, plus Akira:
The most comprehensive debugging interface for AI agents - our flagship product
Repositories: Core | Server | VS Code Extension
✨ Now available as a VS Code extension! Install from Marketplace →
The Problem: AI agents were blind to runtime behavior. They could read your code and suggest fixes, but couldn't see what was actually happening when your code ran. Debugging remained a frustratingly manual process.
The Solution: AI agents can now debug like senior developers—setting breakpoints, inspecting variables, profiling performance, and detecting infinite loops in real-time. Available as both a standalone MCP server and a native VS Code extension with GitHub Copilot integration.
Zero-Configuration Setup:
GitHub Copilot Integration:
Native IDE Integration:
Professional Debugging Workflow:
Language Support:
For Developers:
For AI Agents:
Core Debugging (17 tools):
Advanced Breakpoints (4 tools):
Performance Profiling (4 tools):
Comparison with Other Solutions:
Key Differentiators:
Most MCP servers are hobby projects. We've built enterprise software:
"AI, debug this failing test"
You: "My Jest test is failing but I can't figure out why"
AI: *Sets breakpoints in test, inspects variables, identifies exact divergence*
AI: "Line 42: API returns string but test expects number. Here's the fix..."
"AI, find the performance bottleneck"
You: "This function is slow but I don't know why"
AI: *Starts CPU profiling, analyzes flame graphs, identifies hot paths*
AI: "Bottleneck in nested loop on line 156. Here's 10x faster version..."
"AI, why is my app hanging?"
You: "My Node.js app freezes randomly"
AI: *Detects infinite loop, captures call stack, identifies root cause*
AI: "Infinite loop in processQueue() - exit condition never true because..."
"AI, debug this Node.js issue"
You: "My Express server crashes on startup"
AI: *Sets breakpoints, inspects variables, traces execution*
AI: "Missing environment variable 'PORT' on line 23. Server tries to bind to undefined port..."
Option 1: VS Code Extension (Recommended for VS Code users)
# Install from VS Code Marketplace
# Search for "MCP ACS Debugger" or visit:
# https://marketplace.visualstudio.com/items?itemName=digitaldefiance.ts-mcp-debugger
# Or install via command line
code --install-extension digitaldefiance.ts-mcp-debugger
Features:
Option 2: Standalone MCP Server (For other AI agents)
# NPM (Recommended)
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Docker
docker run digitaldefiance/mcp-debugger-server
# Configure your AI agent (Kiro, Amazon Q, etc.)
{
"servers": {
"debugger": {
"command": "mcp-debugger-server"
}
}
}
Option 3: From Source
# Clone and build
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build
# Run debugger server
node packages/mcp-debugger-server/dist/src/index.js
📚 Documentation:
VS Code Extension (Recommended for VS Code users):
Install from Marketplace:
Start Debugging:
Use with Copilot:
You: "@workspace debug this failing test"
Copilot: *Uses MCP debugger to investigate*
Copilot: "Found the issue on line 42. The API returns..."
Standalone MCP Server (For other AI agents):
Install globally:
npm install -g @ai-capabilities-suite/mcp-debugger-server
Configure your AI agent:
{
"mcpServers": {
"debugger": {
"command": "mcp-debugger-server"
}
}
}
Use with your AI agent:
You: "Debug my Node.js app"
AI: *Uses MCP tools to start debugging session*
AI: "Started debug session. Set breakpoint at app.js:42..."
Transform AI agents from code readers into visual UI experts and documentation partners
Repositories: MCP ACS Screenshot | VS Code Extension
✨ Now available on NPM, Docker Hub, and VS Code Marketplace!
The Problem: AI agents were blind to your actual user interface. They could read HTML/CSS and suggest improvements, but couldn't see what users actually experience—broken layouts, poor contrast, misaligned elements, or accessibility issues.
The Solution: AI agents now have visual superpowers—they can see, analyze, and document your applications like a senior UX designer. From automated documentation generation to accessibility audits, AI can now work with what users actually see.
Screenshot Capture:
Privacy & Security:
Cross-Platform Support:
screenshot_capture_full - Capture entire screen with format options (PNG, JPEG, WebP, BMP)screenshot_capture_window - Capture specific application windows by title or IDscreenshot_capture_region - Capture rectangular screen regions with precise boundariesscreenshot_list_displays - List connected displays with resolutions and scalingscreenshot_list_windows - List visible windows with titles, positions, and dimensionsPrivacy & Security Features:
NPM Package:
npm install -g @ai-capabilities-suite/mcp-screenshot
npx @ai-capabilities-suite/mcp-screenshot
Docker:
docker run -v $(pwd)/screenshots:/app/screenshots digitaldefiance/mcp-screenshot:latest
VSCode Extension:
"AI, create professional documentation"
You: "Document the user onboarding flow"
AI: *Captures each step, analyzes UI elements*
AI: "Generated step-by-step guide with 8 annotated screenshots, user journey map, and accessibility notes..."
"AI, audit this design for accessibility"
You: "Check if this form meets WCAG standards"
AI: *Captures form, analyzes contrast and spacing*
AI: "Found 3 issues: Submit button has 2.1:1 contrast (needs 4.5:1), labels lack focus indicators, touch targets under 44px..."
"AI, help debug this responsive layout"
You: "Why does my navbar break on mobile?"
AI: *Captures multiple viewport sizes*
AI: "Navigation collapses at 768px but hamburger menu overlaps logo. Here's the CSS fix with before/after comparison..."
"AI, compare these two design options"
You: "Which landing page converts better?"
AI: *Captures both versions, analyzes visual hierarchy*
AI: "Version B has 34% better visual flow—CTA button more prominent, hero text clearer, social proof positioned optimally..."
"AI, create a bug report with visuals"
You: "The checkout form validation isn't working"
AI: *Captures error states and user flow*
AI: "Created detailed bug report with 5 screenshots showing error conditions, expected vs actual behavior, and reproduction steps..."
Before: AI worked blind, relying on code descriptions
After: AI sees and analyzes your actual user interface
📚 Documentation:
Advanced file operations beyond basic I/O with strict security boundaries
Repositories: MCP Filesystem | VS Code Extension
✨ Now available on NPM and VS Code Marketplace!
The Problem: AI agents needed advanced file operations beyond basic read/write, but without proper security boundaries, this posed significant risks—path traversal attacks, unauthorized access to system files, and exposure of sensitive credentials.
The Solution: AI agents now have enterprise-grade filesystem operations with 10 layers of security validation. From batch operations with atomic rollback to real-time directory watching, AI can now safely manage your workspace files.
Advanced Operations:
Security (Defense-in-Depth):
fs_batch_operations - Execute multiple operations atomically with rollbackfs_watch_directory - Monitor directories for real-time changesfs_get_watch_events - Retrieve accumulated filesystem eventsfs_stop_watch - Stop watch sessions and clean up resourcesfs_search_files - Search by name, content, or metadatafs_build_index - Build searchable index for fast searchingfs_create_symlink - Create symbolic links within workspacefs_compute_checksum - Compute file checksums for integrity verificationfs_verify_checksum - Verify file checksums match expected valuesfs_analyze_disk_usage - Analyze disk usage and identify large filesfs_copy_directory - Recursively copy directories with optionsfs_sync_directory - Sync directories by copying only newer/missing filesNPM Package:
npm install -g @ai-capabilities-suite/mcp-filesystem
mcp-filesystem --config ./mcp-filesystem-config.json
VS Code Extension:
"AI, backup all my TypeScript files"
You: "Create atomic backup of all .ts files to backup folder"
AI: *Uses batch operations with rollback*
AI: "Backed up 47 TypeScript files (2.3 MB) atomically. All operations succeeded, no rollback needed."
"AI, watch for changes and rebuild"
You: "Watch src directory and notify me of changes"
AI: *Starts directory watch with filters*
AI: "Watching src/ recursively. Detected 3 changes: file1.ts modified, file2.ts created, file3.ts deleted."
"AI, find all TODOs in the codebase"
You: "Search for TODO comments in TypeScript files"
AI: *Builds index and searches content*
AI: "Found 23 TODO comments across 12 files. Most common: 'TODO: Add error handling' (5 occurrences)."
"AI, verify file integrity"
You: "Compute SHA-256 checksum for release.zip"
AI: *Computes checksum*
AI: "SHA-256: a3f5b8c2... File integrity verified against expected checksum."
"AI, analyze disk usage"
You: "What's taking up space in node_modules?"
AI: *Analyzes disk usage*
AI: "node_modules: 487 MB. Largest: webpack (45 MB), typescript (38 MB), @types/* (92 MB total)."
📚 Documentation:
Enterprise-grade process management with strict security boundaries
Repositories: MCP ACS Process | VS Code Extension
✨ Now available on NPM, Docker Hub, and VS Code Marketplace!
The Problem: AI agents couldn't safely manage system processes. They needed to run commands, monitor resources, and manage services, but without proper security boundaries, this posed significant risks—command injection, resource exhaustion, and privilege escalation.
The Solution: AI agents now have enterprise-grade process management with 6 layers of security validation. From launching processes with resource limits to managing long-running services with auto-restart, AI can now safely orchestrate your development environment.
Process Management:
Service Management:
Process Groups:
Security (Defense-in-Depth):
process_start - Launch processes with arguments, environment, and resource limitsprocess_terminate - Graceful or forced termination with timeout escalationprocess_get_stats - Real-time CPU, memory, thread, and I/O statisticsprocess_send_stdin - Send input to interactive processesprocess_get_output - Retrieve captured stdout and stderrprocess_list - List all managed processes with statusprocess_get_status - Detailed process state and uptimeprocess_create_group - Create process groups and pipelinesprocess_add_to_group - Add processes to groupsprocess_terminate_group - Terminate all processes in a groupprocess_start_service - Start long-running services with auto-restartprocess_stop_service - Stop services and disable auto-restart6 Layers of Security Validation:
Executable Allowlist - Only approved executables can be launched
Argument Validation - Prevents command injection
Environment Sanitization - Removes dangerous variables
Resource Limits - Prevents resource exhaustion
Privilege Prevention - No privilege escalation
Audit Logging - Complete operation tracking
"AI, run my build and monitor resources"
You: "Build the project and tell me if it uses too much memory"
AI: *Launches build with resource limits, monitors in real-time*
AI: "Build completed in 45s. Peak memory: 512MB (within limits). CPU averaged 65%."
"AI, start my development services"
You: "Start the API server and database with auto-restart"
AI: *Starts services with health checks and restart policies*
AI: "Started 2 services: api-server (PID 1234), postgres (PID 1235). Health checks enabled."
"AI, create a data processing pipeline"
You: "Process data.txt through grep, sort, and uniq"
AI: *Creates process group with pipeline*
AI: "Pipeline created: cat → grep → sort → uniq. Processing 10,000 lines..."
"AI, debug this hanging process"
You: "My script is stuck, what's it doing?"
AI: *Gets process stats and output*
AI: "Process consuming 100% CPU in infinite loop. Last output: 'Processing item 5000'. Shall I terminate it?"
"AI, run tests with timeout"
You: "Run the test suite but kill it if it takes more than 5 minutes"
AI: *Launches tests with 5-minute timeout*
AI: "Tests completed in 3m 42s. All 247 tests passed. Peak memory: 384MB."
Docker (Recommended):
# Pull the image
docker pull digitaldefiance/mcp-process:latest
# Create configuration
cat > config/mcp-process-config.json << EOF
{
"allowedExecutables": ["node", "python3", "npm"],
"maxConcurrentProcesses": 10,
"enableAuditLog": true
}
EOF
# Run with docker-compose
docker-compose up -d
NPM:
# Install globally
npm install -g @ai-capabilities-suite/mcp-process
# Create config
mcp-process --create-config ./mcp-process-config.json
# Edit config to add allowed executables
# Then start server
mcp-process --config ./mcp-process-config.json
Configuration Example:
{
"allowedExecutables": ["node", "python3", "npm", "git"],
"defaultResourceLimits": {
"maxCpuPercent": 80,
"maxMemoryMB": 1024,
"maxCpuTime": 300
},
"maxConcurrentProcesses": 10,
"maxProcessLifetime": 3600,
"enableAuditLog": true,
"blockShellInterpreters": true,
"blockSetuidExecutables": true,
"allowProcessTermination": true,
"allowForcedTermination": false
}
📚 Documentation:
┌──────────────────────────────────────────────────────────────┐
│ AI Agents & IDEs │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ VS Code │ │ Kiro │ │ Amazon Q │ │
│ │ + Copilot │ │ │ │ │ │
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │ │
│ │ LSP/DAP │ MCP Protocol │ MCP Protocol │
│ │ │ │ │
└─────────┼─────────────────┼──────────────────┼───────────────┘
│ │ │
│ └──────┬───────────┘
│ │
┌─────────▼────────────────────────▼───────────────────────────┐
│ AI Capability Extension Suite │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ MCP ACS Debugger │ │
│ │ • 25+ debugging tools │ │
│ │ • VS Code extension with LSP/DAP integration │ │
│ │ • Standalone MCP server for other agents │ │
│ │ • 94.53% test coverage, 1,059 tests │ │
│ └────────────────────────────────────────────────────────┘ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ System Capabilities (In Development) │ │
│ │ • Screenshot • Recording • Filesystem • Process │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────┬────────────────────────────────────────────────┘
│ Chrome DevTools Protocol, System APIs
│
┌─────────────▼────────────────────────────────────────────────┐
│ Your Development Environment │
│ • Node.js processes with Inspector Protocol │
│ • File system and process management │
│ • Screen capture and recording │
│ • Full system access with security controls │
└───────────────────────────────────────────────────────────────┘
1. VS Code Extension (Native Integration)
2. MCP Server (Universal Integration)
You: "My app crashes when processing large files"
AI: *Starts debugger, sets breakpoints, profiles memory*
AI: "Memory leak in line 156. Buffer not released. Here's the fix..."
You: "Create documentation for the new dashboard"
AI: *Captures screenshots, analyzes UI, generates docs*
AI: "Created comprehensive guide with 12 annotated screenshots..."
You: "Show how the authentication flow works"
AI: *Records screen, adds annotations, exports video*
AI: "Generated 2-minute demo with voiceover script..."
You: "Restructure this codebase following best practices"
AI: *Analyzes structure, moves files, updates imports*
AI: "Reorganized 247 files into proper architecture..."
# Clone the repository
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
# Install dependencies
yarn install
# Build all packages
yarn build
# Run tests
yarn test
# Build debugger packages
npx nx build mcp-debugger-core
npx nx build mcp-debugger-server
# Run debugger tests
npx nx test mcp-debugger-core
npx nx test mcp-debugger-server
# Start debugger server
node packages/mcp-debugger-server/dist/src/index.js
# Build all packages
yarn build
# Build specific package
npx nx build mcp-debugger-core
npx nx build mcp-debugger-server
npx nx build mcp-screenshot
npx nx build mcp-core
# Build with watch mode
npx nx build mcp-screenshot --watch
# Run all tests
yarn test
# Test specific package
npx nx test mcp-debugger-core
npx nx test mcp-debugger-server
npx nx test mcp-screenshot
# Test with coverage
npx nx test mcp-debugger-core --coverage
# Run tests in watch mode
npx nx test mcp-screenshot --watch
# Lint all packages
yarn lint
# Lint specific package
npx nx lint mcp-debugger-core
Distribution Channels:
Quality Metrics:
Enterprise Features:
Documentation:
We welcome contributions! This project follows a spec-driven development approach:
git checkout -b feature/amazing-feature)yarn test)git commit -m 'Add amazing feature')git push origin feature/amazing-feature)Digital Defiance
MIT License - See LICENSE for details
We're building the foundation for AI-powered development workflows.
By giving AI agents professional-grade capabilities, we're creating a future where:
This isn't just a tool suite—it's the future of software development.
# Install from VS Code Marketplace
code --install-extension digitaldefiance.ts-mcp-debugger
# Or search "MCP ACS Debugger" in VS Code Extensions
# Install globally via NPM
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Or use Docker
docker run -p 3000:3000 digitaldefiance/mcp-debugger-server
# Or download standalone binary from GitHub Releases
# Clone and build from source
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build && yarn test
1. Production-Ready Quality
2. Multiple Integration Options
3. Comprehensive Feature Set
4. Active Development & Support
5. Open Source & Extensible
Get Help:
Stay Updated:
Contribute:
npm install -gInstall the extension in 3 ways:
From VS Code:
From Command Line:
code --install-extension digitaldefiance.ts-mcp-debugger
From Marketplace:
Choose your installation method:
# NPM (Global installation)
npm install -g @digitaldefiance/mcp-debugger-server
# Docker (Containerized)
docker run -p 3000:3000 digitaldefiance/mcp-debugger-server
# Homebrew (macOS - coming soon)
brew install digitaldefiance/tap/mcp-debugger-server
# Download Binary (No installation)
# Visit: https://github.com/digital-defiance/ai-capabilities-suite/releases
# Clone and build from source
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build && yarn test
Built with ❤️ by the Digital Defiance team using Amazon Kiro, TypeScript, and the Model Context Protocol
Ready to give your AI agent superpowers? Install now! 🚀
Configure Kiro to use the AI Capability Extension Suite MCP servers by editing ~/.kiro/settings/mcp.json:
{
"mcpServers": {
"mcp-screenshot": {
"command": "npx",
"args": ["-y", "@ai-capabilities-suite/mcp-screenshot"]
},
"mcp-process": {
"command": "npx",
"args": [
"-y",
"@ai-capabilities-suite/mcp-process",
"--config",
"./mcp-process-config.json"
]
},
"mcp-debugger": {
"command": "npx",
"args": ["-y", "@ai-capabilities-suite/mcp-debugger-server"]
}
}
}
Create mcp-process-config.json in your project directory or home directory:
{
"allowedExecutables": ["node", "python3", "npm", "yarn", "git"],
"defaultResourceLimits": {
"maxCpuPercent": 80,
"maxMemoryMB": 1024,
"maxCpuTime": 300
},
"maxConcurrentProcesses": 10,
"maxProcessLifetime": 3600,
"enableAuditLog": true,
"blockShellInterpreters": true,
"blockSetuidExecutables": true,
"allowProcessTermination": true,
"allowForcedTermination": false
}
Note: The config file requirement for mcp-process will be removed in an upcoming release, making it optional with sensible defaults.
For Linux users (Ubuntu/Debian):
# Install Python setuptools for native dependencies
sudo apt-get install -y python3-setuptools build-essential
For macOS users:
# Install Xcode Command Line Tools
xcode-select --install
For Windows users:
# Install Visual Studio Build Tools
# Download from: https://visualstudio.microsoft.com/downloads/
If you prefer global installation over npx:
# Install all three servers globally
npm install -g @ai-capabilities-suite/mcp-screenshot
npm install -g @ai-capabilities-suite/mcp-process
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Then use direct commands in mcp.json
{
"mcpServers": {
"mcp-screenshot": {
"command": "mcp-screenshot"
},
"mcp-process": {
"command": "mcp-process",
"args": ["--config", "./mcp-process-config.json"]
},
"mcp-debugger": {
"command": "mcp-debugger"
}
}
}
After configuration, restart Kiro and verify the servers are connected:
You: "List available MCP tools"
Kiro: *Shows tools from mcp-screenshot, mcp-process, and mcp-debugger*
Connection issues:
node --versionpython3 -c "import setuptools"npm view @ai-capabilities-suite/mcp-screenshotNative dependency errors:
npm cache clean --forcenpm install -g --force @ai-capabilities-suite/mcp-screenshotConfig file not found:
ls -la ./mcp-process-config.jsoncat mcp-process-config.json | jqSpec-driven development powered by GitHub Copilot and MCP
Repository: Akira
The Problem: Traditional AI-assisted development lacks structure—requirements are vague, designs are inconsistent, and implementation happens without proper planning. AI agents generate code without understanding the full context or ensuring correctness.
The Solution: Akira brings professional software engineering methodology to AI-assisted development. Using the Easy Approach to Requirements Syntax (EARS) and INCOSE quality rules, Akira guides AI through a structured workflow: Requirements → Design → Tasks → Execution. With Model Context Protocol (MCP) integration, specifications persist across chat sessions, ensuring consistency and enabling property-based testing.
Structured Spec-Driven Workflow:
Advanced Requirements Engineering:
Property-Based Testing Integration:
Model Context Protocol (MCP) Integration:
"AI, create a spec for user authentication"
You: "@spec create user-authentication"
AI: *Generates EARS-compliant requirements*
AI: "Created spec with 8 requirements (5 ubiquitous, 2 event-driven, 1 state-driven).
All requirements validated against INCOSE rules. Ready for design phase."
"AI, generate correctness properties"
You: "@spec approve requirements user-auth"
AI: *Moves to design phase, extracts properties*
AI: "Generated 12 correctness properties:
- For any valid credentials, login succeeds
- For any expired token, re-authentication required
- For any user, password hash is irreversible
Ready for implementation."
"AI, execute the implementation plan"
You: "@spec execute user-auth"
AI: *Loads full context, executes tasks*
AI: "Executing task 1.1: Implement password hashing...
✅ Implemented with bcrypt
✅ Added property test: password hashing is one-way
Moving to task 1.2..."
Install from VS Code:
Usage with GitHub Copilot:
# Create a new spec
@spec create feature-name
# List all specs
@spec list
# Execute tasks
@spec execute feature-name
# Approve workflow phases
@spec approve requirements feature-name
@spec approve design feature-name
@spec approve tasks feature-name
📚 Documentation:
© 2026 MCP Directory.
Process management and monitoring for AI agents with strict security boundaries
{ "mcpServers": { "io.github.digital-defiance-mcp-process": { "command": "npx", "args": [ "-y", "@ai-capabilities-suite/[email protected]" ] } }}Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
No required environment variable is listed on this record.
MCP Process runs locally over stdio.
Last checked 2026-11-09. Process management and monitoring for AI agents with strict security boundaries