relaydeck 0.1.0__py3-none-any.whl

plugins/__init__.py

@@ -0,0 +1,19 @@
+"""Official relaydeck plugins — relaydeck-maintained, all in one tree.
+
+Every relaydeck-managed plugin lives here: the infrastructure plugins the
+daemon can't boot without (``vault``, ``github``, ``loop``, ``external_agents``,
+``harnesses``) alongside the separable extensions (``messaging``, ``skills``,
+``theme``, ``metering``, ``telegram``, ``gateway``, ``file_watcher``,
+``usage_limits``, ``hitl``, ``dashboard``, ``providers``).
+
+These load through real package import via the daemon plugin loader
+(``PluginRegistry._scan_package("plugins")``). Core never imports this package
+statically — the boundary is one-directional: plugins import the public core
+facades (``relaydeck.sdk``, ``relaydeck.harness``, ``relaydeck.provider``,
+``relaydeck.vault``, ``relaydeck.automation``, ``relaydeck.testing``), never the
+other way around.
+
+The tree ships in the single ``relaydeck`` wheel today; it is laid out so a
+future split into a separately-versioned ``relaydeck-plugins`` distribution (or
+per-plugin wheels) is mechanical. See ``AGENTS.md`` (Package separation).
+"""

plugins/bundle.toml

@@ -0,0 +1,30 @@
+# Recommended bundles of OFFICIAL relaydeck plugins.
+#
+# Every official plugin ships in the single `relaydeck` wheel today, so a
+# bundle is a *recommended set* — the plugins `relaydeck doctor` expects to be
+# present and the dashboard surfaces as the default experience. This file is
+# also the pinned manifest of what an eventual split `relaydeck-plugins` wheel
+# (or per-plugin wheels) must provide, so the recommended set has one source of
+# truth that travels with the plugins.
+#
+# Names are plugin manifest names (the `name = ...` in each plugin.toml), which
+# is what discovery and the lockfile compare against.
+
+[bundle.default]
+description = "The full relaydeck experience — every official plugin."
+plugins = [
+  # Infrastructure (engine depends on these)
+  "vault", "github", "loop", "external",
+  # Harnesses
+  "pi-harness", "claude-code-harness", "codex-harness", "cursor-harness",
+  "opencode-harness", "antigravity-harness", "relaydeck-native",
+  # Extensions
+  "messaging", "skills", "theme", "metering", "telegram",
+  "gateway", "file-watcher", "usage-limits", "hitl", "prompts", "dashboard",
+  # Provider catalogs
+  "openai", "anthropic", "ollama", "openrouter",
+]
+
+[bundle.minimal]
+description = "Engine-essential only — one harness, secrets, and the operator."
+plugins = ["vault", "pi-harness", "relaydeck-native"]

