runspec-chat 0.1.0__py3-none-any.whl

runspec_chat/__init__.py

@@ -0,0 +1,3 @@
+from runspec_chat.adapter import ModelAdapter, ChatResponse, ToolCall
+
+__all__ = ["ModelAdapter", "ChatResponse", "ToolCall"]

runspec_chat/adapter.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    input: dict
+
+
+@dataclass
+class ChatResponse:
+    text: str | None
+    tool_calls: list[ToolCall]
+    stop_reason: str  # "tool_use", "end_turn", "stop"
+    _raw: Any = field(repr=False, default=None)
+
+
+class ModelAdapter(ABC):
+    @abstractmethod
+    async def chat(self, messages: list[dict], tools: list[dict]) -> ChatResponse: ...
+
+    @abstractmethod
+    def make_tool_turn(
+        self, response: ChatResponse, results: list[tuple[ToolCall, str]]
+    ) -> list[dict]:
+        """Returns [assistant_turn, tool_result_turn] messages to append to conversation."""
+        ...

runspec_chat/adapters/anthropic_direct.py

@@ -0,0 +1,70 @@
+import anthropic
+
+from ..adapter import ChatResponse, ModelAdapter, ToolCall
+
+DEFAULT_MODEL = "claude-haiku-4-5-20251001"
+DEFAULT_SYSTEM = (
+    "You are a helpful assistant with access to tools running on remote Linux hosts. "
+    "Use tools when they help answer the user's request. "
+    "When you call a tool, briefly explain what you're doing before the result."
+)
+
+
+class AnthropicAdapter(ModelAdapter):
+    def __init__(
+        self,
+        model: str = DEFAULT_MODEL,
+        system: str = DEFAULT_SYSTEM,
+        api_key: str | None = None,
+    ):
+        # api_key=None falls back to ANTHROPIC_API_KEY env var
+        self.client = anthropic.AsyncAnthropic(api_key=api_key)
+        self.model = model
+        self.system = system
+
+    async def chat(self, messages: list[dict], tools: list[dict]) -> ChatResponse:
+        kwargs: dict = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+
+        response = await self.client.messages.create(**kwargs)
+
+        text = next(
+            (block.text for block in response.content if hasattr(block, "text")),
+            None,
+        )
+        tool_calls = [
+            ToolCall(id=block.id, name=block.name, input=block.input)
+            for block in response.content
+            if block.type == "tool_use"
+        ]
+
+        return ChatResponse(
+            text=text,
+            tool_calls=tool_calls,
+            stop_reason=response.stop_reason,
+            _raw=response,
+        )
+
+    def make_tool_turn(
+        self, response: ChatResponse, results: list[tuple[ToolCall, str]]
+    ) -> list[dict]:
+        return [
+            {"role": "assistant", "content": response._raw.content},
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": tc.id,
+                        "content": result,
+                    }
+                    for tc, result in results
+                ],
+            },
+        ]

runspec_chat/app.py

