Coding Tools MCP

Coding Tools MCP is a Rust + Tauri 2 desktop app. After you select a project directory and start the service, an AI Agent can read files, modify code, run commands and tests, view Git status through MCP, and save key progress as in-project history sessions. It is closer to "an AI opening an IDE workspace that remembers development progress"; ordinary development tools do not require creating a Task first, while history sessions are responsible for restoring context in new conversations.

One desktop app manages workspaces, the MCP service, connection info, and session-restore prompts at the same time.

Understand it in 30 seconds

下载安装桌面端
  → 添加项目目录
  → 启动 MCP 和公网隧道
  → 复制“公网 MCP 地址”
  → ChatGPT 开启开发人员模式
  → 新建 MCP 插件并粘贴地址
  → 完成授权，在新对话中开始开发

For first-time use, only two things matter: the desktop app turns a project into an MCP workspace, and ChatGPT connects to it through the public /mcp address.

• See the full installation and desktop startup steps

• Jump straight to the ChatGPT plugin configuration

Get started in five minutes

1. Install the desktop client

Open Releases and download the matching installer:

The macOS installer is currently unsigned. If the system blocks the first launch, confirm opening it in "System Settings → Privacy & Security".

2. Add a project workspace

1. Click "Add Workspace" on the left.

2. Select the project root directory.

3. Set the workspace name, MCP port, and authentication method.

4. After saving, the workspace stays in the left list permanently.

3. Configure the public tunnel

If the AI client is not on this machine, you need to expose the local MCP as an HTTPS address:

• Install or identify frpc / cloudflared in "Software Management".

• Save the server, port, and Token in "FRP Configuration", or choose Cloudflare for the workspace.

• Fill in a unique subdomain for each workspace. The app manages FRP processes and multiple proxy routes centrally.

FRP server configuration is saved centrally; each workspace only needs to pick a config and fill in its own subdomain.

If you do not have a usable FRPS server yet, see: FRPS server installation tutorial (WeChat article). After installation, fill the server address, port, and Token into the client's "FRP Configuration".

4. Start MCP

Enter the workspace and click "Start" on MCP. The client will show:

• The local MCP address, e.g. http://127.0.0.1:28766/mcp;

• The public HTTPS MCP address;

• The authentication info ChatGPT needs to connect;

• Real-time logs and health check results.

After startup you can directly check the local and public endpoints, OAuth metadata, and MCP protected resources:

The health check shows item by item whether connection and authentication metadata are available.

When you hit connection problems, you can view the latest MCP request logs without leaving the desktop app:

The logs quickly confirm whether tool listing, history initialization, and checkpoint calls actually reached the server.

5. Connect an AI client

MCP-capable clients use the public MCP URL shown in the UI. When using OAuth, the client enters the authorization flow through the server metadata; the authorization code, Client ID, and Secret can all be generated and managed centrally in the desktop app. The current version uses a preconfigured OAuth client, so when creating a ChatGPT plugin you should choose static/manual OAuth credentials and do not need to select CIMD.

For the first connection, we recommend calling history initialization first, then checking the workspace:

history_session_bootstrap
server_info
get_default_cwd
git_status
check_exec_environment

This way the Agent does not need to guess the current project, working directory, and execution capabilities from chat context.

Two ways to connect ChatGPT

MCP Connector

Before configuring, confirm:

1. The workspace's MCP service and public tunnel are both running.

2. The public MCP check in "Health Check" passes; if using OAuth, also confirm the OAuth protected resource and authorization metadata checks pass.

3. Copy the "Public MCP Address" from the "GPT Configuration" card in the desktop app; if using OAuth, also prepare the OAuth Client ID, OAuth Client Secret, and authorization code.

ChatGPT must use the public HTTPS /mcp address, not a local address like http://127.0.0.1:28766/mcp. ChatGPT's menu names may vary slightly by version and language settings.

1. Enable ChatGPT developer mode

Open ChatGPT settings, go to "Account Security & Login", and enable "Developer Mode". This toggle allows adding unverified MCP connectors.

Developer mode has elevated permissions and should only be used to connect MCP services you deployed yourself or explicitly trust.

2. Create an MCP plugin

In ChatGPT, go to "Plugins" on the left, click the + in the top-right to create a new plugin, then choose MCP (beta) and fill in:

When using OAuth, expand "Advanced OAuth Settings", choose static/manual OAuth credentials, and fill in the Client ID and Client Secret from the desktop app; do not select CIMD. After saving or connecting, ChatGPT opens the authorization page; enter the authorization code from the desktop app's "GPT Configuration" card to complete the first authorization.

Client Secret, authorization codes, and Bearer Tokens are sensitive information. Do not paste them into conversations, Issues, or public screenshots. If the desktop app uses Bearer or no authentication, choose the corresponding authentication method shown in the current UI in ChatGPT.

