sootool 0.1.1__py3-none-any.whl

sootool/__init__.py

@@ -0,0 +1,11 @@
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _v
+
+try:
+    __version__ = _v("sootool")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+
+def main() -> None:
+    print("Hello from sootool!")

sootool/__main__.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+
+from sootool.observability.log_format import JsonFormatter
+from sootool.server import _load_modules, build_server
+
+_VALID_TRANSPORTS = {"stdio", "http", "sse-legacy", "websocket", "unix"}
+
+
+def _configure_logging(log_format: str, log_level: str) -> None:
+    handler = logging.StreamHandler(sys.stderr)
+    if log_format == "json":
+        handler.setFormatter(JsonFormatter())
+    else:
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s %(message)s"))
+    root = logging.getLogger()
+    root.handlers.clear()
+    root.addHandler(handler)
+    root.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+
+
+def _parse_transports(raw: str, args: argparse.Namespace | None = None) -> list[str]:
+    if raw.strip() == "all":
+        # "all" activates stdio + http + opt-in transports that are enabled
+        base = ["stdio", "http"]
+        if args is not None:
+            if getattr(args, "enable_sse_legacy", False) or os.environ.get("SOOTOOL_ENABLE_SSE_LEGACY"):
+                base.append("sse-legacy")
+            if getattr(args, "enable_websocket", False) or os.environ.get("SOOTOOL_ENABLE_WEBSOCKET"):
+                base.append("websocket")
+            socket_path = getattr(args, "socket", None) or os.environ.get("SOOTOOL_SOCKET_PATH")
+            if socket_path:
+                base.append("unix")
+        return base
+    parts = [t.strip() for t in raw.split(",") if t.strip()]
+    unknown = set(parts) - _VALID_TRANSPORTS
+    if unknown:
+        raise argparse.ArgumentTypeError(
+            f"unknown transport(s): {', '.join(sorted(unknown))}. "
+            f"valid choices: {', '.join(sorted(_VALID_TRANSPORTS))}"
+        )
+    return parts
+
+
+def _validate_security(
+    host: str,
+    auth_token: str | None,
+    transports: list[str],
+) -> None:
+    effective_token = auth_token or os.environ.get("SOOTOOL_AUTH_TOKEN")
+    network_transports = {"http", "sse-legacy", "websocket"}
+    if host != "127.0.0.1" and not effective_token:
+        if any(t in transports for t in network_transports):
+            sys.exit(
+                "ERROR: --host is set to a non-loopback address but no authentication token is "
+                "configured.\n"
+                "Set SOOTOOL_AUTH_TOKEN or pass --auth-token <token> to enable bearer auth "
+                "before exposing the server externally."
+            )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sootool",
+        description="SooTool MCP server",
+    )
+    parser.add_argument(
+        "--transport",
+        default="stdio",
+        help=(
+            "Transport(s) to activate. Comma-separated or 'all'. "
+            "Valid: stdio, http, sse-legacy, websocket, unix. Default: stdio."
+        ),
+    )
+    parser.add_argument("--host", default="127.0.0.1", help="Network bind address (default 127.0.0.1)")
+    parser.add_argument("--http-port", type=int, default=10535, dest="http_port", help="Streamable HTTP port")
+    parser.add_argument("--sse-port",  type=int, default=10536, dest="sse_port",  help="SSE legacy port (default 10536)")
+    parser.add_argument("--ws-port",   type=int, default=10537, dest="ws_port",   help="WebSocket port (default 10537)")
+    parser.add_argument("--auth-token", default=None, dest="auth_token", help="Bearer token for network transports")
+    parser.add_argument(
+        "--cors-origin",
+        action="append",
+        default=[],
+        dest="cors_origins",
+        metavar="ORIGIN",
+        help="Allowed CORS origin (repeatable). Falls back to SOOTOOL_CORS_ORIGINS env.",
+    )
+    # SSE legacy
+    parser.add_argument(
+        "--enable-sse-legacy",
+        action="store_true",
+        default=False,
+        dest="enable_sse_legacy",
+        help="Enable HTTP+SSE legacy transport (MCP 2024-11). Also: SOOTOOL_ENABLE_SSE_LEGACY=1",
+    )
+    # WebSocket
+    parser.add_argument(
+        "--enable-websocket",
+        action="store_true",
+        default=False,
+        dest="enable_websocket",
+        help="Enable WebSocket transport. Also: SOOTOOL_ENABLE_WEBSOCKET=1",
+    )
+    # Unix socket
+    parser.add_argument(
+        "--socket",
+        default=None,
+        dest="socket",
+        metavar="PATH",
+        help="Unix domain socket path. Also: SOOTOOL_SOCKET_PATH",
+    )
+    parser.add_argument(
+        "--socket-mode",
+        default="0600",
+        dest="socket_mode",
+        metavar="MODE",
+        help="Unix socket file permissions (octal, default 0600)",
+    )
+    parser.add_argument(
+        "--force-socket",
+        action="store_true",
+        default=False,
+        dest="force_socket",
+        help="Remove stale Unix socket file on startup instead of refusing to start",
+    )
+    parser.add_argument("--log-format", choices=["json", "text"], default="json", dest="log_format")
+    parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        default="INFO",
+        dest="log_level",
+    )
+    return parser
+
+
+async def _run(transports: list[str], args: argparse.Namespace) -> None:
+    server = build_server()
+
+    from sootool.transports.http import HttpTransport
+    from sootool.transports.sse_legacy import SseLegacyTransport
+    from sootool.transports.stdio import StdioTransport
+    from sootool.transports.unix import UnixTransport
+    from sootool.transports.websocket import WebSocketTransport
+
+    tasks = []
+
+    if "stdio" in transports and any(t in transports for t in ("http", "sse-legacy", "websocket")):
+        logging.getLogger("sootool").warning(
+            "Running stdio and network transport(s) simultaneously. When managed by "
+            "systemd/supervisor, ensure stdin/stdout are not shared with HTTP processes."
+        )
+
+    if "stdio" in transports:
+        tasks.append(StdioTransport(server).start_async())
+
+    if "http" in transports:
+        tasks.append(
+            HttpTransport(
+                server=server,
+                host=args.host,
+                port=args.http_port,
+                auth_token=args.auth_token,
+                cors_origins=args.cors_origins,
+                log_level=args.log_level.lower(),
+            ).start_async()
+        )
+
+    if "sse-legacy" in transports:
+        tasks.append(
+            SseLegacyTransport(
+                server=server,
+                host=args.host,
+                port=args.sse_port,
+                auth_token=args.auth_token,
+                cors_origins=args.cors_origins,
+                log_level=args.log_level.lower(),
+            ).start_async()
+        )
+
+    if "websocket" in transports:
+        tasks.append(
+            WebSocketTransport(
+                server=server,
+                host=args.host,
+                port=args.ws_port,
+                auth_token=args.auth_token,
+                cors_origins=args.cors_origins,
+                log_level=args.log_level.lower(),
+            ).start_async()
+        )
+
+    if "unix" in transports:
+        socket_mode_str = getattr(args, "socket_mode", "0600")
+        try:
+            socket_mode = int(socket_mode_str, 8)
+        except ValueError:
+            sys.exit(f"ERROR: invalid --socket-mode value: {socket_mode_str!r} (expected octal)")
+        tasks.append(
+            UnixTransport(
+                server=server,
+                socket_path=args.socket,
+                socket_mode=socket_mode,
+                force=args.force_socket,
+            ).start_async()
+        )
+
+    if not tasks:
+        sys.exit("No transports selected.")
+
+    await asyncio.gather(*tasks)
+
+
+def main() -> None:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    _configure_logging(args.log_format, args.log_level)
+
+    try:
+        transports = _parse_transports(args.transport, args)
+    except argparse.ArgumentTypeError as exc:
+        parser.error(str(exc))
+
+    # Opt-in flags augment explicit transport list
+    if args.enable_sse_legacy and "sse-legacy" not in transports:
+        transports.append("sse-legacy")
+    if args.enable_websocket and "websocket" not in transports:
+        transports.append("websocket")
+    unix_path = args.socket or os.environ.get("SOOTOOL_SOCKET_PATH")
+    if unix_path and "unix" not in transports and args.transport.strip() != "all":
+        transports.append("unix")
+
+    _validate_security(args.host, args.auth_token, transports)
+
+    _load_modules()
+    asyncio.run(_run(transports, args))
+
+
+if __name__ == "__main__":
+    main()