plugins/dashboard/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: relaydeck-dashboard
+description: Reshape the live relaydeck web dashboard. Read this when asked to rearrange, add, remove, move, or resize Home widgets, switch the theme/density/glow, or "make the dashboard look like X". Changes apply instantly to every open dashboard. Drive it with the `relaydeck dashboard` CLI.
+metadata:
+  short-description: Restyle and rearrange the relaydeck dashboard
+---
+
+# Controlling the relaydeck dashboard
+
+The dashboard is a 12-column Home widget grid plus an appearance layer
+(theme / density / glow). You change it through the **`relaydeck dashboard`**
+CLI — every command POSTs to the daemon, which broadcasts the change so it
+applies **instantly** to every open dashboard (no reload). A daemon must be
+running.
+
+## See what's there first
+
+```sh
+relaydeck dashboard get          # theme / density / glow + saved widget grid
+```
+
+For the full theme list use `relaydeck theme list`. To author or recolor a
+theme (vs. just switching to one), use the **relaydeck-theme** skill.
+
+## Appearance
+
+```sh
+relaydeck dashboard theme ink            # any theme from `relaydeck theme list`
+relaydeck dashboard density compact      # compact | comfy | regular
+relaydeck dashboard glow off             # on | off
+```
+
+## Widgets (the Home grid)
+
+The grid is **12 columns wide**; `x`/`y` are 0-based cell coordinates and
+`w`/`h` are cell spans. Widget keys:
+
+`fleet` · `usage` · `agents` · `feed` · `workspaces` · `spawn` · `workers`
+· `worktrees` · `clock` · `notes` · `focus`
+
+```sh
+relaydeck dashboard add workers          # add a widget
+relaydeck dashboard remove clock         # remove it
+relaydeck dashboard move usage 8 0       # move 'usage' to column 8, row 0
+relaydeck dashboard resize agents 6 4    # resize 'agents' to 6 wide x 4 tall
+relaydeck dashboard tidy                 # auto-arrange, remove gaps
+relaydeck dashboard reset                # back to the default layout
+```
+
+## Notes
+
+- Invalid values are rejected with the allowed set (e.g. an unknown widget or
+  theme) — read the error and retry; nothing partial is applied.
+- **`theme` / `density` / `glow` persist server-side** and `dashboard get`
+  reflects them immediately — no browser needs to be open. They default to the
+  global (dashboard-wide) scope; pass `--workspace <name>` to scope one
+  workspace, and `dashboard get --workspace <name>` to read that scope.
+- **The saved Home widget grid** is also in `dashboard get` (from
+  `preferences.yaml`). When nothing is saved yet, `get` shows the package
+  default layout. Live `add`/`move`/`resize`/`tidy`/`reset` ops apply instantly
+  in open browsers; the browser persists the grid back to the server.
+- **Widget ops (`add`/`remove`/`move`/`resize`/`tidy`/`reset`) apply to open
+  dashboards live** — the `✓` from the command is your confirmation once the
+  browser applies it.
+- This is the same capability the relaydeck-native agent's `dashboard` tool
+  has, exposed as a CLI so any harness can use it.

plugins/dashboard/__init__.py

@@ -0,0 +1 @@
+"""Dashboard plugin — ships the `relaydeck-dashboard` skill."""

plugins/dashboard/plugin.py

