@oneciel-ai/claude-any 0.1.76 → 0.1.78

package/claude_any.py

@@ -24,7 +24,7 @@ import urllib.request
 from email.utils import parsedate_to_datetime
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any, Callable, Iterable
 
 from claude_any_support.observability import EventBus, render_events_html
 from claude_any_support.transcript_filter import (
@@ -57,6 +57,8 @@ PID_PATH = CONFIG_DIR / "router.pid"
 MODEL_LIST_CACHE_PATH = CONFIG_DIR / "model-list-cache.json"
 WEB_TOOLS_MCP_CONFIG = CONFIG_DIR / "web-tools-mcp.json"
 DUCKDUCKGO_MCP_CONFIG = CONFIG_DIR / "duckduckgo-mcp.json"
+CHANNEL_MCP_CONFIG = CONFIG_DIR / "channel-mcp.json"
+MCP_PROXY_CONFIG = CONFIG_DIR / "mcp-proxy.json"
 ROUTER_HOST = os.environ.get("CLAUDE_ANY_ROUTER_CLIENT_HOST", "127.0.0.1").strip() or "127.0.0.1"
 ROUTER_PORT = 8799
 ROUTER_BASE = f"http://{ROUTER_HOST}:{ROUTER_PORT}"
@@ -102,7 +104,7 @@ OFFICIAL_CHANNEL_PLUGINS = {
     "fakechat": "plugin:fakechat@claude-plugins-official",
 }
 APP_NAME = "Claude Any"
-VERSION = "0.1.76"
+VERSION = "0.1.78"
 CREDITS = "Credits: One Ciel LLC"
 
 LOG_LEVELS = {"SILENT": 0, "ERROR": 1, "WARN": 2, "INFO": 3, "DEBUG": 4, "TRACE": 5}
@@ -120,6 +122,8 @@ _CHAT_CONDITION = threading.Condition()
 _CHAT_NEXT_ID: int | None = None
 _CHANNEL_SSE_LOCK = threading.Lock()
 _CHANNEL_SSE_CONNECTIONS: dict[str, dict[str, Any]] = {}
+_CHANNEL_MCP_LOCK = threading.Lock()
+_CHANNEL_MCP_SESSIONS: dict[str, dict[str, Any]] = {}
 EVENT_BUS = EventBus()
 ADVISOR_FEEDBACK_MARKER = "CLAUDE_ANY_ADVISOR_FEEDBACK"
 PLAN_GUARD_MARKER = "[claude-any-plan-guard]"
@@ -1048,6 +1052,7 @@ UI_TEXT = {
         "advisor_model": "Advisor Model",
         "test": "Test compatibility",
         "options": "LLM options",
+        "log_level": "Log level",
         "presets": "LLM presets",
         "context_setup": "Context setup",
         "timeout_preset": "Timeout preset",
@@ -1068,6 +1073,7 @@ UI_TEXT = {
         "advisor_model": "Advisor Model",
         "test": "호환성 테스트",
         "options": "LLM 옵션",
+        "log_level": "로그 레벨",
         "presets": "LLM 프리셋",
         "context_setup": "컨텍스트 설정",
         "timeout_preset": "타임아웃 프리셋",
@@ -1088,6 +1094,7 @@ UI_TEXT = {
         "advisor_model": "Advisor Model",
         "test": "互換性テスト",
         "options": "LLMオプション",
+        "log_level": "ログレベル",
         "presets": "LLMプリセット",
         "context_setup": "コンテキスト設定",
         "timeout_preset": "timeout プリセット",
@@ -1108,6 +1115,7 @@ UI_TEXT = {
         "advisor_model": "Advisor Model",
         "test": "兼容性测试",
         "options": "LLM 选项",
+        "log_level": "日志级别",
         "presets": "LLM 预设",
         "context_setup": "上下文设置",
         "timeout_preset": "Timeout 预设",
@@ -2247,6 +2255,74 @@ def current_log_level() -> int:
     return level
 
 
+def reset_log_level_cache() -> None:
+    _LOG_LEVEL_CACHE.update({"value": None, "checked_at": 0.0, "file_mtime": 0.0})
+
+
+def log_level_name(value: int | None = None) -> str:
+    if value is None:
+        value = current_log_level()
+    return str(LOG_LEVEL_NAMES.get(int(value), value))
+
+
+def log_level_source() -> str:
+    if LOG_LEVEL_PATH.exists():
+        return "file"
+    if os.environ.get("CLAUDE_ANY_LOG_LEVEL", "").strip():
+        return "env"
+    return "default"
+
+
+def log_level_status() -> str:
+    return f"{log_level_name()} ({log_level_source()})"
+
+
+def normalize_log_level(value: str) -> str | None:
+    raw = str(value or "").strip()
+    if not raw:
+        raise ValueError("log level is empty")
+    upper = raw.upper()
+    aliases = {
+        "OFF": "SILENT",
+        "NONE": "SILENT",
+        "QUIET": "SILENT",
+        "WARNING": "WARN",
+        "WARNINGS": "WARN",
+    }
+    upper = aliases.get(upper, upper)
+    if upper in ("DEFAULT", "RESET", "UNSET", "AUTO"):
+        return None
+    if upper in LOG_LEVELS:
+        return upper
+    if upper.isdigit():
+        numeric = max(0, min(5, int(upper)))
+        return LOG_LEVEL_NAMES[numeric]
+    raise ValueError(f"unknown log level: {value}")
+
+
+def set_log_level_config(value: str) -> list[str]:
+    try:
+        level = normalize_log_level(value)
+    except ValueError as exc:
+        known = ", ".join(LOG_LEVELS)
+        return [f"{exc}. Known levels: {known}, DEFAULT."]
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    if level is None:
+        try:
+            LOG_LEVEL_PATH.unlink()
+        except FileNotFoundError:
+            pass
+        reset_log_level_cache()
+        return [f"Log level reset to {log_level_status()}."]
+    LOG_LEVEL_PATH.write_text(level + "\n", encoding="utf-8")
+    try:
+        os.chmod(LOG_LEVEL_PATH, 0o600)
+    except Exception:
+        pass
+    reset_log_level_cache()
+    return [f"Log level set to {level}."]
+
+
 def router_log(level: str, message: str) -> None:
     """Append a line to router.log if the active level allows it.
     Rotates router.log when it exceeds ROUTER_LOG_MAX_BYTES."""
@@ -4677,6 +4753,134 @@ def stop_channel_sse_connection(name: str | None = None) -> dict[str, Any]:
     return {"stopped": stopped, "connections": channel_sse_status()}
 
 
+def _channel_mcp_session_id() -> str:
+    return f"s{os.getpid()}-{time.time_ns()}"
+
+
+def _channel_mcp_notification(message: dict[str, Any]) -> dict[str, Any]:
+    text = re.sub(r"\s+", " ", str(message.get("message") or "")).strip()
+    channel = str(message.get("channel") or "default")
+    sender = str(message.get("sender_id") or "channel")
+    prefix = f"[{channel}] {sender}"
+    content = f"{prefix}: {text}" if text else prefix
+    meta = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+    merged_meta = {
+        **meta,
+        "claude_any_message_id": message.get("id"),
+        "channel": channel,
+        "sender_id": sender,
+        "thread_id": message.get("thread_id"),
+        "parent_id": message.get("parent_id"),
+    }
+    return {
+        "jsonrpc": "2.0",
+        "method": "notifications/claude/channel",
+        "params": {
+            "content": content,
+            "meta": merged_meta,
+        },
+    }
+
+
+def _write_sse_event(handler: BaseHTTPRequestHandler, event: str, data: Any, event_id: int | None = None) -> None:
+    if event_id is not None:
+        handler.wfile.write(f"id: {event_id}\n".encode("utf-8"))
+    handler.wfile.write(f"event: {event}\n".encode("utf-8"))
+    payload = data if isinstance(data, str) else json.dumps(data, ensure_ascii=False, separators=(",", ":"))
+    for line in payload.splitlines() or [""]:
+        handler.wfile.write(f"data: {line}\n".encode("utf-8"))
+    handler.wfile.write(b"\n")
+    handler.wfile.flush()
+
+
+def handle_channel_mcp_get(handler: BaseHTTPRequestHandler, path: str) -> bool:
+    if path == "/ca/mcp/health":
+        write_json(handler, {"ok": True, "name": "claude-any-router", "sse": "/ca/mcp/sse"})
+        return True
+    if path != "/ca/mcp/sse":
+        return False
+    session = _channel_mcp_session_id()
+    last_id = _chat_init_next_id() - 1
+    with _CHANNEL_MCP_LOCK:
+        _CHANNEL_MCP_SESSIONS[session] = {"created_at": time.time(), "last_id": last_id, "initialized": False}
+    handler.send_response(200)
+    handler.send_header("content-type", "text/event-stream")
+    handler.send_header("cache-control", "no-cache")
+    handler.send_header("connection", "close")
+    handler.end_headers()
+    _write_sse_event(handler, "endpoint", f"/ca/mcp/messages?session={urllib.parse.quote(session)}")
+    try:
+        while True:
+            with _CHANNEL_MCP_LOCK:
+                state = _CHANNEL_MCP_SESSIONS.get(session)
+                if not state:
+                    return True
+                last_id = int(state.get("last_id") or 0)
+            messages = read_chat_messages(last_id, None, None, 100)
+            if messages:
+                for message in messages:
+                    last_id = max(last_id, int(message.get("id") or 0))
+                    _write_sse_event(handler, "message", _channel_mcp_notification(message), last_id)
+                with _CHANNEL_MCP_LOCK:
+                    state = _CHANNEL_MCP_SESSIONS.get(session)
+                    if state:
+                        state["last_id"] = last_id
+                continue
+            handler.wfile.write(b": keepalive\n\n")
+            handler.wfile.flush()
+            with _CHAT_CONDITION:
+                _CHAT_CONDITION.wait(timeout=15.0)
+    except (BrokenPipeError, ConnectionError, ConnectionResetError):
+        return True
+    finally:
+        with _CHANNEL_MCP_LOCK:
+            _CHANNEL_MCP_SESSIONS.pop(session, None)
+
+
+def handle_channel_mcp_post(handler: BaseHTTPRequestHandler, path: str, body: dict[str, Any]) -> bool:
+    if path != "/ca/mcp/messages":
+        return False
+    params = _query_params(handler)
+    session = _first_param(params, "session")
+    with _CHANNEL_MCP_LOCK:
+        if session and session in _CHANNEL_MCP_SESSIONS:
+            _CHANNEL_MCP_SESSIONS[session]["last_seen_at"] = time.time()
+    method = str(body.get("method") or "")
+    request_id = body.get("id")
+    if method == "initialize":
+        protocol = "2024-11-05"
+        req_params = body.get("params") if isinstance(body.get("params"), dict) else {}
+        if req_params.get("protocolVersion"):
+            protocol = str(req_params["protocolVersion"])
+        with _CHANNEL_MCP_LOCK:
+            if session and session in _CHANNEL_MCP_SESSIONS:
+                _CHANNEL_MCP_SESSIONS[session]["initialized"] = True
+        write_json(
+            handler,
+            {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "result": {
+                    "protocolVersion": protocol,
+                    "capabilities": {"tools": {"listChanged": False}},
+                    "serverInfo": {"name": "claude-any-router", "version": VERSION},
+                },
+            },
+        )
+        return True
+    if method == "tools/list":
+        write_json(handler, {"jsonrpc": "2.0", "id": request_id, "result": {"tools": []}})
+        return True
+    if method == "ping":
+        write_json(handler, {"jsonrpc": "2.0", "id": request_id, "result": {}})
+        return True
+    if request_id is None:
+        write_json(handler, {"ok": True})
+        return True
+    write_json(handler, {"jsonrpc": "2.0", "id": request_id, "result": {}})
+    return True
+
+
 def _query_params(handler: BaseHTTPRequestHandler) -> dict[str, list[str]]:
     return urllib.parse.parse_qs(urllib.parse.urlparse(handler.path).query, keep_blank_values=True)
 
@@ -8112,6 +8316,21 @@ class RouterHandler(BaseHTTPRequestHandler):
         except Exception:
             pass
 
+    def do_HEAD(self) -> None:
+        cfg = load_config()
+        if reject_external_router_request(self, cfg):
+            return
+        parsed = urllib.parse.urlparse(self.path)
+        path = parsed.path
+        if path in ("/", "/health", "/healthz"):
+            self.send_response(200)
+            self.send_header("content-type", "text/plain; charset=utf-8")
+            self.end_headers()
+            return
+        self.send_response(404)
+        self.send_header("content-type", "application/json")
+        self.end_headers()
+
     def do_GET(self) -> None:
         parsed = urllib.parse.urlparse(self.path)
         path = parsed.path
@@ -8123,6 +8342,8 @@ class RouterHandler(BaseHTTPRequestHandler):
             return
         if handle_llm_config_get(self, path):
             return
+        if handle_channel_mcp_get(self, path):
+            return
         if handle_chat_get(self, path) or handle_plan_get(self, path):
             return
         provider, pcfg = get_current_provider(cfg)
@@ -8153,6 +8374,8 @@ class RouterHandler(BaseHTTPRequestHandler):
         body = parse_json_body(raw)
         if handle_llm_config_post(self, path, body):
             return
+        if handle_channel_mcp_post(self, path, body):
+            return
         if handle_chat_post(self, path, body) or handle_plan_post(self, path, body):
             return
         provider, pcfg = get_current_provider(cfg)
@@ -8645,6 +8868,7 @@ def status_lines() -> list[str]:
         *([f"request_timeout_ms: {pcfg.get('request_timeout_ms', 'default')}"] if provider in ("vllm", "nvidia-hosted", "self-hosted-nim") else []),
         *([f"stream_idle_timeout_ms: {pcfg.get('stream_idle_timeout_ms', 'auto')}"] if provider in ("vllm", "nvidia-hosted", "self-hosted-nim") else []),
         f"claude_model: {current_upstream_model_id(provider, pcfg) if direct_native else current_alias(cfg)}",
+        f"log_level: {log_level_status()}",
         f"channels: {channel_status_text(cfg)}",
         f"router: {'bypassed for native provider compatibility' if direct_native else (('up' if router_up() else 'down') + ' ' + ROUTER_BASE)}",
         f"config: {CONFIG_PATH}",
@@ -8655,6 +8879,20 @@ def cmd_status(_: argparse.Namespace) -> None:
     print("\n".join(status_lines()))
 
 
+def cmd_log_level(args: argparse.Namespace) -> None:
+    value = getattr(args, "value", None)
+    if not value:
+        print(f"log_level: {log_level_status()}")
+        for numeric in sorted(LOG_LEVEL_NAMES):
+            name = LOG_LEVEL_NAMES[numeric]
+            mark = "*" if name == log_level_name() else " "
+            print(f" {mark} {name:<6} {numeric}")
+        print("   DEFAULT reset to environment/default")
+        return
+    for line in set_log_level_config(str(value)):
+        print(line)
+
+
 def cmd_language(args: argparse.Namespace) -> None:
     cfg = load_config()
     if not args.value:
@@ -8759,6 +8997,298 @@ def channel_specs(cfg: dict[str, Any] | None = None) -> list[str]:
     return channels
 
 
+def _dedupe_strings(values: Iterable[str]) -> list[str]:
+    out: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        text = str(value or "").strip()
+        if not text or text in seen:
+            continue
+        seen.add(text)
+        out.append(text)
+    return out
+
+
+def _path_for_compare(path: Path | str) -> str:
+    try:
+        return str(Path(path).expanduser().resolve()).replace("\\", "/").rstrip("/").casefold()
+    except Exception:
+        return str(path).replace("\\", "/").rstrip("/").casefold()
+
+
+def _project_key_matches_cwd(project_key: str, cwd: Path) -> bool:
+    key = str(project_key or "").strip()
+    if not key:
+        return False
+    try:
+        project_path = Path(key).expanduser()
+    except Exception:
+        return False
+    if not project_path.is_absolute():
+        return False
+    project = _path_for_compare(project_path)
+    current = _path_for_compare(cwd)
+    return current == project or current.startswith(project + "/")
+
+
+def _mcp_server_names_from_mapping(mapping: Any) -> list[str]:
+    if not isinstance(mapping, dict):
+        return []
+    names: list[str] = []
+    for key in ("mcpServers", "servers"):
+        servers = mapping.get(key)
+        if isinstance(servers, dict):
+            names.extend(str(name).strip() for name in servers if str(name).strip())
+    return _dedupe_strings(names)
+
+
+def _mcp_servers_from_mapping(mapping: Any) -> list[tuple[str, dict[str, Any]]]:
+    if not isinstance(mapping, dict):
+        return []
+    found: list[tuple[str, dict[str, Any]]] = []
+    seen: set[str] = set()
+    for key in ("mcpServers", "servers"):
+        servers = mapping.get(key)
+        if not isinstance(servers, dict):
+            continue
+        for raw_name, raw_server in servers.items():
+            name = str(raw_name or "").strip()
+            if not name or name in seen or not isinstance(raw_server, dict):
+                continue
+            seen.add(name)
+            found.append((name, dict(raw_server)))
+    return found
+
+
+def _read_mcp_server_names_from_json(path: Path, cwd: Path) -> list[str]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return []
+    names = _mcp_server_names_from_mapping(data)
+    if path.name == ".claude.json" and isinstance(data, dict):
+        projects = data.get("projects")
+        if isinstance(projects, dict):
+            for project_key, project_data in projects.items():
+                if _project_key_matches_cwd(str(project_key), cwd):
+                    names.extend(_mcp_server_names_from_mapping(project_data))
+    return _dedupe_strings(names)
+
+
+def _read_mcp_servers_from_json(path: Path, cwd: Path) -> list[tuple[str, dict[str, Any]]]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return []
+    servers = _mcp_servers_from_mapping(data)
+    if path.name == ".claude.json" and isinstance(data, dict):
+        projects = data.get("projects")
+        if isinstance(projects, dict):
+            for project_key, project_data in projects.items():
+                if _project_key_matches_cwd(str(project_key), cwd):
+                    servers.extend(_mcp_servers_from_mapping(project_data))
+    out: list[tuple[str, dict[str, Any]]] = []
+    seen: set[str] = set()
+    for name, server in servers:
+        if name in seen:
+            continue
+        seen.add(name)
+        out.append((name, server))
+    return out
+
+
+def _mcp_server_is_stdio(server: dict[str, Any]) -> bool:
+    if not isinstance(server, dict):
+        return False
+    server_type = str(server.get("type") or "").strip().lower()
+    if server_type and server_type not in ("stdio", "command"):
+        return False
+    command = str(server.get("command") or "").strip()
+    if not command:
+        return False
+    joined = " ".join([command, *[str(item) for item in server.get("args", []) if item is not None]])
+    return "mcp-proxy" not in joined
+
+
+def _mcp_config_passthrough_values(passthrough: list[str]) -> list[str]:
+    values: list[str] = []
+    i = 0
+    while i < len(passthrough):
+        arg = passthrough[i]
+        if arg == "--mcp-config":
+            i += 1
+            while i < len(passthrough) and not passthrough[i].startswith("-"):
+                values.append(passthrough[i])
+                i += 1
+            continue
+        if arg.startswith("--mcp-config="):
+            value = arg.split("=", 1)[1].strip()
+            if value:
+                values.append(value)
+        i += 1
+    return values
+
+
+def strip_mcp_config_passthrough(passthrough: list[str]) -> list[str]:
+    stripped: list[str] = []
+    i = 0
+    while i < len(passthrough):
+        arg = passthrough[i]
+        if arg == "--mcp-config":
+            i += 1
+            while i < len(passthrough) and not passthrough[i].startswith("-"):
+                i += 1
+            continue
+        if arg.startswith("--mcp-config="):
+            i += 1
+            continue
+        stripped.append(arg)
+        i += 1
+    return stripped
+
+
+def _safe_mcp_proxy_name(name: str) -> str:
+    safe = re.sub(r"[^A-Za-z0-9_.-]+", "_", name.strip())
+    return safe[:80] or "server"
+
+
+def _mcp_config_paths_from_passthrough(passthrough: list[str]) -> list[Path]:
+    return [Path(value).expanduser() for value in _mcp_config_passthrough_values(passthrough)]
+
+
+def claude_mcp_config_paths(passthrough: list[str] | None = None, cwd: Path | None = None, home: Path | None = None) -> list[Path]:
+    cwd = cwd or Path.cwd()
+    home = home or HOME
+    paths: list[Path] = []
+    paths.extend(_mcp_config_paths_from_passthrough(passthrough or []))
+    current = cwd
+    visited: set[str] = set()
+    while True:
+        key = _path_for_compare(current)
+        if key in visited:
+            break
+        visited.add(key)
+        paths.append(current / ".mcp.json")
+        if current == current.parent:
+            break
+        current = current.parent
+    paths.extend([
+        home / ".mcp.json",
+        home / ".claude" / "settings.json",
+        home / ".claude.json",
+    ])
+    out: list[Path] = []
+    seen: set[str] = set()
+    for path in paths:
+        key = _path_for_compare(path)
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(path)
+    return out
+
+
+def auto_discovered_mcp_channel_specs(
+    passthrough: list[str] | None = None,
+    cwd: Path | None = None,
+    home: Path | None = None,
+) -> list[str]:
+    cwd = cwd or Path.cwd()
+    specs: list[str] = []
+    for path in claude_mcp_config_paths(passthrough, cwd, home):
+        if not path.exists() or not path.is_file():
+            continue
+        for name in _read_mcp_server_names_from_json(path, cwd):
+            if re.search(r"\s", name):
+                continue
+            specs.append(f"server:{name}" if not is_channel_spec_tagged(name) else name)
+    return _dedupe_strings(specs)
+
+
+def _mcp_sse_servers_from_mapping(mapping: Any) -> list[dict[str, Any]]:
+    if not isinstance(mapping, dict):
+        return []
+    found: list[dict[str, Any]] = []
+    for key in ("mcpServers", "servers"):
+        servers = mapping.get(key)
+        if not isinstance(servers, dict):
+            continue
+        for raw_name, raw_server in servers.items():
+            name = str(raw_name or "").strip()
+            if not name or not isinstance(raw_server, dict):
+                continue
+            url = str(raw_server.get("url") or raw_server.get("endpoint") or "").strip()
+            if not url.startswith(("http://", "https://")):
+                continue
+            server_type = str(raw_server.get("type") or "").strip().lower()
+            if server_type and server_type not in ("sse", "http", "streamable-http"):
+                continue
+            headers = raw_server.get("headers") if isinstance(raw_server.get("headers"), dict) else {}
+            found.append(
+                {
+                    "name": f"mcp-{name}",
+                    "url": url,
+                    "headers": {str(k): str(v) for k, v in headers.items() if str(k).strip()},
+                    "channel": name,
+                    "sender_id": name,
+                    "recipient": "all",
+                    "mcp": True,
+                }
+            )
+    return found
+
+
+def _read_mcp_sse_servers_from_json(path: Path, cwd: Path) -> list[dict[str, Any]]:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return []
+    servers = _mcp_sse_servers_from_mapping(data)
+    if path.name == ".claude.json" and isinstance(data, dict):
+        projects = data.get("projects")
+        if isinstance(projects, dict):
+            for project_key, project_data in projects.items():
+                if _project_key_matches_cwd(str(project_key), cwd):
+                    servers.extend(_mcp_sse_servers_from_mapping(project_data))
+    out: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for server in servers:
+        key = f"{server.get('name')}|{server.get('url')}"
+        if key in seen:
+            continue
+        seen.add(key)
+        out.append(server)
+    return out
+
+
+def auto_start_sse_channels_from_mcp_configs(
+    passthrough: list[str] | None = None,
+    cwd: Path | None = None,
+    home: Path | None = None,
+) -> list[dict[str, Any]]:
+    cwd = cwd or Path.cwd()
+    started: list[dict[str, Any]] = []
+    for path in claude_mcp_config_paths(passthrough, cwd, home):
+        if not path.exists() or not path.is_file():
+            continue
+        for server in _read_mcp_sse_servers_from_json(path, cwd):
+            try:
+                status = start_channel_sse_connection(server)
+                started.append(status)
+                router_log("INFO", f"channel_sse_auto_started name={status.get('name')} url={status.get('url')}")
+            except Exception as exc:
+                router_log("WARN", f"channel_sse_auto_start_failed path={path} error={type(exc).__name__}: {exc}")
+    return started
+
+
+def channel_specs_for_launch(cfg: dict[str, Any], passthrough: list[str], extra_specs: list[str] | None = None) -> list[str]:
+    configured = [spec for spec in channel_specs(cfg) if is_channel_spec_tagged(spec)]
+    specs = configured
+    if extra_specs:
+        specs = [*specs, *extra_specs]
+    return _dedupe_strings(spec for spec in specs if is_channel_spec_tagged(spec))
+
+
 def is_channel_spec_tagged(spec: str) -> bool:
     return spec.startswith("plugin:") or spec.startswith("server:")
 
@@ -12046,7 +12576,7 @@ def main_menu_rows(cfg: dict[str, Any], provider: str, pcfg: dict[str, Any], lan
         f"4. {ui_text('model', lang)}  [{compact_text(pcfg.get('current_model', 'unset'), 62)}]",
         f"5. {ui_text('advisor_model', lang)}  [{compact_text(pcfg.get('advisor_model') or 'off', 62)}]",
         f"6. {ui_text('options', lang)}  [{compact_text(llm_options_status(provider, pcfg), 62)}]",
-        f"7. Channels  [{channel_status_text(cfg)}]",
+        f"7. {ui_text('log_level', lang)}  [{log_level_status()}]",
         f"8. {ui_text('test', lang)}",
         f"9. {ui_text('launch', lang)}",
         ui_text("quit", lang),
@@ -12076,6 +12606,30 @@ def language_panel_rows(cfg: dict[str, Any]) -> tuple[list[str], list[str]]:
     return rows, values
 
 
+def log_level_panel_rows(cfg: dict[str, Any]) -> tuple[list[str], list[str]]:
+    rows: list[str] = []
+    values: list[str] = []
+    current = log_level_name()
+    descriptions = {
+        "SILENT": "no router log writes",
+        "ERROR": "errors only",
+        "WARN": "warnings and errors",
+        "INFO": "normal diagnostics",
+        "DEBUG": "verbose diagnostics",
+        "TRACE": "request/response trace detail",
+    }
+    for numeric in sorted(LOG_LEVEL_NAMES):
+        name = LOG_LEVEL_NAMES[numeric]
+        mark = "*" if name == current else " "
+        rows.append(f"{mark} {name:<6} {numeric}  {descriptions.get(name, '')}")
+        values.append(name)
+    rows.append(f"Reset to default/env  [{log_level_status()}]")
+    values.append("DEFAULT")
+    rows.append(ui_text("back", cfg.get("language", "en")))
+    values.append("back")
+    return rows, values
+
+
 def model_panel_rows(provider: str, pcfg: dict[str, Any]) -> tuple[list[str], list[str]]:
     values = unique_model_ids(provider, upstream_model_ids(provider, pcfg))
     rows: list[str] = []
@@ -12482,6 +13036,8 @@ def portable_prelaunch_menu() -> int:
             panel_rows, panel_values = ["Run compatibility test", "Back"], ["run", "back"]
         elif name == "options":
             panel_rows, panel_values = llm_option_panel_rows(provider, pcfg, cfg.get("language", "en"))
+        elif name == "log-level":
+            panel_rows, panel_values = log_level_panel_rows(cfg)
         elif name == "channels":
             panel_rows, panel_values = channel_panel_rows(cfg)
         elif name == "context":
@@ -12661,6 +13217,15 @@ def portable_prelaunch_menu() -> int:
                         panel_rows, panel_values = ["Run compatibility test again", "Back"], ["run", "back"]
                         refresh_checks()
                         main_idx = 9 if "Compatibility: OK" in out else 4
+                elif panel == "log-level":
+                    if value == "back":
+                        close_panel()
+                    elif value:
+                        messages = set_log_level_config(value)
+                        refresh_checks()
+                        cfg = load_config()
+                        panel_rows, panel_values = log_level_panel_rows(cfg)
+                        panel_idx = max(0, min(panel_idx, len(panel_rows) - 1))
                 elif panel == "channels":
                     if value == "back":
                         close_panel()
@@ -12793,7 +13358,7 @@ def portable_prelaunch_menu() -> int:
             elif key in ("esc", "q"):
                 return 10
             elif key == "enter":
-                actions = ["language", "provider", "api-key", "base-url", "model", "advisor-model", "options", "channels", "test", "launch", "quit"]
+                actions = ["language", "provider", "api-key", "base-url", "model", "advisor-model", "options", "log-level", "test", "launch", "quit"]
                 action = actions[main_idx]
                 if action == "launch":
                     blockers = launch_readiness_errors()
@@ -12907,17 +13472,16 @@ def normalize_channel_passthrough(passthrough: list[str]) -> list[str]:
     return normalized
 
 
-def claude_channel_args(cfg: dict[str, Any], passthrough: list[str]) -> list[str]:
-    channels = [spec for spec in channel_specs(cfg) if is_channel_spec_tagged(spec)]
-    if not channels or has_passthrough_option(passthrough, "--channels", "--dangerously-load-development-channels"):
-        return []
-    return ["--dangerously-load-development-channels", *channels]
+def native_channel_passthrough_requested(passthrough: list[str]) -> bool:
+    return has_passthrough_option(passthrough, "--channels", "--dangerously-load-development-channels")
 
 
-def claude_channels_requested(cfg: dict[str, Any], passthrough: list[str]) -> bool:
-    if has_passthrough_option(passthrough, "--channels", "--dangerously-load-development-channels"):
-        return True
-    return any(is_channel_spec_tagged(spec) for spec in channel_specs(cfg))
+def claude_channel_args(cfg: dict[str, Any], passthrough: list[str], extra_specs: list[str] | None = None) -> list[str]:
+    return []
+
+
+def claude_channels_requested(cfg: dict[str, Any], passthrough: list[str], extra_specs: list[str] | None = None) -> bool:
+    return native_channel_passthrough_requested(passthrough)
 
 
 def write_web_tools_mcp_config(cfg: dict[str, Any]) -> Path:
@@ -12960,6 +13524,472 @@ def write_duckduckgo_mcp_config(cfg: dict[str, Any]) -> Path:
     return path
 
 
+def write_channel_mcp_config() -> Path:
+    data = {
+        "mcpServers": {
+            "claude-any-router": {
+                "type": "sse",
+                "url": f"{ROUTER_BASE}/ca/mcp/sse",
+            }
+        }
+    }
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CHANNEL_MCP_CONFIG.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    try:
+        os.chmod(CHANNEL_MCP_CONFIG, 0o600)
+    except Exception:
+        pass
+    return CHANNEL_MCP_CONFIG
+
+
+def write_mcp_proxy_config(
+    passthrough: list[str],
+    *,
+    extra_config_paths: list[Path | str] | None = None,
+    cwd: Path | None = None,
+    home: Path | None = None,
+) -> Path | None:
+    cwd = cwd or Path.cwd()
+    extra = [Path(item).expanduser() for item in (extra_config_paths or [])]
+    paths = [*extra, *claude_mcp_config_paths(passthrough, cwd, home)]
+    servers: dict[str, Any] = {}
+    seen: set[str] = set()
+    server_dir = CONFIG_DIR / "mcp-proxy-servers"
+    for path in paths:
+        if not path.exists() or not path.is_file():
+            continue
+        for name, server in _read_mcp_servers_from_json(path, cwd):
+            if name in seen:
+                continue
+            seen.add(name)
+            if _mcp_server_is_stdio(server):
+                server_dir.mkdir(parents=True, exist_ok=True)
+                server_path = server_dir / f"{_safe_mcp_proxy_name(name)}.json"
+                server_path.write_text(json.dumps(server, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+                try:
+                    os.chmod(server_path, 0o600)
+                except Exception:
+                    pass
+                servers[name] = {
+                    "command": sys.executable,
+                    "args": [
+                        str(Path(__file__).resolve()),
+                        "mcp-proxy",
+                        "--server-name",
+                        name,
+                        "--server-config",
+                        str(server_path),
+                    ],
+                }
+            else:
+                servers[name] = server
+    if not servers:
+        return None
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    MCP_PROXY_CONFIG.write_text(json.dumps({"mcpServers": servers}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    try:
+        os.chmod(MCP_PROXY_CONFIG, 0o600)
+    except Exception:
+        pass
+    router_log("INFO", f"mcp_proxy_config_written servers={','.join(sorted(servers))}")
+    return MCP_PROXY_CONFIG
+
+
+def should_use_channel_stdin_proxy(use_router_mode: bool, passthrough: list[str]) -> bool:
+    return bool(use_router_mode and not native_channel_passthrough_requested(passthrough))
+
+
+def format_channel_wake_prompt(message: dict[str, Any]) -> str:
+    channel = str(message.get("channel") or "default")
+    sender = str(message.get("sender_id") or "channel")
+    mid = str(message.get("id") or "")
+    meta = message.get("meta") if isinstance(message.get("meta"), dict) else {}
+    room = str(meta.get("room_id") or meta.get("room") or channel)
+    thread = str(message.get("thread_id") or meta.get("thread_id") or "")
+    body = re.sub(r"\s+", " ", str(message.get("message") or "")).strip()
+    fields = [f"channel={channel}", f"room={room}", f"from={sender}"]
+    if mid:
+        fields.append(f"id={mid}")
+    if thread:
+        fields.append(f"thread={thread}")
+    return (
+        "[claude-any external channel message] "
+        + " ".join(fields)
+        + f" text={json.dumps(body, ensure_ascii=False)}. "
+        + "If relevant to current work, respond or act now; otherwise keep working."
+    )
+
+
+def _write_fd_all(fd: int, data: bytes) -> None:
+    view = memoryview(data)
+    while view:
+        written = os.write(fd, view)
+        view = view[written:]
+
+
+def _channel_wake_input_bytes(prompt: str) -> bytes:
+    # Ctrl-U clears any stale line editor text before submitting the synthetic prompt.
+    return b"\x15" + prompt.encode("utf-8", errors="replace") + b"\n"
+
+
+def _inject_pending_channel_messages(master_fd: int, last_id: int) -> int:
+    for message in read_chat_messages(last_id, None, None, 100):
+        try:
+            last_id = max(last_id, int(message.get("id") or 0))
+        except Exception:
+            continue
+        prompt = format_channel_wake_prompt(message)
+        _write_fd_all(master_fd, _channel_wake_input_bytes(prompt))
+        router_log("INFO", f"channel_stdin_proxy_injected message_id={message.get('id')} channel={message.get('channel')}")
+    return last_id
+
+
+def _chat_messages_file_marker() -> tuple[float, int]:
+    try:
+        stat = CHAT_MESSAGES_PATH.stat()
+        return (stat.st_mtime, stat.st_size)
+    except Exception:
+        return (0.0, 0)
+
+
+def subprocess_call_with_channel_wake_proxy(cmd: list[str], env: dict[str, str]) -> int:
+    if os.name != "posix" or not sys.stdin.isatty() or not sys.stdout.isatty():
+        router_log("INFO", "channel_stdin_proxy_unavailable; using direct subprocess call")
+        return subprocess.call(cmd, env=env)
+    import pty
+    import select
+    import termios
+    import tty
+
+    master_fd, slave_fd = pty.openpty()
+    proc = subprocess.Popen(cmd, stdin=slave_fd, stdout=slave_fd, stderr=slave_fd, env=env, close_fds=True)
+    os.close(slave_fd)
+    stdin_fd = sys.stdin.fileno()
+    stdout_fd = sys.stdout.fileno()
+    old_attrs = termios.tcgetattr(stdin_fd)
+    last_id = _chat_init_next_id() - 1
+    last_channel_poll = 0.0
+    last_channel_marker = _chat_messages_file_marker()
+    try:
+        tty.setraw(stdin_fd)
+        while proc.poll() is None:
+            try:
+                readable, _, _ = select.select([stdin_fd, master_fd], [], [], 0.2)
+            except OSError:
+                break
+            if stdin_fd in readable:
+                data = os.read(stdin_fd, 4096)
+                if data:
+                    _write_fd_all(master_fd, data)
+            if master_fd in readable:
+                try:
+                    data = os.read(master_fd, 4096)
+                except OSError:
+                    break
+                if data:
+                    _write_fd_all(stdout_fd, data)
+            now = time.time()
+            if now - last_channel_poll >= 0.5:
+                last_channel_poll = now
+                marker = _chat_messages_file_marker()
+                if marker != last_channel_marker:
+                    last_channel_marker = marker
+                    last_id = _inject_pending_channel_messages(master_fd, last_id)
+        while True:
+            try:
+                readable, _, _ = select.select([master_fd], [], [], 0)
+                if master_fd not in readable:
+                    break
+                data = os.read(master_fd, 4096)
+                if not data:
+                    break
+                _write_fd_all(stdout_fd, data)
+            except OSError:
+                break
+        return proc.returncode if proc.returncode is not None else 0
+    finally:
+        try:
+            termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_attrs)
+        except Exception:
+            pass
+        try:
+            os.close(master_fd)
+        except Exception:
+            pass
+        if proc.poll() is None:
+            try:
+                proc.terminate()
+            except Exception:
+                pass
+
+
+def _mcp_proxy_notification_payload(server_name: str, message: dict[str, Any]) -> dict[str, Any] | None:
+    method = str(message.get("method") or "").strip()
+    if not method.startswith("notifications/"):
+        return None
+    params = message.get("params") if isinstance(message.get("params"), dict) else {}
+    payload = params.get("payload") if isinstance(params.get("payload"), dict) else {}
+    data = params.get("data") if isinstance(params.get("data"), dict) else {}
+    event = params.get("event") if isinstance(params.get("event"), dict) else {}
+    meta: dict[str, Any] = {
+        "mcp_server": server_name,
+        "mcp_method": method,
+    }
+    meta.update(_event_meta_from_sources(message, params, payload, data, event))
+    content = (
+        _event_payload_text(params)
+        or _event_payload_text(payload)
+        or _event_payload_text(data)
+        or _event_payload_text(event)
+    )
+    if not content and params:
+        content = json.dumps(params, ensure_ascii=False, separators=(",", ":"), default=str)
+    if not content:
+        return None
+    channel = str(meta.get("channel") or meta.get("room_id") or meta.get("room") or server_name)
+    return {
+        "channel": channel,
+        "sender_id": str(meta.get("sender_id") or meta.get("agent_id") or server_name),
+        "recipients": meta.get("recipient_id") or "all",
+        "thread_id": meta.get("thread_id"),
+        "parent_id": meta.get("parent_id"),
+        "kind": method.replace("notifications/claude/", "").replace("notifications/", "").replace("/", "."),
+        "message": content,
+        "meta": meta,
+    }
+
+
+def _mcp_proxy_observe_json_message(server_name: str, payload: Any) -> None:
+    if not isinstance(payload, dict):
+        return
+    chat_payload = _mcp_proxy_notification_payload(server_name, payload)
+    if not chat_payload:
+        return
+    try:
+        saved = append_chat_message(chat_payload)
+        router_log(
+            "INFO",
+            f"mcp_proxy_notification server={server_name} method={payload.get('method')} message_id={saved.get('id')}",
+        )
+    except Exception as exc:
+        router_log("WARN", f"mcp_proxy_notification_failed server={server_name} error={type(exc).__name__}: {exc}")
+
+
+def _mcp_proxy_observe_stdout_line(server_name: str, line: bytes) -> None:
+    try:
+        text = line.decode("utf-8", errors="replace").strip()
+        if not text or not text.startswith("{"):
+            return
+        payload = json.loads(text)
+    except Exception:
+        return
+    _mcp_proxy_observe_json_message(server_name, payload)
+
+
+def _mcp_proxy_header_end(buffer: bytes) -> tuple[int, int] | None:
+    crlf = buffer.find(b"\r\n\r\n")
+    lf = buffer.find(b"\n\n")
+    candidates: list[tuple[int, int]] = []
+    if crlf >= 0:
+        candidates.append((crlf, 4))
+    if lf >= 0:
+        candidates.append((lf, 2))
+    return min(candidates, key=lambda item: item[0]) if candidates else None
+
+
+def _mcp_proxy_frame_header(buffer: bytes) -> tuple[int, int, int] | None:
+    header = _mcp_proxy_header_end(buffer)
+    if not header:
+        return None
+    header_end, delimiter_len = header
+    length = _mcp_proxy_content_length(buffer[:header_end])
+    if length is None:
+        return None
+    return header_end, delimiter_len, length
+
+
+def _mcp_proxy_content_length(header_bytes: bytes) -> int | None:
+    try:
+        header_text = header_bytes.decode("ascii", errors="replace")
+    except Exception:
+        return None
+    for line in re.split(r"\r?\n", header_text):
+        name, sep, value = line.partition(":")
+        if sep and name.strip().lower() == "content-length":
+            try:
+                length = int(value.strip())
+            except Exception:
+                return None
+            return length if length >= 0 else None
+    return None
+
+
+class _McpStdoutObserver:
+    def __init__(self, server_name: str) -> None:
+        self.server_name = server_name
+        self.buffer = bytearray()
+
+    def feed(self, chunk: bytes) -> None:
+        if not chunk:
+            return
+        self.buffer.extend(chunk)
+        self._drain()
+
+    def _drop_until_candidate(self) -> bool:
+        data = bytes(self.buffer)
+        if not data:
+            return False
+        stripped = data.lstrip()
+        if len(stripped) != len(data):
+            del self.buffer[: len(data) - len(stripped)]
+            data = stripped
+        if _mcp_proxy_frame_header(data) or data.startswith(b"{"):
+            return True
+        lowered = data.lower()
+        content_idx = lowered.find(b"content-length:")
+        json_idx = data.find(b"{")
+        candidates = [idx for idx in (content_idx, json_idx) if idx >= 0]
+        newline_idx = data.find(b"\n")
+        if candidates:
+            keep_from = min(candidates)
+            if newline_idx >= 0 and newline_idx < keep_from:
+                del self.buffer[: newline_idx + 1]
+            elif keep_from > 0:
+                del self.buffer[:keep_from]
+            return True
+        if newline_idx >= 0:
+            del self.buffer[: newline_idx + 1]
+            return True
+        if len(self.buffer) > 1024 * 1024:
+            del self.buffer[:-4096]
+        return False
+
+    def _drain(self) -> None:
+        while self.buffer:
+            if not self._drop_until_candidate():
+                return
+            data = bytes(self.buffer)
+            frame = _mcp_proxy_frame_header(data)
+            if frame:
+                header_end, delimiter_len, length = frame
+                body_start = header_end + delimiter_len
+                body_end = body_start + length
+                if len(data) < body_end:
+                    return
+                body = data[body_start:body_end]
+                del self.buffer[:body_end]
+                try:
+                    payload = json.loads(body.decode("utf-8", errors="replace"))
+                except Exception:
+                    continue
+                _mcp_proxy_observe_json_message(self.server_name, payload)
+                continue
+            if data.startswith(b"{"):
+                newline_idx = data.find(b"\n")
+                if newline_idx < 0:
+                    return
+                line = data[:newline_idx]
+                del self.buffer[: newline_idx + 1]
+                _mcp_proxy_observe_stdout_line(self.server_name, line)
+                continue
+            return
+
+
+def _mcp_proxy_forward_stdin(proc: subprocess.Popen[bytes]) -> None:
+    try:
+        while True:
+            chunk = sys.stdin.buffer.read(65536)
+            if not chunk:
+                break
+            if proc.stdin:
+                proc.stdin.write(chunk)
+                proc.stdin.flush()
+    except Exception:
+        pass
+    finally:
+        try:
+            if proc.stdin:
+                proc.stdin.close()
+        except Exception:
+            pass
+
+
+def _mcp_proxy_forward_stderr(proc: subprocess.Popen[bytes]) -> None:
+    try:
+        if not proc.stderr:
+            return
+        while True:
+            chunk = proc.stderr.read(4096)
+            if not chunk:
+                break
+            sys.stderr.buffer.write(chunk)
+            sys.stderr.buffer.flush()
+    except Exception:
+        pass
+
+
+def run_mcp_stdio_proxy(server_name: str, server_config_path: Path) -> int:
+    try:
+        server = json.loads(server_config_path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        print(f"claude-any mcp-proxy: cannot read server config: {type(exc).__name__}: {exc}", file=sys.stderr, flush=True)
+        return 2
+    if not isinstance(server, dict) or not _mcp_server_is_stdio(server):
+        print("claude-any mcp-proxy: server config is not a stdio MCP server", file=sys.stderr, flush=True)
+        return 2
+    command = str(server.get("command") or "").strip()
+    args = [str(item) for item in server.get("args", [])] if isinstance(server.get("args"), list) else []
+    env = os.environ.copy()
+    raw_env = server.get("env")
+    if isinstance(raw_env, dict):
+        env.update({str(k): str(v) for k, v in raw_env.items() if str(k)})
+    cwd_value = server.get("cwd") or server.get("workingDirectory")
+    cwd = str(cwd_value) if cwd_value else None
+    try:
+        proc = subprocess.Popen(
+            [command, *args],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=cwd,
+            env=env,
+            bufsize=0,
+        )
+    except Exception as exc:
+        print(f"claude-any mcp-proxy: failed to start {command}: {type(exc).__name__}: {exc}", file=sys.stderr, flush=True)
+        return 127
+    router_log("INFO", f"mcp_proxy_started server={server_name} command={command}")
+    threading.Thread(target=_mcp_proxy_forward_stdin, args=(proc,), daemon=True, name=f"mcp-proxy-stdin-{server_name}").start()
+    threading.Thread(target=_mcp_proxy_forward_stderr, args=(proc,), daemon=True, name=f"mcp-proxy-stderr-{server_name}").start()
+    try:
+        observer = _McpStdoutObserver(server_name)
+        if proc.stdout:
+            while True:
+                chunk = proc.stdout.read(65536)
+                if not chunk:
+                    break
+                observer.feed(chunk)
+                sys.stdout.buffer.write(chunk)
+                sys.stdout.buffer.flush()
+        rc = proc.wait()
+        router_log("INFO", f"mcp_proxy_exited server={server_name} rc={rc}")
+        return rc
+    finally:
+        if proc.poll() is None:
+            try:
+                proc.terminate()
+            except Exception:
+                pass
+
+
+def cmd_mcp_proxy(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(prog="claude-any mcp-proxy")
+    parser.add_argument("--server-name", required=True)
+    parser.add_argument("--server-config", required=True)
+    args = parser.parse_args(argv)
+    return run_mcp_stdio_proxy(args.server_name, Path(args.server_config).expanduser())
+
+
 def run_claude_update_check(claude: str, enabled: bool = True) -> None:
     if not enabled:
         return
@@ -13264,14 +14294,16 @@ def launch_claude(
     use_native_anthropic = native_anthropic_enabled(provider)
     use_ollama_native = ollama_native_compat_enabled(provider, pcfg)
     use_provider_native = provider_native_compat_enabled(provider, pcfg)
+    use_router_mode = not (use_native_anthropic or use_ollama_native or use_provider_native)
     cleanup_managed_services_for_provider(provider, pcfg, cfg, quiet=True)
-    if not (use_native_anthropic or use_ollama_native or use_provider_native):
+    if use_router_mode:
         start_router_if_needed()
     env = os.environ.copy()
     env["PATH"] = str(HOME / ".local" / "bin") + os.pathsep + env.get("PATH", "")
     launch_env = env_vars(cfg)
     launch_passthrough = normalize_channel_passthrough(passthrough)
     if claude_channels_requested(cfg, launch_passthrough):
+        env.pop("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS", None)
         launch_env.pop("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS", None)
     if use_native_anthropic:
         for key in (
@@ -13302,8 +14334,21 @@ def launch_claude(
     run_claude_update_check(claude, enabled=update_check)
     claude = find_executable("claude") or claude
     extra_args: list[str] = []
+    mcp_config_paths: list[str] = []
     if should_attach_web_search(provider, cfg, web_search_override):
-        extra_args.extend(["--mcp-config", str(write_duckduckgo_mcp_config(cfg))])
+        mcp_config_paths.append(str(write_duckduckgo_mcp_config(cfg)))
+    claude_passthrough = list(launch_passthrough)
+    if should_use_channel_stdin_proxy(use_router_mode, launch_passthrough):
+        auto_start_sse_channels_from_mcp_configs(launch_passthrough)
+        proxy_config = write_mcp_proxy_config(
+            launch_passthrough,
+            extra_config_paths=[Path(path) for path in mcp_config_paths],
+        )
+        if proxy_config:
+            mcp_config_paths = [str(proxy_config)]
+            claude_passthrough = strip_mcp_config_passthrough(launch_passthrough)
+    if mcp_config_paths:
+        extra_args.extend(["--mcp-config", *mcp_config_paths])
     if should_append_compat_prompt(provider, cfg) and not has_passthrough_option(launch_passthrough, "--system-prompt"):
         extra_args.extend(["--append-system-prompt", NON_ANTHROPIC_COMPAT_PROMPT])
     extra_args.extend(claude_channel_args(cfg, launch_passthrough))
@@ -13315,7 +14360,9 @@ def launch_claude(
     if model:
         cmd.extend(["--model", model])
     cmd.extend(extra_args)
-    cmd.extend(launch_passthrough)
+    cmd.extend(claude_passthrough)
+    if should_use_channel_stdin_proxy(use_router_mode, launch_passthrough):
+        return subprocess_call_with_channel_wake_proxy(cmd, env)
     return subprocess.call(cmd, env=env)
 
 
@@ -13337,7 +14384,8 @@ Control plane, runs before Claude Code and does not require LLM connectivity:
   claude-any set-api-key PROVIDER KEY
   claude-any web-search [on|off]     Auto-attach DuckDuckGo MCP for non-native providers
   claude-any web-fetch [on|off]      Auto-attach fetch MCP for web page content
-  claude-any channels [cmd]          Configure Claude Code --channels auto-injection
+  claude-any log-level [LEVEL]       Show or set router log level
+  claude-any channels [cmd]          Configure external channel specs
   claude-any ollama-native [on|off]  Use Ollama's official Claude Code env path
   claude-any ollama-options [provider] [key=value ...]
                                       Set Ollama num_ctx/options/keep_alive/think
@@ -13372,12 +14420,13 @@ Headless setup flags, namespaced to avoid Claude CLI collisions:
   claude-any --ca-rate-limit-status on|off
   claude-any --ca-stream on|off
   claude-any --ca-stream-word-chunking on|off
+  claude-any --ca-log-level LEVEL    Set router log level: SILENT, ERROR, WARN, INFO, DEBUG, TRACE
   claude-any --ca-web-search         Force DuckDuckGo MCP for this launch
   claude-any --ca-no-web-search      Disable DuckDuckGo MCP for this launch
   claude-any --ca-web-fetch          Enable fetch MCP
   claude-any --ca-no-web-fetch       Disable fetch MCP
   claude-any --ca-channel SPEC       Add an official/approved Claude Code channel
-  claude-any --ca-clear-channels     Clear saved channel auto-injection specs
+  claude-any --ca-clear-channels     Clear saved channel specs
   claude-any --ca-no-self-update-check
                                       Skip Claude Any npm self-update check
   claude-any --ca-no-update-check    Skip Claude Code update check for this launch
@@ -13505,6 +14554,8 @@ def apply_headless_env_config() -> tuple[bool, bool | None, bool | None, bool |
 
 
 def run_cli(argv: list[str]) -> int:
+    if argv and argv[0] == "mcp-proxy":
+        return cmd_mcp_proxy(argv[1:])
     if argv and argv[0] in ("help", "--help", "-h"):
         print(cli_usage())
         return 0
@@ -13560,6 +14611,9 @@ def run_cli(argv: list[str]) -> int:
         if head in ("web-fetch", "webfetch"):
             cmd_web_fetch(argparse.Namespace(value=rest[0] if rest else None))
             return 0
+        if head in ("log-level", "loglevel", "logging"):
+            cmd_log_level(argparse.Namespace(value=rest[0] if rest else None))
+            return 0
         if head in ("channels", "channel"):
             cmd_channels(argparse.Namespace(values=rest))
             return 0
@@ -13881,6 +14935,18 @@ def run_cli(argv: list[str]) -> int:
                 i += 1
             cmd_provider_options(argparse.Namespace(values=[f"stream_word_chunking={value}"]))
             skip_menu = True
+        elif arg == "--ca-log-level" or arg.startswith("--ca-log-level="):
+            value = arg.split("=", 1)[1] if "=" in arg else None
+            if value is None:
+                if i + 1 >= len(argv):
+                    raise SystemExit("Missing level for --ca-log-level")
+                value = argv[i + 1]
+                i += 2
+            else:
+                i += 1
+            for line in set_log_level_config(value):
+                print(line)
+            skip_menu = True
         elif arg == "--ca-web-search":
             web_search_override = True
             skip_menu = True
@@ -14008,6 +15074,9 @@ def build_parser() -> argparse.ArgumentParser:
     wf = sub.add_parser("web-fetch")
     wf.add_argument("value", nargs="?")
     wf.set_defaults(func=cmd_web_fetch)
+    ll = sub.add_parser("log-level")
+    ll.add_argument("value", nargs="?")
+    ll.set_defaults(func=cmd_log_level)
     ch = sub.add_parser("channels")
     ch.add_argument("values", nargs="*")
     ch.set_defaults(func=cmd_channels)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oneciel-ai/claude-any",
-  "version": "0.1.76",
+  "version": "0.1.78",
   "description": "Claude Code provider selector for Anthropic, Ollama, Ollama Cloud, vLLM, NVIDIA hosted, and self-hosted NIM.",
   "license": "MIT",
   "author": "One Ciel LLC",