easyclaw-tui 0.1.0__tar.gz

easyclaw_tui-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: easyclaw-tui
+Version: 0.1.0
+Summary: Interactive terminal installer for OpenClaw — powered by EasyClaw
+Project-URL: Homepage, https://easyclaw.help
+Project-URL: Repository, https://github.com/easyclaw/easyclaw-tui
+Author-email: EasyClaw <johnny@easyclaw.help>
+License-Expression: MIT
+Keywords: easyclaw,installer,openclaw,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Installation/Setup
+Requires-Python: >=3.10
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: textual<4.0.0,>=3.0.0
+Description-Content-Type: text/plain
+
+EasyClaw TUI — Interactive OpenClaw installer.

easyclaw_tui-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "easyclaw-tui"
+version = "0.1.0"
+description = "Interactive terminal installer for OpenClaw — powered by EasyClaw"
+readme = {text = "EasyClaw TUI — Interactive OpenClaw installer.", content-type = "text/plain"}
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "EasyClaw", email = "johnny@easyclaw.help" }]
+keywords = ["openclaw", "easyclaw", "installer", "tui"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Installation/Setup",
+]
+dependencies = [
+    "textual>=3.0.0,<4.0.0",
+    "httpx>=0.27.0,<1.0.0",
+]
+
+[project.scripts]
+easyclaw = "easyclaw_tui.cli:main"
+
+[project.urls]
+Homepage = "https://easyclaw.help"
+Repository = "https://github.com/easyclaw/easyclaw-tui"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/easyclaw_tui"]

easyclaw_tui-0.1.0/src/easyclaw_tui/__init__.py

@@ -0,0 +1,3 @@
+"""EasyClaw TUI — Interactive OpenClaw installer."""
+
+__version__ = "0.1.0"

easyclaw_tui-0.1.0/src/easyclaw_tui/api/client.py

