openclaw-node-harness 2.0.0

package/skills/mesh/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: mesh
+description: >
+  Multi-node mesh network for cross-machine file sharing, remote command execution,
+  screenshots, and visual verification. Two nodes: macOS (lead) and Ubuntu (worker).
+  Files dropped in ~/openclaw/shared/ auto-sync to all nodes via NATS.
+  Use when you need to: run commands on the other machine, take screenshots on either
+  node, share files between machines, verify visual output across nodes, or coordinate
+  work across the mesh.
+version: 1.0.0
+user-invocable: true
+metadata:
+  openclaw:
+    requires:
+      bins:
+        - mesh
+    os:
+      - macos
+      - linux
+---
+
+# Mesh — Multi-Node Coordination
+
+You have access to a **two-node mesh network** connected via NATS over Tailscale.
+
+## Nodes
+
+| Node | Platform | Role | Tailscale IP |
+|------|----------|------|-------------|
+| macOS (this machine) | darwin | **Lead** — orchestrates, delegates | 100.65.201.114 |
+| Ubuntu | linux | **Worker** — executes, renders | 100.91.131.61 |
+
+## Shared Folder
+
+**`~/openclaw/shared/`** exists on both machines with identical contents.
+Files placed here by either node are automatically synced to the other within seconds via NATS.
+
+Use this folder for:
+- Sharing code, configs, markdown, images between nodes
+- Receiving screenshots from either node
+- Passing build artifacts, test results, or renders between machines
+- Any file that both nodes need access to
+
+Screenshots are saved to `~/openclaw/shared/captures/`.
+
+**The path is the same on both machines.** You can reference `~/openclaw/shared/whatever.png`
+and it resolves correctly on both nodes.
+
+## CLI — `mesh` command
+
+The `mesh` CLI is available in your PATH. Use it via bash:
+
+### Check mesh status
+```bash
+mesh status
+```
+Returns: which nodes are online, memory, uptime, number of shared files.
+
+### Run a command on the Ubuntu node
+```bash
+mesh exec "ls -la /home/calos/projects/"
+mesh exec "docker ps"
+mesh exec "cat /etc/os-release"
+```
+Runs the command on the **remote** Ubuntu node and returns stdout/stderr.
+Timeout: 30 seconds. For long-running tasks, background them.
+
+### Take a screenshot on a specific node
+```bash
+mesh capture              # Screenshot this machine (macOS)
+mesh capture --node ubuntu  # Screenshot the Ubuntu node
+```
+Screenshots are saved to `~/openclaw/shared/captures/` and auto-synced.
+The command returns the file path.
+
+### Health check the mesh
+```bash
+mesh health              # Check this node only
+mesh health --all        # Check ALL nodes (local + remote)
+mesh health --json       # Machine-readable JSON output
+```
+Checks every service: Tailscale, NATS, MeshCentral, Mumble, OpenClaw agent,
+shared folder, mesh CLI, disk space, peer reachability.
+Returns per-service status: ok / degraded / down.
+
+### Self-repair the mesh
+```bash
+mesh repair              # Repair this node
+mesh repair --all        # Repair ALL nodes (local + remote)
+```
+Runs health check first, then for each failed service:
+- Restarts the systemd unit (Ubuntu) or LaunchDaemon (macOS)
+- Recreates missing directories and fixes permissions
+- Reconnects Tailscale if disconnected
+- Clears stale logs and PID files
+- Reports what it did and whether it worked
+
+Requires sudo. Safe to re-run (idempotent).
+
+### List shared files
+```bash
+mesh ls
+mesh ls captures/
+```
+
+### Send a file to the shared folder
+```bash
+mesh put /path/to/local/file.txt
+mesh put /path/to/image.png captures/
+```
+Copies the file into `~/openclaw/shared/` (optionally into a subdirectory).
+It will auto-sync to the other node.
+
+### Broadcast a message to all nodes
+```bash
+mesh broadcast "Build starting — do not reboot"
+```
+
+## When to use this skill
+
+- **"Run this on Linux"** -> `mesh exec "<command>"`
+- **"Check what the Ubuntu machine is showing"** -> `mesh capture --node ubuntu`
+- **"Share this file with the other node"** -> `mesh put <file>`
+- **"Is the other node online?"** -> `mesh status`
+- **"Take a screenshot"** -> `mesh capture`
+- **"Deploy to the Linux server"** -> `mesh exec` + `mesh put` for files
+- **"Verify the UI on both platforms"** -> `mesh capture` + `mesh capture --node ubuntu`
+- **"Is the mesh healthy?"** -> `mesh health --all`
+- **"Something's broken / not responding"** -> `mesh health --all` then `mesh repair --all`
+- **"Fix the mesh"** -> `mesh repair --all`
+- **Before delegating work to the remote node** -> `mesh health --all` first
+- **During heartbeat checks** -> `mesh health --json --all` for structured diagnostics
+- **When a remote exec fails or times out** -> `mesh health` then `mesh repair` then retry
+- Any cross-machine coordination
+
+## Autonomous maintenance pattern
+
+When using the mesh in HEARTBEAT.md or cron jobs, follow this pattern:
+
+1. `mesh health --json --all` -- get structured status of entire mesh
+2. If overall != "ok", run `mesh repair --all`
+3. `mesh health --json --all` -- verify repair worked
+4. If still broken, log the failure to `~/openclaw/shared/mesh-incidents.log`
+   and alert the user
+5. Only proceed with delegated work if mesh is healthy
+
+This ensures the mesh self-heals before attempting cross-node operations.
+
+## Security model
+
+**Network isolation:** NATS listens on `0.0.0.0:4222` but is only reachable via Tailscale.
+Tailscale is the authentication layer — no device outside the tailnet can connect.
+There is no additional NATS auth (no tokens, no TLS) because the tailnet is the trust boundary.
+
+**Exec audit log:** Every command run via `mesh exec` is logged to
+`~/openclaw/shared/mesh-audit.log` with timestamp, node ID, command, and exit code.
+This log auto-syncs to both nodes. Review it periodically.
+
+**Destructive command blocklist:** The CLI blocks known-destructive patterns before they
+reach the remote node:
+- `rm -rf`, `mkfs`, `dd of=`, `curl|sh`, `chmod 777 /`, fork bombs
+- If you need to run a blocked command, SSH into the node directly.
+
+**Path traversal protection:** The agent validates all incoming file sync paths stay within
+`~/openclaw/shared/`. Paths containing `../` that escape the shared directory are rejected
+and logged to the audit log.
+
+**Node discovery:** Use `mesh status` to discover online nodes dynamically.
+Do not rely on hardcoded Tailscale IPs — they may change if nodes rejoin the tailnet.
+
+## Anti-patterns — do NOT do these
+
+- **Don't use `mesh exec` for long-running daemons.** The 30s timeout will kill them. Use systemd/launchd on the target node instead.
+- **Don't sync files larger than 10MB via `mesh put`.** Use `scp` over Tailscale directly: `scp file calos@100.91.131.61:~/path/`
+- **Don't run `mesh repair --all` in a tight loop.** It needs time for services to stabilize. Use the autonomous maintenance pattern with backoff.
+- **Don't store secrets in `~/openclaw/shared/`.** It syncs to all nodes unencrypted over NATS. Use Tailscale's built-in file transfer for sensitive data.
+- **Don't assume the shared folder is instant.** Polling interval is 2 seconds. If you write a file and immediately read it on the other node, it may not be there yet. Wait or verify.
+
+## Important notes
+
+- The Ubuntu node runs headless most of the time. Screenshots may show a terminal or desktop depending on session state.
+- Commands on the remote node run as the `calos` user on Ubuntu.
+- Max file sync size is 10MB per file. For larger files, use `scp` over Tailscale directly.
+- The mesh agent runs as a systemd service (Ubuntu) and LaunchDaemon (macOS) — it survives reboots.

