claude-control 0.1.0__tar.gz

claude_control-0.1.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: claude-control
+Version: 0.1.0
+Summary: MCP server for coordinating Claude Code instances across multiple projects
+Author-email: Red Duck Labs <support@redducklabs.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/redducklabs/claude-control
+Project-URL: Repository, https://github.com/redducklabs/claude-control
+Project-URL: Issues, https://github.com/redducklabs/claude-control/issues
+Keywords: mcp,claude,claude-code,automation,orchestration
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: claude-code-sdk>=0.0.25
+Requires-Dist: mcp>=1.12.0
+
+# Claude Control
+
+MCP server that lets a Claude Code session coordinate with Claude Code instances running in other project directories.
+
+## How It Works
+
+Claude Control is an MCP server (stdio transport) that exposes tools for dispatching prompts to Claude Code instances in configured project directories. Each remote instance:
+
+- Runs as a persistent subprocess with conversation context preserved across calls
+- Loads the target project's own `CLAUDE.md`, `.mcp.json`, hooks, and settings
+- Runs with `bypassPermissions` for fully autonomous operation
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install claude-control
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install claude-control
+```
+
+### From Source
+
+```bash
+git clone https://github.com/redducklabs/claude-control.git
+cd claude-control
+pip install .
+```
+
+## Setup
+
+### 1. Configure Projects
+
+Create a `projects.json` file (see `projects.json.example`):
+
+```json
+{
+  "projects": [
+    {
+      "name": "my-backend",
+      "path": "D:\\repos\\my-backend",
+      "description": "Backend API service"
+    },
+    {
+      "name": "my-frontend",
+      "path": "D:\\repos\\my-frontend",
+      "description": "Frontend web application"
+    }
+  ]
+}
+```
+
+### 2. Register as an MCP Server
+
+Add to the `.mcp.json` of the project where you want coordination tools available.
+
+**Using `uvx` (recommended — no global install needed):**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "uvx",
+      "args": ["claude-control"],
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+**Using a pip install:**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "claude-control",
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+**Using `python -m`:**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "python",
+      "args": ["-m", "claude_control"],
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+### 3. Restart Claude Code
+
+The tools will appear as `mcp__claude_control__send_command`, `mcp__claude_control__list_projects`, etc.
+
+## Tools
+
+### `send_command`
+
+Send a prompt to a Claude Code instance in the specified project directory.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name (from projects.json) |
+| `prompt` | string | The prompt to send |
+
+Returns the full text response from the remote instance. Sessions persist across calls — follow-up prompts have access to prior context.
+
+### `list_projects`
+
+List all configured projects with their paths, descriptions, and session status.
+
+### `reset_session`
+
+Tear down a project's Claude Code session. The next `send_command` call creates a fresh session with no prior context.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name to reset |
+
+### `get_session_status`
+
+Check whether a project has an active session, its ID, and turn count.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name to check |
+
+## Dependencies
+
+- Python >= 3.11
+- `claude-code-sdk >= 0.0.25`
+- `mcp >= 1.12.0`
+- Claude Code CLI installed and on PATH
+
+## Configuration
+
+The `CLAUDE_CONTROL_PROJECTS` environment variable points to your `projects.json`. If unset, defaults to `projects.json` in the package's parent directory.

claude_control-0.1.0/README.md

@@ -0,0 +1,155 @@
+# Claude Control
+
+MCP server that lets a Claude Code session coordinate with Claude Code instances running in other project directories.
+
+## How It Works
+
+Claude Control is an MCP server (stdio transport) that exposes tools for dispatching prompts to Claude Code instances in configured project directories. Each remote instance:
+
+- Runs as a persistent subprocess with conversation context preserved across calls
+- Loads the target project's own `CLAUDE.md`, `.mcp.json`, hooks, and settings
+- Runs with `bypassPermissions` for fully autonomous operation
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install claude-control
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install claude-control
+```
+
+### From Source
+
+```bash
+git clone https://github.com/redducklabs/claude-control.git
+cd claude-control
+pip install .
+```
+
+## Setup
+
+### 1. Configure Projects
+
+Create a `projects.json` file (see `projects.json.example`):
+
+```json
+{
+  "projects": [
+    {
+      "name": "my-backend",
+      "path": "D:\\repos\\my-backend",
+      "description": "Backend API service"
+    },
+    {
+      "name": "my-frontend",
+      "path": "D:\\repos\\my-frontend",
+      "description": "Frontend web application"
+    }
+  ]
+}
+```
+
+### 2. Register as an MCP Server
+
+Add to the `.mcp.json` of the project where you want coordination tools available.
+
+**Using `uvx` (recommended — no global install needed):**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "uvx",
+      "args": ["claude-control"],
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+**Using a pip install:**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "claude-control",
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+**Using `python -m`:**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "python",
+      "args": ["-m", "claude_control"],
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+### 3. Restart Claude Code
+
+The tools will appear as `mcp__claude_control__send_command`, `mcp__claude_control__list_projects`, etc.
+
+## Tools
+
+### `send_command`
+
+Send a prompt to a Claude Code instance in the specified project directory.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name (from projects.json) |
+| `prompt` | string | The prompt to send |
+
+Returns the full text response from the remote instance. Sessions persist across calls — follow-up prompts have access to prior context.
+
+### `list_projects`
+
+List all configured projects with their paths, descriptions, and session status.
+
+### `reset_session`
+
+Tear down a project's Claude Code session. The next `send_command` call creates a fresh session with no prior context.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name to reset |
+
+### `get_session_status`
+
+Check whether a project has an active session, its ID, and turn count.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name to check |
+
+## Dependencies
+
+- Python >= 3.11
+- `claude-code-sdk >= 0.0.25`
+- `mcp >= 1.12.0`
+- Claude Code CLI installed and on PATH
+
+## Configuration
+
+The `CLAUDE_CONTROL_PROJECTS` environment variable points to your `projects.json`. If unset, defaults to `projects.json` in the package's parent directory.