@@ -0,0 +1,123 @@
+"""MCP JSON-RPC client for EasyClaw Foreman chat."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import httpx
+
+MCP_URL = "https://mcp.easyclaw.help/mcp"
+
+# Keywords that signal which MCP tool to route to
+_GATEWAY_KEYWORDS = re.compile(
+    r"gateway|bind|port|421|proxy|traefik|reverse proxy|https|tls|ssl|certificate|misdirected",
+    re.IGNORECASE,
+)
+_DIAGNOSE_KEYWORDS = re.compile(
+    r"error|fail|crash|broken|not working|won't start|can't connect|timeout|refused|"
+    r"exit code|traceback|exception|502|503|404|ECONNREFUSED",
+    re.IGNORECASE,
+)
+_SECURITY_KEYWORDS = re.compile(
+    r"security|audit|hardening|firewall|allowlist|dmpolicy|token|permission|auth",
+    re.IGNORECASE,
+)
+
+
+def route_query(text: str) -> tuple[str, dict[str, Any]]:
+    """Pick the best MCP tool for a user's chat message."""
+    if _GATEWAY_KEYWORDS.search(text):
+        return "troubleshoot_gateway", {"symptom": text}
+    if _DIAGNOSE_KEYWORDS.search(text):
+        return "diagnose_issue", {"error_text": text}
+    if _SECURITY_KEYWORDS.search(text):
+        return "security_audit", {}
+    # Default to knowledge search
+    return "search_knowledge", {"query": text}
+
+
+class MCPClient:
+    """Sends JSON-RPC 2.0 requests to the EasyClaw MCP server."""
+
+    def __init__(self, api_key: str, base_url: str = MCP_URL) -> None:
+        self.api_key = api_key
+        self.base_url = base_url
+        self._id = 0
+
+    def _next_id(self) -> int:
+        self._id += 1
+        return self._id
+
+    async def call_tool(self, tool_name: str, arguments: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Call an MCP tool and return the result."""
+        payload = {
+            "jsonrpc": "2.0",
+            "id": self._next_id(),
+            "method": "tools/call",
+            "params": {
+                "name": tool_name,
+                "arguments": arguments or {},
+            },
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            resp = await client.post(self.base_url, json=payload, headers=headers)
+            resp.raise_for_status()
+            data = resp.json()
+
+        if "error" in data:
+            return {"error": data["error"].get("message", str(data["error"]))}
+
+        result = data.get("result", {})
+        # MCP returns content array — extract text
+        if isinstance(result, dict) and "content" in result:
+            texts = [c.get("text", "") for c in result["content"] if c.get("type") == "text"]
+            return {"text": "\n".join(texts)}
+        return result
+
+    async def smart_query(self, text: str) -> str:
+        """Route a user message to the best MCP tool and return the response."""
+        tool_name, args = route_query(text)
+        result = await self.call_tool(tool_name, args)
+        return result.get("text", result.get("error", "No response"))
+
+    async def diagnose(self, error_text: str) -> str:
+        """Diagnose an issue using the MCP server."""
+        result = await self.call_tool("diagnose_issue", {"error_text": error_text})
+        return result.get("text", result.get("error", "No diagnosis available"))
+
+    async def search_knowledge(self, query: str) -> str:
+        """Search the knowledge base."""
+        result = await self.call_tool("search_knowledge", {"query": query})
+        return result.get("text", result.get("error", "No results"))
+
+    async def troubleshoot_gateway(self, symptom: str) -> str:
+        """Troubleshoot gateway issues."""
+        result = await self.call_tool("troubleshoot_gateway", {"symptom": symptom})
+        return result.get("text", result.get("error", "No troubleshooting info"))
+
+    async def validate_deployment(self) -> str:
+        """Run a full deployment health check."""
+        result = await self.call_tool("validate_deployment", {})
+        return result.get("text", result.get("error", "No validation data"))
+
+    async def security_audit(self) -> str:
+        """Run a security audit."""
+        result = await self.call_tool("security_audit", {})
+        return result.get("text", result.get("error", "No audit data"))
+
+    async def health_check(self) -> bool:
+        """Check if the MCP server is reachable."""
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                resp = await client.get(
+                    self.base_url.replace("/mcp", "/health"),
+                    headers={"Authorization": f"Bearer {self.api_key}"},
+                )
+                return resp.status_code == 200
+        except Exception:
+            return False

easyclaw_tui-0.1.0/src/easyclaw_tui/app.py

@@ -0,0 +1,61 @@
+"""Main EasyClaw TUI application."""
+
+from __future__ import annotations
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+
+from easyclaw_tui.state import InstallState
+
+# Re-export for convenience
+from easyclaw_tui.state import StepStatus, StepInfo, MODEL_MAP  # noqa: F401
+
+
+class EasyClawApp(App):
+    """EasyClaw interactive installer."""
+
+    TITLE = "EasyClaw Foreman"
+    SUB_TITLE = "OpenClaw Installer"
+    CSS_PATH = "styles/app.tcss"
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("ctrl+c", "quit", "Quit", show=False),
+        Binding("f1", "toggle_chat", "Foreman Chat", show=True),
+    ]
+
+    def __init__(
+        self,
+        mode: str = "install",
+        api_key: str = "",
+        openrouter_key: str = "",
+        openai_key: str = "",
+        model: str = "minimax-m2.5",
+        channel: str = "none",
+        bind: str = "lan",
+    ) -> None:
+        super().__init__()
+        self.install_state = InstallState(
+            api_key=api_key,
+            openrouter_key=openrouter_key,
+            openai_key=openai_key,
+            model=model,
+            channel=channel,
+            bind=bind,
+        )
+        self.mode = mode
+
+    def on_mount(self) -> None:
+        if self.mode == "help":
+            from easyclaw_tui.screens.help import HelpScreen
+
+            self.push_screen(HelpScreen(self.install_state))
+        else:
+            from easyclaw_tui.screens.install import InstallScreen
+
+            self.push_screen(InstallScreen(self.install_state))
+
+    def action_toggle_chat(self) -> None:
+        screen = self.screen
+        if hasattr(screen, "toggle_chat"):
+            screen.toggle_chat()

easyclaw_tui-0.1.0/src/easyclaw_tui/cli.py

@@ -0,0 +1,93 @@
+"""CLI entry point: easyclaw install / easyclaw help."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="easyclaw",
+        description="EasyClaw — Interactive OpenClaw Installer",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # easyclaw install
+    install_p = sub.add_parser("install", help="Run the interactive installer")
+    install_p.add_argument("--api-key", default="", help="EasyClaw API key (ec_live_...)")
+    install_p.add_argument("--openrouter-key", default="", help="OpenRouter API key (sk-or-...)")
+    install_p.add_argument("--openai-key", default="", help="OpenAI API key (optional, for memory)")
+    install_p.add_argument("--model", default="minimax-m2.5", help="Primary model (default: minimax-m2.5)")
+    install_p.add_argument("--channel", default="none", help="Channel: none, whatsapp, telegram, discord")
+    install_p.add_argument("--bind", default="lan", help="Bind mode: lan, loopback, auto, tailnet")
+    install_p.add_argument("--no-tui", action="store_true", help="Fall back to bash script")
+
+    # easyclaw help
+    sub.add_parser("help", help="Post-install troubleshooting and diagnostics")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        # Default to install
+        args.command = "install"
+        args.api_key = ""
+        args.openrouter_key = ""
+        args.openai_key = ""
+        args.model = "minimax-m2.5"
+        args.channel = "none"
+        args.bind = "lan"
+        args.no_tui = False
+
+    if args.command == "install":
+        if getattr(args, "no_tui", False):
+            print("Falling back to bash installer...")
+            print("Run: curl -fsSL https://easyclaw.help/install.sh | bash")
+            sys.exit(0)
+        _run_install(
+            api_key=getattr(args, "api_key", ""),
+            openrouter_key=getattr(args, "openrouter_key", ""),
+            openai_key=getattr(args, "openai_key", ""),
+            model=getattr(args, "model", "minimax-m2.5"),
+            channel=getattr(args, "channel", "none"),
+            bind=getattr(args, "bind", "lan"),
+        )
+
+    elif args.command == "help":
+        _run_help()
+
+    else:
+        parser.print_help()
+
+
+def _run_install(
+    api_key: str = "",
+    openrouter_key: str = "",
+    openai_key: str = "",
+    model: str = "minimax-m2.5",
+    channel: str = "none",
+    bind: str = "lan",
+) -> None:
+    from easyclaw_tui.app import EasyClawApp
+
+    app = EasyClawApp(
+        mode="install",
+        api_key=api_key,
+        openrouter_key=openrouter_key,
+        openai_key=openai_key,
+        model=model,
+        channel=channel,
+        bind=bind,
+    )
+    app.run()
+
+
+def _run_help() -> None:
+    from easyclaw_tui.app import EasyClawApp
+
+    app = EasyClawApp(mode="help")
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

easyclaw_tui-0.1.0/src/easyclaw_tui/screens/help.py

@@ -0,0 +1,125 @@
+"""Help screen — post-install troubleshooting and diagnostics."""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static, RichLog, Input, Button
+from textual.containers import Vertical, Horizontal
+
+from easyclaw_tui.state import InstallState
+from easyclaw_tui.api.client import MCPClient
+
+
+QUICK_ACTIONS = [
+    ("validate", "Validate Deployment", "validate_deployment"),
+    ("security", "Security Audit", "security_audit"),
+    ("gateway", "Troubleshoot Gateway", "troubleshoot_gateway"),
+]
+
+
+class HelpScreen(Screen):
+    """Post-install troubleshooting with Foreman chat and quick actions."""
+
+    BINDINGS = [
+        ("escape", "app.pop_screen", "Back"),
+    ]
+
+    def __init__(self, state: InstallState) -> None:
+        super().__init__()
+        self.state = state
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Vertical(id="help-container"):
+            yield Static(
+                "[bold #f59e0b]EasyClaw Foreman — Help & Diagnostics[/bold #f59e0b]",
+                id="help-title",
+            )
+            yield Static(
+                "Ask a question or run a quick diagnostic below.",
+                id="help-subtitle",
+            )
+
+            # Quick action buttons
+            with Horizontal(id="quick-actions"):
+                for action_id, label, _ in QUICK_ACTIONS:
+                    yield Button(label, id=f"btn-{action_id}", variant="primary")
+
+            yield RichLog(id="help-log", wrap=True, highlight=True, markup=True)
+
+            # Chat input
+            with Horizontal(id="help-input-container"):
+                yield Input(
+                    placeholder="Describe your issue or ask a question...",
+                    id="help-input",
+                )
+                yield Button("Ask", id="btn-ask", variant="primary")
+
+        yield Footer()
+
+    @property
+    def log(self) -> RichLog:
+        return self.query_one("#help-log", RichLog)
+
+    def _get_client(self) -> MCPClient | None:
+        if not self.state.api_key:
+            self.log.write("[red]No API key set. Run the installer first.[/red]")
+            return None
+        return MCPClient(self.state.api_key)
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id
+
+        if btn_id == "btn-ask":
+            await self._handle_ask()
+        elif btn_id == "btn-validate":
+            await self._run_action("Validating deployment...", "validate_deployment")
+        elif btn_id == "btn-security":
+            await self._run_action("Running security audit...", "security_audit")
+        elif btn_id == "btn-gateway":
+            inp = self.query_one("#help-input", Input)
+            symptom = inp.value.strip() or "gateway not responding"
+            await self._run_action(
+                f"Troubleshooting gateway: {symptom}",
+                "troubleshoot_gateway",
+                {"symptom": symptom},
+            )
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "help-input":
+            await self._handle_ask()
+
+    async def _handle_ask(self) -> None:
+        inp = self.query_one("#help-input", Input)
+        text = inp.value.strip()
+        if not text:
+            return
+        inp.value = ""
+
+        self.log.write(f"\n[bold cyan]You:[/bold cyan] {text}")
+        client = self._get_client()
+        if not client:
+            return
+
+        self.log.write("[dim]Thinking...[/dim]")
+        try:
+            response = await client.smart_query(text)
+            self.log.write(f"[bold #f59e0b]Foreman:[/bold #f59e0b] {response}")
+        except Exception as e:
+            self.log.write(f"[red]Error: {e}[/red]")
+
+    async def _run_action(
+        self, label: str, tool: str, args: dict | None = None
+    ) -> None:
+        self.log.write(f"\n[cyan]→ {label}[/cyan]")
+        client = self._get_client()
+        if not client:
+            return
+
+        try:
+            result = await client.call_tool(tool, args or {})
+            text = result.get("text", result.get("error", "No response"))
+            self.log.write(f"[bold #f59e0b]Foreman:[/bold #f59e0b]\n{text}")
+        except Exception as e:
+            self.log.write(f"[red]Error: {e}[/red]")

easyclaw_tui-0.1.0/src/easyclaw_tui/screens/install.py

@@ -0,0 +1,157 @@
+"""Install screen — orchestrates the 15-step install flow."""
+
+from __future__ import annotations
+
+import asyncio
+
+from textual.app import ComposeResult
+from textual.screen import Screen
+from textual.widgets import Header, Footer, Static
+from textual.containers import Container
+
+from easyclaw_tui.state import InstallState, StepStatus
+from easyclaw_tui.widgets.step_progress import StepProgress
+from easyclaw_tui.widgets.step_panel import StepPanel
+from easyclaw_tui.widgets.chat_panel import ChatPanel
+from easyclaw_tui.api.client import MCPClient
+
+from easyclaw_tui.steps.base import StepResult
+from easyclaw_tui.steps.s01_preflight import PreflightStep
+from easyclaw_tui.steps.s02_nodejs import NodejsStep
+from easyclaw_tui.steps.s03_openclaw import OpenClawStep
+from easyclaw_tui.steps.s04_tools import ToolsStep
+from easyclaw_tui.steps.s05_config import ConfigStep
+from easyclaw_tui.steps.s06_token import TokenStep
+from easyclaw_tui.steps.s07_write_config import WriteConfigStep
+from easyclaw_tui.steps.s08_env_vars import EnvVarsStep
+from easyclaw_tui.steps.s09_workspace import WorkspaceStep
+from easyclaw_tui.steps.s10_validate import ValidateStep
+from easyclaw_tui.steps.s11_init_gateway import InitGatewayStep
+from easyclaw_tui.steps.s12_systemd import SystemdStep
+from easyclaw_tui.steps.s13_mcp import McpStep
+from easyclaw_tui.steps.s14_channel import ChannelStep
+from easyclaw_tui.steps.s15_health import HealthStep
+
+
+class InstallScreen(Screen):
+    """Main install screen with sidebar, content panel, and chat."""
+
+    BINDINGS = []
+
+    def __init__(self, state: InstallState) -> None:
+        super().__init__()
+        self.state = state
+        self._step_classes = [
+            PreflightStep,
+            NodejsStep,
+            OpenClawStep,
+            ToolsStep,
+            ConfigStep,
+            TokenStep,
+            WriteConfigStep,
+            EnvVarsStep,
+            WorkspaceStep,
+            ValidateStep,
+            InitGatewayStep,
+            SystemdStep,
+            McpStep,
+            ChannelStep,
+            HealthStep,
+        ]
+        self._chat_visible = False
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield StepProgress(self.state)
+        yield StepPanel(self.state)
+        yield ChatPanel()
+        yield Footer()
+
+    @property
+    def progress(self) -> StepProgress:
+        return self.query_one(StepProgress)
+
+    @property
+    def panel(self) -> StepPanel:
+        return self.query_one(StepPanel)
+
+    @property
+    def chat(self) -> ChatPanel:
+        return self.query_one(ChatPanel)
+
+    def toggle_chat(self) -> None:
+        self._chat_visible = not self._chat_visible
+        chat = self.chat
+        if self._chat_visible:
+            chat.add_class("--visible")
+        else:
+            chat.remove_class("--visible")
+
+    async def on_mount(self) -> None:
+        # Start the install flow
+        self.run_worker(self._run_install())
+
+    async def _run_install(self) -> None:
+        """Execute steps sequentially."""
+        for i, step_cls in enumerate(self._step_classes):
+            step_num = i + 1
+            step_info = self.state.steps[i]
+
+            # Update UI
+            self.state.set_step_status(step_num, StepStatus.RUNNING)
+            self.progress.refresh_steps()
+            self.panel.set_step(step_num, step_info.name)
+
+            # Create and run the step
+            step = step_cls(self.state, self.panel)
+            try:
+                result = await step.run()
+            except Exception as e:
+                self.panel.log_error(f"Step failed with exception: {e}")
+                result = StepResult(success=False, message=str(e))
+
+            # Update status
+            if result.success:
+                self.state.set_step_status(step_num, StepStatus.SUCCESS)
+            elif result.skipped:
+                self.state.set_step_status(step_num, StepStatus.SKIPPED)
+            else:
+                self.state.set_step_status(step_num, StepStatus.FAILED)
+                self.panel.log_error(f"Step {step_num} failed: {result.message}")
+                # On failure, offer Foreman diagnosis
+                if self.state.api_key:
+                    self.panel.log_info("Asking Foreman for help...")
+                    try:
+                        client = MCPClient(self.state.api_key)
+                        diagnosis = await client.diagnose(result.message)
+                        self.panel.log_raw(f"\n[bold #f59e0b]Foreman says:[/bold #f59e0b]\n{diagnosis}")
+                    except Exception:
+                        self.panel.log_warn("Could not reach Foreman — check API key")
+                # Ask whether to continue or abort
+                self.panel.log_raw("\n[bold]Press Enter to continue or Ctrl+C to abort[/bold]")
+                # Continue to next step after brief pause
+                await asyncio.sleep(2)
+
+            self.progress.refresh_steps()
+            self.state.current_step = step_num + 1
+
+        # All done
+        self.panel.log_raw("\n[bold green]Installation complete![/bold green]")
+
+    async def on_chat_panel_chat_submitted(self, event: ChatPanel.ChatSubmitted) -> None:
+        """Handle chat messages by routing to the best MCP tool."""
+        if not self.state.api_key:
+            self.chat.add_system_message("Set your API key first (Step 5)")
+            return
+
+        from easyclaw_tui.api.client import route_query
+
+        tool_name, _ = route_query(event.text)
+        self.chat.add_system_message(f"Using {tool_name}...")
+
+        try:
+            client = MCPClient(self.state.api_key)
+            response = await client.smart_query(event.text)
+            self.chat.add_bot_message(response)
+        except Exception as e:
+            self.chat.add_system_message(f"Error: {e}")