3. Verify the connection

Create a new conversation with this plugin enabled and send:

请使用 Coding Tools MCP 调用 server_info、get_default_cwd 和 git_status，
告诉我当前连接的工作区、默认目录和 Git 状态。

If it returns info about the current project, the "desktop app → public tunnel → OAuth → ChatGPT → MCP tools" chain is working. For your first real development session, call history_session_bootstrap to initialize or restore project history.

If ChatGPT still shows the old tool list, disconnect and reconnect the plugin, or create a new conversation and verify again.

Common issues

GPT Actions

1. Start the workspace's Actions service.

2. Copy the OpenAPI URL from the Actions panel.

3. Import that URL in the Actions page of the GPT editor.

4. Choose None, API Key, or OAuth according to the desktop app configuration.

MCP and Actions can run for the same workspace at the same time, and can also use different ports and subdomains.

Why you need it

• Built for real development: files, commands, Git, tests, and long-running processes all live in the same Workspace.

• Continuous development across sessions: a new conversation first gets a bounded current state; when precise old context is needed, locate it by keyword and read the original archive — no need to re-explain project background and current progress to the AI.

• Traceable progress: after each round of tasks you can save structured checkpoints; decisions, changes, test results, and next steps all stay in the project directory.

• Multi-workspace management: one desktop client can save multiple projects and manage their own MCP, Actions, and public addresses.

• More direct ChatGPT connection: built-in Streamable HTTP, OAuth, Bearer Token, OpenAPI, FRP, and Cloudflare tunnels.

• Simple default tool surface: stable core tools are available by default; advanced Harness capabilities are enabled on demand.

Let the project remember every conversation

Ordinary chat history is fine for reviewing conversations, but not suitable as a long-term development handoff. Coding Tools MCP writes session progress into the current project's docs/history-session/, so context follows the project instead of being trapped in a single chat window.

Copy the full prompt into a new conversation to initialize or restore history; save a checkpoint after each round of tasks.

It provides five history tools that work together:

Typical effect:

对话 1：分析项目 → 修改代码 → 运行测试 → 保存检查点
                                      ↓
对话 2：读取有界当前状态 → 搜索并精读需要的旧档案 → 从上次进度继续 → 保存新检查点

History archives use readable Markdown, so they can be backed up with the project or committed to Git, and developers can review and revise them directly. memory/state.json is the bounded current-state projection; memory/manifest.json only stores locations, hashes, and keywords — it does not copy body text; Markdown is the long-term, lossless source of truth. The first input and each round's input must be passed by ChatGPT as the initial_user_input and raw_user_input tool arguments; the server cannot read remote chat text that was not passed in. Checkpoints use idempotent appends; when the same turn_id content changes, revision and supersedes evidence is kept, and the save is only confirmed after ok=true is returned and the session target matches.

History persistence is done by the AI calling MCP tools, not by the desktop app recording chat content in the background. If the client does not trigger tool calls, the server cannot know about new conversations or task progress out of thin air.

What the Agent can do

The default core profile provides a stable, composable set of development tools:

A typical development flow:

打开 Workspace
  → 理解项目和 Git 状态
  → 搜索并读取代码
  → 事务化应用 Patch
  → 运行命令和测试
  → 检查 diff 并提交

The advanced profile also keeps Harness capabilities such as project state and operation records, but ordinary file editing and command execution do not require creating a Task first.

Permission and recovery model

The project uses a Workspace-first permission model:

• Ordinary files inside the Workspace can be read, created, modified, deleted, and executed.

• Outside the Workspace, full read-only access is allowed: read_file, list_dir, list_files, search_text, view_image.

• Writes, deletes, and execution outside the Workspace are blocked.

• .git and .github cannot be damaged by ordinary file tools, Patch, or interpreter commands.

• Patch performs pre-checks and failure recovery within a single operation; long-term recovery uniformly uses Git, and no full Workspace Snapshot is created.

Windows child processes are currently still a policy_only execution boundary; sandbox_enforced: false in the return value is the real state. A static command policy is not equivalent to a full OS filesystem sandbox.

Local development

Environment requirements: Node.js 20+, Rust stable, and the Tauri 2 prerequisites for your system.

npm install
npm run desktop

Common verification commands:

npm run check
npm run build
cd src-tauri && cargo test
cd src-tauri && cargo clippy --all-targets -- -D warnings

On Windows you can also double-click dev-desktop.cmd. Do not verify the desktop app with only npm run dev — it only starts Vite, not the Tauri shell.

Project structure

Acknowledgments

Thanks to the Linux.do community for promoting the project and providing feedback.

License

Apache-2.0