@@ -0,0 +1,468 @@
+import asyncio
+import json
+import os
+import shlex
+import shutil
+import sys
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+import chainlit as cl
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from runspec_chat.adapter import ChatResponse, ToolCall
+from runspec_chat.adapters.anthropic_direct import AnthropicAdapter
+from runspec_chat.chat import _host_pass_key, _shared_pass_key, _sync_user_env
+
+_LOCAL_CONN = "__runspec_local__"
+_DEFAULT_MODEL = os.environ.get("RUNSPEC_CHAT_MODEL", "claude-haiku-4-5-20251001")
+_SELF_TOOLS = {"runspec-chat", "setup-keys"}  # hide from "Local tools ready" message
+_COMMANDS_HIDE = {"runspec-chat"}             # hide from slash-command autocomplete
+
+_sync_user_env(
+    hosts_path=Path(
+        os.environ.get("RUNSPEC_CHAT_HOSTS", "~/.config/runspec-chat/hosts.toml")
+    ).expanduser(),
+    chainlit_config=Path(__file__).parent.parent / ".chainlit" / "config.toml",
+)
+
+
+async def _refresh_commands() -> None:
+    # Local tools stored separately so they survive mcp_tools session resets
+    local_tools: list = cl.user_session.get("local_tools", [])
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+
+    seen: set[str] = set()
+    commands = []
+    for t in local_tools + [t for conn, tools in mcp_tools.items() for t in tools if conn != _LOCAL_CONN]:
+        if t["name"] in _COMMANDS_HIDE or t["name"] in seen:
+            continue
+        seen.add(t["name"])
+        icon = "key" if t["name"] == "setup-keys" else "terminal"
+        commands.append({
+            "id": t["name"],
+            "description": t.get("description") or t["name"],
+            "icon": icon,
+            "button": False,
+        })
+    try:
+        await cl.context.emitter.set_commands(commands)
+    except Exception as exc:
+        await cl.Message(content=f"⚠ Could not update command list: {exc}").send()
+
+
+def _local_runspec_exe() -> str:
+    """Return the runspec executable in the same venv as this process."""
+    exe = Path(sys.executable).parent / "runspec"
+    return str(exe) if exe.exists() else "runspec"
+
+
+# ---------------------------------------------------------------------------
+# MCP connection lifecycle  (user-initiated via Chainlit plug icon)
+# ---------------------------------------------------------------------------
+
+@cl.on_mcp_connect
+async def on_mcp_connect(connection, session: ClientSession) -> None:
+    result = await session.list_tools()
+    tools = [
+        {"name": t.name, "description": t.description, "input_schema": t.inputSchema}
+        for t in result.tools
+    ]
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+    mcp_tools[connection.name] = tools
+    cl.user_session.set("mcp_tools", mcp_tools)
+    tool_names = [t["name"] for t in tools]
+    await cl.Message(
+        content=f"Connected to **{connection.name}** — {len(tools)} tool(s): `{'`, `'.join(tool_names)}`"
+    ).send()
+    await _refresh_commands()
+
+
+@cl.on_mcp_disconnect
+async def on_mcp_disconnect(name: str, session: ClientSession) -> None:
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+    mcp_tools.pop(name, None)
+    cl.user_session.set("mcp_tools", mcp_tools)
+    await _refresh_commands()
+
+
+# ---------------------------------------------------------------------------
+# Chat lifecycle
+# ---------------------------------------------------------------------------
+
+@cl.on_chat_start
+async def on_chat_start() -> None:
+    cl.user_session.set("messages", [])
+    cl.user_session.set("mcp_tools", {})
+    cl.user_session.set("local_sessions", {})
+
+    # API key: browser settings take precedence over .env
+    env = cl.user_session.get("env") or {}
+    api_key = env.get("ANTHROPIC_API_KEY") or os.environ.get("ANTHROPIC_API_KEY")
+    if not api_key:
+        await cl.Message(
+            content="No API key found. Open **Settings** (⚙ gear icon) and enter your `ANTHROPIC_API_KEY`."
+        ).send()
+    cl.user_session.set("adapter", AnthropicAdapter(model=_DEFAULT_MODEL, api_key=api_key or None))
+
+    await _connect_local()
+
+
+@cl.on_chat_end
+async def on_chat_end() -> None:
+    stop: asyncio.Event | None = cl.user_session.get("local_stop")
+    if stop:
+        stop.set()
+    task: asyncio.Task | None = cl.user_session.get("local_task")
+    if task:
+        try:
+            await asyncio.wait_for(asyncio.shield(task), timeout=2.0)
+        except Exception:
+            task.cancel()
+
+
+async def _local_mcp_task(
+    session_holder: list,
+    tools_holder: list,
+    ready: asyncio.Event,
+    stop: asyncio.Event,
+) -> None:
+    """Runs the full local MCP session in one task so anyio cancel scopes are
+    entered and exited in the same task — required by anyio's task model."""
+    params = StdioServerParameters(command=_local_runspec_exe(), args=["serve"])
+    try:
+        async with stdio_client(params) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+                result = await session.list_tools()
+                tools_holder.extend(
+                    {"name": t.name, "description": t.description, "input_schema": t.inputSchema}
+                    for t in result.tools
+                )
+                session_holder.append(session)
+                ready.set()
+                await stop.wait()
+    except Exception:
+        ready.set()  # unblock _connect_local even on failure
+
+
+async def _connect_local() -> None:
+    session_holder: list = []
+    tools_holder: list = []
+    ready = asyncio.Event()
+    stop = asyncio.Event()
+
+    task = asyncio.create_task(_local_mcp_task(session_holder, tools_holder, ready, stop))
+    cl.user_session.set("local_stop", stop)
+    cl.user_session.set("local_task", task)
+
+    try:
+        await asyncio.wait_for(asyncio.shield(ready.wait()), timeout=5.0)
+    except asyncio.TimeoutError:
+        await cl.Message(content="⚠ Local tools timed out on startup.").send()
+        return
+
+    if not session_holder:
+        await cl.Message(content="⚠ Could not start local tools.").send()
+        return
+
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+    mcp_tools[_LOCAL_CONN] = tools_holder
+    cl.user_session.set("mcp_tools", mcp_tools)
+    cl.user_session.set("local_session", session_holder[0])
+    cl.user_session.set("local_tools", tools_holder)  # survives mcp_tools resets
+
+    user_tools = [t["name"] for t in tools_holder if t["name"] not in _SELF_TOOLS]
+    if user_tools:
+        await cl.Message(content=f"Local tools ready: `{'`, `'.join(user_tools)}`").send()
+    else:
+        await cl.Message(
+            content="Ready. Connect a remote host via the **plug icon**, or type `/setup-keys` to set up SSH keys."
+        ).send()
+    await _refresh_commands()
+
+
+# ---------------------------------------------------------------------------
+# Built-in: setup-keys  (runs in-process so it can use browser credentials)
+# ---------------------------------------------------------------------------
+
+async def _builtin_setup_keys(tool_input: dict) -> str:
+    hosts_path = Path(tool_input.get("hosts", "~/.config/runspec-chat/hosts.toml")).expanduser()
+    if not hosts_path.exists():
+        return f"No hosts config at `{hosts_path}`. Copy `hosts.toml.example` and edit it."
+
+    with open(hosts_path, "rb") as f:
+        config = tomllib.load(f)
+
+    defaults = config.get("config", {})
+    default_user = defaults.get("user")
+    default_password = defaults.get("password")
+
+    ssh_hosts = [
+        (name, info)
+        for name, info in config.get("hosts", {}).items()
+        if info.get("ssh")
+    ]
+    if not ssh_hosts:
+        return "No SSH hosts found in config (hosts with an `ssh` field)."
+
+    # Resolve credentials — password comes from browser Settings (user_env)
+    env_vals = cl.user_session.get("env") or {}
+    resolved: list[tuple[str, str, str]] = []  # (name, target, password)
+    missing: list[str] = []
+    for name, info in ssh_hosts:
+        user = info.get("user") or default_user
+        target = f"{user}@{info['ssh']}" if user else info["ssh"]
+        # Hosts with their own user get a dedicated key; others share SSH_PASS
+        pass_key = _host_pass_key(name) if info.get("user") else _shared_pass_key()
+        password = env_vals.get(pass_key)
+        if not password:
+            missing.append(f"  - `{name}`: enter `{pass_key}` in Settings (⚙)")
+        else:
+            resolved.append((name, target, password))
+
+    if missing and not resolved:
+        return (
+            "No passwords set. Open **Settings** (⚙) and fill in:\n"
+            + "\n".join(missing)
+        )
+
+    key_type = tool_input.get("key_type", "ed25519")
+    key_path = Path.home() / ".ssh" / f"runspec-chat_{key_type}"
+    pub_key = key_path.with_suffix(".pub")
+
+    if not key_path.exists():
+        async with cl.Step(name="ssh-keygen") as step:
+            proc = await asyncio.create_subprocess_exec(
+                "ssh-keygen", "-t", key_type, "-f", str(key_path), "-N", "", "-C", "runspec-chat",
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+            )
+            _, stderr = await proc.communicate()
+            if proc.returncode != 0:
+                step.output = f"Failed: {stderr.decode()}"
+                return step.output
+            step.output = f"Created {pub_key}"
+
+    is_windows = sys.platform == "win32"
+    has_sshpass = not is_windows and bool(shutil.which("sshpass"))
+
+    if is_windows or not has_sshpass:
+        pub_key_content = pub_key.read_text().strip()
+        host_lines = "\n".join(
+            f"  ssh {target} \"cat >> ~/.ssh/authorized_keys\" << 'EOF'\n  {pub_key_content}\n  EOF"
+            for _, target, _ in resolved
+        )
+        reason = "Windows" if is_windows else "`sshpass` not installed (`sudo apt-get install sshpass`)"
+        return (
+            f"Key generated at `{pub_key}` ✓\n\n"
+            f"Automated copy unavailable ({reason}). "
+            f"Run these commands once on the machine running runspec-chat:\n\n"
+            f"```bash\n{host_lines}\n```\n\n"
+            f"Or ask your admin to add `{pub_key}` to each host's `~/.ssh/authorized_keys`."
+        )
+
+    ok, failed = [], []
+    for name, target, password in resolved:
+        async with cl.Step(name=f"ssh-copy-id → {name}") as step:
+            proc = await asyncio.create_subprocess_exec(
+                "sshpass", "-e", "ssh-copy-id", "-i", str(pub_key), target,
+                stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, "SSHPASS": password},
+            )
+            _, stderr = await proc.communicate()
+            if proc.returncode != 0:
+                step.output = f"Failed: {stderr.decode().strip()}"
+                failed.append(name)
+            else:
+                step.output = "Done"
+                ok.append(name)
+
+    lines = []
+    if missing:
+        lines.append("Skipped (no password in Settings): " + ", ".join(f"`{m.split('`')[1]}`" for m in missing))
+    if ok:
+        lines.append(f"{len(ok)} host(s) configured: {', '.join(f'`{n}`' for n in ok)}")
+    if failed:
+        lines.append(f"{len(failed)} failed: {', '.join(f'`{n}`' for n in failed)}")
+    if ok:
+        lines.append(
+            f"\nAdd to `~/.ssh/config`:\n```\nHost *\n    IdentityFile ~/.ssh/runspec-chat_{key_type}\n```"
+        )
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Tool dispatch
+# ---------------------------------------------------------------------------
+
+def _get_session(mcp_name: str) -> ClientSession | None:
+    """Return the ClientSession for a named connection, local or Chainlit-managed."""
+    if mcp_name == _LOCAL_CONN:
+        return cl.user_session.get("local_session")
+    pair = cl.context.session.mcp_sessions.get(mcp_name)
+    return pair.client if pair else None
+
+
+@cl.step(type="tool")
+async def call_tool(tool_call: ToolCall) -> str:
+    step = cl.context.current_step
+    step.name = tool_call.name
+    step.input = tool_call.input
+
+    # setup-keys runs in-process so it can access browser credentials
+    if tool_call.name == "setup-keys":
+        step.output = await _builtin_setup_keys(tool_call.input)
+        return step.output
+
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+    mcp_name = next(
+        (conn for conn, tools in mcp_tools.items() if any(t["name"] == tool_call.name for t in tools)),
+        None,
+    )
+
+    if not mcp_name:
+        step.output = json.dumps({"error": f"Tool '{tool_call.name}' not found in any connected MCP server"})
+        return step.output
+
+    mcp_session = _get_session(mcp_name)
+    if not mcp_session:
+        step.output = json.dumps({"error": f"MCP session '{mcp_name}' unavailable"})
+        return step.output
+
+    try:
+        raw = await mcp_session.call_tool(tool_call.name, tool_call.input)
+        if hasattr(raw, "content") and raw.content:
+            step.output = "\n".join(block.text for block in raw.content if hasattr(block, "text"))
+        else:
+            step.output = str(raw)
+        rs_meta = (getattr(raw, "meta", None) or {}).get("runspec", {})
+        if rs_meta.get("duration_ms") is not None:
+            step.name = f"{tool_call.name} ({rs_meta['duration_ms']}ms)"
+    except Exception as exc:
+        step.output = json.dumps({"error": str(exc)})
+
+    return step.output
+
+
+# ---------------------------------------------------------------------------
+# Slash command handler  (/toolname --arg value ...)
+# ---------------------------------------------------------------------------
+
+def _parse_slash(text: str) -> tuple[str, dict]:
+    try:
+        parts = shlex.split(text[1:])
+    except ValueError:
+        parts = text[1:].split()
+
+    name = parts[0] if parts else ""
+    args: dict = {}
+    i = 1
+    while i < len(parts):
+        token = parts[i]
+        if token.startswith("--"):
+            key = token[2:].replace("-", "_")
+            if i + 1 < len(parts) and not parts[i + 1].startswith("--"):
+                args[key] = parts[i + 1]
+                i += 2
+            else:
+                args[key] = True
+                i += 1
+        else:
+            i += 1
+    return name, args
+
+
+async def _handle_slash(text: str) -> None:
+    tool_name, tool_input = _parse_slash(text)
+    if not tool_name:
+        await cl.Message(content="Usage: `/tool_name --arg value`").send()
+        return
+
+    local_tools: list = cl.user_session.get("local_tools", [])
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+    all_tools = local_tools + [t for conn, tools in mcp_tools.items() for t in tools if conn != _LOCAL_CONN]
+    tool_def = next((t for t in all_tools if t["name"] == tool_name), None)
+
+    if tool_def is None:
+        known = sorted({t["name"] for t in all_tools})
+        available = ", ".join(f"`{n}`" for n in known) if known else "none"
+        await cl.Message(content=f"Unknown tool `{tool_name}`. Available: {available}").send()
+        return
+
+    if tool_input.get("help"):
+        schema = tool_def.get("input_schema", {})
+        props = schema.get("properties", {})
+        required = set(schema.get("required", []))
+        desc = tool_def.get("description") or ""
+        lines = [f"**/{tool_name}** — {desc}" if desc else f"**/{tool_name}**"]
+        if props:
+            lines.append("\n**Arguments:**")
+            for arg, info in props.items():
+                req = " *(required)*" if arg in required else ""
+                arg_desc = info.get("description", "")
+                arg_type = info.get("type", "")
+                lines.append(f"  `--{arg}`{req} `{arg_type}` — {arg_desc}")
+        else:
+            lines.append("No arguments.")
+        await cl.Message(content="\n".join(lines)).send()
+        return
+
+    tc = ToolCall(id="slash-0", name=tool_name, input=tool_input)
+    result = await call_tool(tc)
+    content = result if isinstance(result, str) else str(result)
+    await cl.Message(content=f"```\n{content.strip()}\n```").send()
+
+
+# ---------------------------------------------------------------------------
+# LLM message loop
+# ---------------------------------------------------------------------------
+
+async def _llm_loop(user_text: str) -> None:
+    adapter: AnthropicAdapter | None = cl.user_session.get("adapter")
+    if not adapter:
+        await cl.Message(
+            content="No LLM configured. Open **Settings** (⚙ gear icon) and enter your `ANTHROPIC_API_KEY`."
+        ).send()
+        return
+
+    messages: list = cl.user_session.get("messages", [])
+    messages.append({"role": "user", "content": user_text})
+
+    mcp_tools: dict = cl.user_session.get("mcp_tools", {})
+    tools = [t for conn_tools in mcp_tools.values() for t in conn_tools]
+
+    response: ChatResponse = await adapter.chat(messages, tools)
+
+    while response.stop_reason == "tool_use":
+        results: list[tuple[ToolCall, str]] = []
+        for tc in response.tool_calls:
+            result = await call_tool(tc)
+            results.append((tc, str(result)))
+
+        messages.extend(adapter.make_tool_turn(response, results))
+        response = await adapter.chat(messages, tools)
+
+    reply = response.text or ""
+    await cl.Message(content=reply).send()
+
+    messages.append({"role": "assistant", "content": reply})
+    cl.user_session.set("messages", messages)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+@cl.on_message
+async def on_message(msg: cl.Message) -> None:
+    await _refresh_commands()
+    text = msg.content.strip()
+    if text.startswith("/"):
+        await _handle_slash(text)
+    else:
+        await _llm_loop(text)