@@ -0,0 +1,69 @@
+"""
+Dashboard plugin — the skill-shipping surface for live dashboard control.
+
+The control surface itself is core: the validator
+(`relaydeck/dashboard_commands.py`), the endpoint
+(`POST /api/dashboard/command`), and the CLI (`relaydeck dashboard …`). The
+browser applies the emitted `dashboard.command` events live. This plugin
+exists for one reason: to materialize the `relaydeck-dashboard` SKILL.md into
+workspaces via the generic `[plugin.skills]` mechanism, so an agent on ANY
+harness can reshape the dashboard through the `relaydeck dashboard` CLI — the
+same capability the native `dashboard` tool gives the relaydeck-native agent.
+
+Daemon-wide (not workspace-scoped) and opt-out via the `inject_skill`
+setting; mirrors the theme plugin.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from relaydeck.sdk import Plugin, PluginHost
+
+logger = logging.getLogger(__name__)
+
+PLUGIN_NAME = "dashboard"
+
+
+def _setting(key: str, default: Any) -> Any:
+    from relaydeck.plugin_settings import get_setting
+    return get_setting(PLUGIN_NAME, key, default=default)
+
+
+def _inject_skill_enabled() -> bool:
+    v = _setting("inject_skill", True)
+    if isinstance(v, bool):
+        return v
+    if isinstance(v, str):
+        return v.strip().lower() not in ("false", "0", "no", "off", "")
+    return bool(v)
+
+
+class DashboardPlugin(Plugin):
+    """Daemon-wide plugin that ships the `relaydeck-dashboard` skill."""
+
+    def on_load(self, host: PluginHost) -> None:
+        self.host = host
+        self._config_home = host.config_home
+
+    def on_unload(self) -> None:
+        # The skills plugin strips materialized skills on plugin unload.
+        pass
+
+    def on_settings_changed(self, new_values: dict[str, Any]) -> None:
+        del new_values
+        try:
+            self.host.events.emit("plugin.skills.changed", {"plugin": PLUGIN_NAME})
+        except Exception:
+            pass
+
+    def skill_target_workspaces(self, all_workspaces: list[str]) -> list[str]:
+        """Dashboard control is universal — ship to every workspace unless the
+        operator turned `inject_skill` off."""
+        if not _inject_skill_enabled():
+            return []
+        return list(all_workspaces)
+
+
+PLUGIN = DashboardPlugin()

plugins/dashboard/plugin.toml

@@ -0,0 +1,21 @@
+[plugin]
+name = "dashboard"
+version = "0.1.0"
+description = "Live dashboard control — ships the `relaydeck-dashboard` skill so any harness agent can reshape the dashboard"
+author = "relaydeck"
+license = "MIT"
+category = "tool"
+host_api_version = 1
+# Daemon-wide: the control surface (validator, POST /api/dashboard/command,
+# `relaydeck dashboard` CLI) lives in core. This plugin's only job is to ship
+# the `relaydeck-dashboard` SKILL.md to workspaces so agents learn the CLI.
+workspace_scoped = false
+declared_capabilities = [
+  "events.emit",
+]
+
+[plugin.settings]
+inject_skill = { type = "bool", default = true, description = "Materialize the `relaydeck-dashboard` skill into every workspace so agents can reshape the dashboard." }
+
+[plugin.skills]
+relaydeck-dashboard = "SKILL.md"

plugins/external_agents/__init__.py

@@ -0,0 +1,2 @@
+"""Bundled external-agents plugin: discover, observe, and surface Hermes /
+OpenClaw runtimes that relaydeck does not run (read-only)."""

plugins/external_agents/detector.py

@@ -0,0 +1,223 @@
+"""Detect whether a path is a Hermes or OpenClaw runtime.
+
+Detection is **filesystem-first and side-effect-free**: it reads a few marker
+files and directory names and scores the evidence. The only host probe is an
+injectable `which(<cli>)` check ("is the runtime's CLI installed?") which is a
+soft signal — it never executes the CLI. We deliberately do NOT run
+`hermes`/`openclaw` here (that's `probes.py`, and only on demand) so `detect`
+stays fast and safe to call while scanning many directories.
+
+Returns a `Detection` (scored evidence). The caller decides whether the
+confidence is high enough to register or surface as a candidate.
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from .models import (
+    HERMES,
+    OPENCLAW,
+    T_GATEWAY_WS,
+    T_MCP,
+    UNKNOWN,
+    Detection,
+)
+
+# Confidence weights per signal. Tuned so a single strong marker (a
+# pyproject naming hermes-agent, an openclaw.mjs, or a `.hermes`/`.openclaw`
+# home) clears the 0.5 "candidate" bar, and two independent markers clear
+# the 0.9 "confident" bar.
+_W_HOME_NAME = 0.6        # dir literally named .hermes / .openclaw
+_W_STRONG_REPO = 0.6      # pyproject/package.json/openclaw.mjs naming the project
+_W_CONFIG_FILE = 0.35     # config.yaml in a plausible home
+_W_CONTEXT_FILE = 0.15    # .hermes.md / SOUL.md etc.
+_W_DIR_HINT = 0.12        # a hermes/openclaw-looking subdir
+_W_CLI_ON_PATH = 0.25     # the runtime's CLI is installed on this host
+
+_CONFIDENCE_CAP = 0.99
+CANDIDATE_THRESHOLD = 0.5
+
+
+def _which(name: str) -> str | None:
+    """Indirection point so tests can monkeypatch CLI presence without
+    depending on whether hermes/openclaw is actually installed."""
+    return shutil.which(name)
+
+
+def _read_head(path: Path, limit: int = 8192) -> str:
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as f:
+            return f.read(limit)
+    except OSError:
+        return ""
+
+
+def _score_hermes(path: Path) -> tuple[float, list[str], str | None]:
+    signals: list[str] = []
+    score = 0.0
+    config_home: str | None = None
+
+    if path.name == ".hermes":
+        score += _W_HOME_NAME
+        signals.append("dir named .hermes")
+        config_home = str(path)
+
+    cfg = path / "config.yaml"
+    if cfg.exists():
+        score += _W_CONFIG_FILE
+        signals.append("config.yaml present")
+        config_home = config_home or str(path)
+
+    pyproject = path / "pyproject.toml"
+    if pyproject.exists():
+        head = _read_head(pyproject).lower()
+        if "hermes-agent" in head or "hermes_agent" in head or "hermes agent" in head:
+            score += _W_STRONG_REPO
+            signals.append("pyproject names hermes-agent")
+        elif "hermes" in head:
+            score += _W_DIR_HINT
+            signals.append("pyproject mentions hermes")
+
+    for ctx in (".hermes.md", "SOUL.md"):
+        if (path / ctx).exists():
+            score += _W_CONTEXT_FILE
+            signals.append(f"{ctx} present")
+
+    for d in ("hermes_cli", "hermes_agent"):
+        if (path / d).is_dir():
+            score += _W_DIR_HINT
+            signals.append(f"{d}/ dir")
+
+    if _which("hermes"):
+        score += _W_CLI_ON_PATH
+        signals.append("hermes CLI on PATH")
+
+    # A conventional home alongside a repo checkout.
+    if config_home is None:
+        home = Path.home() / ".hermes"
+        if home.exists():
+            config_home = str(home)
+
+    return score, signals, config_home
+
+
+def _score_openclaw(path: Path) -> tuple[float, list[str], str | None]:
+    signals: list[str] = []
+    score = 0.0
+    config_home: str | None = None
+
+    if path.name == ".openclaw":
+        score += _W_HOME_NAME
+        signals.append("dir named .openclaw")
+        config_home = str(path)
+
+    if (path / "config.yaml").exists() or (path / "config.json").exists():
+        score += _W_CONFIG_FILE
+        signals.append("config file present")
+        config_home = config_home or str(path)
+
+    if (path / "openclaw.mjs").exists():
+        score += _W_STRONG_REPO
+        signals.append("openclaw.mjs present")
+
+    pkg = path / "package.json"
+    if pkg.exists():
+        head = _read_head(pkg).lower()
+        if "openclaw" in head:
+            score += _W_STRONG_REPO
+            signals.append("package.json names openclaw")
+
+    if (path / "pnpm-workspace.yaml").exists():
+        score += _W_DIR_HINT
+        signals.append("pnpm-workspace.yaml")
+
+    for d in ("extensions", "apps"):
+        if (path / d).is_dir():
+            score += _W_DIR_HINT * 0.5
+            signals.append(f"{d}/ dir")
+
+    if _which("openclaw"):
+        score += _W_CLI_ON_PATH
+        signals.append("openclaw CLI on PATH")
+
+    if config_home is None:
+        home = Path.home() / ".openclaw"
+        if home.exists():
+            config_home = str(home)
+
+    return score, signals, config_home
+
+
+def detect(path: str | Path) -> Detection:
+    """Score `path` as a hermes/openclaw runtime. Filesystem-only."""
+    p = Path(path).expanduser()
+    root = str(p)
+    if not p.exists():
+        return Detection(
+            kind=UNKNOWN, confidence=0.0, root=root,
+            warnings=[f"path does not exist: {root}"],
+        )
+    if not p.is_dir():
+        return Detection(
+            kind=UNKNOWN, confidence=0.0, root=root,
+            warnings=[f"not a directory: {root}"],
+        )
+
+    h_score, h_signals, h_home = _score_hermes(p)
+    o_score, o_signals, o_home = _score_openclaw(p)
+
+    if h_score == 0.0 and o_score == 0.0:
+        return Detection(
+            kind=UNKNOWN, confidence=0.0, root=root,
+            warnings=["no hermes/openclaw markers found"],
+        )
+
+    if h_score >= o_score:
+        kind, score, signals, home, transport = (
+            HERMES, h_score, h_signals, h_home, T_MCP,
+        )
+    else:
+        kind, score, signals, home, transport = (
+            OPENCLAW, o_score, o_signals, o_home, T_GATEWAY_WS,
+        )
+
+    return Detection(
+        kind=kind,
+        confidence=min(score, _CONFIDENCE_CAP),
+        signals=signals,
+        recommended_transport=transport,
+        root=root,
+        config_home=home,
+    )
+
+
+def scan_candidates(extra_roots: list[str] | None = None) -> list[Detection]:
+    """Auto-detect external runtimes on this machine.
+
+    Scans the conventional config homes (`~/.hermes`, `~/.openclaw`) plus any
+    `extra_roots` (e.g. registered relaydeck workspace paths) and returns
+    detections at or above the candidate threshold. The caller filters out
+    anything already registered before surfacing "detected — add?" affordances.
+    """
+    seen: set[str] = set()
+    out: list[Detection] = []
+    roots: list[Path] = [Path.home() / ".hermes", Path.home() / ".openclaw"]
+    for r in extra_roots or []:
+        try:
+            roots.append(Path(r).expanduser())
+        except (OSError, ValueError):
+            continue
+    for root in roots:
+        key = str(root)
+        if key in seen:
+            continue
+        seen.add(key)
+        if not root.exists() or not root.is_dir():
+            continue
+        det = detect(root)
+        if det.matched and det.confidence >= CANDIDATE_THRESHOLD:
+            out.append(det)
+    out.sort(key=lambda d: d.confidence, reverse=True)
+    return out

plugins/external_agents/harness.py

@@ -0,0 +1,83 @@
+"""
+Harnesses that run a linked external runtime's interactive chat TUI as a
+relaydeck agent.
+
+The `external` plugin observes Hermes/OpenClaw read-only — but once a
+runtime is linked, the most useful next step is to actually *use* it: drop
+an instance of its chat TUI into any workspace, live in the dashboard
+terminal tile alongside your pi/claude agents (attach, watch, message it).
+
+relaydeck already wraps CLIs (pi, claude-code, codex) as PTY-backed
+`HarnessAgent`s, so the external runtime's CLI is just another harness. We
+spawn `<cli> <subcommand>` in the *workspace's* directory (so the runtime
+operates on that workspace) using the runtime's OWN config/auth home
+(`~/.hermes`, `~/.openclaw`). We never copy secrets or mutate the external
+config — relaydeck only runs the binary.
+
+Unlike the native harnesses this deliberately does NOT inject relaydeck's
+model preset or `--append-system-prompt`: Hermes/OpenClaw own their model
+selection + prompting, and those flags differ per runtime. The command is
+just `<CLI> <DEFAULT_ARGS>` plus optional per-agent `config.command` (full
+override) / `config.args` (additive) — so an operator can tune it
+(`-m`, `--continue`, `--worktree`, …) without code changes.
+"""
+
+from __future__ import annotations
+
+import shlex
+
+from relaydeck.harness import HarnessAgent
+
+
+class ExternalChatAgent(HarnessAgent):
+    """Base harness for an external runtime's interactive chat CLI."""
+
+    CLI = ""  # set by subclass
+    DEFAULT_ARGS: list[str] = []
+
+    def _build_command(self) -> list[str]:
+        cmd = [self.CLI] + list(self.DEFAULT_ARGS)
+        user_cmd = self.config.get("command")
+        if isinstance(user_cmd, list):
+            cmd = [str(a) for a in user_cmd]
+        elif isinstance(user_cmd, str) and user_cmd.strip():
+            cmd = shlex.split(user_cmd)
+        extra = self.config.get("args")
+        if isinstance(extra, list):
+            cmd.extend(str(a) for a in extra)
+        elif isinstance(extra, str) and extra.strip():
+            cmd.extend(shlex.split(extra))
+        return cmd
+
+
+class HermesChatAgent(ExternalChatAgent):
+    """Hermes Agent — `hermes chat` (verified: "Interactive chat with the agent")."""
+
+    CLI = "hermes"
+    DEFAULT_ARGS = ["chat"]
+
+
+class OpenClawChatAgent(ExternalChatAgent):
+    """OpenClaw — bare `openclaw` launches its TUI.
+
+    The exact chat subcommand is best-effort (OpenClaw needs Node >= 22.19;
+    if the local node is older the CLI exits with an upgrade hint, which the
+    operator will see in the terminal tile). Override per-agent with
+    `config.args` / `config.command` if the invocation differs.
+    """
+
+    CLI = "openclaw"
+    DEFAULT_ARGS: list[str] = []
+
+
+# External-agent kind -> registered relaydeck harness type name.
+KIND_TO_TYPE: dict[str, str] = {
+    "hermes": "hermes",
+    "openclaw": "openclaw",
+}
+
+# Harness type name -> class, registered by the plugin's on_load.
+HARNESS_TYPES: dict[str, type[ExternalChatAgent]] = {
+    "hermes": HermesChatAgent,
+    "openclaw": OpenClawChatAgent,
+}