coreforged-mcp 0.1.0__tar.gz

coreforged_mcp-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CoreForged LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

coreforged_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: coreforged-mcp
+Version: 0.1.0
+Summary: MCP gateway that docks multiple servers behind one endpoint with named loadout profiles
+Author-email: CoreForged LLC <corporate@coreforged.com>
+License: MIT
+Project-URL: Homepage, https://coreforged.com/products/coreforged-mcp
+Project-URL: Repository, https://github.com/coreforged/coreforged-mcp
+Project-URL: Documentation, https://github.com/coreforged/coreforged-mcp#readme
+Keywords: mcp,claude,ai,gateway,plugins
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp[cli]<2,>=1.0.0
+Provides-Extra: keyring
+Requires-Dist: coreforged-mcp; extra == "keyring"
+Provides-Extra: all
+Requires-Dist: coreforged-mcp; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"
+Dynamic: license-file
+
+# CoreforgedMCP
+
+**One MCP server to dock them all.**
+
+CoreforgedMCP is a gateway that consolidates multiple MCP servers behind a single endpoint. Instead of configuring 5 separate servers in your `.mcp.json`, you configure one — and control which plugins load with a single environment variable.
+
+```
+Before: 5 servers × 5 processes × 5 config blocks
+After:  1 server  × 1 process  × 1 config block
+```
+
+## Quick Start
+
+```bash
+pip install coreforged-mcp
+coreforged-mcp init
+```
+
+This adds CoreforgedMCP to your `.mcp.json`. Restart Claude Code — you're running.
+
+## What You Get
+
+### The Gateway (free, open source)
+
+- **Plugin docking** — native Python plugins load in-process; proxy plugins spawn as subprocesses
+- **Named loadouts** — switch your entire tool stack by setting `COREFORGED_LOADOUT=analytics`
+- **Plugin discovery** — drop a plugin into `~/.coreforged/plugins/` and it auto-loads
+- **Cross-platform** — Windows, Mac, Linux
+
+### KeyRing (bundled)
+
+Your API keys never enter the conversation. The keyring retrieves the secret, makes the authenticated API call, and returns only the response data. Every checkout is logged.
+
+```
+Agent: "Call the GitHub API with my token"
+  → KeyRing retrieves token from encrypted store
+  → KeyRing makes the API call
+  → KeyRing returns the response data
+  → Token never appears in tool results or context
+```
+
+## Usage
+
+### Basic (default plugins)
+
+```json
+{
+  "mcpServers": {
+    "coreforged": {
+      "command": "coreforged-mcp",
+      "args": ["run"]
+    }
+  }
+}
+```
+
+### With a loadout
+
+```json
+{
+  "mcpServers": {
+    "coreforged": {
+      "command": "coreforged-mcp",
+      "args": ["run"],
+      "env": {
+        "COREFORGED_LOADOUT": "analytics"
+      }
+    }
+  }
+}
+```
+
+### Specific plugins only
+
+```json
+{
+  "mcpServers": {
+    "coreforged": {
+      "command": "coreforged-mcp",
+      "args": ["run"],
+      "env": {
+        "COREFORGED_PLUGINS": "keyring,my-custom-plugin"
+      }
+    }
+  }
+}
+```
+
+## Installing Plugins
+
+### From a zip file
+
+```bash
+coreforged-mcp install-plugin analytics-bundle.zip --key YOUR_LICENSE_KEY
+```
+
+Plugins install to `~/.coreforged/plugins/` and are discovered automatically on next restart.
+
+### From a directory
+
+Drop any directory with a `plugin.json` manifest into `~/.coreforged/plugins/`:
+
+```
+~/.coreforged/plugins/
+├── my-plugin/
+│   ├── plugin.json
+│   └── server.py
+```
+
+## Writing a Plugin
+
+A plugin is any Python module with a FastMCP instance. If it runs standalone, it docks into the gateway.
+
+**1. Write the server**
+
+```python
+# my-plugin/server.py
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("my-plugin", instructions="What this does.")
+
+@mcp.tool()
+def my_tool(query: str) -> str:
+    """Tool description."""
+    return do_something(query)
+
+if __name__ == "__main__":
+    mcp.run()
+```
+
+**2. Add the manifest**
+
+```json
+// my-plugin/plugin.json
+{
+  "name": "my-plugin",
+  "version": "0.1.0",
+  "description": "What it does",
+  "type": "native",
+  "module": "server",
+  "mcp_attr": "mcp",
+  "default": false
+}
+```
+
+**3. Test**
+
+```bash
+# Standalone
+python my-plugin/server.py
+
+# Docked
+cp -r my-plugin ~/.coreforged/plugins/
+coreforged-mcp status
+```
+
+A template plugin is included at `src/coreforged_mcp/plugins/_template/`.
+
+## Plugin Types
+
+| Type | How It Works | Best For |
+|------|-------------|----------|
+| **Native** | Python module imported in-process | Python tools, zero overhead |
+| **Proxy** | External process spawned, tools bridged via JSON-RPC | Node.js, Go, Rust servers |
+
+## CLI Commands
+
+| Command | What It Does |
+|---------|-------------|
+| `coreforged-mcp run` | Start the gateway server |
+| `coreforged-mcp status` | Show discovered plugins and loadouts |
+| `coreforged-mcp init` | Add CoreforgedMCP to `.mcp.json` |
+| `coreforged-mcp install-plugin <path> [--key KEY]` | Install a plugin from a zip |
+
+## Available Plugins
+
+| Plugin | Source | What It Does |
+|--------|--------|-------------|
+| **KeyRing** | Bundled | Sovereign secrets — API keys never enter context |
+| Digital Analytics | [coreforged.com](https://coreforged.com) | GA4 + Search Console + PageSpeed |
+| SEO Bundle | [coreforged.com](https://coreforged.com) | Keyword research + SERP analysis |
+
+## License
+
+MIT — the gateway is free and open source. Some plugins on [coreforged.com](https://coreforged.com) are commercially licensed.
+
+## Contributing
+
+PRs welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+Built by [CoreForged LLC](https://coreforged.com).

coreforged_mcp-0.1.0/README.md

@@ -0,0 +1,191 @@
+# CoreforgedMCP
+
+**One MCP server to dock them all.**
+
+CoreforgedMCP is a gateway that consolidates multiple MCP servers behind a single endpoint. Instead of configuring 5 separate servers in your `.mcp.json`, you configure one — and control which plugins load with a single environment variable.
+
+```
+Before: 5 servers × 5 processes × 5 config blocks
+After:  1 server  × 1 process  × 1 config block
+```
+
+## Quick Start
+
+```bash
+pip install coreforged-mcp
+coreforged-mcp init
+```
+
+This adds CoreforgedMCP to your `.mcp.json`. Restart Claude Code — you're running.
+
+## What You Get
+
+### The Gateway (free, open source)
+
+- **Plugin docking** — native Python plugins load in-process; proxy plugins spawn as subprocesses
+- **Named loadouts** — switch your entire tool stack by setting `COREFORGED_LOADOUT=analytics`
+- **Plugin discovery** — drop a plugin into `~/.coreforged/plugins/` and it auto-loads
+- **Cross-platform** — Windows, Mac, Linux
+
+### KeyRing (bundled)
+
+Your API keys never enter the conversation. The keyring retrieves the secret, makes the authenticated API call, and returns only the response data. Every checkout is logged.
+
+```
+Agent: "Call the GitHub API with my token"
+  → KeyRing retrieves token from encrypted store
+  → KeyRing makes the API call
+  → KeyRing returns the response data
+  → Token never appears in tool results or context
+```
+
+## Usage
+
+### Basic (default plugins)
+
+```json
+{
+  "mcpServers": {
+    "coreforged": {
+      "command": "coreforged-mcp",
+      "args": ["run"]
+    }
+  }
+}
+```
+
+### With a loadout
+
+```json
+{
+  "mcpServers": {
+    "coreforged": {
+      "command": "coreforged-mcp",
+      "args": ["run"],
+      "env": {
+        "COREFORGED_LOADOUT": "analytics"
+      }
+    }
+  }
+}
+```
+
+### Specific plugins only
+
+```json
+{
+  "mcpServers": {
+    "coreforged": {
+      "command": "coreforged-mcp",
+      "args": ["run"],
+      "env": {
+        "COREFORGED_PLUGINS": "keyring,my-custom-plugin"
+      }
+    }
+  }
+}
+```
+
+## Installing Plugins
+
+### From a zip file
+
+```bash
+coreforged-mcp install-plugin analytics-bundle.zip --key YOUR_LICENSE_KEY
+```
+
+Plugins install to `~/.coreforged/plugins/` and are discovered automatically on next restart.
+
+### From a directory
+
+Drop any directory with a `plugin.json` manifest into `~/.coreforged/plugins/`:
+
+```
+~/.coreforged/plugins/
+├── my-plugin/
+│   ├── plugin.json
+│   └── server.py
+```
+
+## Writing a Plugin
+
+A plugin is any Python module with a FastMCP instance. If it runs standalone, it docks into the gateway.
+
+**1. Write the server**
+
+```python
+# my-plugin/server.py
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("my-plugin", instructions="What this does.")
+
+@mcp.tool()
+def my_tool(query: str) -> str:
+    """Tool description."""
+    return do_something(query)
+
+if __name__ == "__main__":
+    mcp.run()
+```
+
+**2. Add the manifest**
+
+```json
+// my-plugin/plugin.json
+{
+  "name": "my-plugin",
+  "version": "0.1.0",
+  "description": "What it does",
+  "type": "native",
+  "module": "server",
+  "mcp_attr": "mcp",
+  "default": false
+}
+```
+
+**3. Test**
+
+```bash
+# Standalone
+python my-plugin/server.py
+
+# Docked
+cp -r my-plugin ~/.coreforged/plugins/
+coreforged-mcp status
+```
+
+A template plugin is included at `src/coreforged_mcp/plugins/_template/`.
+
+## Plugin Types
+
+| Type | How It Works | Best For |
+|------|-------------|----------|
+| **Native** | Python module imported in-process | Python tools, zero overhead |
+| **Proxy** | External process spawned, tools bridged via JSON-RPC | Node.js, Go, Rust servers |
+
+## CLI Commands
+
+| Command | What It Does |
+|---------|-------------|
+| `coreforged-mcp run` | Start the gateway server |
+| `coreforged-mcp status` | Show discovered plugins and loadouts |
+| `coreforged-mcp init` | Add CoreforgedMCP to `.mcp.json` |
+| `coreforged-mcp install-plugin <path> [--key KEY]` | Install a plugin from a zip |
+
+## Available Plugins
+
+| Plugin | Source | What It Does |
+|--------|--------|-------------|
+| **KeyRing** | Bundled | Sovereign secrets — API keys never enter context |
+| Digital Analytics | [coreforged.com](https://coreforged.com) | GA4 + Search Console + PageSpeed |
+| SEO Bundle | [coreforged.com](https://coreforged.com) | Keyword research + SERP analysis |
+
+## License
+
+MIT — the gateway is free and open source. Some plugins on [coreforged.com](https://coreforged.com) are commercially licensed.
+
+## Contributing
+
+PRs welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+Built by [CoreForged LLC](https://coreforged.com).

coreforged_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "coreforged-mcp"
+version = "0.1.0"
+description = "MCP gateway that docks multiple servers behind one endpoint with named loadout profiles"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "CoreForged LLC", email = "corporate@coreforged.com"}]
+keywords = ["mcp", "claude", "ai", "gateway", "plugins"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+
+dependencies = [
+    "mcp[cli]>=1.0.0,<2",
+]
+
+[project.optional-dependencies]
+keyring = ["coreforged-mcp"]
+all = ["coreforged-mcp"]
+test = ["pytest>=8.0", "pytest-asyncio>=0.23"]
+
+[project.urls]
+Homepage = "https://coreforged.com/products/coreforged-mcp"
+Repository = "https://github.com/coreforged/coreforged-mcp"
+Documentation = "https://github.com/coreforged/coreforged-mcp#readme"
+
+[project.scripts]
+coreforged-mcp = "coreforged_mcp.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["coreforged_mcp*"]
+
+[tool.setuptools.package-data]
+"coreforged_mcp" = ["plugins/*/plugin.json", "plugins/*/permissions.json", "plugins/*/secret_manifest.json", "loadouts.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

coreforged_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

coreforged_mcp-0.1.0/src/coreforged_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""CoreforgedMCP — one MCP server to dock them all."""
+
+__version__ = "0.1.0"

coreforged_mcp-0.1.0/src/coreforged_mcp/cli.py

@@ -0,0 +1,148 @@
+"""CoreforgedMCP CLI — manage the gateway and plugins."""
+
+import argparse
+import json
+import os
+import sys
+
+
+def cmd_run(args):
+    """Start the gateway server."""
+    from coreforged_mcp.gateway import gateway
+    gateway.run()
+
+
+def cmd_status(args):
+    """Show gateway status without starting the server."""
+    from coreforged_mcp.gateway import _discover_plugins, _plugin_status, _loadouts, _load_loadouts
+    _load_loadouts()
+    registry = _discover_plugins()
+    print(f"CoreforgedMCP v{_get_version()}")
+    print(f"Discovered plugins: {len(registry)}")
+    for name, manifest in registry.items():
+        source = manifest.get("_source", "?")
+        default = "default" if manifest.get("default") else "opt-in"
+        print(f"  {name} ({source}, {default}): {manifest.get('description', '')}")
+    if _loadouts:
+        print(f"\nLoadouts: {len(_loadouts)}")
+        for name, profile in _loadouts.items():
+            print(f"  {name}: {profile.get('description', '')}")
+
+
+def cmd_init(args):
+    """Initialize CoreforgedMCP config for this project."""
+    mcp_json_path = os.path.join(os.getcwd(), ".mcp.json")
+
+    if os.path.exists(mcp_json_path):
+        with open(mcp_json_path, encoding="utf-8") as f:
+            config = json.load(f)
+    else:
+        config = {}
+
+    servers = config.setdefault("mcpServers", {})
+    if "coreforged" in servers:
+        print("CoreforgedMCP already configured in .mcp.json")
+        return
+
+    servers["coreforged"] = {
+        "command": "coreforged-mcp",
+        "args": ["run"],
+    }
+
+    with open(mcp_json_path, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+    print(f"Added CoreforgedMCP to {mcp_json_path}")
+    print("Restart Claude Code to load the gateway.")
+
+
+def cmd_install_plugin(args):
+    """Install a plugin from a zip file."""
+    import zipfile
+    import shutil
+
+    zip_path = args.path
+    if not os.path.isfile(zip_path):
+        print(f"Error: {zip_path} not found", file=sys.stderr)
+        sys.exit(1)
+
+    user_dir = os.path.join(os.path.expanduser("~"), ".coreforged", "plugins")
+    os.makedirs(user_dir, exist_ok=True)
+
+    with zipfile.ZipFile(zip_path, "r") as zf:
+        names = zf.namelist()
+        manifest_candidates = [n for n in names if n.endswith("plugin.json")]
+        if not manifest_candidates:
+            print("Error: no plugin.json found in archive", file=sys.stderr)
+            sys.exit(1)
+
+        manifest_path = manifest_candidates[0]
+        manifest_data = json.loads(zf.read(manifest_path))
+        plugin_name = manifest_data.get("name", os.path.basename(zip_path).replace(".zip", ""))
+
+        if args.key:
+            manifest_data["license_key"] = args.key
+
+        dest = os.path.join(user_dir, plugin_name)
+        if os.path.exists(dest):
+            shutil.rmtree(dest)
+
+        prefix = os.path.dirname(manifest_path)
+        for member in names:
+            if prefix and not member.startswith(prefix):
+                continue
+            rel = member[len(prefix):].lstrip("/") if prefix else member
+            if not rel or rel.endswith("/"):
+                continue
+            target = os.path.join(dest, rel)
+            os.makedirs(os.path.dirname(target), exist_ok=True)
+            with open(target, "wb") as out:
+                out.write(zf.read(member))
+
+        if args.key:
+            manifest_out = os.path.join(dest, "plugin.json")
+            with open(manifest_out, "w", encoding="utf-8") as f:
+                json.dump(manifest_data, f, indent=2)
+
+    print(f"Installed plugin '{plugin_name}' to {dest}")
+    print("Restart Claude Code to load the new plugin.")
+
+
+def _get_version():
+    from coreforged_mcp import __version__
+    return __version__
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="coreforged-mcp",
+        description="CoreforgedMCP — one MCP server to dock them all",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {_get_version()}")
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("run", help="Start the gateway server")
+    sub.add_parser("status", help="Show discovered plugins and loadouts")
+    sub.add_parser("init", help="Add CoreforgedMCP to .mcp.json in the current directory")
+
+    install = sub.add_parser("install-plugin", help="Install a plugin from a zip file")
+    install.add_argument("path", help="Path to plugin .zip file")
+    install.add_argument("--key", help="License key for paid plugins")
+
+    args = parser.parse_args()
+
+    commands = {
+        "run": cmd_run,
+        "status": cmd_status,
+        "init": cmd_init,
+        "install-plugin": cmd_install_plugin,
+    }
+
+    if args.command in commands:
+        commands[args.command](args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()