@hunyed15/codecgc 0.2.9 → 0.2.11

package/mcp/codexmcp/src/codexmcp/server.py

@@ -198,6 +198,41 @@ def _terminate_process_tree(process: subprocess.Popen[str]) -> None:
     process.kill()
 
 
+CODEX_JS_RELATIVE = Path("node_modules") / "@openai" / "codex" / "bin" / "codex.js"
+
+
+def resolve_cli_command(cli_name: str) -> list[str]:
+    """Resolve a CLI command to a cross-platform executable command list.
+
+    On Windows, prefers direct node invocation (node cli.js) to avoid .cmd shim
+    issues. Falls back to cmd.exe wrapper if .js file is not found.
+
+    Args:
+        cli_name: The CLI command name (e.g., "codex")
+
+    Returns:
+        Command list ready for subprocess.Popen, e.g.:
+        - Linux/Mac: ["/usr/local/bin/codex"]
+        - Windows (node): ["node", "C:\\...\\codex.js"]
+        - Windows (.cmd): ["cmd.exe", "/s", "/c", "C:\\...\\codex.CMD"]
+    """
+    resolved_path = shutil.which(cli_name) or cli_name
+
+    if os.name == "nt":
+        # Prefer direct node invocation on Windows (avoids .cmd shim complexity)
+        shim_dir = Path(resolved_path).parent
+        cli_js = shim_dir / CODEX_JS_RELATIVE
+        if cli_js.is_file():
+            node_path = shutil.which("node") or "node"
+            return [node_path, str(cli_js)]
+
+        # Fallback: wrap .cmd/.bat with cmd.exe
+        if resolved_path.lower().endswith((".cmd", ".bat")):
+            return ["cmd.exe", "/s", "/c", resolved_path]
+
+    return [resolved_path]
+
+
 def run_shell_command(cmd: list[str], timeout_seconds: int = DEFAULT_CODEX_TIMEOUT_SECONDS) -> Generator[str, None, None]:
     """Execute a command and stream its output line-by-line.
 
@@ -207,14 +242,12 @@ def run_shell_command(cmd: list[str], timeout_seconds: int = DEFAULT_CODEX_TIMEO
     Yields:
         Output lines from the command
     """
-    # On Windows, codex is exposed via a *.cmd shim. Use cmd.exe with /s so
-    # user prompts containing quotes/newlines aren't reinterpreted as shell syntax.
-    popen_cmd = cmd.copy()
-    codex_path = shutil.which('codex') or cmd[0]
-    popen_cmd[0] = codex_path
+    # Resolve cmd[0] (e.g., "codex") to a platform-appropriate executable command,
+    # wrapping .cmd/.bat shims with cmd.exe on Windows. The remaining args are
+    # passed through unchanged.
+    popen_cmd = resolve_cli_command(cmd[0]) + cmd[1:]
 
     # Ensure Codex CLI inherits the same Python environment as this MCP server
-    # This is critical for Python 3.11+ syntax compatibility (e.g., except*)
     env = os.environ.copy()
     python_executable = sys.executable
     if python_executable:

package/mcp/geminimcp/src/geminimcp/server.py

@@ -160,23 +160,32 @@ GEMINI_JS_RELATIVE = Path("node_modules") / "@google" / "gemini-cli" / "bundle"
 
 
 def _resolve_gemini_command(cmd: list[str]) -> list[str]:
-    """Resolve the gemini CLI command, preferring direct node invocation on Windows."""
+    """Resolve the gemini CLI command to a cross-platform executable command list.
+
+    On Windows, prefers direct node invocation (node gemini.js) to avoid .cmd shim
+    issues. Falls back to cmd.exe wrapper if gemini.js is not found.
+
+    Args:
+        cmd: Command list starting with "gemini", e.g., ["gemini", "-o", "stream-json", ...]
+
+    Returns:
+        Platform-appropriate command list ready for subprocess.Popen
+    """
     gemini_shim = shutil.which("gemini") or cmd[0]
 
     if os.name == "nt":
+        # Prefer direct node invocation on Windows (avoids .cmd shim complexity)
         shim_dir = Path(gemini_shim).parent
         gemini_js = shim_dir / GEMINI_JS_RELATIVE
         if gemini_js.is_file():
             node_path = shutil.which("node") or "node"
             return [node_path, str(gemini_js)] + cmd[1:]
 
+        # Fallback: wrap .cmd/.bat with cmd.exe
         if gemini_shim.lower().endswith((".cmd", ".bat")):
-            from subprocess import list2cmdline
-            cmd[0] = gemini_shim
-            return ["cmd.exe", "/s", "/c", list2cmdline(cmd)]
+            return ["cmd.exe", "/s", "/c", gemini_shim] + cmd[1:]
 
-    cmd[0] = gemini_shim
-    return cmd
+    return [gemini_shim] + cmd[1:]
 
 
 def run_shell_command(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunyed15/codecgc",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Claude-hosted multi-model workflow product shell for CodeCGC.",
   "license": "MIT",
   "type": "commonjs",

package/scripts/run_codecgc_task.py

@@ -294,9 +294,22 @@ async def execute_payload(payload: dict[str, Any], timeout_seconds: int) -> dict
                     payload["tool_args"],
                     read_timeout_seconds=datetime.timedelta(seconds=timeout_seconds),
                 )
-    except* ExceptionGroup:
-        # MCP SDK 清理阶段的 TaskGroup 异常不影响已获得的结果
-        pass
+    except ExceptionGroup as eg:
+        # 递归展开 TaskGroup 中所有叶子异常
+        def _flatten(exc: BaseException) -> list[str]:
+            if isinstance(exc, ExceptionGroup):
+                result = []
+                for sub in exc.exceptions:
+                    result.extend(_flatten(sub))
+                return result
+            return [f"{type(exc).__name__}: {exc}"]
+        sub_errors = _flatten(eg)
+        if raw_result is None:
+            raise RuntimeError(f"MCP call failed with TaskGroup errors: {'; '.join(sub_errors)}") from eg
+    except Exception as _exc:
+        # 只有在已获得结果的情况下才忽略清理阶段异常；否则保留真实错误
+        if raw_result is None:
+            raise RuntimeError(f"MCP call failed: {type(_exc).__name__}: {_exc}") from _exc
 
     if raw_result is None:
         raise RuntimeError("MCP call failed before producing a result.")