claude_control-0.1.0/claude_control/__init__.py

@@ -0,0 +1 @@
+"""Claude Control — MCP server for coordinating Claude Code instances across projects."""

claude_control-0.1.0/claude_control/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m claude_control`."""
+
+from claude_control.server import main
+
+main()

claude_control-0.1.0/claude_control/config.py

@@ -0,0 +1,70 @@
+"""Load and validate project configuration."""
+
+import json
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class ProjectConfig:
+    name: str
+    path: str
+    description: str = ""
+
+
+def load_projects(config_path: str | None = None) -> dict[str, ProjectConfig]:
+    """Load project configurations from JSON file.
+
+    Resolution order for config path:
+    1. Explicit config_path argument
+    2. CLAUDE_CONTROL_PROJECTS environment variable
+    3. projects.json next to this package's parent directory
+    """
+    if config_path is None:
+        config_path = os.environ.get("CLAUDE_CONTROL_PROJECTS")
+
+    if config_path is None:
+        # Default: projects.json in the repo root (parent of claude_control/)
+        package_dir = Path(__file__).resolve().parent
+        config_path = str(package_dir.parent / "projects.json")
+
+    config_file = Path(config_path)
+    if not config_file.exists():
+        print(
+            f"Config file not found: {config_file}. "
+            f"Create it or set CLAUDE_CONTROL_PROJECTS env var.",
+            file=sys.stderr,
+        )
+        return {}
+
+    with open(config_file) as f:
+        data = json.load(f)
+
+    projects: dict[str, ProjectConfig] = {}
+    for entry in data.get("projects", []):
+        name = entry.get("name")
+        path = entry.get("path")
+
+        if not name or not path:
+            print(
+                f"Skipping invalid project entry (missing name or path): {entry}",
+                file=sys.stderr,
+            )
+            continue
+
+        resolved_path = Path(path).resolve()
+        if not resolved_path.exists():
+            print(
+                f"Warning: path does not exist for project '{name}': {resolved_path}",
+                file=sys.stderr,
+            )
+
+        projects[name] = ProjectConfig(
+            name=name,
+            path=str(resolved_path),
+            description=entry.get("description", ""),
+        )
+
+    return projects

claude_control-0.1.0/claude_control/server.py

@@ -0,0 +1,138 @@
+"""Claude Control MCP Server — coordinate Claude Code instances across projects."""
+
+import json
+import logging
+import sys
+from typing import Any, Dict, Optional
+
+from mcp.server.fastmcp import FastMCP
+
+from .config import load_projects
+from .session_manager import SessionManager
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+    stream=sys.stderr,
+)
+logger = logging.getLogger(__name__)
+
+# Initialize MCP server
+mcp = FastMCP("Claude Control")
+
+# Module-level session manager (initialized lazily)
+_session_manager: SessionManager | None = None
+
+
+def _get_manager() -> SessionManager:
+    global _session_manager
+    if _session_manager is None:
+        projects = load_projects()
+        if not projects:
+            logger.warning("No projects configured. Tools will return errors.")
+        else:
+            logger.info("Loaded %d project(s): %s", len(projects), ", ".join(projects.keys()))
+        _session_manager = SessionManager(projects)
+    return _session_manager
+
+
+@mcp.tool()
+async def send_command(project: str, prompt: str) -> Dict[str, Any]:
+    """Send a prompt to a Claude Code instance running in the specified project directory.
+
+    The remote instance maintains conversation context across calls — follow-up
+    prompts will have access to prior context. Use reset_session to start fresh.
+
+    The remote instance runs with full permissions and loads the target project's
+    own CLAUDE.md, MCP servers, and hooks.
+
+    Args:
+        project: Name of the project (as defined in projects.json)
+        prompt: The prompt/command to send to the remote Claude instance
+    """
+    manager = _get_manager()
+    try:
+        result = await manager.send(project, prompt)
+        response: Dict[str, Any] = {"text": result.text}
+        if result.session_id:
+            response["session_id"] = result.session_id
+        if result.is_error:
+            response["is_error"] = True
+        if result.cost_usd is not None:
+            response["cost_usd"] = result.cost_usd
+        if result.num_turns:
+            response["num_turns"] = result.num_turns
+        return response
+    except Exception as e:
+        logger.exception("send_command failed for project '%s'", project)
+        return {"text": f"Error: {e}", "is_error": True}
+
+
+@mcp.tool()
+async def list_projects() -> Dict[str, Any]:
+    """List all configured projects and their session status.
+
+    Returns project names, directory paths, descriptions, and whether
+    each project has an active Claude Code session.
+    """
+    manager = _get_manager()
+    projects = []
+    for name, config in manager.projects.items():
+        status = manager.get_status(name)
+        projects.append({
+            "name": name,
+            "path": config.path,
+            "description": config.description,
+            "active_session": status["active"],
+            "session_id": status["session_id"],
+            "turn_count": status["turn_count"],
+        })
+    return {"projects": projects}
+
+
+@mcp.tool()
+async def reset_session(project: str) -> Dict[str, Any]:
+    """Reset a project's Claude Code session, starting fresh on the next command.
+
+    Disconnects the persistent Claude Code subprocess for the named project.
+    The next send_command call will create a new session with no prior context.
+
+    Args:
+        project: Name of the project whose session to reset
+    """
+    manager = _get_manager()
+    try:
+        existed = await manager.reset(project)
+        if existed:
+            return {"status": "reset", "project": project}
+        return {"status": "no_session", "project": project, "message": "No active session to reset"}
+    except Exception as e:
+        logger.exception("reset_session failed for project '%s'", project)
+        return {"status": "error", "project": project, "message": str(e)}
+
+
+@mcp.tool()
+async def get_session_status(project: str) -> Dict[str, Any]:
+    """Check whether a project has an active Claude Code session.
+
+    Returns session activity status, session ID, and turn count.
+
+    Args:
+        project: Name of the project to check
+    """
+    manager = _get_manager()
+    return manager.get_status(project)
+
+
+def main():
+    try:
+        mcp.run()
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        logger.error("Server failed: %s", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

claude_control-0.1.0/claude_control/session_manager.py

@@ -0,0 +1,160 @@
+"""Manage persistent ClaudeSDKClient sessions for each project."""
+
+import logging
+import sys
+from dataclasses import dataclass, field
+
+from claude_code_sdk import (
+    AssistantMessage,
+    ClaudeCodeOptions,
+    ClaudeSDKClient,
+    ResultMessage,
+    TextBlock,
+)
+from claude_code_sdk._internal.message_parser import parse_message
+
+from .config import ProjectConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class SessionInfo:
+    client: ClaudeSDKClient
+    session_id: str | None = None
+    turn_count: int = 0
+
+
+@dataclass
+class SendResult:
+    text: str
+    session_id: str | None = None
+    is_error: bool = False
+    num_turns: int = 0
+    cost_usd: float | None = None
+
+
+class SessionManager:
+    """Manages persistent Claude Code sessions, one per project."""
+
+    def __init__(self, projects: dict[str, ProjectConfig]) -> None:
+        self.projects = projects
+        self._sessions: dict[str, SessionInfo] = {}
+
+    def _make_options(self, project: ProjectConfig) -> ClaudeCodeOptions:
+        return ClaudeCodeOptions(
+            cwd=project.path,
+            permission_mode="bypassPermissions",
+        )
+
+    async def _ensure_session(self, project_name: str) -> SessionInfo:
+        """Get existing session or create a new one."""
+        if project_name not in self.projects:
+            raise ValueError(
+                f"Unknown project: '{project_name}'. "
+                f"Available: {', '.join(sorted(self.projects.keys()))}"
+            )
+
+        if project_name in self._sessions:
+            return self._sessions[project_name]
+
+        project = self.projects[project_name]
+        options = self._make_options(project)
+        client = ClaudeSDKClient(options)
+
+        try:
+            await client.connect()
+        except Exception as e:
+            logger.error("Failed to connect to Claude for project '%s': %s", project_name, e)
+            raise
+
+        info = SessionInfo(client=client)
+        self._sessions[project_name] = info
+        logger.info("Created new session for project '%s' (cwd=%s)", project_name, project.path)
+        return info
+
+    async def send(self, project_name: str, prompt: str) -> SendResult:
+        """Send a prompt to a project's Claude instance and collect the response."""
+        info = await self._ensure_session(project_name)
+
+        try:
+            await info.client.query(prompt)
+        except Exception as e:
+            # Connection may have died — try once to reconnect
+            logger.warning("Query failed for '%s', attempting reconnect: %s", project_name, e)
+            await self.reset(project_name)
+            info = await self._ensure_session(project_name)
+            await info.client.query(prompt)
+
+        text_parts: list[str] = []
+        result_msg: ResultMessage | None = None
+
+        # Read raw messages from the internal query stream and parse them
+        # ourselves. This lets us skip unknown message types (e.g.
+        # rate_limit_event) that the SDK's parse_message() doesn't handle,
+        # without killing the iteration.
+        async for raw in info.client._query.receive_messages():
+            try:
+                message = parse_message(raw)
+            except Exception as e:
+                logger.debug("Skipping unparseable message (type=%s): %s", raw.get("type"), e)
+                continue
+
+            if isinstance(message, AssistantMessage):
+                for block in message.content:
+                    if isinstance(block, TextBlock):
+                        text_parts.append(block.text)
+            elif isinstance(message, ResultMessage):
+                result_msg = message
+                break
+
+        info.turn_count += 1
+
+        if result_msg:
+            info.session_id = result_msg.session_id
+            return SendResult(
+                text="\n".join(text_parts) if text_parts else "(no text response)",
+                session_id=result_msg.session_id,
+                is_error=result_msg.is_error,
+                num_turns=result_msg.num_turns,
+                cost_usd=result_msg.total_cost_usd,
+            )
+
+        return SendResult(
+            text="\n".join(text_parts) if text_parts else "(no response received)",
+            is_error=True,
+        )
+
+    async def reset(self, project_name: str) -> bool:
+        """Disconnect and remove a project's session. Returns True if a session existed."""
+        info = self._sessions.pop(project_name, None)
+        if info is None:
+            return False
+
+        try:
+            await info.client.disconnect()
+        except Exception:
+            # The SDK's disconnect can throw cancel scope errors due to
+            # anyio/asyncio interaction. The subprocess still gets cleaned up.
+            pass
+
+        logger.info("Reset session for project '%s'", project_name)
+        return True
+
+    def get_status(self, project_name: str) -> dict:
+        """Get session status for a project."""
+        if project_name not in self.projects:
+            return {"error": f"Unknown project: '{project_name}'"}
+
+        info = self._sessions.get(project_name)
+        return {
+            "project": project_name,
+            "active": info is not None,
+            "session_id": info.session_id if info else None,
+            "turn_count": info.turn_count if info else 0,
+        }
+
+    async def shutdown(self) -> None:
+        """Disconnect all sessions."""
+        for name in list(self._sessions.keys()):
+            await self.reset(name)

claude_control-0.1.0/claude_control.egg-info/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: claude-control
+Version: 0.1.0
+Summary: MCP server for coordinating Claude Code instances across multiple projects
+Author-email: Red Duck Labs <support@redducklabs.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/redducklabs/claude-control
+Project-URL: Repository, https://github.com/redducklabs/claude-control
+Project-URL: Issues, https://github.com/redducklabs/claude-control/issues
+Keywords: mcp,claude,claude-code,automation,orchestration
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: claude-code-sdk>=0.0.25
+Requires-Dist: mcp>=1.12.0
+
+# Claude Control
+
+MCP server that lets a Claude Code session coordinate with Claude Code instances running in other project directories.
+
+## How It Works
+
+Claude Control is an MCP server (stdio transport) that exposes tools for dispatching prompts to Claude Code instances in configured project directories. Each remote instance:
+
+- Runs as a persistent subprocess with conversation context preserved across calls
+- Loads the target project's own `CLAUDE.md`, `.mcp.json`, hooks, and settings
+- Runs with `bypassPermissions` for fully autonomous operation
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install claude-control
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install claude-control
+```
+
+### From Source
+
+```bash
+git clone https://github.com/redducklabs/claude-control.git
+cd claude-control
+pip install .
+```
+
+## Setup
+
+### 1. Configure Projects
+
+Create a `projects.json` file (see `projects.json.example`):
+
+```json
+{
+  "projects": [
+    {
+      "name": "my-backend",
+      "path": "D:\\repos\\my-backend",
+      "description": "Backend API service"
+    },
+    {
+      "name": "my-frontend",
+      "path": "D:\\repos\\my-frontend",
+      "description": "Frontend web application"
+    }
+  ]
+}
+```
+
+### 2. Register as an MCP Server
+
+Add to the `.mcp.json` of the project where you want coordination tools available.
+
+**Using `uvx` (recommended — no global install needed):**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "uvx",
+      "args": ["claude-control"],
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+**Using a pip install:**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "claude-control",
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+**Using `python -m`:**
+
+```json
+{
+  "mcpServers": {
+    "claude_control": {
+      "command": "python",
+      "args": ["-m", "claude_control"],
+      "env": {
+        "CLAUDE_CONTROL_PROJECTS": "/path/to/your/projects.json"
+      }
+    }
+  }
+}
+```
+
+### 3. Restart Claude Code
+
+The tools will appear as `mcp__claude_control__send_command`, `mcp__claude_control__list_projects`, etc.
+
+## Tools
+
+### `send_command`
+
+Send a prompt to a Claude Code instance in the specified project directory.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name (from projects.json) |
+| `prompt` | string | The prompt to send |
+
+Returns the full text response from the remote instance. Sessions persist across calls — follow-up prompts have access to prior context.
+
+### `list_projects`
+
+List all configured projects with their paths, descriptions, and session status.
+
+### `reset_session`
+
+Tear down a project's Claude Code session. The next `send_command` call creates a fresh session with no prior context.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name to reset |
+
+### `get_session_status`
+
+Check whether a project has an active session, its ID, and turn count.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `project` | string | Project name to check |
+
+## Dependencies
+
+- Python >= 3.11
+- `claude-code-sdk >= 0.0.25`
+- `mcp >= 1.12.0`
+- Claude Code CLI installed and on PATH
+
+## Configuration
+
+The `CLAUDE_CONTROL_PROJECTS` environment variable points to your `projects.json`. If unset, defaults to `projects.json` in the package's parent directory.

