talkops-opscloud 0.3.0b1__py3-none-any.whl

opscloud/cli/commands/doctor.py

@@ -0,0 +1,100 @@
+"""Doctor command verifying AWS credentials, tools, and environment."""
+
+from __future__ import annotations
+
+import shutil
+import sys
+
+from rich.console import Console
+from rich.table import Table
+
+from opscloud.config.aws import get_aws_context
+from opscloud.output import OutputFormat, write_json
+
+
+def run_doctor_command(output_format: OutputFormat = "text") -> int:
+    aws_ctx = get_aws_context()
+    tools = ["aws", "kubectl", "terraform", "helm", "docker", "git"]
+    tool_statuses: dict[str, str | None] = {}
+    for tool_name in tools:
+        tool_statuses[tool_name] = shutil.which(tool_name)
+
+    py_ver = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+    from opscloud.utils.logger import (
+        get_active_log_dir,
+        get_active_log_file,
+        get_configured_log_level,
+        is_console_logging_enabled,
+    )
+
+    log_dir = str(get_active_log_dir())
+    log_file = str(get_active_log_file())
+    log_level = get_configured_log_level()
+    console_logging = is_console_logging_enabled()
+
+    if output_format == "json":
+        write_json(
+            "doctor",
+            {
+                "aws_sts": {
+                    "authenticated": aws_ctx.is_authenticated,
+                    "account_id": aws_ctx.account_id,
+                    "region": aws_ctx.region,
+                    "profile": aws_ctx.profile,
+                    "error": aws_ctx.error,
+                },
+                "tools": tool_statuses,
+                "python": py_ver,
+                "logging": {
+                    "directory": log_dir,
+                    "file": log_file,
+                    "level": log_level,
+                    "console_enabled": console_logging,
+                },
+            },
+        )
+        return 0
+
+    console = Console()
+    console.print("\n[bold yellow]OpsCloud System & Cloud Environment Doctor[/bold yellow]\n")
+
+    table = Table(title="Environment Diagnostics", border_style="cyan")
+    table.add_column("Component", style="bold")
+    table.add_column("Status")
+    table.add_column("Details")
+
+    # 1. AWS Credentials
+    if aws_ctx.is_authenticated:
+        table.add_row(
+            "AWS STS Identity",
+            "[green]OK[/green]",
+            f"Account: {aws_ctx.account_id}, Region: {aws_ctx.region}, Profile: {aws_ctx.profile}",
+        )
+    else:
+        table.add_row(
+            "AWS STS Identity",
+            "[yellow]Unauthenticated[/yellow]",
+            aws_ctx.error or "No active AWS credentials found via STS",
+        )
+
+    # 2. Tooling
+    for tool_name, path in tool_statuses.items():
+        if path:
+            table.add_row(f"CLI: {tool_name}", "[green]Found[/green]", path)
+        else:
+            table.add_row(f"CLI: {tool_name}", "[dim]Not installed[/dim]", "Optional")
+
+    # 3. Python version
+    table.add_row("Python Runtime", "[green]OK[/green]", f"Python {py_ver}")
+
+    # 4. Logging subsystem
+    table.add_row(
+        "Log Destination",
+        "[green]Active[/green]",
+        f"{log_file} (level={log_level}, console={'enabled' if console_logging else 'silent'})",
+    )
+
+    console.print(table)
+    console.print()
+    return 0

opscloud/cli/commands/mcp.py