runspec_chat/chat.py

@@ -0,0 +1,82 @@
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import runspec as rs
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+
+def _shared_pass_key() -> str:
+    return "SSH_PASS"
+
+
+def _host_pass_key(host_name: str) -> str:
+    return f"SSH_{host_name.upper().replace('-', '_').replace(' ', '_')}_PASS"
+
+
+def _sync_user_env(hosts_path: Path, chainlit_config: Path) -> None:
+    """Rewrite user_env in .chainlit/config.toml from hosts.toml.
+
+    Hosts that share the default username → one SSH_PASS field.
+    Hosts that declare their own username → individual SSH_{HOST}_PASS fields.
+    """
+    user_env = ["ANTHROPIC_API_KEY"]
+
+    if hosts_path.exists():
+        with open(hosts_path, "rb") as f:
+            cfg = tomllib.load(f)
+
+        has_shared = False
+        host_keys: list[str] = []
+        for name, info in cfg.get("hosts", {}).items():
+            if not info.get("ssh"):
+                continue
+            if info.get("user"):
+                host_keys.append(_host_pass_key(name))
+            else:
+                has_shared = True
+
+        if has_shared:
+            user_env.append(_shared_pass_key())
+        user_env.extend(host_keys)
+
+    if not chainlit_config.exists():
+        return
+
+    text = chainlit_config.read_text()
+    text = re.sub(r"user_env = \[.*?\]", f"user_env = {json.dumps(user_env)}", text)
+    chainlit_config.write_text(text)
+
+
+def main() -> None:
+    spec = rs.parse("runspec-chat")
+
+    package_root = Path(__file__).parent.parent
+    os.environ["CHAINLIT_ROOT"] = str(package_root)
+
+    hosts_path = Path(str(spec.hosts)).expanduser()
+    chainlit_config = package_root / ".chainlit" / "config.toml"
+    _sync_user_env(hosts_path, chainlit_config)
+
+    if spec.model:
+        os.environ["RUNSPEC_CHAT_MODEL"] = str(spec.model)
+    if spec.hosts:
+        os.environ["RUNSPEC_CHAT_HOSTS"] = str(spec.hosts)
+
+    app_py = Path(__file__).parent / "app.py"
+    cmd = [
+        sys.executable, "-m", "chainlit", "run", str(app_py),
+        "--port", str(spec.port),
+        "--host", "0.0.0.0",
+    ]
+    try:
+        sys.exit(subprocess.run(cmd).returncode)
+    except KeyboardInterrupt:
+        sys.exit(0)

