kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/cli/mcp.py

@@ -0,0 +1,349 @@
+import json
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+import typer
+
+cli = typer.Typer(help="Manage MCP server configurations.")
+
+
+def get_global_mcp_config_file() -> Path:
+    """Get the global MCP config file path."""
+    from kimi_cli.share import get_share_dir
+
+    return get_share_dir() / "mcp.json"
+
+
+def _load_mcp_config() -> dict[str, Any]:
+    """Load MCP config from global mcp config file."""
+    from fastmcp.mcp_config import MCPConfig
+    from pydantic import ValidationError
+
+    mcp_file = get_global_mcp_config_file()
+    if not mcp_file.exists():
+        return {"mcpServers": {}}
+    try:
+        config = json.loads(mcp_file.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON in MCP config file '{mcp_file}': {e}") from e
+
+    try:
+        MCPConfig.model_validate(config)
+    except ValidationError as e:
+        raise typer.BadParameter(f"Invalid MCP config in '{mcp_file}': {e}") from e
+
+    return config
+
+
+def _save_mcp_config(config: dict[str, Any]) -> None:
+    """Save MCP config to default file."""
+    mcp_file = get_global_mcp_config_file()
+    mcp_file.write_text(json.dumps(config, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def _get_mcp_server(name: str, *, require_remote: bool = False) -> dict[str, Any]:
+    """Get MCP server config by name."""
+    config = _load_mcp_config()
+    servers = config.get("mcpServers", {})
+    if name not in servers:
+        typer.echo(f"MCP server '{name}' not found.", err=True)
+        raise typer.Exit(code=1)
+    server = servers[name]
+    if require_remote and "url" not in server:
+        typer.echo(f"MCP server '{name}' is not a remote server.", err=True)
+        raise typer.Exit(code=1)
+    return server
+
+
+def _parse_key_value_pairs(
+    items: list[str], option_name: str, *, separator: str = "=", strip_whitespace: bool = False
+) -> dict[str, str]:
+    """Parse key/value pairs from CLI options."""
+    parsed: dict[str, str] = {}
+    for item in items:
+        if separator not in item:
+            typer.echo(
+                f"Invalid {option_name} format: {item} (expected KEY{separator}VALUE).",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        key, value = item.split(separator, 1)
+        if strip_whitespace:
+            key, value = key.strip(), value.strip()
+        if not key:
+            typer.echo(f"Invalid {option_name} format: {item} (empty key).", err=True)
+            raise typer.Exit(code=1)
+        parsed[key] = value
+    return parsed
+
+
+Transport = Literal["stdio", "http"]
+
+
+@cli.command(
+    "add",
+    epilog="""
+    Examples:\n
+      \n
+      # Add streamable HTTP server:\n
+      kimi mcp add --transport http context7 https://mcp.context7.com/mcp --header \"CONTEXT7_API_KEY: ctx7sk-your-key\"\n
+      \n
+      # Add streamable HTTP server with OAuth authorization:\n
+      kimi mcp add --transport http --auth oauth linear https://mcp.linear.app/mcp\n
+      \n
+      # Add stdio server:\n
+      kimi mcp add --transport stdio chrome-devtools -- npx chrome-devtools-mcp@latest
+    """.strip(),  # noqa: E501
+)
+def mcp_add(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to add."),
+    ],
+    server_args: Annotated[
+        list[str] | None,
+        typer.Argument(
+            metavar="TARGET_OR_COMMAND...",
+            help="For http: server URL. For stdio: command to run (prefix with `--`).",
+        ),
+    ] = None,
+    transport: Annotated[
+        Transport,
+        typer.Option(
+            "--transport",
+            "-t",
+            help="Transport type for the MCP server. Default: stdio.",
+        ),
+    ] = "stdio",
+    env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--env",
+            "-e",
+            help="Environment variables in KEY=VALUE format. Can be specified multiple times.",
+        ),
+    ] = None,
+    header: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--header",
+            "-H",
+            help="HTTP headers in KEY:VALUE format. Can be specified multiple times.",
+        ),
+    ] = None,
+    auth: Annotated[
+        str | None,
+        typer.Option(
+            "--auth",
+            "-a",
+            help="Authorization type (e.g., 'oauth').",
+        ),
+    ] = None,
+):
+    """Add an MCP server."""
+    config = _load_mcp_config()
+    server_args = server_args or []
+
+    if transport not in {"stdio", "http"}:
+        typer.echo(f"Unsupported transport: {transport}.", err=True)
+        raise typer.Exit(code=1)
+
+    if transport == "stdio":
+        if not server_args:
+            typer.echo(
+                "For stdio transport, provide the command to start the MCP server after `--`.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        if header:
+            typer.echo("--header is only valid for http transport.", err=True)
+            raise typer.Exit(code=1)
+        if auth:
+            typer.echo("--auth is only valid for http transport.", err=True)
+            raise typer.Exit(code=1)
+        command, *command_args = server_args
+        server_config: dict[str, Any] = {"command": command, "args": command_args}
+        if env:
+            server_config["env"] = _parse_key_value_pairs(env, "env")
+    else:
+        if env:
+            typer.echo("--env is only supported for stdio transport.", err=True)
+            raise typer.Exit(code=1)
+        if not server_args:
+            typer.echo("URL is required for http transport.", err=True)
+            raise typer.Exit(code=1)
+        if len(server_args) > 1:
+            typer.echo(
+                "Multiple targets provided. Supply a single URL for http transport.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        server_config = {"url": server_args[0], "transport": "http"}
+        if header:
+            server_config["headers"] = _parse_key_value_pairs(
+                header, "header", separator=":", strip_whitespace=True
+            )
+        if auth:
+            server_config["auth"] = auth
+
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+    config["mcpServers"][name] = server_config
+    _save_mcp_config(config)
+    typer.echo(f"Added MCP server '{name}' to {get_global_mcp_config_file()}.")
+
+
+@cli.command("remove")
+def mcp_remove(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to remove."),
+    ],
+):
+    """Remove an MCP server."""
+    _get_mcp_server(name)
+    config = _load_mcp_config()
+    del config["mcpServers"][name]
+    _save_mcp_config(config)
+    typer.echo(f"Removed MCP server '{name}' from {get_global_mcp_config_file()}.")
+
+
+def _has_oauth_tokens(server_url: str) -> bool:
+    """Check if OAuth tokens exist for the server."""
+    import asyncio
+
+    async def _check() -> bool:
+        try:
+            from fastmcp.client.auth.oauth import FileTokenStorage
+
+            storage = FileTokenStorage(server_url=server_url)
+            tokens = await storage.get_tokens()
+            return tokens is not None
+        except Exception:
+            return False
+
+    return asyncio.run(_check())
+
+
+@cli.command("list")
+def mcp_list():
+    """List all MCP servers."""
+    config_file = get_global_mcp_config_file()
+    config = _load_mcp_config()
+    servers: dict[str, Any] = config.get("mcpServers", {})
+
+    typer.echo(f"MCP config file: {config_file}")
+    if not servers:
+        typer.echo("No MCP servers configured.")
+        return
+
+    for name, server in servers.items():
+        if "command" in server:
+            cmd = server["command"]
+            cmd_args = " ".join(server.get("args", []))
+            line = f"{name} (stdio): {cmd} {cmd_args}".rstrip()
+        elif "url" in server:
+            transport = server.get("transport") or "http"
+            if transport == "streamable-http":
+                transport = "http"
+            line = f"{name} ({transport}): {server['url']}"
+            if server.get("auth") == "oauth" and not _has_oauth_tokens(server["url"]):
+                line += " [authorization required - run: kimi mcp auth " + name + "]"
+        else:
+            line = f"{name}: {server}"
+        typer.echo(f"  {line}")
+
+
+@cli.command("auth")
+def mcp_auth(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to authorize."),
+    ],
+):
+    """Authorize with an OAuth-enabled MCP server."""
+    import asyncio
+
+    server = _get_mcp_server(name, require_remote=True)
+    if server.get("auth") != "oauth":
+        typer.echo(f"MCP server '{name}' does not use OAuth. Add with --auth oauth.", err=True)
+        raise typer.Exit(code=1)
+
+    async def _auth() -> None:
+        import fastmcp
+
+        typer.echo(f"Authorizing with '{name}'...")
+        typer.echo("A browser window will open for authorization.")
+
+        client = fastmcp.Client({"mcpServers": {name: server}})
+        try:
+            async with client:
+                tools = await client.list_tools()
+                typer.echo(f"Successfully authorized with '{name}'.")
+                typer.echo(f"Available tools: {len(tools)}")
+        except Exception as e:
+            typer.echo(f"Authorization failed: {type(e).__name__}: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+    asyncio.run(_auth())
+
+
+@cli.command("reset-auth")
+def mcp_reset_auth(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to reset authorization."),
+    ],
+):
+    """Reset OAuth authorization for an MCP server (clear cached tokens)."""
+    server = _get_mcp_server(name, require_remote=True)
+
+    try:
+        from fastmcp.client.auth.oauth import FileTokenStorage
+
+        storage = FileTokenStorage(server_url=server["url"])
+        storage.clear()
+        typer.echo(f"OAuth tokens cleared for '{name}'.")
+    except ImportError:
+        typer.echo("OAuth support not available.", err=True)
+        raise typer.Exit(code=1) from None
+    except Exception as e:
+        typer.echo(f"Failed to clear tokens: {type(e).__name__}: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+
+@cli.command("test")
+def mcp_test(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to test."),
+    ],
+):
+    """Test connection to an MCP server and list available tools."""
+    import asyncio
+
+    server = _get_mcp_server(name)
+
+    async def _test() -> None:
+        import fastmcp
+
+        typer.echo(f"Testing connection to '{name}'...")
+        client = fastmcp.Client({"mcpServers": {name: server}})
+
+        try:
+            async with client:
+                tools = await client.list_tools()
+                typer.echo(f"✓ Connected to '{name}'")
+                typer.echo(f"  Available tools: {len(tools)}")
+                if tools:
+                    typer.echo("  Tools:")
+                    for tool in tools:
+                        desc = tool.description or ""
+                        if len(desc) > 50:
+                            desc = desc[:47] + "..."
+                        typer.echo(f"    - {tool.name}: {desc}")
+        except Exception as e:
+            typer.echo(f"✗ Connection failed: {type(e).__name__}: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+    asyncio.run(_test())

kimi_cli/config.py

@@ -1,10 +1,15 @@
+from __future__ import annotations
+
 import json
 from pathlib import Path
-from typing import Literal, Self
+from typing import Self
 
+import tomlkit
 from pydantic import BaseModel, Field, SecretStr, ValidationError, field_serializer, model_validator
+from tomlkit.exceptions import TOMLKitError
 
 from kimi_cli.exception import ConfigError
+from kimi_cli.llm import ModelCapability, ProviderType
 from kimi_cli.share import get_share_dir
 from kimi_cli.utils.logging import logger
 
@@ -12,12 +17,14 @@ from kimi_cli.utils.logging import logger
 class LLMProvider(BaseModel):
     """LLM provider configuration."""
 
-    type: Literal["kimi", "openai_legacy", "_chaos"]
+    type: ProviderType
     """Provider type"""
     base_url: str
     """API base URL"""
     api_key: SecretStr
     """API key"""
+    env: dict[str, str] | None = None
+    """Environment variables to set before creating the provider instance"""
     custom_headers: dict[str, str] | None = None
     """Custom headers to include in API requests"""
 
@@ -26,9 +33,6 @@ class LLMProvider(BaseModel):
         return v.get_secret_value()
 
 
-LLMModelCapability = Literal["image_in"]
-
-
 class LLMModel(BaseModel):
     """LLM model configuration."""
 
@@ -38,17 +42,19 @@ class LLMModel(BaseModel):
     """Model name"""
     max_context_size: int
     """Maximum context size (unit: tokens)"""
-    capabilities: set[LLMModelCapability] | None = None
+    capabilities: set[ModelCapability] | None = None
     """Model capabilities"""
 
 
 class LoopControl(BaseModel):
     """Agent loop control configuration."""
 
-    max_steps_per_run: int = 100
-    """Maximum number of steps in one run"""
-    max_retries_per_step: int = 3
+    max_steps_per_turn: int = Field(default=100, ge=1, validation_alias="max_steps_per_run")
+    """Maximum number of steps in one turn"""
+    max_retries_per_step: int = Field(default=3, ge=1)
     """Maximum number of retries in one step"""
+    max_ralph_iterations: int = Field(default=0, ge=-1)
+    """Extra iterations after the first turn in Ralph mode. Use -1 for unlimited."""
 
 
 class MoonshotSearchConfig(BaseModel):
@@ -66,23 +72,62 @@ class MoonshotSearchConfig(BaseModel):
         return v.get_secret_value()
 
 
+class MoonshotFetchConfig(BaseModel):
+    """Moonshot Fetch configuration."""
+
+    base_url: str
+    """Base URL for Moonshot Fetch service."""
+    api_key: SecretStr
+    """API key for Moonshot Fetch service."""
+    custom_headers: dict[str, str] | None = None
+    """Custom headers to include in API requests."""
+
+    @field_serializer("api_key", when_used="json")
+    def dump_secret(self, v: SecretStr):
+        return v.get_secret_value()
+
+
 class Services(BaseModel):
     """Services configuration."""
 
     moonshot_search: MoonshotSearchConfig | None = None
     """Moonshot Search configuration."""
+    moonshot_fetch: MoonshotFetchConfig | None = None
+    """Moonshot Fetch configuration."""
+
+
+class MCPClientConfig(BaseModel):
+    """MCP client configuration."""
+
+    tool_call_timeout_ms: int = 60000
+    """Timeout for tool calls in milliseconds."""
+
+
+class MCPConfig(BaseModel):
+    """MCP configuration."""
+
+    client: MCPClientConfig = Field(
+        default_factory=MCPClientConfig, description="MCP client configuration"
+    )
 
 
 class Config(BaseModel):
     """Main configuration structure."""
 
+    is_from_default_location: bool = Field(
+        default=False,
+        description="Whether the config was loaded from the default location",
+        exclude=True,
+    )
     default_model: str = Field(default="", description="Default model to use")
+    default_thinking: bool = Field(default=False, description="Default thinking mode")
     models: dict[str, LLMModel] = Field(default_factory=dict, description="List of LLM models")
     providers: dict[str, LLMProvider] = Field(
         default_factory=dict, description="List of LLM providers"
     )
     loop_control: LoopControl = Field(default_factory=LoopControl, description="Agent loop control")
     services: Services = Field(default_factory=Services, description="Services configuration")
+    mcp: MCPConfig = Field(default_factory=MCPConfig, description="MCP configuration")
 
     @model_validator(mode="after")
     def validate_model(self) -> Self:
@@ -96,7 +141,7 @@ class Config(BaseModel):
 
 def get_config_file() -> Path:
     """Get the configuration file path."""
-    return get_share_dir() / "config.json"
+    return get_share_dir() / "config.toml"
 
 
 def get_default_config() -> Config:
@@ -123,24 +168,79 @@ def load_config(config_file: Path | None = None) -> Config:
     Raises:
         ConfigError: If the configuration file is invalid.
     """
-    config_file = config_file or get_config_file()
+    default_config_file = get_config_file()
+    if config_file is None:
+        config_file = default_config_file
+    is_default_config_file = config_file.expanduser().resolve(
+        strict=False
+    ) == default_config_file.expanduser().resolve(strict=False)
     logger.debug("Loading config from file: {file}", file=config_file)
 
+    # If the user hasn't provided an explicit config path, migrate legacy JSON config once.
+    if is_default_config_file and not config_file.exists():
+        _migrate_json_config_to_toml()
+
     if not config_file.exists():
         config = get_default_config()
         logger.debug("No config file found, creating default config: {config}", config=config)
-        with open(config_file, "w", encoding="utf-8") as f:
-            f.write(config.model_dump_json(indent=2, exclude_none=True))
+        save_config(config, config_file)
+        config.is_from_default_location = is_default_config_file
         return config
 
     try:
-        with open(config_file, encoding="utf-8") as f:
-            data = json.load(f)
-        return Config(**data)
+        config_text = config_file.read_text(encoding="utf-8")
+        if config_file.suffix.lower() == ".json":
+            data = json.loads(config_text)
+        else:
+            data = tomlkit.loads(config_text)
+        config = Config.model_validate(data)
     except json.JSONDecodeError as e:
         raise ConfigError(f"Invalid JSON in configuration file: {e}") from e
+    except TOMLKitError as e:
+        raise ConfigError(f"Invalid TOML in configuration file: {e}") from e
     except ValidationError as e:
         raise ConfigError(f"Invalid configuration file: {e}") from e
+    config.is_from_default_location = is_default_config_file
+    return config
+
+
+def load_config_from_string(config_string: str) -> Config:
+    """
+    Load configuration from a TOML or JSON string.
+
+    Args:
+        config_string (str): TOML or JSON configuration text.
+
+    Returns:
+        Validated Config object.
+
+    Raises:
+        ConfigError: If the configuration text is invalid.
+    """
+    if not config_string.strip():
+        raise ConfigError("Configuration text cannot be empty")
+
+    json_error: json.JSONDecodeError | None = None
+    try:
+        data = json.loads(config_string)
+    except json.JSONDecodeError as exc:
+        json_error = exc
+        data = None
+
+    if data is None:
+        try:
+            data = tomlkit.loads(config_string)
+        except TOMLKitError as toml_error:
+            raise ConfigError(
+                f"Invalid configuration text: {json_error}; {toml_error}"
+            ) from toml_error
+
+    try:
+        config = Config.model_validate(data)
+    except ValidationError as e:
+        raise ConfigError(f"Invalid configuration text: {e}") from e
+    config.is_from_default_location = False
+    return config
 
 
 def save_config(config: Config, config_file: Path | None = None):
@@ -153,5 +253,41 @@ def save_config(config: Config, config_file: Path | None = None):
     """
     config_file = config_file or get_config_file()
     logger.debug("Saving config to file: {file}", file=config_file)
+    config_file.parent.mkdir(parents=True, exist_ok=True)
+    config_data = config.model_dump(mode="json", exclude_none=True)
     with open(config_file, "w", encoding="utf-8") as f:
-        f.write(config.model_dump_json(indent=2, exclude_none=True))
+        if config_file.suffix.lower() == ".json":
+            f.write(json.dumps(config_data, ensure_ascii=False, indent=2))
+        else:
+            f.write(tomlkit.dumps(config_data))  # type: ignore[reportUnknownMemberType]
+
+
+def _migrate_json_config_to_toml() -> None:
+    old_json_config_file = get_share_dir() / "config.json"
+    new_toml_config_file = get_share_dir() / "config.toml"
+
+    if not old_json_config_file.exists():
+        return
+    if new_toml_config_file.exists():
+        return
+
+    logger.info(
+        "Migrating legacy config file from {old} to {new}",
+        old=old_json_config_file,
+        new=new_toml_config_file,
+    )
+
+    try:
+        with open(old_json_config_file, encoding="utf-8") as f:
+            data = json.load(f)
+        config = Config.model_validate(data)
+    except json.JSONDecodeError as e:
+        raise ConfigError(f"Invalid JSON in legacy configuration file: {e}") from e
+    except ValidationError as e:
+        raise ConfigError(f"Invalid legacy configuration file: {e}") from e
+
+    # Write new TOML config, then keep a backup of the original JSON file.
+    save_config(config, new_toml_config_file)
+    backup_path = old_json_config_file.with_name("config.json.bak")
+    old_json_config_file.replace(backup_path)
+    logger.info("Legacy config backed up to {file}", file=backup_path)

kimi_cli/constant.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import importlib.metadata
 
+NAME = "Kimi CLI"
 VERSION = importlib.metadata.version("kimi-cli")
 USER_AGENT = f"KimiCLI/{VERSION}"

kimi_cli/exception.py

@@ -1,16 +1,37 @@
+from __future__ import annotations
+
+
 class KimiCLIException(Exception):
     """Base exception class for Kimi CLI."""
 
     pass
 
 
-class ConfigError(KimiCLIException):
+class ConfigError(KimiCLIException, ValueError):
     """Configuration error."""
 
     pass
 
 
-class AgentSpecError(KimiCLIException):
+class AgentSpecError(KimiCLIException, ValueError):
     """Agent specification error."""
 
     pass
+
+
+class InvalidToolError(KimiCLIException, ValueError):
+    """Invalid tool error."""
+
+    pass
+
+
+class MCPConfigError(KimiCLIException, ValueError):
+    """MCP config error."""
+
+    pass
+
+
+class MCPRuntimeError(KimiCLIException, RuntimeError):
+    """MCP runtime error."""
+
+    pass