@cpujia/codex-mcp-server 1.0.0

package/.env.example

@@ -0,0 +1,24 @@
+# Codex API Configuration
+CODEX_API_BASE_URL=https://your-codex-service.com/v1
+CODEX_API_KEY=your-api-key-here
+
+# Model Configuration
+# Available models:
+# - gpt-5.3-codex (最强，推荐)
+# - gpt-5.3-codex-spark (超快速，实时编码)
+# - gpt-5.2-codex (稳定版)
+CODEX_MODEL=gpt-5.3-codex
+
+# Reasoning Effort (推理强度)
+# Available values: none, minimal, low, medium, high, xhigh
+# - xhigh: 最强推理能力，适合复杂算法和架构设计
+# - high: 高推理能力，适合一般复杂任务
+# - medium: 中等推理，平衡速度和质量
+# - low: 快速响应，简单任务
+CODEX_REASONING_EFFORT=xhigh
+
+# Optional: Timeout settings (milliseconds)
+CODEX_TIMEOUT=60000
+
+# Optional: Max tokens
+CODEX_MAX_TOKENS=4096

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CPU-JIA
+
+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.

package/README.md

@@ -0,0 +1,210 @@
+# Codex MCP Server
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)](https://www.typescriptlang.org/)
+
+MCP Server for integrating OpenAI Codex `/v1/responses` API with Claude Code. Enables Claude Code to leverage GPT-5.3-Codex's powerful code generation capabilities.
+
+## ✨ Features
+
+- 🚀 **GPT-5.3-Codex Support**: Latest and most powerful Codex model
+- 🧠 **Reasoning Control**: Configurable reasoning effort (xhigh, high, medium, low)
+- 🛠️ **5 Professional Tools**: Generate, edit, explain, fix, and refactor code
+- 📡 **Native `/v1/responses` API**: Full protocol support with streaming
+- 🔒 **Type-Safe**: Complete TypeScript type definitions
+- ⚡ **Production-Ready**: Error handling, timeouts, and retry mechanisms
+
+## 📦 Installation
+
+### Option A: Install via npm (Recommended)
+
+```bash
+# Global installation
+npm install -g @cpujia/codex-mcp-server
+
+# Add to Claude Code
+claude mcp add --scope user codex -- codex-mcp
+```
+
+### Option B: Install from source
+
+```bash
+# Clone the repository
+git clone https://github.com/CPU-JIA/codex-mcp-server.git
+cd codex-mcp-server
+
+# Install dependencies
+npm install
+
+# Configure environment
+cp .env.example .env
+# Edit .env with your Codex API credentials
+
+# Build
+npm run build
+
+# Add to Claude Code
+claude mcp add --scope user codex -- node /absolute/path/to/codex-mcp-server/dist/index.js
+```
+
+### Option C: Use with npx (No installation required)
+
+```bash
+# Add to Claude Code using npx
+claude mcp add --scope user codex -- npx @cpujia/codex-mcp-server
+```
+
+### Detailed Installation
+
+See [QUICKSTART.md](QUICKSTART.md) for step-by-step instructions.
+
+## 🔧 Configuration
+
+### Environment Variables
+
+```env
+CODEX_API_BASE_URL=https://your-codex-service.com/v1
+CODEX_API_KEY=your-api-key-here
+CODEX_MODEL=gpt-5.3-codex
+CODEX_REASONING_EFFORT=xhigh
+CODEX_TIMEOUT=60000
+CODEX_MAX_TOKENS=4096
+```
+
+### Claude Code Integration
+
+**Option A: Command Line (Recommended)**
+
+```bash
+claude mcp add --scope user codex -- node /path/to/codex-mcp-server/dist/index.js
+```
+
+**Option B: Manual Configuration**
+
+Edit `%APPDATA%\Claude\mcp.json` (Windows) or `~/.config/claude/mcp.json` (Linux/Mac):
+
+```json
+{
+  "mcpServers": {
+    "codex": {
+      "command": "node",
+      "args": ["/absolute/path/to/codex-mcp-server/dist/index.js"],
+      "env": {
+        "CODEX_API_BASE_URL": "https://your-codex-service.com/v1",
+        "CODEX_API_KEY": "your-api-key-here",
+        "CODEX_MODEL": "gpt-5.3-codex",
+        "CODEX_REASONING_EFFORT": "xhigh"
+      }
+    }
+  }
+}
+```
+
+See [CLAUDE_CODE_CONFIG.md](CLAUDE_CODE_CONFIG.md) for detailed configuration options.
+
+## 🛠️ Available Tools
+
+| Tool             | Description                                | Use Case                                 |
+| ---------------- | ------------------------------------------ | ---------------------------------------- |
+| `codex_generate` | Generate new code from natural language    | Create functions, components, algorithms |
+| `codex_edit`     | Modify existing code based on instructions | Add features, refactor, optimize         |
+| `codex_explain`  | Explain code logic and complexity          | Understand algorithms, review code       |
+| `codex_fix`      | Fix bugs based on error messages           | Debug, resolve issues                    |
+| `codex_refactor` | Improve code quality and structure         | Simplify logic, enhance readability      |
+
+### Example Usage
+
+```
+Claude, use codex_generate to create a TypeScript function that implements a binary search tree
+```
+
+See [EXAMPLES.md](EXAMPLES.md) for more detailed examples.
+
+## 🎯 Reasoning Effort Levels
+
+| Level    | Speed   | Quality | Best For                                |
+| -------- | ------- | ------- | --------------------------------------- |
+| `xhigh`  | Slowest | Highest | Complex algorithms, architecture design |
+| `high`   | Slow    | High    | General complex tasks, refactoring      |
+| `medium` | Medium  | Medium  | Daily development, balanced use         |
+| `low`    | Fast    | Basic   | Simple tasks, code completion           |
+
+See [GPT-5.3-CODEX-CONFIG.md](GPT-5.3-CODEX-CONFIG.md) for detailed reasoning configuration.
+
+## 📚 Documentation
+
+- [QUICKSTART.md](QUICKSTART.md) - Quick installation guide
+- [EXAMPLES.md](EXAMPLES.md) - Detailed usage examples
+- [CLAUDE_CODE_CONFIG.md](CLAUDE_CODE_CONFIG.md) - Claude Code integration
+- [GPT-5.3-CODEX-CONFIG.md](GPT-5.3-CODEX-CONFIG.md) - GPT-5.3-Codex configuration
+
+## 🏗️ Architecture
+
+```
+Claude Code (Orchestrator)
+    ↓
+MCP Server (Protocol Bridge)
+    ↓
+Codex API (/v1/responses)
+```
+
+**Separation of Concerns:**
+
+- **Claude Code**: Requirement understanding, file operations, command execution, tool orchestration
+- **Codex**: Code generation, editing, analysis (with powerful reasoning)
+
+## 🔍 Troubleshooting
+
+### "Cannot find module"
+
+```bash
+cd /path/to/codex-mcp-server
+npm run build
+```
+
+### "CODEX_API_BASE_URL must be set"
+
+Check your `.env` file or Claude Code configuration `env` fields.
+
+### Claude Code doesn't see the tools
+
+1. Verify the configuration file path is correct
+2. Restart Claude Code
+3. Check Claude Code logs for errors
+
+### API call failures
+
+1. Test your Codex API endpoint:
+   ```bash
+   curl -X POST https://your-codex-service.com/v1/responses \
+     -H "Authorization: Bearer your-api-key" \
+     -H "Content-Type: application/json" \
+     -d '{"model":"gpt-5.3-codex","input":[{"role":"user","content":"test"}]}'
+   ```
+2. Verify API key is valid
+3. Check network connectivity
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- [Anthropic](https://www.anthropic.com/) for Claude Code and MCP
+- [OpenAI](https://openai.com/) for GPT-5.3-Codex
+- [Model Context Protocol](https://modelcontextprotocol.io/) community
+
+## 📞 Support
+
+- **Issues**: [GitHub Issues](https://github.com/CPU-JIA/codex-mcp-server/issues)
+- **Documentation**: See docs in this repository
+- **Community**: [MCP Discord](https://discord.gg/modelcontextprotocol)
+
+---
+
+**Enjoy the powerful combination of Claude + Codex!** 🚀

package/dist/codex-client.d.ts

@@ -0,0 +1,15 @@
+interface CodexClientConfig {
+    baseURL: string;
+    apiKey: string;
+    model: string;
+    timeout: number;
+    maxTokens: number;
+    reasoningEffort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh";
+}
+export declare class CodexClient {
+    private config;
+    constructor(config: CodexClientConfig);
+    generate(input: string): Promise<string>;
+    generateStream(input: string, onChunk: (text: string) => void): Promise<void>;
+}
+export {};

package/dist/codex-client.js

@@ -0,0 +1,139 @@
+export class CodexClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async generate(input) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const requestBody = {
+                model: this.config.model,
+                input: [
+                    {
+                        role: "user",
+                        content: input,
+                    },
+                ],
+                max_output_tokens: this.config.maxTokens,
+            };
+            if (this.config.reasoningEffort) {
+                requestBody.reasoning = {
+                    effort: this.config.reasoningEffort,
+                };
+            }
+            const response = await fetch(`${this.config.baseURL}/responses`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Codex API error (${response.status}): ${errorText}`);
+            }
+            const data = (await response.json());
+            if (data.status !== "completed") {
+                throw new Error(`Unexpected response status: ${data.status}`);
+            }
+            const textContent = data.content.find((c) => c.type === "output_text");
+            if (!textContent?.text) {
+                throw new Error("No text content in response");
+            }
+            return textContent.text;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error) {
+                if (error.name === "AbortError") {
+                    throw new Error(`Request timeout after ${this.config.timeout}ms`);
+                }
+                throw error;
+            }
+            throw new Error(`Unknown error: ${String(error)}`);
+        }
+    }
+    async generateStream(input, onChunk) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const requestBody = {
+                model: this.config.model,
+                input: [
+                    {
+                        role: "user",
+                        content: input,
+                    },
+                ],
+                max_output_tokens: this.config.maxTokens,
+                stream: true,
+            };
+            if (this.config.reasoningEffort) {
+                requestBody.reasoning = {
+                    effort: this.config.reasoningEffort,
+                };
+            }
+            const response = await fetch(`${this.config.baseURL}/responses`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify(requestBody),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Codex API error (${response.status}): ${errorText}`);
+            }
+            if (!response.body) {
+                throw new Error("No response body");
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (!line.trim() || line.startsWith(":"))
+                        continue;
+                    if (line.startsWith("data: ")) {
+                        const data = line.slice(6);
+                        if (data === "[DONE]") {
+                            return;
+                        }
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed.type === "response.output_text.delta") {
+                                onChunk(parsed.delta || "");
+                            }
+                        }
+                        catch (e) {
+                            console.error("Failed to parse SSE data:", e);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error) {
+                if (error.name === "AbortError") {
+                    throw new Error(`Request timeout after ${this.config.timeout}ms`);
+                }
+                throw error;
+            }
+            throw new Error(`Unknown error: ${String(error)}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CodexClient } from "./codex-client.js";
+import { tools } from "./tools.js";
+const CODEX_API_BASE_URL = process.env.CODEX_API_BASE_URL;
+const CODEX_API_KEY = process.env.CODEX_API_KEY;
+const CODEX_MODEL = process.env.CODEX_MODEL || "gpt-5.3-codex";
+const CODEX_REASONING_EFFORT = process.env.CODEX_REASONING_EFFORT;
+if (!CODEX_API_BASE_URL || !CODEX_API_KEY) {
+    console.error("Error: CODEX_API_BASE_URL and CODEX_API_KEY must be set");
+    process.exit(1);
+}
+const codexClient = new CodexClient({
+    baseURL: CODEX_API_BASE_URL,
+    apiKey: CODEX_API_KEY,
+    model: CODEX_MODEL,
+    timeout: parseInt(process.env.CODEX_TIMEOUT || "60000"),
+    maxTokens: parseInt(process.env.CODEX_MAX_TOKENS || "4096"),
+    reasoningEffort: CODEX_REASONING_EFFORT,
+});
+const server = new Server({
+    name: "codex-mcp-server",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case "codex_generate": {
+                const { prompt, language, context } = args;
+                const input = buildGenerateInput(prompt, language, context);
+                const result = await codexClient.generate(input);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result,
+                        },
+                    ],
+                };
+            }
+            case "codex_edit": {
+                const { code, instruction, language } = args;
+                const input = buildEditInput(code, instruction, language);
+                const result = await codexClient.generate(input);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result,
+                        },
+                    ],
+                };
+            }
+            case "codex_explain": {
+                const { code, language, focus } = args;
+                const input = buildExplainInput(code, language, focus);
+                const result = await codexClient.generate(input);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result,
+                        },
+                    ],
+                };
+            }
+            case "codex_fix": {
+                const { code, error, language } = args;
+                const input = buildFixInput(code, error, language);
+                const result = await codexClient.generate(input);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result,
+                        },
+                    ],
+                };
+            }
+            case "codex_refactor": {
+                const { code, goal, language } = args;
+                const input = buildRefactorInput(code, goal, language);
+                const result = await codexClient.generate(input);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: result,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+function buildGenerateInput(prompt, language, context) {
+    let input = "";
+    if (language) {
+        input += `Language: ${language}\n\n`;
+    }
+    if (context) {
+        input += `Context:\n${context}\n\n`;
+    }
+    input += `Task: ${prompt}\n\nGenerate the code:`;
+    return input;
+}
+function buildEditInput(code, instruction, language) {
+    let input = "";
+    if (language) {
+        input += `Language: ${language}\n\n`;
+    }
+    input += `Original code:\n\`\`\`\n${code}\n\`\`\`\n\n`;
+    input += `Instruction: ${instruction}\n\n`;
+    input += `Modified code:`;
+    return input;
+}
+function buildExplainInput(code, language, focus) {
+    let input = "";
+    if (language) {
+        input += `Language: ${language}\n\n`;
+    }
+    input += `Code:\n\`\`\`\n${code}\n\`\`\`\n\n`;
+    if (focus) {
+        input += `Focus on: ${focus}\n\n`;
+    }
+    input += `Explain this code:`;
+    return input;
+}
+function buildFixInput(code, error, language) {
+    let input = "";
+    if (language) {
+        input += `Language: ${language}\n\n`;
+    }
+    input += `Code with error:\n\`\`\`\n${code}\n\`\`\`\n\n`;
+    input += `Error message:\n${error}\n\n`;
+    input += `Fixed code:`;
+    return input;
+}
+function buildRefactorInput(code, goal, language) {
+    let input = "";
+    if (language) {
+        input += `Language: ${language}\n\n`;
+    }
+    input += `Original code:\n\`\`\`\n${code}\n\`\`\`\n\n`;
+    input += `Refactoring goal: ${goal}\n\n`;
+    input += `Refactored code:`;
+    return input;
+}
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Codex MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/tools.d.ts

@@ -0,0 +1,131 @@
+export declare const tools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            prompt: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                description: string;
+            };
+            code?: undefined;
+            instruction?: undefined;
+            focus?: undefined;
+            error?: undefined;
+            goal?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            code: {
+                type: string;
+                description: string;
+            };
+            instruction: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                description: string;
+            };
+            prompt?: undefined;
+            context?: undefined;
+            focus?: undefined;
+            error?: undefined;
+            goal?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            code: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                description: string;
+            };
+            focus: {
+                type: string;
+                description: string;
+            };
+            prompt?: undefined;
+            context?: undefined;
+            instruction?: undefined;
+            error?: undefined;
+            goal?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            code: {
+                type: string;
+                description: string;
+            };
+            error: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                description: string;
+            };
+            prompt?: undefined;
+            context?: undefined;
+            instruction?: undefined;
+            focus?: undefined;
+            goal?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            code: {
+                type: string;
+                description: string;
+            };
+            goal: {
+                type: string;
+                description: string;
+            };
+            language: {
+                type: string;
+                description: string;
+            };
+            prompt?: undefined;
+            context?: undefined;
+            instruction?: undefined;
+            focus?: undefined;
+            error?: undefined;
+        };
+        required: string[];
+    };
+})[];