runspec_chat/runspec.toml

@@ -0,0 +1,39 @@
+[runspec-chat]
+description = "Launch the runspec-chat Chainlit web app"
+
+[runspec-chat.args.hosts]
+type = "path"
+short = "-H"
+description = "Path to hosts configuration file"
+default = "~/.config/runspec-chat/hosts.toml"
+required = false
+
+[runspec-chat.args.port]
+type = "int"
+short = "-p"
+description = "Port for the Chainlit web server"
+default = 8000
+
+[runspec-chat.args.model]
+type = "str"
+description = "LLM model identifier passed to the adapter"
+default = "claude-haiku-4-5-20251001"
+
+# ---
+
+[setup-keys]
+description = "Generate an SSH key (if missing) and copy it to all configured jump hosts"
+autonomy = "confirm"
+
+[setup-keys.args.hosts]
+type = "path"
+short = "-H"
+description = "Path to hosts configuration file"
+default = "~/.config/runspec-chat/hosts.toml"
+required = false
+
+[setup-keys.args.key-type]
+type = "choice"
+options = ["ed25519", "rsa"]
+default = "ed25519"
+description = "SSH key algorithm to generate"

runspec_chat/setup_keys.py

@@ -0,0 +1,87 @@
+import subprocess
+import sys
+from pathlib import Path
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+import runspec as rs
+
+
+def _load_hosts(hosts_path: Path) -> dict:
+    if not hosts_path.exists():
+        print(f"No hosts config found at {hosts_path}")
+        print("Copy hosts.toml.example and edit it, then re-run setup-keys.")
+        sys.exit(1)
+    with open(hosts_path, "rb") as f:
+        return tomllib.load(f)
+
+
+def _ensure_key(key_path: Path, key_type: str) -> Path:
+    pub = key_path.with_suffix(".pub")
+    if key_path.exists():
+        print(f"Using existing key: {key_path}")
+        return pub
+
+    print(f"Generating {key_type} key at {key_path} ...")
+    result = subprocess.run([
+        "ssh-keygen", "-t", key_type,
+        "-f", str(key_path),
+        "-N", "",
+        "-C", "runspec-chat",
+    ])
+    if result.returncode != 0:
+        print("ssh-keygen failed.")
+        sys.exit(1)
+    print(f"Key created: {pub}")
+    return pub
+
+
+def _copy_to_host(pub_key: Path, ssh_target: str, name: str) -> bool:
+    print(f"\nCopying public key to {name} ({ssh_target}) ...")
+    print("You may be prompted for the remote password.")
+    result = subprocess.run(["ssh-copy-id", "-i", str(pub_key), ssh_target])
+    if result.returncode != 0:
+        print(f"  Warning: ssh-copy-id failed for {name} — skipping.")
+        return False
+    print("  Done.")
+    return True
+
+
+def main() -> None:
+    spec = rs.parse("setup-keys")
+
+    hosts_path = Path(str(spec.hosts)).expanduser()
+    config = _load_hosts(hosts_path)
+
+    ssh_hosts = [
+        (name, info["ssh"])
+        for name, info in config.get("hosts", {}).items()
+        if info.get("ssh")
+    ]
+
+    if not ssh_hosts:
+        print("No SSH hosts found in the config (hosts with an 'ssh' field).")
+        sys.exit(0)
+
+    key_type: str = spec.key_type
+    key_path = Path.home() / ".ssh" / f"runspec-chat_{key_type}"
+    pub_key = _ensure_key(key_path, key_type)
+
+    ok, failed = [], []
+    for name, ssh_target in ssh_hosts:
+        if _copy_to_host(pub_key, ssh_target, name):
+            ok.append(name)
+        else:
+            failed.append(name)
+
+    print(f"\nDone. {len(ok)} host(s) configured", end="")
+    if failed:
+        print(f", {len(failed)} failed: {', '.join(failed)}", end="")
+    print(".")
+
+    if ok:
+        print("\nAdd this to your ~/.ssh/config for each host:")
+        print(f"  IdentityFile ~/.ssh/runspec-chat_{key_type}")

