@hoanghainh/komagu 2.6.0 → 2.7.0

package/examples/member-portal/backend-spring/src/main/kotlin/io/komagu/portal/model/Entities.kt

@@ -8,6 +8,8 @@ import java.math.BigDecimal
 import java.time.Instant
 import java.util.UUID
 
+// JPA entity: one constructor parameter per column.
+@Suppress("LongParameterList")
 @Entity
 @Table(name = "portal_orders")
 class OrderEntity(
@@ -21,6 +23,8 @@ class OrderEntity(
     var createdAt: Instant = Instant.now()
 ) : OwnedResource<String>
 
+// JPA entity: one constructor parameter per column.
+@Suppress("LongParameterList")
 @Entity
 @Table(name = "portal_documents")
 class DocumentEntity(

package/examples/member-portal/tests/test_d6_demo_app.py

@@ -86,7 +86,7 @@ class TestDemoAppVerification(unittest.TestCase):
         health_url = f"{cls.base_url}/api/v1/auth/personas"
         for _ in range(50):
             try:
-                with urllib.request.urlopen(health_url, timeout=1.0) as resp:
+                with urllib.request.urlopen(health_url, timeout=1.0) as resp:  # nosec B310  # http://127.0.0.1 test server
                     if resp.status == 200:
                         ready = True
                         break
@@ -124,7 +124,7 @@ class TestDemoAppVerification(unittest.TestCase):
             url,
             headers={"Authorization": "Bearer token-user-a"},
         )
-        with urllib.request.urlopen(req, timeout=5) as resp:
+        with urllib.request.urlopen(req, timeout=5) as resp:  # nosec B310  # http://127.0.0.1 test server
             self.assertEqual(resp.status, 200)
             data = json.loads(resp.read().decode("utf-8"))
             self.assertEqual(data["id"], "ord-001")
@@ -188,7 +188,7 @@ class TestDemoAppVerification(unittest.TestCase):
             headers={"Authorization": "Bearer token-user-c"},
         )
         with self.assertRaises(urllib.error.HTTPError) as ctx:
-            urllib.request.urlopen(req, timeout=5)
+            urllib.request.urlopen(req, timeout=5)  # nosec B310  # http://127.0.0.1 test server
         self.assertEqual(ctx.exception.code, 404)
 
     def test_05_safe_sort_protects_against_sqli(self) -> None:
@@ -199,7 +199,7 @@ class TestDemoAppVerification(unittest.TestCase):
             headers={"Authorization": "Bearer token-user-a"},
         )
         with self.assertRaises(urllib.error.HTTPError) as ctx:
-            urllib.request.urlopen(req, timeout=5)
+            urllib.request.urlopen(req, timeout=5)  # nosec B310  # http://127.0.0.1 test server
         # Server must reject with 400 or 500 SecurityException, not 200
         self.assertIn(ctx.exception.code, [400, 500])
 

package/examples/member-portal/tests/test_d6_remediation_verification.py

@@ -88,7 +88,7 @@ class TestRemediationVerification(unittest.TestCase):
         health_url = f"{cls.base_url}/api/v1/auth/personas"
         for _ in range(50):
             try:
-                with urllib.request.urlopen(health_url, timeout=1.0) as resp:
+                with urllib.request.urlopen(health_url, timeout=1.0) as resp:  # nosec B310  # http://127.0.0.1 test server
                     if resp.status == 200:
                         ready = True
                         break
@@ -126,7 +126,7 @@ class TestRemediationVerification(unittest.TestCase):
             url,
             headers={"Authorization": "Bearer token-user-a"},
         )
-        with urllib.request.urlopen(req, timeout=5) as resp:
+        with urllib.request.urlopen(req, timeout=5) as resp:  # nosec B310  # http://127.0.0.1 test server
             self.assertEqual(resp.status, 200)
             data = json.loads(resp.read().decode("utf-8"))
             self.assertEqual(data["id"], "ord-001")
@@ -169,7 +169,7 @@ class TestRemediationVerification(unittest.TestCase):
             headers={"Authorization": "Bearer token-user-b"},
         )
         with self.assertRaises(urllib.error.HTTPError) as ctx:
-            urllib.request.urlopen(req, timeout=5)
+            urllib.request.urlopen(req, timeout=5)  # nosec B310  # http://127.0.0.1 test server
         self.assertEqual(ctx.exception.code, 404)
 
     def test_04_attacker_direct_put_unauthorized_returns_404(self) -> None:
@@ -186,7 +186,7 @@ class TestRemediationVerification(unittest.TestCase):
             method="PUT",
         )
         with self.assertRaises(urllib.error.HTTPError) as ctx:
-            urllib.request.urlopen(req, timeout=5)
+            urllib.request.urlopen(req, timeout=5)  # nosec B310  # http://127.0.0.1 test server
         self.assertEqual(ctx.exception.code, 404)
 
     def test_05_attacker_direct_delete_unauthorized_returns_404(self) -> None:
@@ -198,7 +198,7 @@ class TestRemediationVerification(unittest.TestCase):
             method="DELETE",
         )
         with self.assertRaises(urllib.error.HTTPError) as ctx:
-            urllib.request.urlopen(req, timeout=5)
+            urllib.request.urlopen(req, timeout=5)  # nosec B310  # http://127.0.0.1 test server
         self.assertEqual(ctx.exception.code, 404)
 
     def test_06_parameterized_search_neutralizes_sqli(self) -> None:
@@ -210,7 +210,7 @@ class TestRemediationVerification(unittest.TestCase):
             url,
             headers={"Authorization": "Bearer token-user-a"},
         )
-        with urllib.request.urlopen(req, timeout=5) as resp:
+        with urllib.request.urlopen(req, timeout=5) as resp:  # nosec B310  # http://127.0.0.1 test server
             self.assertEqual(resp.status, 200)
             data = json.loads(resp.read().decode("utf-8"))
             # When safely parameterized as LIKE '%...%', it searches for the literal string and matches nothing

package/operate/README.md

@@ -22,7 +22,12 @@ This directory provides CI/CD components for automated security verification, pr
    - `github/cross-user-authz.yml`: Reusable GitHub Actions workflow.
    - `gitlab/cross-user-authz.gitlab-ci.yml`: GitLab CI security template.
 
-4. **Automated Remediation Runner (`remediator/runner.py` / `komagu fix`)**:
+4. **MCP server (`operate/mcp/`, `komagu mcp --stdio`)**:
+   - Speaks the Model Context Protocol on stdin/stdout with the Python standard library only (no MCP SDK).
+   - Tools stay local: Tier 1 `scan`, `read_audit`, `leak_check`, `inventory`, and `fix_preview`.
+   - `fix_preview` is a dry run and does not modify source. Patch apply, the edge gateway, and live cross-user tests stay on the CLI.
+
+5. **Automated Remediation Runner (`remediator/runner.py` / `komagu fix`)**:
    - Parses audit findings (`findings.json` or SARIF) and generates automated code fixes for BOLA/IDOR and SQLi vulnerabilities.
    - Supports dry-run simulation, unified patch export, and direct in-place remediation.
 

package/operate/ai/client.py

@@ -9,6 +9,7 @@ import json
 import re
 import time
 import urllib.error
+import urllib.parse
 import urllib.request
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -29,6 +30,8 @@ class LLMClient:
     ) -> None:
         if reasoning_effort is not None and reasoning_effort not in REASONING_EFFORTS:
             raise ValueError(f"reasoning_effort must be one of {', '.join(REASONING_EFFORTS)}")
+        if urllib.parse.urlparse(endpoint).scheme.lower() not in ("http", "https"):
+            raise ValueError("LLM endpoint must be an http:// or https:// URL")
         raw_endpoint = endpoint.rstrip("/")
         if not raw_endpoint.endswith("/chat/completions"):
             self.endpoint = f"{raw_endpoint}/chat/completions"
@@ -58,7 +61,8 @@ class LLMClient:
         req = urllib.request.Request(self.endpoint, data=data, headers=headers, method="POST")
         started = time.monotonic()
         try:
-            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            # The endpoint scheme is checked to be http(s) in __init__.
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:  # nosec B310
                 body = resp.read().decode("utf-8")
                 res_json = json.loads(body)
                 self._record_usage(res_json.get("usage") or {}, time.monotonic() - started)

package/operate/cli/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "2.6.0"  # x-release-please-version
+__version__ = "2.7.0"  # x-release-please-version

package/operate/cli/commands/fix.py

@@ -4,10 +4,14 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import sys
 from pathlib import Path
 from typing import Any
 
+from operate.ai.client import REASONING_EFFORTS
+from operate.remediator.ai_fixer import AITier2Fixer
+
 from operate.cli.ui import (
     BOLD,
     CYAN,
@@ -89,6 +93,38 @@ Examples:
         default="summary",
         help="Output format: summary table (default), json, or diff",
     )
