@oneciel-ai/claude-any 0.1.96 → 0.1.98

package/claude_any.py

@@ -9,6 +9,7 @@ import importlib.util
 import json
 import math
 import os
+import queue
 import re
 import signal
 import shlex
@@ -59,6 +60,7 @@ 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"
 CHANNEL_MCP_CURSOR_PATH = CONFIG_DIR / "channel-mcp-cursor.json"
+CHANNEL_PROBE_CACHE_PATH = CONFIG_DIR / "channel-probe-cache.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
@@ -105,7 +107,7 @@ OFFICIAL_CHANNEL_PLUGINS = {
     "fakechat": "plugin:fakechat@claude-plugins-official",
 }
 APP_NAME = "Claude Any"
-VERSION = "0.1.96"
+VERSION = "0.1.98"
 CREDITS = "Credits: One Ciel LLC"
 
 LOG_LEVELS = {"SILENT": 0, "ERROR": 1, "WARN": 2, "INFO": 3, "DEBUG": 4, "TRACE": 5}
@@ -1060,6 +1062,7 @@ UI_TEXT = {
         "test": "Test compatibility",
         "options": "LLM options",
         "channel_delivery": "Channel delivery",
+        "channels": "Channels",
         "log_level": "Log level",
         "presets": "LLM presets",
         "context_setup": "Context setup",
@@ -1082,6 +1085,7 @@ UI_TEXT = {
         "test": "호환성 테스트",
         "options": "LLM 옵션",
         "channel_delivery": "채널 전달 방식",
+        "channels": "채널",
         "log_level": "로그 레벨",
         "presets": "LLM 프리셋",
         "context_setup": "컨텍스트 설정",
@@ -1104,6 +1108,7 @@ UI_TEXT = {
         "test": "互換性テスト",
         "options": "LLMオプション",
         "channel_delivery": "チャンネル配信方式",
+        "channels": "チャンネル",
         "log_level": "ログレベル",
         "presets": "LLMプリセット",
         "context_setup": "コンテキスト設定",
@@ -1126,6 +1131,7 @@ UI_TEXT = {
         "test": "兼容性测试",
         "options": "LLM 选项",
         "channel_delivery": "频道投递方式",
+        "channels": "频道",
         "log_level": "日志级别",
         "presets": "LLM 预设",
         "context_setup": "上下文设置",
@@ -9498,6 +9504,233 @@ def _mcp_server_is_stdio(server: dict[str, Any]) -> bool:
     return "mcp-proxy" not in args
 
 
+def _channel_probe_initialize_payload() -> bytes:
+    payload = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "initialize",
+        "params": {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {"name": "claude-any-channel-probe", "version": VERSION},
+        },
+    }
+    return json.dumps(payload, ensure_ascii=False).encode("utf-8")
+
+
+def _channel_probe_parse_framed_responses(buffer: bytes) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    idx = 0
+    while idx < len(buffer):
+        header_end = buffer.find(b"\r\n\r\n", idx)
+        if header_end < 0:
+            return out
+        header = buffer[idx:header_end].decode("ascii", errors="replace")
+        length: int | None = None
+        for line in header.split("\r\n"):
+            if line.lower().startswith("content-length:"):
+                try:
+                    length = int(line.split(":", 1)[1].strip())
+                except Exception:
+                    return out
+                break
+        if length is None:
+            return out
+        body_start = header_end + 4
+        body_end = body_start + length
+        if len(buffer) < body_end:
+            return out
+        try:
+            msg = json.loads(buffer[body_start:body_end].decode("utf-8", errors="replace"))
+        except Exception:
+            idx = body_end
+            continue
+        if isinstance(msg, dict):
+            out.append(msg)
+        idx = body_end
+    return out
+
+
+def _channel_probe_parse_jsonl_responses(buffer: bytes) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
+    for raw_line in buffer.split(b"\n"):
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line.decode("utf-8", errors="replace"))
+        except Exception:
+            continue
+        if isinstance(msg, dict):
+            out.append(msg)
+    return out
+
+
+def _channel_probe_find_initialize_response(buffer: bytes, framed: bool) -> dict[str, Any] | None:
+    msgs = _channel_probe_parse_framed_responses(buffer) if framed else _channel_probe_parse_jsonl_responses(buffer)
+    for msg in msgs:
+        if msg.get("id") == 1 and "result" in msg:
+            return msg
+    return None
+
+
+def _channel_probe_capability_present(initialize_response: dict[str, Any]) -> bool:
+    result = initialize_response.get("result")
+    if not isinstance(result, dict):
+        return False
+    capabilities = result.get("capabilities")
+    if not isinstance(capabilities, dict):
+        return False
+    experimental = capabilities.get("experimental")
+    if not isinstance(experimental, dict):
+        return False
+    value = experimental.get("claude/channel")
+    return value is not None and value is not False
+
+
+def probe_stdio_mcp_for_channel_capability(server_name: str, server: dict[str, Any], timeout: float = 3.0) -> bool:
+    if not _mcp_server_is_stdio(server):
+        return False
+    command = str(server.get("command") or "").strip()
+    args_raw = server.get("args", [])
+    args = [str(item) for item in args_raw] if isinstance(args_raw, list) else []
+    if not command:
+        return False
+    command, args = resolve_mcp_server_process(command, args)
+    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
+    framed = _mcp_proxy_stdio_mode(server) != "jsonl"
+
+    proc: subprocess.Popen[bytes] | None = None
+    try:
+        proc = subprocess.Popen(
+            [command, *args],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            cwd=cwd,
+            env=env,
+            bufsize=0,
+            close_fds=True,
+        )
+    except Exception as exc:
+        router_log("DEBUG", f"channel_probe_spawn_failed server={server_name} error={type(exc).__name__}: {exc}")
+        return False
+
+    chunks_queue: queue.Queue[bytes | None] = queue.Queue()
+
+    def _reader() -> None:
+        try:
+            assert proc is not None
+            stdout = proc.stdout
+            if stdout is None:
+                return
+            while True:
+                chunk = stdout.read(4096)
+                if not chunk:
+                    break
+                chunks_queue.put(chunk)
+        except Exception:
+            pass
+        finally:
+            chunks_queue.put(None)
+
+    threading.Thread(target=_reader, daemon=True, name=f"channel-probe-stdout-{server_name}").start()
+
+    body = _channel_probe_initialize_payload()
+    if framed:
+        frame = b"Content-Length: " + str(len(body)).encode("ascii") + b"\r\n\r\n" + body
+    else:
+        frame = body + b"\n"
+    try:
+        if proc.stdin:
+            proc.stdin.write(frame)
+            proc.stdin.flush()
+    except Exception:
+        pass
+
+    deadline = time.time() + timeout
+    stdout_buf = bytearray()
+    capable = False
+    try:
+        while time.time() < deadline:
+            wait = min(0.2, max(0.001, deadline - time.time()))
+            try:
+                chunk = chunks_queue.get(timeout=wait)
+            except queue.Empty:
+                continue
+            if chunk is None:
+                break
+            stdout_buf.extend(chunk)
+            response = _channel_probe_find_initialize_response(bytes(stdout_buf), framed)
+            if response is not None:
+                capable = _channel_probe_capability_present(response)
+                break
+    finally:
+        try:
+            if proc.stdin:
+                proc.stdin.close()
+        except Exception:
+            pass
+        try:
+            proc.terminate()
+            proc.wait(timeout=1.0)
+        except Exception:
+            try:
+                proc.kill()
+            except Exception:
+                pass
+
+    router_log(
+        "INFO",
+        f"channel_probe_result server={server_name} channel_capable={capable} bytes={len(stdout_buf)}",
+    )
+    return capable
+
+
+def detect_channel_capable_mcp_servers(
+    mcp_config_paths: Iterable[str],
+    cwd: Path,
+    *,
+    include_router_self: bool = True,
+    timeout_per_server: float = 3.0,
+) -> list[str]:
+    """Probe MCP servers declared in given config files; return names that declare experimental['claude/channel']."""
+    capable: list[str] = []
+    seen: set[str] = set()
+    if include_router_self:
+        capable.append("claude-any-router")
+        seen.add("claude-any-router")
+    for path_str in mcp_config_paths:
+        if not path_str:
+            continue
+        path = Path(path_str)
+        if not path.exists():
+            continue
+        for name, server in _read_mcp_servers_from_json(path, cwd):
+            if name in seen:
+                continue
+            seen.add(name)
+            if name == "claude-any-router":
+                continue
+            if not _mcp_server_is_stdio(server):
+                # Non-stdio (sse/http) probing not implemented; skip silently.
+                continue
+            try:
+                if probe_stdio_mcp_for_channel_capability(name, server, timeout=timeout_per_server):
+                    capable.append(name)
+            except Exception as exc:
+                router_log(
+                    "WARN",
+                    f"channel_probe_exception server={name} error={type(exc).__name__}: {exc}",
+                )
+    return capable
+
+
 def _mcp_config_passthrough_values(passthrough: list[str]) -> list[str]:
     values: list[str] = []
     i = 0
@@ -9593,6 +9826,215 @@ def auto_discovered_mcp_channel_specs(
     return _dedupe_strings(specs)
 
 
+CHANNEL_PROBE_CACHE_VERSION = 1
+
+
+def _builtin_router_probe_record() -> dict[str, Any]:
+    return {
+        "name": "claude-any-router",
+        "capable": True,
+        "transport": "sse",
+        "source_path": "<built-in>",
+        "url": f"{ROUTER_BASE}/ca/mcp/sse",
+        "response_bytes": 0,
+        "reason": "built-in",
+    }
+
+
+def _server_transport_label(server: dict[str, Any]) -> str:
+    if not isinstance(server, dict):
+        return "unknown"
+    declared = str(server.get("type") or "").strip().lower()
+    if declared:
+        return declared
+    if server.get("url"):
+        return "sse"
+    if server.get("command"):
+        return "stdio"
+    return "unknown"
+
+
+def _probe_mcp_servers_to_records(
+    paths: Iterable[str],
+    cwd: Path,
+    *,
+    include_router_self: bool = True,
+    timeout_per_server: float = 3.0,
+) -> list[dict[str, Any]]:
+    """Probe every MCP server referenced from the given config paths and
+    return one record per server (capable and non-capable alike) for cache
+    consumers and menu rendering."""
+    records: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    if include_router_self:
+        records.append(_builtin_router_probe_record())
+        seen.add("claude-any-router")
+    for path_str in paths:
+        if not path_str:
+            continue
+        path = Path(path_str)
+        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 name == "claude-any-router":
+                continue
+            transport = _server_transport_label(server)
+            record: dict[str, Any] = {
+                "name": name,
+                "capable": False,
+                "transport": transport,
+                "source_path": str(path),
+                "response_bytes": 0,
+                "reason": "",
+            }
+            if isinstance(server.get("url"), str):
+                record["url"] = str(server.get("url"))
+            if not _mcp_server_is_stdio(server):
+                record["reason"] = "non_stdio_probe_not_implemented"
+                records.append(record)
+                continue
+            try:
+                capable = probe_stdio_mcp_for_channel_capability(name, server, timeout=timeout_per_server)
+                record["capable"] = bool(capable)
+                if not capable:
+                    record["reason"] = "no_experimental_claude_channel_or_timeout"
+            except Exception as exc:
+                record["reason"] = f"probe_exception:{type(exc).__name__}"
+                router_log("WARN", f"channel_probe_exception server={name} error={type(exc).__name__}: {exc}")
+            records.append(record)
+    return records
+
+
+def read_channel_probe_cache() -> dict[str, Any]:
+    if not CHANNEL_PROBE_CACHE_PATH.exists():
+        return {"version": CHANNEL_PROBE_CACHE_VERSION, "probed_at": 0.0, "servers": []}
+    try:
+        data = json.loads(CHANNEL_PROBE_CACHE_PATH.read_text(encoding="utf-8"))
+    except Exception as exc:
+        router_log("WARN", f"channel_probe_cache_read_failed error={type(exc).__name__}: {exc}")
+        return {"version": CHANNEL_PROBE_CACHE_VERSION, "probed_at": 0.0, "servers": []}
+    if not isinstance(data, dict):
+        return {"version": CHANNEL_PROBE_CACHE_VERSION, "probed_at": 0.0, "servers": []}
+    data.setdefault("version", CHANNEL_PROBE_CACHE_VERSION)
+    data.setdefault("probed_at", 0.0)
+    servers = data.get("servers")
+    data["servers"] = [item for item in servers if isinstance(item, dict)] if isinstance(servers, list) else []
+    return data
+
+
+def _write_channel_probe_cache(cache: dict[str, Any]) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    tmp = CHANNEL_PROBE_CACHE_PATH.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(cache, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    tmp.replace(CHANNEL_PROBE_CACHE_PATH)
+    try:
+        os.chmod(CHANNEL_PROBE_CACHE_PATH, 0o600)
+    except Exception:
+        pass
+
+
+def refresh_channel_probe_cache(
+    passthrough: list[str] | None = None,
+    cwd: Path | None = None,
+    home: Path | None = None,
+    timeout_per_server: float = 3.0,
+) -> dict[str, Any]:
+    """Re-scan known MCP config files, probe each stdio entry for the
+    channel capability, write the result to disk and return it. Only called
+    on explicit user action (menu refresh or CLI subcommand)."""
+    cwd = cwd or Path.cwd()
+    paths = [str(p) for p in claude_mcp_config_paths(passthrough or [], cwd, home)]
+    records = _probe_mcp_servers_to_records(paths, cwd, timeout_per_server=timeout_per_server)
+    cache = {
+        "version": CHANNEL_PROBE_CACHE_VERSION,
+        "probed_at": time.time(),
+        "servers": records,
+    }
+    _write_channel_probe_cache(cache)
+    capable = [r["name"] for r in records if r.get("capable")]
+    router_log(
+        "INFO",
+        f"channel_probe_cache_refreshed total={len(records)} capable={len(capable)} servers={','.join(capable) or '-'}",
+    )
+    return cache
+
+
+def cached_channel_probe_servers() -> list[dict[str, Any]]:
+    cache = read_channel_probe_cache()
+    servers = cache.get("servers")
+    if isinstance(servers, list):
+        return [item for item in servers if isinstance(item, dict)]
+    return []
+
+
+def cached_channel_capable_server_names() -> list[str]:
+    """Capable server names from cache, with claude-any-router always
+    present (because the router's own MCP bridge is built into claude-any)."""
+    names = [str(r.get("name")) for r in cached_channel_probe_servers() if r.get("capable") and r.get("name")]
+    if "claude-any-router" not in names:
+        names.insert(0, "claude-any-router")
+    return _dedupe_strings(names)
+
+
+def parse_passthrough_channel_specs(passthrough: list[str]) -> list[str]:
+    """Extract channel specs from passthrough args of either
+    --channels or --dangerously-load-development-channels (and the
+    =VALUE inline form)."""
+    specs: list[str] = []
+    i = 0
+    while i < len(passthrough):
+        arg = passthrough[i]
+        if arg in ("--channels", "--dangerously-load-development-channels"):
+            i += 1
+            while i < len(passthrough) and is_channel_spec_tagged(passthrough[i]):
+                specs.append(passthrough[i])
+                i += 1
+            continue
+        if arg.startswith("--channels=") or arg.startswith("--dangerously-load-development-channels="):
+            value = arg.split("=", 1)[1].strip()
+            if value and is_channel_spec_tagged(value):
+                specs.append(value)
+            i += 1
+            continue
+        i += 1
+    return _dedupe_strings(specs)
+
+
+def auto_import_passthrough_channels(passthrough: list[str]) -> list[str]:
+    """Add channel specs that arrived as CLI passthrough to the persisted
+    cfg.channels list, so they show up alongside auto-detected entries in
+    the menu and survive subsequent launches. Returns the newly added specs."""
+    specs = parse_passthrough_channel_specs(passthrough)
+    if not specs:
+        return []
+    cfg = load_config()
+    existing = set(channel_specs(cfg))
+    if all(spec in existing for spec in specs):
+        return []
+    cc = cfg.setdefault("claude_code", {})
+    merged = list(channel_specs(cfg))
+    added: list[str] = []
+    for spec in specs:
+        if spec in existing:
+            continue
+        merged.append(spec)
+        existing.add(spec)
+        added.append(spec)
+    if not added:
+        return []
+    cc["channels"] = merged
+    save_config(cfg)
+    invalidate_config_cache()
+    router_log(
+        "INFO",
+        f"channels_auto_imported_from_passthrough count={len(added)} specs={','.join(added)}",
+    )
+    return added
+
+
 def _mcp_sse_servers_from_mapping(mapping: Any) -> list[dict[str, Any]]:
     if not isinstance(mapping, dict):
         return []
@@ -9795,6 +10237,29 @@ def cmd_channels(args: argparse.Namespace) -> None:
         for line in clear_channel_specs():
             print(line)
         return
+    if head in ("detect", "probe", "refresh"):
+        try:
+            result = refresh_channel_probe_cache()
+        except Exception as exc:
+            raise SystemExit(f"Channel probe failed: {type(exc).__name__}: {exc}")
+        servers = result.get("servers") or []
+        capable = [r for r in servers if r.get("capable")]
+        non_capable = [r for r in servers if not r.get("capable")]
+        probed_at = result.get("probed_at") or 0
+        ts_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(probed_at)) if probed_at else "-"
+        print(f"channel probe complete (cached at {ts_str})")
+        print(f"  capable     : {len(capable)}")
+        for r in capable:
+            transport = r.get("transport") or "?"
+            source = r.get("source_path") or ""
+            suffix = " built-in" if source == "<built-in>" else f" {source}"
+            print(f"    * {r.get('name')} ({transport}){suffix}")
+        print(f"  non-capable : {len(non_capable)}")
+        for r in non_capable:
+            transport = r.get("transport") or "?"
+            reason = r.get("reason") or "-"
+            print(f"      {r.get('name')} ({transport}) reason={reason}")
+        return
     if head in ("delivery", "mode"):
         if len(values) < 2:
             print(f"channel_delivery: {channel_delivery_mode(cfg)}")
@@ -13011,9 +13476,10 @@ def main_menu_rows(cfg: dict[str, Any], provider: str, pcfg: dict[str, Any], lan
         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. {ui_text('channel_delivery', lang)}  [{channel_delivery_mode(cfg)}]",
-        f"8. {ui_text('log_level', lang)}  [{log_level_status()}]",
-        f"9. {ui_text('test', lang)}",
-        f"10. {ui_text('launch', lang)}",
+        f"8. {ui_text('channels', lang)}  [{channel_status_text(cfg)}]",
+        f"9. {ui_text('log_level', lang)}  [{log_level_status()}]",
+        f"10. {ui_text('test', lang)}",
+        f"11. {ui_text('launch', lang)}",
         ui_text("quit", lang),
     ]
 
@@ -13110,13 +13576,71 @@ def advisor_model_panel_rows(provider: str, pcfg: dict[str, Any]) -> tuple[list[
 
 
 def channel_panel_rows(cfg: dict[str, Any]) -> tuple[list[str], list[str]]:
-    channels = channel_specs(cfg)
+    channels = set(channel_specs(cfg))
+    cache = read_channel_probe_cache()
+    records = cache.get("servers") or []
+    probed_at = cache.get("probed_at") or 0
+    capable_records = [r for r in records if r.get("capable")]
+    non_capable_records = [r for r in records if not r.get("capable")]
+
     rows: list[str] = []
     values: list[str] = []
-    for name, spec in OFFICIAL_CHANNEL_PLUGINS.items():
+
+    rows.append("[Auto-detected channel-capable]")
+    values.append("__heading__")
+    if capable_records:
+        for r in capable_records:
+            name = str(r.get("name") or "")
+            spec = f"server:{name}"
+            mark = "*" if spec in channels else " "
+            transport = str(r.get("transport") or "?")
+            source = str(r.get("source_path") or "")
+            if source == "<built-in>":
+                rows.append(f"{mark} {name:<14} ({transport}, built-in)")
+            else:
+                rows.append(f"{mark} {name:<14} ({transport})")
+            values.append(spec)
+    else:
+        hint = "press Re-probe now" if not probed_at else "none capable"
+        rows.append(f"  ({hint})")
+        values.append("__noop__")
+
+    if non_capable_records:
+        rows.append("[Detected but not channel-capable]")
+        values.append("__heading__")
+        for r in non_capable_records:
+            name = str(r.get("name") or "")
+            transport = str(r.get("transport") or "?")
+            reason = str(r.get("reason") or "-")
+            rows.append(f"  {name:<14} ({transport}) {reason}")
+            values.append("__noop__")
+
+    rows.append("[Official plugins]")
+    values.append("__heading__")
+    for plugin_name, spec in OFFICIAL_CHANNEL_PLUGINS.items():
         mark = "*" if spec in channels else " "
-        rows.append(f"{mark} {name:<10} {spec}")
+        rows.append(f"{mark} {plugin_name:<10} {spec}")
         values.append(spec)
+
+    covered: set[str] = set(OFFICIAL_CHANNEL_PLUGINS.values())
+    for r in capable_records:
+        covered.add(f"server:{r.get('name')}")
+    custom_specs = [spec for spec in channel_specs(cfg) if spec not in covered]
+    if custom_specs:
+        rows.append("[Configured custom / imported]")
+        values.append("__heading__")
+        for spec in custom_specs:
+            rows.append(f"* {spec}")
+            values.append(spec)
+
+    rows.append("[Actions]")
+    values.append("__heading__")
+    if probed_at:
+        ts_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(probed_at))
+        rows.append(f"Re-probe now (last: {ts_str})")
+    else:
+        rows.append("Re-probe now (no cache yet)")
+    values.append("__reprobe__")
     rows.append("+ Add custom channel...")
     values.append("__add_custom__")
     if channels:
@@ -13129,6 +13653,25 @@ def channel_panel_rows(cfg: dict[str, Any]) -> tuple[list[str], list[str]]:
     return rows, values
 
 
+def _channel_panel_first_selectable(values: list[str]) -> int:
+    for idx, value in enumerate(values):
+        if value not in ("__heading__", "__noop__"):
+            return idx
+    return 0
+
+
+def _channel_panel_step(values: list[str], start: int, delta: int) -> int:
+    if not values:
+        return 0
+    n = len(values)
+    idx = start
+    for _ in range(n):
+        idx = (idx + delta) % n
+        if values[idx] not in ("__heading__", "__noop__"):
+            return idx
+    return start
+
+
 def channel_delivery_panel_rows(cfg: dict[str, Any]) -> tuple[list[str], list[str]]:
     current = channel_delivery_mode(cfg)
     rows = [
@@ -13440,9 +13983,10 @@ def portable_language_menu() -> int:
     return 0
 
 
-def portable_prelaunch_menu() -> int:
+def portable_prelaunch_menu(passthrough: list[str] | None = None) -> int:
+    passthrough = list(passthrough or [])
     enable_ansi()
-    main_idx = 10 if settings_ready_except_api_key() else 0
+    main_idx = 11 if settings_ready_except_api_key() else 0
     panel: str | None = None
     panel_idx = 0
     panel_rows: list[str] = []
@@ -13490,6 +14034,8 @@ def portable_prelaunch_menu() -> int:
             panel_rows, panel_values = log_level_panel_rows(cfg)
         elif name == "channels":
             panel_rows, panel_values = channel_panel_rows(cfg)
+            if panel_values:
+                panel_idx = _channel_panel_first_selectable(panel_values)
         elif name == "context":
             panel_rows, panel_values = context_setup_panel_rows(provider, pcfg, cfg.get("language", "en"))
         elif name == "preset":
@@ -13557,11 +14103,17 @@ def portable_prelaunch_menu() -> int:
             if panel:
                 panel_name = panel
                 if key in ("up", "k"):
-                    panel_idx = (panel_idx - 1) % max(1, len(panel_rows))
+                    if panel == "channels":
+                        panel_idx = _channel_panel_step(panel_values, panel_idx, -1)
+                    else:
+                        panel_idx = (panel_idx - 1) % max(1, len(panel_rows))
                     panel_last_idx[panel_name] = panel_idx
                     continue
                 if key in ("down", "j"):
-                    panel_idx = (panel_idx + 1) % max(1, len(panel_rows))
+                    if panel == "channels":
+                        panel_idx = _channel_panel_step(panel_values, panel_idx, 1)
+                    else:
+                        panel_idx = (panel_idx + 1) % max(1, len(panel_rows))
                     panel_last_idx[panel_name] = panel_idx
                     continue
                 if key in ("esc", "left", "q"):
@@ -13666,7 +14218,7 @@ def portable_prelaunch_menu() -> int:
                         messages = lines[-8:] if lines else ["Test produced no output."]
                         panel_rows, panel_values = ["Run compatibility test again", "Back"], ["run", "back"]
                         refresh_checks()
-                        main_idx = 10 if "Compatibility: OK" in out else 4
+                        main_idx = 11 if "Compatibility: OK" in out else 4
                 elif panel == "log-level":
                     if value == "back":
                         close_panel()
@@ -13688,23 +14240,43 @@ def portable_prelaunch_menu() -> int:
                 elif panel == "channels":
                     if value == "back":
                         close_panel()
+                    elif value in ("__heading__", "__noop__"):
+                        continue
+                    elif value == "__reprobe__":
+                        panel_rows, panel_values = ["Re-probing MCP channel capability..."], []
+                        first_render = render_prelaunch_screen(main_idx, panel, 0, panel_rows, checks, messages, first_render)
+                        try:
+                            result = refresh_channel_probe_cache(passthrough)
+                            capable = [r for r in result.get("servers") or [] if r.get("capable")]
+                            messages = [f"Probe complete: {len(capable)} channel-capable server(s)."]
+                        except Exception as exc:
+                            messages = [f"Re-probe failed: {type(exc).__name__}: {exc}"]
+                        cfg = load_config()
+                        panel_rows, panel_values = channel_panel_rows(cfg)
+                        if panel_values:
+                            panel_idx = _channel_panel_first_selectable(panel_values)
                     elif value == "__add_custom__":
                         spec = prompt_menu_value("Channel spec (for example plugin:ainet@local or server:ainet)", restore_tty=restore_line_mode, raw_tty=restore_raw_mode)
                         if spec:
                             messages = add_channel_spec(spec)
                             cfg = load_config()
                             panel_rows, panel_values = channel_panel_rows(cfg)
+                            if panel_values:
+                                panel_idx = _channel_panel_first_selectable(panel_values)
                     elif value == "__remove__":
                         spec = prompt_menu_value("Channel spec to remove", "", restore_tty=restore_line_mode, raw_tty=restore_raw_mode)
                         if spec:
                             messages = remove_channel_spec(spec)
                             cfg = load_config()
                             panel_rows, panel_values = channel_panel_rows(cfg)
+                            if panel_values:
+                                panel_idx = _channel_panel_first_selectable(panel_values)
                     elif value == "__clear__":
                         messages = clear_channel_specs()
                         cfg = load_config()
                         panel_rows, panel_values = channel_panel_rows(cfg)
-                        panel_idx = 0
+                        if panel_values:
+                            panel_idx = _channel_panel_first_selectable(panel_values)
                     elif value:
                         if value in channel_specs(cfg):
                             messages = remove_channel_spec(value)
@@ -13821,7 +14393,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", "channel-delivery", "log-level", "test", "launch", "quit"]
+                actions = ["language", "provider", "api-key", "base-url", "model", "advisor-model", "options", "channel-delivery", "channels", "log-level", "test", "launch", "quit"]
                 action = actions[main_idx]
                 if action == "launch":
                     blockers = launch_readiness_errors()
@@ -13868,14 +14440,16 @@ def run_prelaunch_menu(passthrough: list[str], skip_menu: bool = False, force_me
         rc = run_external_menu("claude-any-menu")
         if rc is not None:
             return rc
-    return portable_prelaunch_menu()
+    return portable_prelaunch_menu(passthrough)
 
 
 def start_router_if_needed() -> None:
     if router_up():
+        router_log("INFO", f"router_check_state running=True spawn=False base={ROUTER_BASE}")
         return
     stop_router_processes(quiet=True)
     if router_up():
+        router_log("INFO", f"router_check_state running=True spawn=False after_stop=True base={ROUTER_BASE}")
         return
     CONFIG_DIR.mkdir(parents=True, exist_ok=True)
     cmd = [sys.executable, str(Path(__file__).resolve()), "serve"]
@@ -13886,11 +14460,13 @@ def start_router_if_needed() -> None:
             kwargs["creationflags"] = flags
     else:
         kwargs["start_new_session"] = True
+    router_log("INFO", f"router_check_state running=False spawn=True base={ROUTER_BASE}")
     with open(LOG_PATH, "ab", buffering=0) as log:
         subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=log, stderr=log, **kwargs)
     deadline = time.time() + 30
     while time.time() < deadline:
         if router_up():
+            router_log("INFO", f"router_spawned running=True base={ROUTER_BASE} elapsed={time.time()-(deadline-30):.1f}s")
             return
         time.sleep(0.5)
     raise RuntimeError(f"claude-any router did not start. See {LOG_PATH}")
@@ -13939,8 +14515,21 @@ def native_channel_passthrough_requested(passthrough: list[str]) -> bool:
     return has_passthrough_option(passthrough, "--channels", "--dangerously-load-development-channels")
 
 
-def claude_channel_args(cfg: dict[str, Any], passthrough: list[str], extra_specs: list[str] | None = None) -> list[str]:
-    return []
+def claude_channel_args(
+    cfg: dict[str, Any],
+    passthrough: list[str],
+    extra_specs: list[str] | None = None,
+    *,
+    native_channel_bridge: bool = False,
+) -> list[str]:
+    if not native_channel_bridge:
+        return []
+    if native_channel_passthrough_requested(passthrough):
+        return []
+    specs = list(channel_specs_for_launch(cfg, passthrough, extra_specs))
+    if not specs:
+        return []
+    return ["--dangerously-load-development-channels", *specs]
 
 
 def claude_channels_requested(cfg: dict[str, Any], passthrough: list[str], extra_specs: list[str] | None = None) -> bool:
@@ -15103,6 +15692,7 @@ def launch_claude(
         update_check = False
         self_update_check = False
     run_claude_any_update_check(enabled=self_update_check)
+    auto_import_passthrough_channels(passthrough)
     rc = run_prelaunch_menu(passthrough, skip_menu=skip_menu, force_menu=force_menu)
     if rc == 10:
         return 0
@@ -15180,7 +15770,26 @@ def launch_claude(
         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))
+    detected_channel_specs: list[str] = []
+    if native_channel_bridge:
+        try:
+            capable_names = cached_channel_capable_server_names()
+            detected_channel_specs = [f"server:{name}" for name in capable_names]
+            cache_age = read_channel_probe_cache().get("probed_at") or 0
+            router_log(
+                "INFO",
+                f"channel_probe_loaded source=cache cache_age_ts={int(cache_age)} count={len(capable_names)} servers={','.join(capable_names) or '-'}",
+            )
+        except Exception as exc:
+            router_log("WARN", f"channel_probe_cache_load_failed error={type(exc).__name__}: {exc}")
+    extra_args.extend(
+        claude_channel_args(
+            cfg,
+            launch_passthrough,
+            extra_specs=detected_channel_specs,
+            native_channel_bridge=native_channel_bridge,
+        )
+    )
     cmd = [
         claude,
         "--dangerously-skip-permissions",
@@ -15190,11 +15799,124 @@ def launch_claude(
         cmd.extend(["--model", model])
     cmd.extend(extra_args)
     cmd.extend(claude_passthrough)
+    _log_claude_command_for_diagnostics(cmd, env)
+    capture_stderr = env_bool(os.environ.get("CLAUDE_ANY_CAPTURE_CC_STDERR"), False)
     if stdin_channel_proxy:
         return subprocess_call_with_channel_wake_proxy(cmd, env)
+    if capture_stderr:
+        return _subprocess_call_capturing_stderr(cmd, env)
     return subprocess.call(cmd, env=env)
 
 
+CLAUDE_CODE_STDERR_LOG = CONFIG_DIR / "claude-code-stderr.log"
+
+
+def _log_claude_command_for_diagnostics(cmd: list[str], env: dict[str, str]) -> None:
+    try:
+        mcp_idx = cmd.index("--mcp-config") if "--mcp-config" in cmd else -1
+        mcp_value = cmd[mcp_idx + 1] if 0 <= mcp_idx < len(cmd) - 1 else "-"
+    except Exception:
+        mcp_value = "-"
+    channel_specs_in_cmd: list[str] = []
+    if "--dangerously-load-development-channels" in cmd:
+        start = cmd.index("--dangerously-load-development-channels") + 1
+        for arg in cmd[start:]:
+            if arg.startswith("--"):
+                break
+            channel_specs_in_cmd.append(arg)
+    router_log(
+        "INFO",
+        "claude_launch_cmd mcp_config=%s channels=%s argv_len=%d"
+        % (
+            mcp_value,
+            ",".join(channel_specs_in_cmd) or "-",
+            len(cmd),
+        ),
+    )
+    relevant_env_keys = (
+        "ANTHROPIC_BASE_URL",
+        "ANTHROPIC_MODEL",
+        "ANTHROPIC_API_KEY",
+        "ANTHROPIC_AUTH_TOKEN",
+        "CLAUDE_ANY_PROVIDER",
+        "CLAUDE_ANY_MODEL_ALIAS",
+        "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
+    )
+    env_summary = []
+    for key in relevant_env_keys:
+        if key in env:
+            val = env[key]
+            if "KEY" in key or "TOKEN" in key:
+                val = mask_secret(val)
+            env_summary.append(f"{key}={val}")
+    if env_summary:
+        router_log("INFO", "claude_launch_env " + " ".join(env_summary))
+
+
+def _subprocess_call_capturing_stderr(cmd: list[str], env: dict[str, str]) -> int:
+    """Like subprocess.call but tees Claude Code's stderr into
+    ~/.config/claude-any/claude-code-stderr.log so the user can collect
+    the exact context around messages like
+    `--dangerously-load-development-channels ignored (server:...)`.
+
+    Enabled via CLAUDE_ANY_CAPTURE_CC_STDERR=1."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        if CLAUDE_CODE_STDERR_LOG.exists() and CLAUDE_CODE_STDERR_LOG.stat().st_size > 2_000_000:
+            CLAUDE_CODE_STDERR_LOG.replace(CLAUDE_CODE_STDERR_LOG.with_suffix(".log.1"))
+    except Exception:
+        pass
+    try:
+        log_handle = CLAUDE_CODE_STDERR_LOG.open("ab", buffering=0)
+    except Exception as exc:
+        router_log("WARN", f"claude_stderr_capture_open_failed error={type(exc).__name__}: {exc}")
+        return subprocess.call(cmd, env=env)
+    header = f"\n===== claude launch at {time.strftime('%Y-%m-%dT%H:%M:%S')} =====\n".encode("utf-8")
+    try:
+        log_handle.write(header)
+    except Exception:
+        pass
+    try:
+        proc = subprocess.Popen(cmd, env=env, stderr=subprocess.PIPE)
+    except Exception as exc:
+        router_log("WARN", f"claude_stderr_capture_spawn_failed error={type(exc).__name__}: {exc}")
+        try:
+            log_handle.close()
+        except Exception:
+            pass
+        return subprocess.call(cmd, env=env)
+
+    def _tee_stderr() -> None:
+        try:
+            if proc.stderr is None:
+                return
+            while True:
+                chunk = proc.stderr.read(4096)
+                if not chunk:
+                    break
+                try:
+                    sys.stderr.buffer.write(chunk)
+                    sys.stderr.buffer.flush()
+                except Exception:
+                    pass
+                try:
+                    log_handle.write(chunk)
+                except Exception:
+                    pass
+        finally:
+            try:
+                log_handle.close()
+            except Exception:
+                pass
+
+    tee_thread = threading.Thread(target=_tee_stderr, daemon=True, name="claude-stderr-tee")
+    tee_thread.start()
+    rc = proc.wait()
+    tee_thread.join(timeout=2.0)
+    router_log("INFO", f"claude_exit code={rc} stderr_log={CLAUDE_CODE_STDERR_LOG}")
+    return rc
+
+
 def cli_usage() -> str:
     return """Usage:
   claude-any                         Launch Claude Code through claude-any router

package/package.json

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