package/skills/model-usage/.clawhub/origin.json

@@ -0,0 +1,7 @@
+{
+  "version": 1,
+  "registry": "https://clawhub.ai",
+  "slug": "model-usage",
+  "installedVersion": "1.0.0",
+  "installedAt": 1770237086875
+}

package/skills/model-usage/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: model-usage
+description: "Summarize per-model usage costs from CodexBar CLI logs. Use when asked for model-level cost breakdowns, current model usage, or full model spending summaries for Codex or Claude."
+triggers:
+  - "show my model usage"
+  - "how much did I spend on Claude"
+  - "codexbar cost breakdown"
+  - "what model am I using"
+negative_triggers:
+  - "check API rate limits"
+  - "configure model settings"
+  - "switch to a different model"
+metadata: {"clawdbot":{"emoji":"📊","os":["darwin"],"requires":{"bins":["codexbar"]},"install":[{"id":"brew-cask","kind":"brew","cask":"steipete/tap/codexbar","bins":["codexbar"],"label":"Install CodexBar (brew cask)"}]}}
+---
+
+# Model usage
+
+## Overview
+Get per-model usage cost from CodexBar's local cost logs. Supports "current model" (most recent daily entry) or "all models" summaries for Codex or Claude.
+
+TODO: add Linux CLI support guidance once CodexBar CLI install path is documented for Linux.
+
+## Quick start
+1) Fetch cost JSON via CodexBar CLI or pass a JSON file.
+2) Use the bundled script to summarize by model.
+
+```bash
+python {baseDir}/scripts/model_usage.py --provider codex --mode current
+python {baseDir}/scripts/model_usage.py --provider codex --mode all
+python {baseDir}/scripts/model_usage.py --provider claude --mode all --format json --pretty
+```
+
+## Current model logic
+- Uses the most recent daily row with `modelBreakdowns`.
+- Picks the model with the highest cost in that row.
+- Falls back to the last entry in `modelsUsed` when breakdowns are missing.
+- Override with `--model <name>` when you need a specific model.
+
+## Inputs
+- Default: runs `codexbar cost --format json --provider <codex|claude>`.
+- File or stdin:
+
+```bash
+codexbar cost --provider codex --format json > /tmp/cost.json
+python {baseDir}/scripts/model_usage.py --input /tmp/cost.json --mode all
+cat /tmp/cost.json | python {baseDir}/scripts/model_usage.py --input - --mode current
+```
+
+## Output
+- Text (default) or JSON (`--format json --pretty`).
+- Values are cost-only per model; tokens are not split by model in CodexBar output.
+
+## References
+- Read `references/codexbar-cli.md` for CLI flags and cost JSON fields.