@@ -0,0 +1,137 @@
+"""MCP management CLI command for opscloud."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+from rich.table import Table
+
+from opscloud.mcp.discovery import MCPDiscovery
+from opscloud.mcp.preload import preload_mcp_metadata
+
+
+def setup_mcp_parser(subparsers: Any) -> None:
+    """Setup parser for `opscloud mcp`."""
+    mcp_parser = subparsers.add_parser(
+        "mcp",
+        help="List, probe, and inspect configured Model Context Protocol (MCP) servers.",
+    )
+    mcp_parser.add_argument(
+        "action",
+        nargs="?",
+        default="list",
+        choices=["list", "ls", "status", "probe"],
+        help="Action to perform (default: list).",
+    )
+    mcp_parser.add_argument(
+        "--json",
+        action="store_true",
+        dest="json_output",
+        help="Output in JSON format.",
+    )
+    mcp_parser.add_argument(
+        "--probe",
+        action="store_true",
+        help="Actively probe configured servers to inspect tools and health status.",
+    )
+
+
+def run_mcp_command(args: argparse.Namespace | None = None) -> int:
+    """Execute the `opscloud mcp` CLI command."""
+    console = Console()
+    action = getattr(args, "action", "list") if args else "list"
+    json_output = getattr(args, "json_output", False) if args else False
+    do_probe = getattr(args, "probe", False) if args else False
+
+    if action in ("status", "probe"):
+        do_probe = True
+
+    discovery = MCPDiscovery()
+    configs = discovery.discover()
+
+    if not configs:
+        if json_output:
+            console.print(json.dumps({"mcp_servers": [], "total_servers": 0}, indent=2))
+        else:
+            console.print("\n[yellow]No MCP servers configured.[/yellow]")
+            console.print("Add servers in [bold].mcp.json[/bold] or [bold]~/.opscloud/.mcp.json[/bold].\n")
+        return 0
+
+    server_infos = None
+    if do_probe:
+        with console.status("[cyan]Probing MCP servers...[/cyan]"):
+            server_infos = asyncio.run(preload_mcp_metadata(configs))
+
+    if json_output:
+        if server_infos:
+            payload = {
+                "mcp_servers": [s.to_dict() for s in server_infos],
+                "total_servers": len(server_infos),
+                "total_tools": sum(s.tool_count for s in server_infos),
+            }
+        else:
+            payload = {
+                "mcp_servers": [
+                    {"name": k, **v} for k, v in configs.items()
+                ],
+                "total_servers": len(configs),
+            }
+        console.print(json.dumps(payload, indent=2))
+        return 0
+
+    console.print("\n[bold cyan]Configured MCP Servers[/bold cyan]\n")
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Status", width=8, justify="center")
+    table.add_column("Server Name", style="bold")
+    table.add_column("Transport", style="dim")
+    table.add_column("Command / URL")
+    table.add_column("Source", style="dim")
+    table.add_column("Tools", justify="right")
+
+    if server_infos:
+        for srv in server_infos:
+            if srv.status == "ok":
+                status_glyph = "[bold green]● OK[/bold green]"
+            elif srv.status == "disabled":
+                status_glyph = "[dim]○ OFF[/dim]"
+            elif srv.status == "unauthenticated":
+                status_glyph = "[bold yellow]▲ AUTH[/bold yellow]"
+            else:
+                status_glyph = "[bold red]✗ ERR[/bold red]"
+
+            cmd_or_url = srv.url or f"{srv.command} {' '.join(srv.args or [])}".strip()
+            table.add_row(
+                status_glyph,
+                srv.name,
+                srv.transport,
+                cmd_or_url or "-",
+                srv.source or "unknown",
+                str(srv.tool_count),
+            )
+    else:
+        for name, cfg in configs.items():
+            enabled = cfg.get("enabled", True)
+            status_glyph = "[green]● ON[/green]" if enabled else "[dim]○ OFF[/dim]"
+            transport = cfg.get("transport") or ("http" if cfg.get("url") else "stdio")
+            cmd_or_url = cfg.get("url") or f"{cfg.get('command', '')} {' '.join(cfg.get('args') or [])}".strip()
+            source = cfg.get("source", "project")
+            table.add_row(
+                status_glyph,
+                name,
+                transport,
+                cmd_or_url or "-",
+                source,
+                "-",
+            )
+
+    console.print(table)
+    if not do_probe:
+        console.print("\n[dim]Tip: Run `opscloud mcp probe` to test live server connections and tool schemas.[/dim]\n")
+    else:
+        console.print("")
+    return 0

opscloud/cli/commands/threads.py

@@ -0,0 +1,51 @@
+"""Threads management CLI command."""
+
+from __future__ import annotations
+
+import asyncio
+from rich.console import Console
+from rich.table import Table
+
+from opscloud.output import OutputFormat, write_json
+from opscloud.state.session import (
+    format_relative_timestamp,
+    format_timestamp,
+    list_threads,
+)
+
+
+def run_threads_command(output_format: OutputFormat = "text") -> int:
+    threads = asyncio.run(list_threads(include_message_count=True))
+
+    if output_format == "json":
+        write_json("threads list", threads)
+        return 0
+
+    console = Console()
+    console.print("\n[bold yellow]Saved Session Threads[/bold yellow]\n")
+    if not threads:
+        console.print("[dim]No saved sessions found in SQLite database.[/dim]\n")
+        return 0
+
+    table = Table(border_style="cyan", show_lines=False)
+    table.add_column("Thread ID", style="bold green", no_wrap=True)
+    table.add_column("Cloud / Env", style="bold magenta", no_wrap=True)
+    table.add_column("Msgs", justify="right", style="cyan", no_wrap=True)
+    table.add_column("Initial Prompt", style="white")
+    table.add_column("Updated", style="dim", no_wrap=True)
+
+    for t in threads:
+        tid = t.get("thread_id", "")
+        short_id = tid[:8] if len(tid) > 8 else tid
+        cloud = t.get("cloud_badge") or t.get("cloud_provider") or "-"
+        msg_count = str(t.get("message_count", 0))
+        prompt = t.get("initial_prompt") or "(No initial prompt)"
+        if len(prompt) > 50:
+            prompt = prompt[:47] + "..."
+        updated = format_relative_timestamp(t.get("updated_at")) or format_timestamp(t.get("updated_at"))
+
+        table.add_row(short_id, cloud, msg_count, prompt, updated)
+
+    console.print(table)
+    console.print("\n[dim]To resume a thread, run:[/dim] opscloud -r <thread_id>\n")
+    return 0

opscloud/cli/interactive.py

@@ -0,0 +1,154 @@
+"""Interactive TUI runner for OpsCloud."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from typing import Any
+
+from opscloud.approval_mode import ApprovalMode
+from opscloud.config.settings import sync_aws_env_aliases
+from opscloud.server import ServerConfig, ServerProcess
+from opscloud.ui.app import OpsCloudApp
+from opscloud.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def run_interactive(
+    *,
+    model: str | None = None,
+    approval_mode: ApprovalMode | str = ApprovalMode.MANUAL,
+    resume_thread: str | None = None,
+    cwd: str | None = None,
+    goal: str | None = None,
+    initial_prompt: str | None = None,
+    initial_skill: str | None = None,
+    startup_cmd: str | None = None,
+    read_only: bool = False,
+    aws_profile: str | None = None,
+    aws_region: str | None = None,
+    shell_allow_list: list[str] | None = None,
+    mcp_config_path: str | None = None,
+    no_mcp: bool = False,
+    trust_project_mcp: bool = False,
+) -> int:
+    """Launch interactive TUI session with background server and cloud context."""
+    if resume_thread:
+        from opscloud.utils.logger import bind_logging_to_thread
+
+        bind_logging_to_thread(resume_thread)
+
+    # 1. Startup command
+    if startup_cmd:
+        try:
+            print(f"[Running startup command: {startup_cmd}]", file=sys.stderr)
+            subprocess.run(startup_cmd, shell=True, check=False)
+        except Exception as e:
+            logger.warning("Startup command failed: %s", e)
+
+    # 2. AWS Profile & Region sync
+    from opscloud.config.cloud_profiles import get_active_aws_profile, get_active_aws_region
+
+    if not aws_profile:
+        aws_profile = get_active_aws_profile()
+
+    if not aws_region:
+        aws_region = get_active_aws_region()
+
+    if aws_profile:
+        os.environ["AWS_PROFILE"] = aws_profile
+    if aws_region:
+        os.environ["AWS_REGION"] = aws_region
+    if aws_profile or aws_region:
+        sync_aws_env_aliases()
+
+    from pathlib import Path
+    from opscloud.project_utils import ProjectContext
+
+    project_context = (
+        ProjectContext.from_user_cwd(Path(cwd))
+        if cwd is not None
+        else ProjectContext.from_user_cwd(Path.cwd())
+    )
+    resolved_cwd = str(project_context.user_cwd)
+
+    defer_server_start = False
+    resolved_model = model
+    if not resolved_model:
+        try:
+            from opscloud.model.factory import _get_default_model_spec
+
+            resolved_model = _get_default_model_spec()
+        except Exception:
+            resolved_model = None
+            defer_server_start = True
+
+    proc: ServerProcess | None = None
+    url: str | None = None
+    if not defer_server_start and resolved_model:
+        config = ServerConfig.from_cli_args(
+            project_context=project_context,
+            model=resolved_model,
+            interactive=True,
+            approval_mode=str(approval_mode),
+            read_only=read_only,
+            aws_profile=aws_profile,
+            aws_region=aws_region,
+            shell_allow_list=tuple(shell_allow_list) if shell_allow_list else None,
+            mcp_config_path=mcp_config_path,
+            no_mcp=no_mcp,
+            trust_project_mcp=trust_project_mcp,
+        )
+        proc = ServerProcess(config)
+        url = proc.start()
+
+    effective_prompt = initial_prompt
+    if initial_skill and not effective_prompt:
+        effective_prompt = f"Use skill {initial_skill}"
+
+    mcp_preload_kwargs: dict[str, Any] = {
+        "mcp_config_path": mcp_config_path,
+        "no_mcp": no_mcp,
+        "trust_project_mcp": trust_project_mcp,
+    }
+
+    try:
+        app = OpsCloudApp(
+            server_url=url,
+            server=proc,
+            server_proc=proc,
+            thread_id=resume_thread,
+            model=resolved_model,
+            approval_mode=approval_mode,
+            defer_server_start=defer_server_start,
+            goal=goal,
+            cwd=resolved_cwd,
+            mcp_preload_kwargs=mcp_preload_kwargs,
+        )
+        if effective_prompt and hasattr(app, "_initial_prompt"):
+            app._initial_prompt = effective_prompt
+
+        thread_id = app.run()
+        if thread_id and isinstance(thread_id, str) and thread_id != "local_session":
+            try:
+                from rich.console import Console
+                from rich.text import Text
+
+                console = Console()
+                console.print()
+                console.print("[dim]Resume this thread with:[/dim]")
+                hint = Text("opscloud -r ", style="cyan")
+                hint.append(thread_id, style="cyan")
+                console.print(hint)
+            except Exception:
+                pass
+        return 0
+    except Exception as e:
+        logger.critical("OpsCloud TUI run failed: %s", e, exc_info=True)
+        print(f"Error starting OpsCloud: {e}")
+        return 1
+    finally:
+        if proc is not None:
+            proc.stop()