+    parser.add_argument(
+        "--ai",
+        action="store_true",
+        help="Enable Tier 2 AI-assisted multi-line fix fallback with verification gate when deterministic patchers cannot rewrite a finding",
+    )
+    parser.add_argument(
+        "--ai-endpoint",
+        default=os.environ.get("KOMAGU_AI_ENDPOINT", "http://localhost:11434/v1"),
+        help="OpenAI-compatible /v1 endpoint for --ai fixes (default: $KOMAGU_AI_ENDPOINT or http://localhost:11434/v1)",
+    )
+    parser.add_argument(
+        "--ai-model",
+        default=os.environ.get("KOMAGU_AI_MODEL", "llama3.1"),
+        help="Model name for --ai fixes (default: $KOMAGU_AI_MODEL or llama3.1)",
+    )
+    parser.add_argument(
+        "--ai-api-key",
+        default=os.environ.get("KOMAGU_AI_API_KEY") or os.environ.get("OPENAI_API_KEY"),
+        help="API key for --ai endpoint (default: $KOMAGU_AI_API_KEY or $OPENAI_API_KEY)",
+    )
+    parser.add_argument(
+        "--ai-timeout",
+        type=int,
+        default=120,
+        help="Timeout in seconds per --ai LLM request (default: 120)",
+    )
+    parser.add_argument(
+        "--ai-reasoning-effort",
+        choices=REASONING_EFFORTS,
+        default=None,
+        help="Reasoning effort passed to OpenAI-compatible endpoint (default: not sent)",
+    )
     parser.set_defaults(func=run_fix)
 
 
@@ -100,6 +136,16 @@ def run_fix(args: argparse.Namespace) -> int:
         step_fail(f"Target path does not exist: {target_path}")
         return 1
 
+    ai_fixer = None
+    if getattr(args, "ai", False):
+        ai_fixer = AITier2Fixer(
+            endpoint=args.ai_endpoint,
+            model=args.ai_model,
+            api_key=args.ai_api_key,
+            timeout=args.ai_timeout,
+            reasoning_effort=args.ai_reasoning_effort,
+        )
+
     runner = RemediationRunner(
         target_dir=target_path,
         findings_path=args.findings_path,
@@ -107,6 +153,7 @@ def run_fix(args: argparse.Namespace) -> int:
         output_patch=args.output_patch,
         scan_sca=getattr(args, "sca", False),
         query_osv=getattr(args, "osv", False),
+        ai_fixer=ai_fixer,
     )
 
     mode_label = "DRY-RUN (Simulated)" if args.dry_run else "APPLY (In-place)"

package/operate/cli/commands/mcp.py

@@ -0,0 +1,54 @@
+"""Command: komagu mcp - zero-dependency Model Context Protocol server."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def register_subcommand(subparsers: argparse._SubParsersAction) -> None:
+    """Register the mcp subcommand parser."""
+    parser = subparsers.add_parser(
+        "mcp",
+        help="Serve Komagu analysis tools over the Model Context Protocol on stdio",
+        description=(
+            "Speaks MCP JSON-RPC on stdin and stdout using the Python standard library only. "
+            "Tools are local: Tier 1 scan, audit summary, leak check, API inventory, and a dry-run fix preview. "
+            "The preview never modifies source. Logging is written to stderr so stdout stays a protocol stream."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Cursor, Claude Code, or any MCP client that launches a stdio server
+  komagu mcp --stdio
+
+Client configuration:
+  {
+    "mcpServers": {
+      "komagu": {
+        "command": "komagu",
+        "args": ["mcp", "--stdio"]
+      }
+    }
+  }
+""",
+    )
+    parser.add_argument(
+        "--stdio",
+        action="store_true",
+        help="Speak newline-delimited MCP JSON-RPC on stdin/stdout (the only transport)",
+    )
+    parser.set_defaults(func=run_mcp)
+
+
+def run_mcp(args: argparse.Namespace) -> int:
+    """Start the stdio server, or reject the command when --stdio was omitted."""
+    if not getattr(args, "stdio", False):
+        print(
+            "komagu mcp: the only transport is stdio. Run: komagu mcp --stdio",
+            file=sys.stderr,
+        )
+        return 2
+    from operate.mcp.server import serve_stdio
+
+    return serve_stdio()

package/operate/cli/main.py

@@ -7,7 +7,20 @@ import sys
 from typing import List, Optional
 
 from operate.cli import __version__