package/skills/model-usage/references/codexbar-cli.md

@@ -0,0 +1,28 @@
+# CodexBar CLI quick ref (usage + cost)
+
+## Install
+- App: Preferences -> Advanced -> Install CLI
+- Repo: ./bin/install-codexbar-cli.sh
+
+## Commands
+- Usage snapshot (web/cli sources):
+  - codexbar usage --format json --pretty
+  - codexbar --provider all --format json
+- Local cost usage (Codex + Claude only):
+  - codexbar cost --format json --pretty
+  - codexbar cost --provider codex|claude --format json
+
+## Cost JSON fields
+The payload is an array (one per provider).
+- provider, source, updatedAt
+- sessionTokens, sessionCostUSD
+- last30DaysTokens, last30DaysCostUSD
+- daily[]: date, inputTokens, outputTokens, cacheReadTokens, cacheCreationTokens, totalTokens, totalCost, modelsUsed, modelBreakdowns[]
+- modelBreakdowns[]: modelName, cost
+- totals: totalInputTokens, totalOutputTokens, cacheReadTokens, cacheCreationTokens, totalTokens, totalCost
+
+## Notes
+- Cost usage is local-only. It reads JSONL logs under:
+  - Codex: ~/.codex/sessions/**/*.jsonl
+  - Claude: ~/.config/claude/projects/**/*.jsonl or ~/.claude/projects/**/*.jsonl
+- If web usage is required (non-local), use codexbar usage (not cost).