runspec_chat-0.1.0.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: runspec-chat
+Version: 0.1.0
+Requires-Python: >=3.11
+Requires-Dist: chainlit>=2.7.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: runspec>=0.13.1
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: anthropic>=0.40.0; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'

runspec_chat-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+runspec_chat/__init__.py,sha256=AT1_k-bAMQTF8ksSi5uHVT77eb-tgS5A1UkgFlJkvSA,126
+runspec_chat/adapter.py,sha256=nDZqVFrEdYqZi7vjNUyt38LcOPd8uZUi4dLATappgL4,738
+runspec_chat/app.py,sha256=WgRzwpVVhym0vEmNq3ie-RZzZisDC4NIalG4qYrQD9o,17852
+runspec_chat/chat.py,sha256=bpmvNVqrZClbZln3stw4vjjRCOZQNM8524iAdrBKt9M,2242
+runspec_chat/runspec.toml,sha256=ZjpTz8_ykwp-qq6b6sLtWxVndXD-BoDdE7vN5GwGkmc,926
+runspec_chat/setup_keys.py,sha256=IZwJgo3WJj_PNmkkfL7tA5ZyqMD_Mb79AhXRKZliwC0,2489
+runspec_chat/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+runspec_chat/adapters/anthropic_direct.py,sha256=72WuCunhiNWQuEftB8H5qIz9Xz4vxbE_9bhKNQYfL6E,2144
+runspec_chat-0.1.0.dist-info/METADATA,sha256=DQ8R3Yb4fr3UBKmLfvu73zzFTRQXlIS3xfK5TTizims,461
+runspec_chat-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+runspec_chat-0.1.0.dist-info/entry_points.txt,sha256=EMzKVTL7Fl8EbRib_LRc9-ubCKzvkULbJj424jbY3Qg,98
+runspec_chat-0.1.0.dist-info/RECORD,,

runspec_chat-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

runspec_chat-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+runspec-chat = runspec_chat.chat:main
+setup-keys = runspec_chat.setup_keys:main