Local Repo MCP

Secure Agent Coding Runtime for local Git repos: policy, RBAC, sessions, approval workflow, and sandboxed writes. Run as a standalone MCP Server for Cursor / Claude Desktop, etc. Optionally connect ChatGPT via OpenAI Secure MCP Tunnel and tunnel-client — no public MCP endpoint required.

Two modes:

# MCP only
MCP client → Local Repo MCP → local repo

# ChatGPT (optional)
ChatGPT → Custom MCP App → Secure MCP Tunnel → tunnel-client → Local Repo MCP → local repo

Features

• Policy Engine — read/write/execute rules via config/policy.yaml

• Enterprise RBAC — user/role permissions in policy file

• Risk Scoring — high-risk operations blocked and scored in audit logs

• Session model — write and test operations require an active session

• Approval workflow — prepare → approve → apply for patches

• Git branch sandbox — protected branches auto-switch to agent/{session_id}

• Path sandbox — all operations confined to REPO_ROOT

• Secret scanning — blocks credentials in patches before apply

• Docker test sandbox — isolated containers (no network, read-only mount)

• Prompt injection mitigation — file content wrapped as UNTRUSTED_DATA

• Audit logging — structured logs with sensitive data redaction

• GUI control panel — full configuration, one-click start and monitoring

Related MCP server: codex-web-bridge

Project Structure

local-repo-mcp/
├── server.py              # entry shim
├── config/policy.yaml     # policy, RBAC, risk thresholds
├── src/
│   ├── mcp_app/server.py  # MCP registration
│   ├── tools/             # read, patch, test, session tools
│   ├── security/          # policy_engine, rbac, risk, scanner
│   ├── session/
│   ├── repo/
│   ├── sandbox/
│   └── audit/
├── tests/                 # security acceptance tests
├── gui/
├── run_gui.py
├── start_gui.bat
├── requirements.txt
├── .env.example
└── systemd/

Requirements

Quick Start

1. Install

git clone git@github.com:cloud-Xolt/local-repo-mcp.git
cd local-repo-mcp
python -m venv .venv

# Windows
.venv\Scripts\activate
.venv\Scripts\pip install -r requirements.txt

# Linux / macOS
source .venv/bin/activate
pip install -r requirements.txt

2. GUI (Recommended — all operations in-app)

Windows: double-click start_gui.bat (auto-creates venv, installs deps, opens the panel)

python run_gui.py

Four tabs:

Save Config writes config.json, .env, and config/policy.yaml.

3. CLI

export REPO_ROOT=/path/to/your/repo
export MCP_MODE=read
export POLICY_RULES=./config/policy.yaml
export AUDIT_LOG=./audit.log

python server.py

ChatGPT Integration (Optional)

Prerequisites

1. ChatGPT workspace with Developer Mode enabled

2. Tunnel created on OpenAI Platform and linked to your workspace

3. tunnel-client installed

Initialize Tunnel

export CONTROL_PLANE_API_KEY="sk-..."

tunnel-client init \
  --sample sample_mcp_stdio_local \
  --profile local-repo \
  --tunnel-id tunnel_xxxxxxxx \
  --mcp-command "bash -lc 'cd /opt/local-repo-mcp && source .venv/bin/activate && REPO_ROOT=/opt/repos/project-a MCP_MODE=read python server.py'"

tunnel-client doctor --profile local-repo --explain
tunnel-client run --profile local-repo

Create Custom MCP App

In ChatGPT: Apps → Create developer-mode app → Connection: Tunnel → Scan Tools → Create

Recommended Workflow

repo_session_start(user, permission="write")
  → repo_prepare_patch(patch, session_id)
  → repo_approve_patch(patch, session_id)
  → repo_apply_patch(patch, session_id)
  → repo_run_test(command_key, session_id)
  → repo_session_end(session_id)

MCP Tools

Configuration

See .env.example for a full template.

Rollout Phases

Never enable: arbitrary shell, git push, git reset, git rebase, etc.

Tests

python -m pytest tests/ -v

Security Notes

• Do not commit config.json, .env, or API keys to Git

• Start with read mode; expand permissions after validation

• Perform git push manually, not via ChatGPT

Linux Deployment

See systemd/ for service unit examples. Run as a low-privilege user (e.g. repo-mcp).

References

• OpenAI Secure MCP Tunnel

• tunnel-client

• ChatGPT Developer Mode

• MCP Python SDK

License

MIT