sootool/core/audit.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Any
+
+
+def _normalize(v: Any) -> Any:
+    if isinstance(v, Decimal):
+        return str(v)
+    if isinstance(v, (list, tuple)):
+        return [_normalize(x) for x in v]
+    if isinstance(v, dict):
+        return {k: _normalize(x) for k, x in v.items()}
+    return v
+
+
+@dataclass
+class CalcTrace:
+    tool:         str
+    formula:      str              = ""
+    inputs:       dict[str, Any]   = field(default_factory=dict)
+    steps:        list[dict[str, Any]] = field(default_factory=list)
+    output_value: Any              = None
+
+    def input(self, name: str, value: Any) -> None:
+        self.inputs[name] = _normalize(value)
+
+    def step(self, label: str, value: Any) -> None:
+        self.steps.append({"label": label, "value": _normalize(value)})
+
+    def output(self, value: Any) -> None:
+        self.output_value = _normalize(value)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "tool":    self.tool,
+            "formula": self.formula,
+            "inputs":  self.inputs,
+            "steps":   self.steps,
+            "output":  self.output_value,
+        }

sootool/core/batch.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import time
+from concurrent.futures import Future, ThreadPoolExecutor, as_completed
+from concurrent.futures import TimeoutError as FuturesTimeout
+from dataclasses import dataclass
+from typing import Any
+
+from sootool.core.errors import SooToolError
+from sootool.core.registry import ToolRegistry
+
+
+class BatchLimitError(SooToolError):
+    pass
+
+
+@dataclass
+class BatchExecutor:
+    registry: ToolRegistry
+    max_items: int = 500
+    item_timeout_s: float = 10.0
+    batch_timeout_s: float = 60.0
+    max_workers: int = 16
+    deterministic: bool = True
+
+    def run(self, items: list[dict[str, Any]]) -> dict[str, Any]:
+        if len(items) > self.max_items:
+            raise BatchLimitError(f"배치 항목 수 {len(items)} > 한도 {self.max_items}")
+        ids = [it["id"] for it in items]
+        if len(set(ids)) != len(ids):
+            raise ValueError("배치 항목 id 중복")
+
+        started = time.monotonic()
+        workers = min(self.max_workers, max(1, len(items)))
+        results: dict[str, dict[str, Any]] = {}
+
+        with ThreadPoolExecutor(max_workers=workers) as pool:
+            futures: dict[Future[Any], str] = {}
+            for it in items:
+                fut = pool.submit(self.registry.invoke, it["tool"], **it.get("args", {}))
+                futures[fut] = it["id"]
+
+            if self.deterministic:
+                # Collect by future mapped to item id, then order by input order
+                id_to_future: dict[str, Future[Any]] = {v: k for k, v in futures.items()}
+                for item_id, fut in id_to_future.items():
+                    t0 = time.monotonic()
+                    try:
+                        res = fut.result(timeout=self.item_timeout_s)
+                        results[item_id] = {
+                            "id": item_id,
+                            "status": "ok",
+                            "result": res,
+                            "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                        }
+                    except FuturesTimeout:
+                        fut.cancel()
+                        results[item_id] = {
+                            "id": item_id,
+                            "status": "timeout",
+                            "error": {"type": "TimeoutError", "message": f"item_timeout_s={self.item_timeout_s}"},
+                            "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                        }
+                    except Exception as e:
+                        results[item_id] = {
+                            "id": item_id,
+                            "status": "error",
+                            "error": {"type": type(e).__name__, "message": str(e)},
+                            "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                        }
+            else:
+                # Non-deterministic: collect by completion order
+                for fut in as_completed(futures):
+                    item_id = futures[fut]
+                    t0 = time.monotonic()
+                    try:
+                        res = fut.result(timeout=0)
+                        results[item_id] = {
+                            "id": item_id,
+                            "status": "ok",
+                            "result": res,
+                            "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                        }
+                    except FuturesTimeout:
+                        results[item_id] = {
+                            "id": item_id,
+                            "status": "timeout",
+                            "error": {"type": "TimeoutError", "message": f"item_timeout_s={self.item_timeout_s}"},
+                            "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                        }
+                    except Exception as e:
+                        results[item_id] = {
+                            "id": item_id,
+                            "status": "error",
+                            "error": {"type": type(e).__name__, "message": str(e)},
+                            "elapsed_ms": int((time.monotonic() - t0) * 1000),
+                        }
+
+        total_ms = int((time.monotonic() - started) * 1000)
+
+        if self.deterministic:
+            ordered = [results[it["id"]] for it in items]
+        else:
+            # Ordered by completion time (already in insertion order via dict)
+            ordered = list(results.values())
+
+        count_ok      = sum(1 for r in ordered if r["status"] == "ok")
+        count_error   = sum(1 for r in ordered if r["status"] == "error")
+        count_timeout = sum(1 for r in ordered if r["status"] == "timeout")
+
+        if count_ok == len(ordered):
+            status = "all_ok"
+        elif count_ok == 0:
+            status = "all_failed"
+        else:
+            status = "partial"
+
+        response: dict[str, Any] = {
+            "status":         status,
+            "results":        ordered,
+            "count_ok":       count_ok,
+            "count_error":    count_error,
+            "count_timeout":  count_timeout,
+            "total_time_ms":  total_ms,
+            "parallelism":    workers,
+        }
+        if not self.deterministic:
+            response["non_deterministic"] = True
+        return response