package/dist/tools.js

@@ -0,0 +1,112 @@
+export const tools = [
+    {
+        name: "codex_generate",
+        description: "Generate code based on a natural language prompt. Use this for creating new code from scratch, implementing features, or writing functions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                prompt: {
+                    type: "string",
+                    description: "Natural language description of what code to generate",
+                },
+                language: {
+                    type: "string",
+                    description: "Programming language (e.g., typescript, python, rust)",
+                },
+                context: {
+                    type: "string",
+                    description: "Additional context like existing code, dependencies, or requirements",
+                },
+            },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "codex_edit",
+        description: "Edit existing code based on instructions. Use this for modifying, updating, or improving existing code.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The existing code to edit",
+                },
+                instruction: {
+                    type: "string",
+                    description: "What changes to make to the code",
+                },
+                language: {
+                    type: "string",
+                    description: "Programming language of the code",
+                },
+            },
+            required: ["code", "instruction"],
+        },
+    },
+    {
+        name: "codex_explain",
+        description: "Explain how code works. Use this for understanding complex code, algorithms, or logic.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code to explain",
+                },
+                language: {
+                    type: "string",
+                    description: "Programming language of the code",
+                },
+                focus: {
+                    type: "string",
+                    description: "Specific aspect to focus on (e.g., 'performance', 'security', 'algorithm')",
+                },
+            },
+            required: ["code"],
+        },
+    },
+    {
+        name: "codex_fix",
+        description: "Fix buggy code based on error messages. Use this for debugging and fixing runtime or compilation errors.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code with the bug",
+                },
+                error: {
+                    type: "string",
+                    description: "The error message or description of the bug",
+                },
+                language: {
+                    type: "string",
+                    description: "Programming language of the code",
+                },
+            },
+            required: ["code", "error"],
+        },
+    },
+    {
+        name: "codex_refactor",
+        description: "Refactor code to improve quality, readability, or performance. Use this for code cleanup and optimization.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "The code to refactor",
+                },
+                goal: {
+                    type: "string",
+                    description: "Refactoring goal (e.g., 'improve readability', 'optimize performance', 'reduce complexity')",
+                },
+                language: {
+                    type: "string",
+                    description: "Programming language of the code",
+                },
+            },
+            required: ["code", "goal"],
+        },
+    },
+];

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@cpujia/codex-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP Server for OpenAI Codex /v1/responses API integration with Claude Code",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "codex-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "codex",
+    "openai",
+    "gpt-5.3-codex",
+    "code-generation",
+    "claude-code",
+    "model-context-protocol",
+    "ai",
+    "code-assistant",
+    "typescript"
+  ],
+  "author": "CPU-JIA <jia202520@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CPU-JIA/codex-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/CPU-JIA/codex-mcp-server/issues"
+  },
+  "homepage": "https://github.com/CPU-JIA/codex-mcp-server#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}