-from operate.cli.commands import demo, devsecops, evidence, fix, init, inventory, leak_check, protect, scan, simulate, test
+from operate.cli.commands import (
+    demo,
+    devsecops,
+    evidence,
+    fix,
+    init,
+    inventory,
+    leak_check,
+    mcp,
+    protect,
+    scan,
+    simulate,
+    test,
+)
 from operate.cli.ui import print_banner
 
 
@@ -30,6 +43,7 @@ Quick Start Workflow:
   9. Reconcile API inventory:   komagu inventory --routes OUT/routes.json --openapi openapi.json
   10. Bundle METI SCS evidence: komagu evidence --audit-dir OUT/ --output-dir ./evidence-pack
   11. Check outputs for leaks:   komagu leak-check OUT/ --canary-file canaries.txt
+  12. Serve tools to an AI client: komagu mcp --stdio
 
 Documentation & Guides:
   Comprehensive User Guide: docs/cli-guide.md
@@ -68,6 +82,7 @@ Learn more about a specific command:
     inventory.register_subcommand(subparsers)
     evidence.register_subcommand(subparsers)
     leak_check.register_subcommand(subparsers)
+    mcp.register_subcommand(subparsers)
 
     help_parser = subparsers.add_parser(
         "help",
@@ -77,8 +92,24 @@ Learn more about a specific command:
     help_parser.add_argument(
         "topic",
         nargs="?",
-        choices=["scan", "protect", "test", "demo", "devsecops", "fix", "init", "simulate", "inventory", "evidence", "leak-check"],
-        help="Subcommand topic to display help for (scan, protect, test, demo, devsecops, fix, init, simulate, inventory, evidence, leak-check)",
+        choices=[
+            "scan",
+            "protect",
+            "test",
+            "demo",
+            "devsecops",
+            "fix",
+            "init",
+            "simulate",
+            "inventory",
+            "evidence",
+            "leak-check",
+            "mcp",
+        ],
+        help=(
+            "Subcommand topic to display help for "
+            "(scan, protect, test, demo, devsecops, fix, init, simulate, inventory, evidence, leak-check, mcp)"
+        ),
     )
 
     return parser
@@ -90,7 +121,14 @@ def main(argv: Optional[List[str]] = None) -> int:
     args = parser.parse_args(argv)
 
     is_json = getattr(args, "format", "") == "json"
-    if not getattr(args, "no_banner", False) and getattr(args, "subcommand", None) is not None and not is_json:
+    # The MCP server owns stdout. A banner would break the JSON-RPC stream.
+    suppress_banner = getattr(args, "subcommand", None) == "mcp"
+    if (
+        not getattr(args, "no_banner", False)
+        and getattr(args, "subcommand", None) is not None
+        and not is_json
+        and not suppress_banner
+    ):
         print_banner()
 
     if getattr(args, "subcommand", None) is None:

package/operate/cross_user_tester/runner.py

@@ -242,7 +242,10 @@ class CrossUserTestRunner:
         error_message = None
 
         try:
-            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+            if urllib.parse.urlparse(url).scheme.lower() not in ("http", "https"):
+                raise ValueError("base URL must be an http:// or https:// URL")
+            # The scheme is checked just above.
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:  # nosec B310
                 status_code = resp.status
                 raw = resp.read()
                 response_body = raw.decode("utf-8", errors="replace")[:1000]

package/operate/devsecops/sbom.py

@@ -24,6 +24,16 @@ import xml.etree.ElementTree as ET
 from typing import Any, Dict, List, Optional
 
 
+def _parse_xml_without_dtd(file_path: str) -> ET.Element:
+    """Parse a manifest from the scanned project, refusing DTDs (entity expansion)."""
+    with open(file_path, "r", encoding="utf-8", errors="replace") as handle:
+        text = handle.read()
+    if "<!DOCTYPE" in text.upper() or "<!ENTITY" in text.upper():
+        raise ValueError(f"{file_path}: XML with a DTD is not parsed")
+    # DTDs are refused above, so no entity can be declared or expanded.
+    return ET.fromstring(text)  # nosec B314
+
+
 class Component:
     """Represents a software package or component in an SBOM."""
 
@@ -195,8 +205,7 @@ class SBOMGenerator:
     def _parse_csproj(self, file_path: str) -> List[Component]:
         components = []
         try:
-            tree = ET.parse(file_path)
-            root = tree.getroot()
+            root = _parse_xml_without_dtd(file_path)
             for pkg in root.findall(".//PackageReference"):
                 name = pkg.get("Include") or pkg.get("Update")
                 version = pkg.get("Version")
@@ -213,8 +222,7 @@ class SBOMGenerator:
     def _parse_pom_xml(self, file_path: str) -> List[Component]:
         components = []
         try:
-            tree = ET.parse(file_path)
-            root = tree.getroot()
+            root = _parse_xml_without_dtd(file_path)
             ns = {"m": "http://maven.apache.org/POM/4.0.0"}
             # Search both with namespace and without
             deps = root.findall(".//m:dependency", ns) or root.findall(".//dependency")

package/operate/mcp/__init__.py

@@ -0,0 +1,11 @@
+"""Zero-dependency Model Context Protocol server for the Komagu CLI.
+
+Python 3.8+ standard library only. Messages are newline-delimited JSON-RPC
+on stdio. Nothing except protocol messages is written to stdout.
+"""
+
+from __future__ import annotations
+
+from operate.mcp.server import serve_stdio
+
+__all__ = ["serve_stdio"]

package/operate/mcp/server.py

@@ -0,0 +1,206 @@
+"""Newline-delimited JSON-RPC session for the Model Context Protocol.
+
+Supported protocol revisions: 2024-11-05, 2025-03-26, and 2025-06-18.
+A requested revision we implement is echoed back. Any other revision is
+answered with the newest one this server implements.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import traceback
+from typing import Any, Dict, IO, Optional, TextIO
+
+from operate.cli import __version__
+from operate.mcp.tools import INSTRUCTIONS, ToolError, ToolRegistry, build_registry
+
+JSONRPC = "2.0"
+PROTOCOL_VERSIONS = ("2024-11-05", "2025-03-26", "2025-06-18")
+LATEST_PROTOCOL = PROTOCOL_VERSIONS[-1]
+SERVER_NAME = "komagu"
+MAX_LINE_CHARS = 1_048_576
+TEXT_CAP = 60_000
+
+PARSE_ERROR = -32700
+INVALID_REQUEST = -32600
+METHOD_NOT_FOUND = -32601
+INVALID_PARAMS = -32602
+INTERNAL_ERROR = -32603
+
+
+def error_response(request_id: Any, code: int, message: str) -> Dict[str, Any]:
+    """JSON-RPC error object. request_id is null when the request id could not be read."""
+    return {"jsonrpc": JSONRPC, "id": request_id, "error": {"code": code, "message": message}}
+
+
+def success_response(request_id: Any, result: Dict[str, Any]) -> Dict[str, Any]:
+    """JSON-RPC result object."""
+    return {"jsonrpc": JSONRPC, "id": request_id, "result": result}
+
+
+def tool_result(payload: Dict[str, Any], is_error: bool) -> Dict[str, Any]:
+    """MCP tools/call result. Text is the payload the client shows the model."""
+    if is_error:
+        text = payload.get("message", "tool error")
+        return {"content": [{"type": "text", "text": text}], "isError": True}
+    text = json.dumps(payload, indent=2, ensure_ascii=False, sort_keys=True)
+    if len(text) > TEXT_CAP:
+        text = text[:TEXT_CAP] + "\n…truncated"
+    return {
+        "content": [{"type": "text", "text": text}],
+        "structuredContent": payload,
+        "isError": False,
+    }
+
+
+class Session:
+    """One stdio client. Requests other than initialize and ping wait for initialized."""
+
+    def __init__(self, registry: ToolRegistry, version: str, instructions: str) -> None:
+        self.registry = registry
+        self.version = version
+        self.instructions = instructions
+        self.initialized = False
+        self.negotiated: Optional[str] = None
+
+    def handle(self, message: Any) -> Optional[Dict[str, Any]]:
+        """Return a response, or None when the message is a notification."""
+        if not isinstance(message, dict):
+            return error_response(None, INVALID_REQUEST, "Invalid Request")
+
+        is_request = "id" in message
+        request_id = message.get("id") if is_request else None
+        if message.get("jsonrpc") != JSONRPC:
+            return error_response(request_id, INVALID_REQUEST, "Invalid Request") if is_request else None
+
+        method = message.get("method")
+        if not isinstance(method, str) or not method:
+            return error_response(request_id, INVALID_REQUEST, "Invalid Request") if is_request else None
+
+        params = message.get("params", {})
+        if params is None:
+            params = {}
+        if not isinstance(params, dict):
+            return error_response(request_id, INVALID_PARAMS, "Invalid params") if is_request else None
+
+        if method == "initialize":
+            if not is_request:
+                return None
+            return self._initialize(request_id, params)
+
+        if method in ("notifications/initialized", "initialized"):
+            if self.negotiated is not None:
+                self.initialized = True
+            return None
+
+        if method == "ping":
+            return success_response(request_id, {}) if is_request else None
+
+        if method.startswith("notifications/"):
+            return None
+
+        if not is_request:
+            return None
+
+        if not self.initialized:
+            return error_response(request_id, INVALID_REQUEST, "Server not initialized")
+
+        if method == "tools/list":
+            cursor = params.get("cursor")
+            if cursor not in (None, ""):
+                return error_response(request_id, INVALID_PARAMS, "Unknown cursor")
+            return success_response(request_id, {"tools": self.registry.descriptors()})
+
+        if method == "tools/call":
+            return self._call_tool(request_id, params)
+
+        if method == "logging/setLevel":
+            return success_response(request_id, {})
+
+        return error_response(request_id, METHOD_NOT_FOUND, f"Method not found: {method}")
+
+    def _initialize(self, request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
+        if self.negotiated is not None:
+            return error_response(request_id, INVALID_REQUEST, "Server already initialized")
+        version = params.get("protocolVersion")
+        if not isinstance(version, str) or not version:
+            return error_response(request_id, INVALID_PARAMS, "protocolVersion is required")
+        chosen = version if version in PROTOCOL_VERSIONS else LATEST_PROTOCOL
+        self.negotiated = chosen
+        return success_response(
+            request_id,
+            {
+                "protocolVersion": chosen,
+                "capabilities": {"tools": {"listChanged": False}},
+                "serverInfo": {"name": SERVER_NAME, "version": self.version},
+                "instructions": self.instructions,
+            },
+        )
+
+    def _call_tool(self, request_id: Any, params: Dict[str, Any]) -> Dict[str, Any]:
+        name = params.get("name")
+        if not isinstance(name, str) or not name:
+            return error_response(request_id, INVALID_PARAMS, "tool name is required")
+        arguments = params.get("arguments", {})
+        if arguments is None:
+            arguments = {}
+        if not isinstance(arguments, dict):
+            return error_response(request_id, INVALID_PARAMS, "arguments must be an object")
+        try:
+            payload = self.registry.call(name, arguments)
+        except KeyError:
+            return error_response(request_id, INVALID_PARAMS, f"Unknown tool: {name}")
+        except ToolError as exc:
+            return success_response(request_id, tool_result({"message": str(exc)}, is_error=True))
+        except Exception as exc:
+            traceback.print_exc(file=sys.stderr)
+            return success_response(request_id, tool_result({"message": f"Tool failed: {exc}"}, is_error=True))
+        return success_response(request_id, tool_result(payload, is_error=False))
+
+
+def _write(stdout: TextIO, message: Dict[str, Any]) -> None:
+    """One JSON object per line. ensure_ascii keeps the line free of raw separators."""
+    stdout.write(json.dumps(message, ensure_ascii=True, separators=(",", ":")) + "\n")
+    flush = getattr(stdout, "flush", None)
+    if flush is not None:
+        flush()
+
+
+def serve(session: Session, stdin: IO[str], stdout: TextIO) -> None:
+    """Read messages until stdin closes. Blank lines are ignored."""
+    while True:
+        line = stdin.readline()
+        if line == "":
+            return
+        if len(line) > MAX_LINE_CHARS:
+            _write(stdout, error_response(None, INVALID_REQUEST, "Message too large"))
+            continue
+        if not line.strip():
+            continue
+        try:
+            message = json.loads(line)
+        except json.JSONDecodeError:
+            _write(stdout, error_response(None, PARSE_ERROR, "Parse error"))
+            continue
+        if isinstance(message, list):
+            _write(stdout, error_response(None, INVALID_REQUEST, "Batch requests are not supported"))
+            continue
+        response = session.handle(message)
+        if response is not None:
+            _write(stdout, response)
+
+
+def serve_stdio() -> int:
+    """Serve on process stdin and stdout. Logs go to stderr."""
+    if hasattr(sys.stdin, "reconfigure"):
+        sys.stdin.reconfigure(encoding="utf-8")
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", line_buffering=True)
+    print("komagu mcp: serving Model Context Protocol on stdio", file=sys.stderr, flush=True)
+    session = Session(build_registry(), __version__, INSTRUCTIONS)
+    try:
+        serve(session, sys.stdin, sys.stdout)
+    except BrokenPipeError:
+        return 0
+    return 0