claude_control-0.1.0/claude_control.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+claude_control/__init__.py
+claude_control/__main__.py
+claude_control/config.py
+claude_control/server.py
+claude_control/session_manager.py
+claude_control.egg-info/PKG-INFO
+claude_control.egg-info/SOURCES.txt
+claude_control.egg-info/dependency_links.txt
+claude_control.egg-info/entry_points.txt
+claude_control.egg-info/requires.txt
+claude_control.egg-info/top_level.txt

claude_control-0.1.0/claude_control.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

claude_control-0.1.0/claude_control.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+claude-control = claude_control.server:main

claude_control-0.1.0/claude_control.egg-info/requires.txt

@@ -0,0 +1,2 @@
+claude-code-sdk>=0.0.25
+mcp>=1.12.0

claude_control-0.1.0/claude_control.egg-info/top_level.txt

@@ -0,0 +1 @@
+claude_control

claude_control-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "claude-control"
+version = "0.1.0"
+description = "MCP server for coordinating Claude Code instances across multiple projects"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+  {name = "Red Duck Labs", email = "support@redducklabs.com"}
+]
+keywords = ["mcp", "claude", "claude-code", "automation", "orchestration"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "claude-code-sdk>=0.0.25",
+    "mcp>=1.12.0",
+]
+
+[project.scripts]
+claude-control = "claude_control.server:main"
+
+[project.urls]
+Homepage = "https://github.com/redducklabs/claude-control"
+Repository = "https://github.com/redducklabs/claude-control"
+Issues = "https://github.com/redducklabs/claude-control/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["claude_control*"]

claude_control-0.1.0/setup.cfg

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