codex-cli-mcp-slim 0.1.0__tar.gz → 0.1.1__tar.gz

{codex_cli_mcp_slim-0.1.0/src/codex_cli_mcp_slim.egg-info → codex_cli_mcp_slim-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-cli-mcp-slim
-Version: 0.1.0
+Version: 0.1.1
 Summary: A thin, auditable MCP server wrapping the Codex CLI (codex exec). Same tools as the deprecated `codex mcp-server`; forward-compatible with future CLI flags via extra_args passthrough.
 Author-email: tksfjt1024 <tksfjt1024@gmail.com>
 License: MIT
@@ -171,7 +171,9 @@ After:
 Parameter names differ from the old server where `codex exec` names the flag
 differently: `cwd` is now `cd` (the `-C/--cd` flag), and `codex-reply` takes
 `thread_id` instead of `threadId`. The result's `structuredContent` field keeps
-the shape the old server returned, `{"threadId": ..., "content": ...}`.
+the shape the old server returned, `{"threadId": ..., "content": ...}`. It
+gains an `ignoredParameters` key only when the server's own flags overrode a
+per-call parameter (see [Server-level flags](#server-level-flags)).
 
 ### Other MCP clients
 
@@ -207,11 +209,25 @@ in reasoning effort look like this:
 
 A call to `codex-high` runs
 `codex exec -c model_reasoning_effort=high [per-call flags] --json -`. Per-call
-flags come after the server-level ones, and `-c` may repeat with the last one
-winning, so a per-call `config` entry overrides a server-level `-c`. Single-value
-flags such as `-m` and `-C` may not repeat: `codex` rejects the second one, and
-the tool result carries that error. Keep server-level flags and per-call
-parameters disjoint for those.
+flags come after the server-level ones. `-c` and `--add-dir` may repeat. For
+`-c` the last one wins, so a per-call `config` entry overrides a server-level
+`-c`.
+
+The other typed flags (`-C`, `-m`, `--sandbox`, `-p`, `--ephemeral`,
+`--skip-git-repo-check`) may appear only once: `codex` exits with "cannot be used
+multiple times" on a second one. When the server's command line already sets one
+of them, in any spelling (for example `-C DIR`, `-CDIR`, `--cd=DIR`), the
+server-level value wins. A token that is another flag's value (the `-m` in
+`-c -m`) or that comes after `--` does not count as setting a flag. The `codex`
+tool leaves the matching per-call parameter (`cd`, `model`, `sandbox`,
+`profile`, `ephemeral`, `skip_git_repo_check`) out of the command and names it
+in the result together with the server-level value used instead: in the text
+after the `[codex]` line (`cd="/other"; this server runs with -C /srv`) and in
+`structuredContent.ignoredParameters`. Its schema tells the caller which
+parameters the server already sets, and to what. `codex-reply` keeps such
+parameters, because after `resume` they are the subcommand's own flags and
+`codex` accepts them there. `extra_args` is passed through unchecked, so a flag
+repeated through it still fails with `codex`'s own error.
 
 ## Tool: `codex`
 
@@ -226,7 +242,10 @@ The tool returns that final message followed by one metadata line:
 ```
 
 `thread_id` and `status` are always present; the token fields appear when the
-run reported them. `isError` is the flag on an MCP tool result that tells the
+run reported them. A per-call parameter that a server-level flag overrode is
+named after this line, with the value used instead (see
+[Server-level flags](#server-level-flags)).
+`isError` is the flag on an MCP tool result that tells the
 client a call failed. This server sets it when `codex` exited non-zero, when the
 subprocess timed out, and when the turn itself failed. The last case matters
 because `codex exec` exits 0 after a failure inside the model API; the tool

{codex_cli_mcp_slim-0.1.0 → codex_cli_mcp_slim-0.1.1}/README.md

@@ -136,7 +136,9 @@ After:
 Parameter names differ from the old server where `codex exec` names the flag
 differently: `cwd` is now `cd` (the `-C/--cd` flag), and `codex-reply` takes
 `thread_id` instead of `threadId`. The result's `structuredContent` field keeps
-the shape the old server returned, `{"threadId": ..., "content": ...}`.
+the shape the old server returned, `{"threadId": ..., "content": ...}`. It
+gains an `ignoredParameters` key only when the server's own flags overrode a
+per-call parameter (see [Server-level flags](#server-level-flags)).
 
 ### Other MCP clients
 
@@ -172,11 +174,25 @@ in reasoning effort look like this:
 
 A call to `codex-high` runs
 `codex exec -c model_reasoning_effort=high [per-call flags] --json -`. Per-call
-flags come after the server-level ones, and `-c` may repeat with the last one
-winning, so a per-call `config` entry overrides a server-level `-c`. Single-value
-flags such as `-m` and `-C` may not repeat: `codex` rejects the second one, and
-the tool result carries that error. Keep server-level flags and per-call
-parameters disjoint for those.
+flags come after the server-level ones. `-c` and `--add-dir` may repeat. For
+`-c` the last one wins, so a per-call `config` entry overrides a server-level
+`-c`.
+
+The other typed flags (`-C`, `-m`, `--sandbox`, `-p`, `--ephemeral`,
+`--skip-git-repo-check`) may appear only once: `codex` exits with "cannot be used
+multiple times" on a second one. When the server's command line already sets one
+of them, in any spelling (for example `-C DIR`, `-CDIR`, `--cd=DIR`), the
+server-level value wins. A token that is another flag's value (the `-m` in
+`-c -m`) or that comes after `--` does not count as setting a flag. The `codex`
+tool leaves the matching per-call parameter (`cd`, `model`, `sandbox`,
+`profile`, `ephemeral`, `skip_git_repo_check`) out of the command and names it
+in the result together with the server-level value used instead: in the text
+after the `[codex]` line (`cd="/other"; this server runs with -C /srv`) and in
+`structuredContent.ignoredParameters`. Its schema tells the caller which
+parameters the server already sets, and to what. `codex-reply` keeps such
+parameters, because after `resume` they are the subcommand's own flags and
+`codex` accepts them there. `extra_args` is passed through unchecked, so a flag
+repeated through it still fails with `codex`'s own error.
 
 ## Tool: `codex`
 
@@ -191,7 +207,10 @@ The tool returns that final message followed by one metadata line:
 ```
 
 `thread_id` and `status` are always present; the token fields appear when the
-run reported them. `isError` is the flag on an MCP tool result that tells the
+run reported them. A per-call parameter that a server-level flag overrode is
+named after this line, with the value used instead (see
+[Server-level flags](#server-level-flags)).
+`isError` is the flag on an MCP tool result that tells the
 client a call failed. This server sets it when `codex` exited non-zero, when the
 subprocess timed out, and when the turn itself failed. The last case matters
 because `codex exec` exits 0 after a failure inside the model API; the tool

{codex_cli_mcp_slim-0.1.0 → codex_cli_mcp_slim-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codex-cli-mcp-slim"
-version = "0.1.0"
+version = "0.1.1"
 description = "A thin, auditable MCP server wrapping the Codex CLI (codex exec). Same tools as the deprecated `codex mcp-server`; forward-compatible with future CLI flags via extra_args passthrough."
 readme = "README.md"
 requires-python = ">=3.10"

{codex_cli_mcp_slim-0.1.0 → codex_cli_mcp_slim-0.1.1}/src/codex_cli_mcp_slim/server.py

@@ -20,10 +20,11 @@ import contextlib
 import json
 import logging
 import os
+import shlex
 import signal
 import sys
 from importlib.metadata import version as _pkg_version
-from typing import Any
+from typing import Any, NamedTuple
 
 from mcp.server import Server, ServerRequestContext
 from mcp.server.stdio import stdio_server
@@ -49,12 +50,89 @@ _PKG_NAME = "codex-cli-mcp-slim"
 #
 #     uvx codex-cli-mcp-slim -c model_reasoning_effort=high -C /srv/scratch
 #
-# `-c` may repeat and the last one wins, so a per-call `config` can override a server-level
-# `-c`. Single-value flags such as `-m` and `-C` may not repeat: codex rejects the second
-# one, and the tool result carries that error. Keep server-level flags and per-call
-# parameters disjoint for those.
+# `-c` and `--add-dir` may repeat (for `-c` the last one wins), so a per-call `config` can
+# override a server-level `-c`. The flags in _SINGLE_USE_FLAGS may not: see there.
 SERVER_ARGS: list[str] = []
 
+# Per-call parameters whose flag codex accepts only once, with every spelling of that flag.
+# A second occurrence makes `codex exec` exit 2 with "cannot be used multiple times", so when
+# the server's own command line already carries one of these flags, the per-call parameter
+# is left out of argv and the server-level value is used: whoever started the server fixed
+# that configuration on purpose.
+_SINGLE_USE_FLAGS: dict[str, tuple[str, ...]] = {
+    "cd": ("-C", "--cd"),
+    "model": ("-m", "--model"),
+    "sandbox": ("-s", "--sandbox"),
+    "profile": ("-p", "--profile"),
+    "ephemeral": ("--ephemeral",),
+    "skip_git_repo_check": ("--skip-git-repo-check",),
+}
+
+
+# The `codex exec` options (codex-cli 0.159.2) that take the next token as their value, so
+# _params_set_by reads that token as a value and never as a flag of its own.
+_VALUE_FLAGS = frozenset(
+    {
+        *("-c", "--config", "--enable", "--disable", "-i", "--image"),
+        *("-m", "--model", "--local-provider", "-p", "--profile", "-s", "--sandbox"),
+        *("-C", "--cd", "--add-dir", "--thread-source", "--output-schema", "--color"),
+        *("-o", "--output-last-message"),
+    }
+)
+
+
+class _ServerSetting(NamedTuple):
+    """How the server's own command line sets one of the _SINGLE_USE_FLAGS parameters."""
+
+    value: str | bool  # the flag's value, or True for a flag without one
+    written: str  # the flag as that command line spells it, for example `-C /srv`
+
+
+def _params_set_by(server_args: list[str]) -> dict[str, _ServerSetting]:
+    """The _SINGLE_USE_FLAGS parameters whose flag already appears in `server_args`.
+
+    A flag counts in every form codex parses as that flag: `--cd DIR`, `--cd=DIR`, `-C DIR`
+    and the attached short forms `-CDIR` and `-C=DIR`. Short flags are case-sensitive, so the
+    repeatable `-c` is not mistaken for `-C`. The token after a _VALUE_FLAGS option is its
+    value (`-m` in `-c -m` is not the model flag), and nothing after `--` is a flag.
+    """
+    held: dict[str, _ServerSetting] = {}
+    tokens = iter(server_args)
+    for token in tokens:
+        if token == "--":
+            break
+        if token in _VALUE_FLAGS:
+            value = next(tokens, None)
+            if value is None:
+                break
+            param = next((p for p, flags in _SINGLE_USE_FLAGS.items() if token in flags), None)
+            if param is not None:
+                held.setdefault(param, _ServerSetting(value, shlex.join([token, value])))
+            continue
+        for param, spellings in _SINGLE_USE_FLAGS.items():
+            for flag in spellings:
+                if token == flag:
+                    held.setdefault(param, _ServerSetting(True, token))
+                elif len(flag) == 2 and token.startswith(flag):
+                    value = token[2:].removeprefix("=")
+                    held.setdefault(param, _ServerSetting(value, shlex.quote(token)))
+                elif token.startswith(flag + "="):
+                    value = token[len(flag) + 1 :]
+                    held.setdefault(param, _ServerSetting(value, shlex.quote(token)))
+    return held
+
+
+# What SERVER_ARGS sets among the _SINGLE_USE_FLAGS parameters. _set_server_args parses it
+# once, together with SERVER_ARGS, so _build_argv, _invoke and on_list_tools read one answer.
+_SERVER_SET: dict[str, _ServerSetting] = {}
+
+
+def _set_server_args(server_args: list[str]) -> None:
+    global SERVER_ARGS, _SERVER_SET
+    SERVER_ARGS = list(server_args)
+    _SERVER_SET = _params_set_by(SERVER_ARGS)
+
+
 # The Server is built at the bottom of this file: v2 takes the handlers as constructor
 # arguments, so they must already be defined by the time it is constructed.
 
@@ -73,8 +151,11 @@ def _build_argv(
     extra_args: list[str] | None = None,
     server_args: list[str] | None = None,
 ) -> list[str]:
-    argv: list[str] = [CODEX_CMD, "exec"]
-    argv += SERVER_ARGS if server_args is None else server_args
+    if server_args is None:
+        server_args, server_set = SERVER_ARGS, _SERVER_SET
+    else:
+        server_set = _params_set_by(server_args)
+    argv: list[str] = [CODEX_CMD, "exec", *server_args]
     if thread_id:
         # `codex exec resume <id>` is a subcommand: it has to come before the per-call flags,
         # and it accepts only a subset of them (the `codex-reply` schema advertises just that
@@ -82,21 +163,25 @@ def _build_argv(
         # `exec` options there, so a server pinned to a working directory keeps that
         # directory for replies as well.
         argv += ["resume", thread_id]
-    if cd:
+    # Per-call flags after `resume` are the subcommand's own, and codex accepts them there
+    # even when the same flag sits among the server-level ones, so only a plain `exec` call
+    # leaves out what the server already sets.
+    held = {} if thread_id else server_set
+    if cd and "cd" not in held:
         argv += ["-C", cd]
-    if model:
+    if model and "model" not in held:
         argv += ["-m", model]
     for item in config or []:
         argv += ["-c", item]  # repeatable flag: one -c per key=value
-    if sandbox:
+    if sandbox and "sandbox" not in held:
         argv += ["--sandbox", sandbox]
     for d in add_dir or []:
         argv += ["--add-dir", d]  # repeatable flag: one --add-dir per directory
-    if profile:
+    if profile and "profile" not in held:
         argv += ["-p", profile]
-    if ephemeral:
+    if ephemeral and "ephemeral" not in held:
         argv.append("--ephemeral")
-    if skip_git_repo_check:
+    if skip_git_repo_check and "skip_git_repo_check" not in held:
         argv.append("--skip-git-repo-check")
     if extra_args:
         argv += list(extra_args)
@@ -608,11 +693,33 @@ async def _invoke(arguments: dict[str, Any] | None, *, reply: bool) -> CallToolR
     )
     parsed = _parse_events(result.get("stdout", ""))
     text = _format_result(result)
+    # Name what _build_argv left out, and the value used instead, so a caller does not take a
+    # run in the server's directory (say) for a run in the one it asked for.
+    held = {} if reply else _SERVER_SET
+    dropped = [param for param in _SINGLE_USE_FLAGS if param in held and args.get(param)]
     structured: dict[str, Any] | None = None
     if parsed["thread_id"]:
         # The same shape the deprecated `codex mcp-server` returned, so a client that reads
         # structuredContent.threadId keeps working.
         structured = {"threadId": parsed["thread_id"], "content": _response_text(parsed)}
+    if dropped:
+        lines = [
+            f"{p}={json.dumps(args[p], ensure_ascii=False)}; "
+            f"this server runs with {held[p].written}"
+            for p in dropped
+        ]
+        logger.warning("per-call parameters ignored: %s", " | ".join(lines))
+        text += (
+            "\n\nignored, because this server's own command line already sets the flag "
+            "and codex takes it only once:\n" + "\n".join(lines)
+        )
+        # A client that reads only structuredContent learns it here.
+        structured = {
+            **(structured or {}),
+            "ignoredParameters": [
+                {"name": p, "value": args[p], "serverValue": held[p].value} for p in dropped
+            ],
+        }
     return CallToolResult(
         content=[TextContent(type="text", text=text)],
         structured_content=structured,
@@ -631,7 +738,23 @@ async def codex_reply(arguments: dict[str, Any] | None) -> CallToolResult:
 async def on_list_tools(
     ctx: ServerRequestContext, params: PaginatedRequestParams | None
 ) -> ListToolsResult:
-    return ListToolsResult(tools=[_CODEX_TOOL, _REPLY_TOOL])
+    # The caller cannot see the server's command line, so the `codex` schema says which
+    # parameters it already fixes, rather than inviting values that _build_argv would drop.
+    if not _SERVER_SET:
+        return ListToolsResult(tools=[_CODEX_TOOL, _REPLY_TOOL])
+    props = dict(_CODEX_PROPS)
+    for param, setting in _SERVER_SET.items():
+        props[param] = {
+            **props[param],
+            "description": (
+                f"{props[param]['description']} This server's own command line already "
+                f"sets {setting.written}, so a value passed here is ignored."
+            ),
+        }
+    codex_tool = _CODEX_TOOL.model_copy(
+        update={"input_schema": {**_CODEX_TOOL.input_schema, "properties": props}}
+    )
+    return ListToolsResult(tools=[codex_tool, _REPLY_TOOL])
 
 
 async def on_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
@@ -691,7 +814,7 @@ def main() -> None:
     if sys.argv[1:] == ["--version"]:
         print(f"{_PKG_NAME} {_pkg_version(_PKG_NAME)}")
         return
-    SERVER_ARGS[:] = sys.argv[1:]
+    _set_server_args(sys.argv[1:])
     asyncio.run(_amain())
 
 

{codex_cli_mcp_slim-0.1.0 → codex_cli_mcp_slim-0.1.1/src/codex_cli_mcp_slim.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-cli-mcp-slim
-Version: 0.1.0
+Version: 0.1.1
 Summary: A thin, auditable MCP server wrapping the Codex CLI (codex exec). Same tools as the deprecated `codex mcp-server`; forward-compatible with future CLI flags via extra_args passthrough.
 Author-email: tksfjt1024 <tksfjt1024@gmail.com>
 License: MIT
@@ -171,7 +171,9 @@ After:
 Parameter names differ from the old server where `codex exec` names the flag
 differently: `cwd` is now `cd` (the `-C/--cd` flag), and `codex-reply` takes
 `thread_id` instead of `threadId`. The result's `structuredContent` field keeps
-the shape the old server returned, `{"threadId": ..., "content": ...}`.
+the shape the old server returned, `{"threadId": ..., "content": ...}`. It
+gains an `ignoredParameters` key only when the server's own flags overrode a
+per-call parameter (see [Server-level flags](#server-level-flags)).
 
 ### Other MCP clients
 
@@ -207,11 +209,25 @@ in reasoning effort look like this:
 
 A call to `codex-high` runs
 `codex exec -c model_reasoning_effort=high [per-call flags] --json -`. Per-call
-flags come after the server-level ones, and `-c` may repeat with the last one
-winning, so a per-call `config` entry overrides a server-level `-c`. Single-value
-flags such as `-m` and `-C` may not repeat: `codex` rejects the second one, and
-the tool result carries that error. Keep server-level flags and per-call
-parameters disjoint for those.
+flags come after the server-level ones. `-c` and `--add-dir` may repeat. For
+`-c` the last one wins, so a per-call `config` entry overrides a server-level
+`-c`.
+
+The other typed flags (`-C`, `-m`, `--sandbox`, `-p`, `--ephemeral`,
+`--skip-git-repo-check`) may appear only once: `codex` exits with "cannot be used
+multiple times" on a second one. When the server's command line already sets one
+of them, in any spelling (for example `-C DIR`, `-CDIR`, `--cd=DIR`), the
+server-level value wins. A token that is another flag's value (the `-m` in
+`-c -m`) or that comes after `--` does not count as setting a flag. The `codex`
+tool leaves the matching per-call parameter (`cd`, `model`, `sandbox`,
+`profile`, `ephemeral`, `skip_git_repo_check`) out of the command and names it
+in the result together with the server-level value used instead: in the text
+after the `[codex]` line (`cd="/other"; this server runs with -C /srv`) and in
+`structuredContent.ignoredParameters`. Its schema tells the caller which
+parameters the server already sets, and to what. `codex-reply` keeps such
+parameters, because after `resume` they are the subcommand's own flags and
+`codex` accepts them there. `extra_args` is passed through unchecked, so a flag
+repeated through it still fails with `codex`'s own error.
 
 ## Tool: `codex`
 
@@ -226,7 +242,10 @@ The tool returns that final message followed by one metadata line:
 ```
 
 `thread_id` and `status` are always present; the token fields appear when the
-run reported them. `isError` is the flag on an MCP tool result that tells the
+run reported them. A per-call parameter that a server-level flag overrode is
+named after this line, with the value used instead (see
+[Server-level flags](#server-level-flags)).
+`isError` is the flag on an MCP tool result that tells the
 client a call failed. This server sets it when `codex` exited non-zero, when the
 subprocess timed out, and when the turn itself failed. The last case matters
 because `codex exec` exits 0 after a failure inside the model API; the tool

codex_cli_mcp_slim-0.1.1/tests/test_basic.py

@@ -0,0 +1,346 @@
+"""Tests for argv construction, including how per-call flags meet server-level ones.
+
+The subprocess is never started here; the tests that go through the tool replace
+`_run_codex` with a stub that records the argv it was handed.
+"""
+
+import pytest
+
+from codex_cli_mcp_slim import server
+from codex_cli_mcp_slim.server import CODEX_CMD, _build_argv
+
+
+def _ok_run(**kwargs):
+    stdout = (
+        '{"type": "thread.started", "thread_id": "t"}\n'
+        '{"type": "item.completed", "item": {"type": "agent_message", "text": "answer"}}\n'
+        '{"type": "turn.completed", "usage": {}}\n'
+    )
+    return {"ok": True, "returncode": 0, "stdout": stdout, "stderr": "", "argv": kwargs["argv"]}
+
+
+@pytest.fixture
+def start_server_with(monkeypatch):
+    """Set the server's own command line the way main() does, restored after the test."""
+    monkeypatch.setattr(server, "SERVER_ARGS", server.SERVER_ARGS)
+    monkeypatch.setattr(server, "_SERVER_SET", server._SERVER_SET)
+    return server._set_server_args
+
+
+def test_build_argv_minimal():
+    argv = _build_argv(server_args=[])
+    assert argv == [CODEX_CMD, "exec", "--json", "-"]
+
+
+def test_build_argv_ends_with_json_and_stdin_prompt():
+    # --json and `-` stay last so nothing in extra_args can capture `-` as its own value,
+    # and so the prompt is read from stdin rather than taken from argv.
+    argv = _build_argv(server_args=[], extra_args=["--output-schema", "/tmp/schema.json"])
+    assert argv[-2:] == ["--json", "-"]
+    assert argv[-4:-2] == ["--output-schema", "/tmp/schema.json"]
+
+
+def test_build_argv_server_args_come_right_after_exec():
+    server_args = ["-c", "model_reasoning_effort=high", "-C", "/srv/scratch"]
+    argv = _build_argv(server_args=server_args)
+    assert argv[:6] == [CODEX_CMD, "exec", *server_args]
+
+
+def test_build_argv_per_call_config_follows_server_args_so_it_wins():
+    # codex applies repeated -c flags in order, last one wins; a per-call override therefore
+    # has to come after the server-level one.
+    argv = _build_argv(
+        server_args=["-c", "model_reasoning_effort=high"],
+        config=["model_reasoning_effort=low"],
+    )
+    positions = [i for i, tok in enumerate(argv) if tok == "-c"]
+    assert argv[positions[0] + 1] == "model_reasoning_effort=high"
+    assert argv[positions[1] + 1] == "model_reasoning_effort=low"
+
+
+def test_build_argv_resume_is_a_subcommand_before_per_call_flags():
+    argv = _build_argv(server_args=["-c", "k=v"], thread_id="thread-1", model="m")
+    assert argv[:6] == [CODEX_CMD, "exec", "-c", "k=v", "resume", "thread-1"]
+    assert argv[6:8] == ["-m", "m"]
+
+
+def test_build_argv_cd_maps_to_dash_c_upper():
+    argv = _build_argv(server_args=[], cd="/repo")
+    assert argv[argv.index("-C") + 1] == "/repo"
+
+
+def test_build_argv_model_maps_to_dash_m():
+    argv = _build_argv(server_args=[], model="gpt-example")
+    assert argv[argv.index("-m") + 1] == "gpt-example"
+
+
+def test_build_argv_config_is_repeated_not_comma_joined():
+    argv = _build_argv(server_args=[], config=["a=1", "b=2", "c=3"])
+    assert argv.count("-c") == 3
+    for item in ("a=1", "b=2", "c=3"):
+        assert argv[argv.index(item) - 1] == "-c"
+    assert "a=1,b=2,c=3" not in argv
+
+
+def test_build_argv_add_dir_is_repeated_not_comma_joined():
+    argv = _build_argv(server_args=[], add_dir=["/a", "/b", "/c"])
+    assert argv.count("--add-dir") == 3
+    for d in ("/a", "/b", "/c"):
+        assert argv[argv.index(d) - 1] == "--add-dir"
+    assert "/a,/b,/c" not in argv
+
+
+def test_build_argv_sandbox():
+    argv = _build_argv(server_args=[], sandbox="read-only")
+    assert argv[argv.index("--sandbox") + 1] == "read-only"
+
+
+def test_build_argv_profile():
+    argv = _build_argv(server_args=[], profile="research")
+    assert argv[argv.index("-p") + 1] == "research"
+
+
+def test_build_argv_boolean_flags():
+    argv = _build_argv(server_args=[], ephemeral=True, skip_git_repo_check=True)
+    assert "--ephemeral" in argv
+    assert "--skip-git-repo-check" in argv
+    argv = _build_argv(server_args=[])
+    assert "--ephemeral" not in argv
+    assert "--skip-git-repo-check" not in argv
+
+
+def test_build_argv_extra_args_appended_verbatim_before_json():
+    argv = _build_argv(server_args=[], extra_args=["--ignore-rules", "--enable", "x"])
+    assert argv[-5:-2] == ["--ignore-rules", "--enable", "x"]
+
+
+def test_build_argv_all_typed_flags_combine():
+    argv = _build_argv(
+        server_args=[],
+        cd="/repo",
+        model="m",
+        config=["k=v"],
+        sandbox="workspace-write",
+        add_dir=["/x"],
+        profile="p",
+        ephemeral=True,
+        skip_git_repo_check=True,
+        extra_args=["--custom"],
+    )
+    for token in (
+        "-C",
+        "/repo",
+        "-m",
+        "m",
+        "-c",
+        "k=v",
+        "--sandbox",
+        "workspace-write",
+        "--add-dir",
+        "/x",
+        "-p",
+        "p",
+        "--ephemeral",
+        "--skip-git-repo-check",
+        "--custom",
+    ):
+        assert token in argv
+
+
+# codex rejects a second -C, -m, -s, -p, --ephemeral or --skip-git-repo-check with "cannot
+# be used multiple times" (exit 2), so a per-call parameter whose flag the server's own
+# command line already sets is left out and the server-level value is used.
+
+
+def _value_after(argv, *flags):
+    return [argv[i + 1] for i, tok in enumerate(argv) if tok in flags]
+
+
+def test_build_argv_drops_per_call_flags_the_server_already_sets():
+    argv = _build_argv(
+        server_args=["-C", "/srv/scratch", "--skip-git-repo-check"],
+        cd="/other",
+        skip_git_repo_check=True,
+    )
+    assert argv.count("--skip-git-repo-check") == 1
+    assert _value_after(argv, "-C", "--cd") == ["/srv/scratch"]
+    assert "/other" not in argv
+
+
+@pytest.mark.parametrize(
+    ("server_args", "param", "value"),
+    [
+        (["--cd", "/srv"], "cd", "/other"),
+        (["--cd=/srv"], "cd", "/other"),
+        (["-C/srv"], "cd", "/other"),
+        (["-C=/srv"], "cd", "/other"),
+        (["-m", "a"], "model", "b"),
+        (["--model=a"], "model", "b"),
+        (["-ma"], "model", "b"),
+        (["-s", "read-only"], "sandbox", "workspace-write"),
+        (["--sandbox=read-only"], "sandbox", "workspace-write"),
+        (["-p", "a"], "profile", "b"),
+        (["--profile", "a"], "profile", "b"),
+        (["--ephemeral"], "ephemeral", True),
+        (["--skip-git-repo-check"], "skip_git_repo_check", True),
+    ],
+)
+def test_build_argv_recognises_every_spelling_of_a_server_level_flag(server_args, param, value):
+    argv = _build_argv(server_args=server_args, **{param: value})
+    assert argv == [CODEX_CMD, "exec", *server_args, "--json", "-"]
+
+
+@pytest.mark.parametrize(
+    "server_args",
+    [
+        ["-c", "-model=1"],  # the value of -c, not the model flag
+        ["--", "-m"],  # past the end of the flags
+    ],
+)
+def test_build_argv_reads_neither_a_value_nor_a_token_after_double_dash_as_a_flag(server_args):
+    assert "model" not in server._params_set_by(server_args)
+    argv = _build_argv(server_args=server_args, model="b")
+    assert argv == [CODEX_CMD, "exec", *server_args, "-m", "b", "--json", "-"]
+
+
+@pytest.mark.parametrize(
+    ("server_args", "value", "written"),
+    [
+        (["-C", "/srv"], "/srv", "-C /srv"),
+        (["-c", "k=v", "--cd", "/srv"], "/srv", "--cd /srv"),
+        (["--cd=/srv"], "/srv", "--cd=/srv"),
+        (["-C/srv"], "/srv", "-C/srv"),
+        (["-C=/srv"], "/srv", "-C=/srv"),
+        (["-C", "/my dir"], "/my dir", "-C '/my dir'"),
+    ],
+)
+def test_params_set_by_keeps_the_server_level_value_and_its_spelling(server_args, value, written):
+    assert server._params_set_by(server_args) == {"cd": (value, written)}
+
+
+def test_params_set_by_reports_a_flag_without_a_value_as_true():
+    assert server._params_set_by(["--ephemeral"]) == {"ephemeral": (True, "--ephemeral")}
+
+
+def test_build_argv_keeps_per_call_flags_the_server_does_not_set():
+    argv = _build_argv(
+        server_args=["--skip-git-repo-check"],
+        cd="/repo",
+        model="m",
+        sandbox="read-only",
+        profile="p",
+        ephemeral=True,
+    )
+    assert _value_after(argv, "-C") == ["/repo"]
+    assert _value_after(argv, "-m") == ["m"]
+    assert _value_after(argv, "--sandbox") == ["read-only"]
+    assert _value_after(argv, "-p") == ["p"]
+    assert "--ephemeral" in argv
+
+
+def test_build_argv_server_level_dash_c_lower_is_not_mistaken_for_cd():
+    argv = _build_argv(server_args=["-c", "model_reasoning_effort=high"], cd="/repo")
+    assert _value_after(argv, "-C") == ["/repo"]
+
+
+def test_build_argv_repeatable_flags_still_stack_on_server_level_ones():
+    argv = _build_argv(
+        server_args=["-c", "k=1", "--add-dir", "/a"],
+        config=["k=2"],
+        add_dir=["/b"],
+    )
+    assert _value_after(argv, "-c") == ["k=1", "k=2"]
+    assert _value_after(argv, "--add-dir") == ["/a", "/b"]
+
+
+def test_build_argv_reply_keeps_per_call_flags_after_resume():
+    # After `resume` the per-call flags belong to the subcommand, which codex parses on its
+    # own, so a repeat of a server-level flag is accepted there and nothing is dropped.
+    argv = _build_argv(
+        server_args=["--skip-git-repo-check", "-m", "a"],
+        thread_id="t",
+        skip_git_repo_check=True,
+        model="b",
+    )
+    after_resume = argv[argv.index("resume") + 2 :]
+    assert "--skip-git-repo-check" in after_resume
+    assert _value_after(after_resume, "-m") == ["b"]
+
+
+async def test_tool_reports_the_per_call_parameters_it_dropped(monkeypatch, start_server_with):
+    seen = {}
+
+    async def fake_run(**kwargs):
+        seen.update(kwargs)
+        return _ok_run(**kwargs)
+
+    start_server_with(["-C", "/srv", "--skip-git-repo-check"])
+    monkeypatch.setattr(server, "_run_codex", fake_run)
+    result = await server.codex(
+        {"prompt": "p", "cd": "/other", "skip_git_repo_check": True, "model": "m"}
+    )
+    assert seen["argv"].count("--skip-git-repo-check") == 1
+    assert _value_after(seen["argv"], "-C") == ["/srv"]
+    assert _value_after(seen["argv"], "-m") == ["m"]
+    text = result.content[0].text
+    assert result.is_error is False
+    assert text.startswith("answer\n\n[codex] thread_id=t")
+    assert 'cd="/other"; this server runs with -C /srv' in text
+    assert "skip_git_repo_check=true; this server runs with --skip-git-repo-check" in text
+    assert "model=" not in text
+    assert result.structured_content == {
+        "threadId": "t",
+        "content": "answer",
+        "ignoredParameters": [
+            {"name": "cd", "value": "/other", "serverValue": "/srv"},
+            {"name": "skip_git_repo_check", "value": True, "serverValue": True},
+        ],
+    }
+
+
+async def test_tool_reports_dropped_parameters_in_structured_content_without_a_thread(
+    monkeypatch, start_server_with
+):
+    async def fake_run(**kwargs):
+        return {"ok": False, "error": "boom", "argv": kwargs["argv"]}
+
+    start_server_with(["--model=a"])
+    monkeypatch.setattr(server, "_run_codex", fake_run)
+    result = await server.codex({"prompt": "p", "model": "b"})
+    assert result.is_error is True
+    assert result.content[0].text.startswith("[ERROR] boom")
+    assert 'model="b"; this server runs with --model=a' in result.content[0].text
+    assert result.structured_content == {
+        "ignoredParameters": [{"name": "model", "value": "b", "serverValue": "a"}]
+    }
+
+
+async def test_tool_adds_nothing_when_no_per_call_parameter_was_dropped(
+    monkeypatch, start_server_with
+):
+    async def fake_run(**kwargs):
+        return _ok_run(**kwargs)
+
+    start_server_with(["--skip-git-repo-check"])
+    monkeypatch.setattr(server, "_run_codex", fake_run)
+    result = await server.codex({"prompt": "p", "cd": "/repo"})
+    assert result.content[0].text == "answer\n\n[codex] thread_id=t status=completed"
+    assert result.structured_content == {"threadId": "t", "content": "answer"}
+
+
+async def test_tool_schema_names_the_parameters_the_server_already_sets(start_server_with):
+    def props():
+        return {tool.name: tool.input_schema["properties"] for tool in listed.tools}
+
+    start_server_with(["--skip-git-repo-check", "-C", "/srv"])
+    listed = await server.on_list_tools(None, None)
+    assert (
+        "already sets --skip-git-repo-check"
+        in props()["codex"]["skip_git_repo_check"]["description"]
+    )
+    assert "already sets -C /srv," in props()["codex"]["cd"]["description"]
+    assert "already" not in props()["codex"]["model"]["description"]
+
+    start_server_with([])
+    listed = await server.on_list_tools(None, None)
+    assert "already" not in props()["codex"]["skip_git_repo_check"]["description"]

codex_cli_mcp_slim-0.1.0/tests/test_basic.py

@@ -1,123 +0,0 @@
-"""Pure-function tests for argv construction. Subprocess execution is not tested here."""
-
-from codex_cli_mcp_slim.server import CODEX_CMD, _build_argv
-
-
-def test_build_argv_minimal():
-    argv = _build_argv(server_args=[])
-    assert argv == [CODEX_CMD, "exec", "--json", "-"]
-
-
-def test_build_argv_ends_with_json_and_stdin_prompt():
-    # --json and `-` stay last so nothing in extra_args can capture `-` as its own value,
-    # and so the prompt is read from stdin rather than taken from argv.
-    argv = _build_argv(server_args=[], extra_args=["--output-schema", "/tmp/schema.json"])
-    assert argv[-2:] == ["--json", "-"]
-    assert argv[-4:-2] == ["--output-schema", "/tmp/schema.json"]
-
-
-def test_build_argv_server_args_come_right_after_exec():
-    server_args = ["-c", "model_reasoning_effort=high", "-C", "/srv/scratch"]
-    argv = _build_argv(server_args=server_args)
-    assert argv[:6] == [CODEX_CMD, "exec", *server_args]
-
-
-def test_build_argv_per_call_config_follows_server_args_so_it_wins():
-    # codex applies repeated -c flags in order, last one wins; a per-call override therefore
-    # has to come after the server-level one.
-    argv = _build_argv(
-        server_args=["-c", "model_reasoning_effort=high"],
-        config=["model_reasoning_effort=low"],
-    )
-    positions = [i for i, tok in enumerate(argv) if tok == "-c"]
-    assert argv[positions[0] + 1] == "model_reasoning_effort=high"
-    assert argv[positions[1] + 1] == "model_reasoning_effort=low"
-
-
-def test_build_argv_resume_is_a_subcommand_before_per_call_flags():
-    argv = _build_argv(server_args=["-c", "k=v"], thread_id="thread-1", model="m")
-    assert argv[:6] == [CODEX_CMD, "exec", "-c", "k=v", "resume", "thread-1"]
-    assert argv[6:8] == ["-m", "m"]
-
-
-def test_build_argv_cd_maps_to_dash_c_upper():
-    argv = _build_argv(server_args=[], cd="/repo")
-    assert argv[argv.index("-C") + 1] == "/repo"
-
-
-def test_build_argv_model_maps_to_dash_m():
-    argv = _build_argv(server_args=[], model="gpt-example")
-    assert argv[argv.index("-m") + 1] == "gpt-example"
-
-
-def test_build_argv_config_is_repeated_not_comma_joined():
-    argv = _build_argv(server_args=[], config=["a=1", "b=2", "c=3"])
-    assert argv.count("-c") == 3
-    for item in ("a=1", "b=2", "c=3"):
-        assert argv[argv.index(item) - 1] == "-c"
-    assert "a=1,b=2,c=3" not in argv
-
-
-def test_build_argv_add_dir_is_repeated_not_comma_joined():
-    argv = _build_argv(server_args=[], add_dir=["/a", "/b", "/c"])
-    assert argv.count("--add-dir") == 3
-    for d in ("/a", "/b", "/c"):
-        assert argv[argv.index(d) - 1] == "--add-dir"
-    assert "/a,/b,/c" not in argv
-
-
-def test_build_argv_sandbox():
-    argv = _build_argv(server_args=[], sandbox="read-only")
-    assert argv[argv.index("--sandbox") + 1] == "read-only"
-
-
-def test_build_argv_profile():
-    argv = _build_argv(server_args=[], profile="research")
-    assert argv[argv.index("-p") + 1] == "research"
-
-
-def test_build_argv_boolean_flags():
-    argv = _build_argv(server_args=[], ephemeral=True, skip_git_repo_check=True)
-    assert "--ephemeral" in argv
-    assert "--skip-git-repo-check" in argv
-    argv = _build_argv(server_args=[])
-    assert "--ephemeral" not in argv
-    assert "--skip-git-repo-check" not in argv
-
-
-def test_build_argv_extra_args_appended_verbatim_before_json():
-    argv = _build_argv(server_args=[], extra_args=["--ignore-rules", "--enable", "x"])
-    assert argv[-5:-2] == ["--ignore-rules", "--enable", "x"]
-
-
-def test_build_argv_all_typed_flags_combine():
-    argv = _build_argv(
-        server_args=[],
-        cd="/repo",
-        model="m",
-        config=["k=v"],
-        sandbox="workspace-write",
-        add_dir=["/x"],
-        profile="p",
-        ephemeral=True,
-        skip_git_repo_check=True,
-        extra_args=["--custom"],
-    )
-    for token in (
-        "-C",
-        "/repo",
-        "-m",
-        "m",
-        "-c",
-        "k=v",
-        "--sandbox",
-        "workspace-write",
-        "--add-dir",
-        "/x",
-        "-p",
-        "p",
-        "--ephemeral",
-        "--skip-git-repo-check",
-        "--custom",
-    ):
-        assert token in argv