package/skills/model-usage/scripts/model_usage.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""
+Summarize CodexBar local cost usage by model.
+
+Defaults to current model (most recent daily entry), or list all models.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+
+def eprint(msg: str) -> None:
+    print(msg, file=sys.stderr)
+
+
+def run_codexbar_cost(provider: str) -> List[Dict[str, Any]]:
+    cmd = ["codexbar", "cost", "--format", "json", "--provider", provider]
+    try:
+        output = subprocess.check_output(cmd, text=True)
+    except FileNotFoundError:
+        raise RuntimeError("codexbar not found on PATH. Install CodexBar CLI first.")
+    except subprocess.CalledProcessError as exc:
+        raise RuntimeError(f"codexbar cost failed (exit {exc.returncode}).")
+    try:
+        payload = json.loads(output)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(f"Failed to parse codexbar JSON output: {exc}")
+    if not isinstance(payload, list):
+        raise RuntimeError("Expected codexbar cost JSON array.")
+    return payload
+
+
+def load_payload(input_path: Optional[str], provider: str) -> Dict[str, Any]:
+    if input_path:
+        if input_path == "-":
+            raw = sys.stdin.read()
+        else:
+            with open(input_path, "r", encoding="utf-8") as handle:
+                raw = handle.read()
+        data = json.loads(raw)
+    else:
+        data = run_codexbar_cost(provider)
+
+    if isinstance(data, dict):
+        return data
+
+    if isinstance(data, list):
+        for entry in data:
+            if isinstance(entry, dict) and entry.get("provider") == provider:
+                return entry
+        raise RuntimeError(f"Provider '{provider}' not found in codexbar payload.")
+
+    raise RuntimeError("Unsupported JSON input format.")
+
+
+@dataclass
+class ModelCost:
+    model: str
+    cost: float
+
+
+def parse_daily_entries(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+    daily = payload.get("daily")
+    if not daily:
+        return []
+    if not isinstance(daily, list):
+        return []
+    return [entry for entry in daily if isinstance(entry, dict)]
+
+
+def parse_date(value: str) -> Optional[date]:
+    try:
+        return datetime.strptime(value, "%Y-%m-%d").date()
+    except Exception:
+        return None
+
+
+def filter_by_days(entries: List[Dict[str, Any]], days: Optional[int]) -> List[Dict[str, Any]]:
+    if not days:
+        return entries
+    cutoff = date.today() - timedelta(days=days - 1)
+    filtered: List[Dict[str, Any]] = []
+    for entry in entries:
+        day = entry.get("date")
+        if not isinstance(day, str):
+            continue
+        parsed = parse_date(day)
+        if parsed and parsed >= cutoff:
+            filtered.append(entry)
+    return filtered
+
+
+def aggregate_costs(entries: Iterable[Dict[str, Any]]) -> Dict[str, float]:
+    totals: Dict[str, float] = {}
+    for entry in entries:
+        breakdowns = entry.get("modelBreakdowns")
+        if not breakdowns:
+            continue
+        if not isinstance(breakdowns, list):
+            continue
+        for item in breakdowns:
+            if not isinstance(item, dict):
+                continue
+            model = item.get("modelName")
+            cost = item.get("cost")
+            if not isinstance(model, str):
+                continue
+            if not isinstance(cost, (int, float)):
+                continue
+            totals[model] = totals.get(model, 0.0) + float(cost)
+    return totals
+
+
+def pick_current_model(entries: List[Dict[str, Any]]) -> Tuple[Optional[str], Optional[str]]:
+    if not entries:
+        return None, None
+    sorted_entries = sorted(
+        entries,
+        key=lambda entry: entry.get("date") or "",
+    )
+    for entry in reversed(sorted_entries):
+        breakdowns = entry.get("modelBreakdowns")
+        if isinstance(breakdowns, list) and breakdowns:
+            scored: List[ModelCost] = []
+            for item in breakdowns:
+                if not isinstance(item, dict):
+                    continue
+                model = item.get("modelName")
+                cost = item.get("cost")
+                if isinstance(model, str) and isinstance(cost, (int, float)):
+                    scored.append(ModelCost(model=model, cost=float(cost)))
+            if scored:
+                scored.sort(key=lambda item: item.cost, reverse=True)
+                return scored[0].model, entry.get("date") if isinstance(entry.get("date"), str) else None
+        models_used = entry.get("modelsUsed")
+        if isinstance(models_used, list) and models_used:
+            last = models_used[-1]
+            if isinstance(last, str):
+                return last, entry.get("date") if isinstance(entry.get("date"), str) else None
+    return None, None
+
+
+def usd(value: Optional[float]) -> str:
+    if value is None:
+        return "—"
+    return f"${value:,.2f}"
+
+
+def latest_day_cost(entries: List[Dict[str, Any]], model: str) -> Tuple[Optional[str], Optional[float]]:
+    if not entries:
+        return None, None
+    sorted_entries = sorted(
+        entries,
+        key=lambda entry: entry.get("date") or "",
+    )
+    for entry in reversed(sorted_entries):
+        breakdowns = entry.get("modelBreakdowns")
+        if not isinstance(breakdowns, list):
+            continue
+        for item in breakdowns:
+            if not isinstance(item, dict):
+                continue
+            if item.get("modelName") == model:
+                cost = item.get("cost") if isinstance(item.get("cost"), (int, float)) else None
+                day = entry.get("date") if isinstance(entry.get("date"), str) else None
+                return day, float(cost) if cost is not None else None
+    return None, None
+
+
+def render_text_current(
+    provider: str,
+    model: str,
+    latest_date: Optional[str],
+    total_cost: Optional[float],
+    latest_cost: Optional[float],
+    latest_cost_date: Optional[str],
+    entry_count: int,
+) -> str:
+    lines = [f"Provider: {provider}", f"Current model: {model}"]
+    if latest_date:
+        lines.append(f"Latest model date: {latest_date}")
+    lines.append(f"Total cost (rows): {usd(total_cost)}")
+    if latest_cost_date:
+        lines.append(f"Latest day cost: {usd(latest_cost)} ({latest_cost_date})")
+    lines.append(f"Daily rows: {entry_count}")
+    return "\n".join(lines)
+
+
+def render_text_all(provider: str, totals: Dict[str, float]) -> str:
+    lines = [f"Provider: {provider}", "Models:"]
+    for model, cost in sorted(totals.items(), key=lambda item: item[1], reverse=True):
+        lines.append(f"- {model}: {usd(cost)}")
+    return "\n".join(lines)
+
+
+def build_json_current(
+    provider: str,
+    model: str,
+    latest_date: Optional[str],
+    total_cost: Optional[float],
+    latest_cost: Optional[float],
+    latest_cost_date: Optional[str],
+    entry_count: int,
+) -> Dict[str, Any]:
+    return {
+        "provider": provider,
+        "mode": "current",
+        "model": model,
+        "latestModelDate": latest_date,
+        "totalCostUSD": total_cost,
+        "latestDayCostUSD": latest_cost,
+        "latestDayCostDate": latest_cost_date,
+        "dailyRowCount": entry_count,
+    }
+
+
+def build_json_all(provider: str, totals: Dict[str, float]) -> Dict[str, Any]:
+    return {
+        "provider": provider,
+        "mode": "all",
+        "models": [
+            {"model": model, "totalCostUSD": cost}
+            for model, cost in sorted(totals.items(), key=lambda item: item[1], reverse=True)
+        ],
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Summarize CodexBar model usage from local cost logs.")
+    parser.add_argument("--provider", choices=["codex", "claude"], default="codex")
+    parser.add_argument("--mode", choices=["current", "all"], default="current")
+    parser.add_argument("--model", help="Explicit model name to report instead of auto-current.")
+    parser.add_argument("--input", help="Path to codexbar cost JSON (or '-' for stdin).")
+    parser.add_argument("--days", type=int, help="Limit to last N days (based on daily rows).")
+    parser.add_argument("--format", choices=["text", "json"], default="text")
+    parser.add_argument("--pretty", action="store_true", help="Pretty-print JSON output.")
+
+    args = parser.parse_args()
+
+    try:
+        payload = load_payload(args.input, args.provider)
+    except Exception as exc:
+        eprint(str(exc))
+        return 1
+
+    entries = parse_daily_entries(payload)
+    entries = filter_by_days(entries, args.days)
+
+    if args.mode == "current":
+        model = args.model
+        latest_date = None
+        if not model:
+            model, latest_date = pick_current_model(entries)
+        if not model:
+            eprint("No model data found in codexbar cost payload.")
+            return 2
+        totals = aggregate_costs(entries)
+        total_cost = totals.get(model)
+        latest_cost_date, latest_cost = latest_day_cost(entries, model)
+
+        if args.format == "json":
+            payload_out = build_json_current(
+                provider=args.provider,
+                model=model,
+                latest_date=latest_date,
+                total_cost=total_cost,
+                latest_cost=latest_cost,
+                latest_cost_date=latest_cost_date,
+                entry_count=len(entries),
+            )
+            indent = 2 if args.pretty else None
+            print(json.dumps(payload_out, indent=indent, sort_keys=args.pretty))
+        else:
+            print(
+                render_text_current(
+                    provider=args.provider,
+                    model=model,
+                    latest_date=latest_date,
+                    total_cost=total_cost,
+                    latest_cost=latest_cost,
+                    latest_cost_date=latest_cost_date,
+                    entry_count=len(entries),
+                )
+            )
+        return 0
+
+    totals = aggregate_costs(entries)
+    if not totals:
+        eprint("No model breakdowns found in codexbar cost payload.")
+        return 2
+
+    if args.format == "json":
+        payload_out = build_json_all(provider=args.provider, totals=totals)
+        indent = 2 if args.pretty else None
+        print(json.dumps(payload_out, indent=indent, sort_keys=args.pretty))
+    else:
+        print(render_text_all(provider=args.provider, totals=totals))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/moltbook-interact/.clawhub/origin.json

@@ -0,0 +1,7 @@
+{
+  "version": 1,
+  "registry": "https://clawhub.ai",
+  "slug": "moltbook-interact",
+  "installedVersion": "1.0.1",
+  "installedAt": 1770236761224
+}