chore: archive mac mini automation baseline
This commit is contained in:
Adolfo Reyna
+20
@@ -0,0 +1,20 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Fetch ICS into local cache. Watchdog: silent on success, error only on fail.
|
||||
Replaces old Pi cron: 0 * * * * calendar_fetch.py <ics_url>
|
||||
Now used as fallback when Mac Mini is unreachable.
|
||||
"""
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
result = subprocess.run(
|
||||
["uv", "run", "reyna-cli", "calendar", "fetch", "--json"],
|
||||
cwd="/home/adolforeyna/reyna-cli",
|
||||
text=True,
|
||||
capture_output=True,
|
||||
)
|
||||
if result.returncode != 0:
|
||||
# Print so Hermes delivery shows error (non-empty stdout = delivered)
|
||||
print(result.stdout[-2000:] if result.stdout else "")
|
||||
print(result.stderr[-2000:] if result.stderr else "", file=sys.stderr)
|
||||
sys.exit(1)
|
||||
# Success -> silent (no delivery), watchdog pattern
|
||||
Executable
+148
@@ -0,0 +1,148 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Silent watchdog for Chiapas flight prices.
|
||||
|
||||
Checks the user's preferred KAYAK search URL and only prints an alert when a
|
||||
meaningful price drop is detected. Empty stdout means no WhatsApp message.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
URL = "https://www.kayak.com/flights/MIA,MCO-TGZ/2026-09-21/2026-10-09/2adults/children-5-8?ucs=uwkx32&sort=bestflight_a"
|
||||
STATE_PATH = Path.home() / ".hermes" / "state" / "chiapas_flight_monitor.json"
|
||||
CHROMIUM = "/snap/bin/chromium"
|
||||
|
||||
# Alert policy: establish a baseline silently, then alert only if the best price
|
||||
# is materially better than what we have seen before.
|
||||
DROP_PERCENT = 0.20 # at least 20% lower than baseline/best seen
|
||||
DROP_ABSOLUTE = 300 # or at least $300 lower for the searched party
|
||||
VERY_GOOD_TOTAL = 450 # always alert at or below this displayed fare
|
||||
MIN_REASONABLE = 400 # ignore UI noise like baggage/filter slider prices
|
||||
MAX_REASONABLE = 8000 # ignore unrelated large numbers
|
||||
|
||||
|
||||
def load_state():
|
||||
if STATE_PATH.exists():
|
||||
try:
|
||||
return json.loads(STATE_PATH.read_text())
|
||||
except Exception:
|
||||
return {}
|
||||
return {}
|
||||
|
||||
|
||||
def save_state(state):
|
||||
STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
|
||||
STATE_PATH.write_text(json.dumps(state, indent=2, sort_keys=True))
|
||||
|
||||
|
||||
def fetch_html():
|
||||
if not Path(CHROMIUM).exists():
|
||||
return ""
|
||||
with tempfile.NamedTemporaryFile(prefix="chiapas_kayak_", suffix=".html", delete=False) as tmp:
|
||||
out_path = tmp.name
|
||||
try:
|
||||
cmd = [
|
||||
CHROMIUM,
|
||||
"--headless",
|
||||
"--disable-gpu",
|
||||
"--no-sandbox",
|
||||
"--disable-dev-shm-usage",
|
||||
"--user-agent=Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/120 Safari/537.36",
|
||||
"--virtual-time-budget=60000",
|
||||
"--dump-dom",
|
||||
URL,
|
||||
]
|
||||
result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, timeout=120)
|
||||
return result.stdout or ""
|
||||
except Exception:
|
||||
return ""
|
||||
finally:
|
||||
try:
|
||||
os.unlink(out_path)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
def extract_prices(html):
|
||||
# KAYAK may render prices as visible text or escaped JSON. Keep this simple
|
||||
# and conservative: only currency-looking amounts in a plausible full-party range.
|
||||
raw = re.findall(r"\$\s*([0-9][0-9,]{2,5})", html)
|
||||
prices = []
|
||||
for s in raw:
|
||||
try:
|
||||
val = int(s.replace(",", ""))
|
||||
except ValueError:
|
||||
continue
|
||||
if MIN_REASONABLE <= val <= MAX_REASONABLE:
|
||||
prices.append(val)
|
||||
return sorted(set(prices))
|
||||
|
||||
|
||||
def main():
|
||||
now = datetime.now(timezone.utc).isoformat()
|
||||
state = load_state()
|
||||
html = fetch_html()
|
||||
prices = extract_prices(html)
|
||||
|
||||
state["last_checked_utc"] = now
|
||||
state["url"] = URL
|
||||
|
||||
if not prices:
|
||||
state["last_status"] = "no_parseable_prices"
|
||||
save_state(state)
|
||||
return 0
|
||||
|
||||
current = min(prices)
|
||||
state["last_prices_seen"] = prices[:10]
|
||||
state["last_lowest"] = current
|
||||
|
||||
baseline = state.get("baseline_lowest")
|
||||
best_seen = state.get("best_seen")
|
||||
|
||||
if baseline is None:
|
||||
state["baseline_lowest"] = current
|
||||
state["best_seen"] = current
|
||||
state["last_status"] = "baseline_set_silent"
|
||||
save_state(state)
|
||||
return 0
|
||||
|
||||
if best_seen is None or current < best_seen:
|
||||
state["best_seen"] = current
|
||||
|
||||
threshold_from_baseline = int(baseline * (1 - DROP_PERCENT))
|
||||
threshold_from_best = int(best_seen * (1 - DROP_PERCENT)) if best_seen else threshold_from_baseline
|
||||
absolute_threshold = max(0, baseline - DROP_ABSOLUTE)
|
||||
|
||||
should_alert = (
|
||||
current <= VERY_GOOD_TOTAL
|
||||
or current <= threshold_from_baseline
|
||||
or current <= threshold_from_best
|
||||
or current <= absolute_threshold
|
||||
)
|
||||
|
||||
already_alerted_at = state.get("last_alert_price")
|
||||
if should_alert and (already_alerted_at is None or current < already_alerted_at):
|
||||
state["last_alert_price"] = current
|
||||
state["last_status"] = "alerted"
|
||||
save_state(state)
|
||||
print(
|
||||
"Chiapas flight price alert: KAYAK is showing a notably better fare.\n"
|
||||
f"Route/search: MIA or MCO → TGZ, Sept 21–Oct 9, 2026, family search.\n"
|
||||
f"Lowest price I could parse today: ${current:,}.\n"
|
||||
f"Baseline: ${baseline:,}. Best previously seen: ${best_seen:,}.\n"
|
||||
f"Check/book here: {URL}"
|
||||
)
|
||||
return 0
|
||||
|
||||
state["last_status"] = "checked_no_alert"
|
||||
save_state(state)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+263
@@ -0,0 +1,263 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Collect Deco clients, persist snapshots to MongoDB, and maintain local network history.
|
||||
|
||||
This script is intended to be run by Hermes cron via the companion shell wrapper
|
||||
`deco_network_watchdog.sh` every 5 minutes. It is deliberately non-agentic and
|
||||
prints nothing on success so no_agent cron runs stay silent.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from collections import defaultdict
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
REYNA_DIR = Path("/home/adolforeyna/reyna-cli")
|
||||
STATE_DIR = Path.home() / ".hermes" / "deco_network"
|
||||
LAST_STATE_FILE = STATE_DIR / "last_state.json"
|
||||
HISTOGRAM_FILE = STATE_DIR / "histogram_1h.json"
|
||||
DECO_CHANGES_FILE = STATE_DIR / "linked_deco_changes.jsonl"
|
||||
NEW_DEVICES_FILE = STATE_DIR / "new_devices.jsonl"
|
||||
FETCH_ERRORS_FILE = STATE_DIR / "fetch_errors.jsonl"
|
||||
SNAPSHOT_FILE = STATE_DIR / "latest_snapshot.json"
|
||||
MONGO_DB = os.environ.get("DECO_NETWORK_MONGO_DB", "reyna_home")
|
||||
MONGO_COLLECTION = os.environ.get("DECO_NETWORK_MONGO_COLLECTION", "deco_client_snapshots")
|
||||
WINDOW = timedelta(hours=1)
|
||||
FETCH_TIMEOUT_SECONDS = 45
|
||||
|
||||
|
||||
def utc_now() -> datetime:
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def iso(dt: datetime) -> str:
|
||||
return dt.isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def parse_iso(value: str) -> datetime:
|
||||
if value.endswith("Z"):
|
||||
value = value[:-1] + "+00:00"
|
||||
return datetime.fromisoformat(value)
|
||||
|
||||
|
||||
def load_json(path: Path, default: Any) -> Any:
|
||||
try:
|
||||
if path.exists():
|
||||
return json.loads(path.read_text(encoding="utf-8"))
|
||||
except Exception:
|
||||
# Keep the collector running even if a local state file is corrupt.
|
||||
backup = path.with_suffix(path.suffix + f".corrupt-{int(utc_now().timestamp())}")
|
||||
try:
|
||||
path.replace(backup)
|
||||
except Exception:
|
||||
pass
|
||||
return default
|
||||
|
||||
|
||||
def atomic_write_json(path: Path, data: Any) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
tmp = path.with_name(path.name + ".tmp")
|
||||
tmp.write_text(json.dumps(data, indent=2, sort_keys=True, default=str), encoding="utf-8")
|
||||
os.replace(tmp, path)
|
||||
|
||||
|
||||
def append_jsonl(path: Path, records: list[dict[str, Any]]) -> None:
|
||||
if not records:
|
||||
return
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
with path.open("a", encoding="utf-8") as handle:
|
||||
for record in records:
|
||||
handle.write(json.dumps(record, sort_keys=True, default=str) + "\n")
|
||||
|
||||
|
||||
def fetch_deco_clients() -> tuple[list[dict[str, Any]], dict[str, Any]]:
|
||||
# The shell wrapper runs this under `uv run python` from REYNA_DIR, so the
|
||||
# project dependencies are available. Query Deco directly from reyna-cli
|
||||
# instead of depending on the Mac mini MCP endpoint.
|
||||
sys.path.insert(0, str(REYNA_DIR / "src"))
|
||||
from reyna_cli.deco_direct import DecoDirectClient
|
||||
|
||||
data = DecoDirectClient().list_clients()
|
||||
clients = data.get("clients") if isinstance(data, dict) else None
|
||||
if not isinstance(clients, list):
|
||||
raise RuntimeError("deco clients result did not contain clients list")
|
||||
return clients, data
|
||||
|
||||
|
||||
def device_key(client: dict[str, Any]) -> str:
|
||||
return str(client.get("mac") or client.get("ip") or client.get("hostname") or "unknown")
|
||||
|
||||
|
||||
def compact_device(client: dict[str, Any]) -> dict[str, Any]:
|
||||
keys = [
|
||||
"hostname",
|
||||
"mac",
|
||||
"ip",
|
||||
"connection",
|
||||
"interface",
|
||||
"active",
|
||||
"linkedDecoMac",
|
||||
"linkedDecoName",
|
||||
"linkedDecoRole",
|
||||
]
|
||||
return {key: client.get(key) for key in keys if client.get(key) is not None}
|
||||
|
||||
|
||||
def maintain_local_files(now: datetime, clients: list[dict[str, Any]], raw_result: dict[str, Any]) -> None:
|
||||
now_s = iso(now)
|
||||
current: dict[str, dict[str, Any]] = {device_key(client): compact_device(client) for client in clients}
|
||||
last_state = load_json(LAST_STATE_FILE, {})
|
||||
if not isinstance(last_state, dict):
|
||||
last_state = {}
|
||||
|
||||
deco_changes: list[dict[str, Any]] = []
|
||||
new_devices: list[dict[str, Any]] = []
|
||||
for key, current_device in current.items():
|
||||
previous = last_state.get(key)
|
||||
if not previous:
|
||||
new_devices.append({"timestamp": now_s, "device_key": key, "device": current_device})
|
||||
continue
|
||||
old_deco = previous.get("linkedDecoName")
|
||||
new_deco = current_device.get("linkedDecoName")
|
||||
if old_deco != new_deco:
|
||||
deco_changes.append(
|
||||
{
|
||||
"timestamp": now_s,
|
||||
"device_key": key,
|
||||
"hostname": current_device.get("hostname"),
|
||||
"mac": current_device.get("mac"),
|
||||
"ip": current_device.get("ip"),
|
||||
"old_linkedDecoName": old_deco,
|
||||
"new_linkedDecoName": new_deco,
|
||||
"old_linkedDecoMac": previous.get("linkedDecoMac"),
|
||||
"new_linkedDecoMac": current_device.get("linkedDecoMac"),
|
||||
}
|
||||
)
|
||||
|
||||
append_jsonl(DECO_CHANGES_FILE, deco_changes)
|
||||
append_jsonl(NEW_DEVICES_FILE, new_devices)
|
||||
atomic_write_json(LAST_STATE_FILE, current)
|
||||
|
||||
histogram = load_json(HISTOGRAM_FILE, {"buckets": []})
|
||||
buckets = histogram.get("buckets", []) if isinstance(histogram, dict) else []
|
||||
cutoff = now - WINDOW
|
||||
kept_buckets = []
|
||||
for bucket in buckets:
|
||||
try:
|
||||
if parse_iso(bucket["timestamp"]) >= cutoff:
|
||||
kept_buckets.append(bucket)
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
bucket_devices = sorted(current)
|
||||
kept_buckets.append(
|
||||
{
|
||||
"timestamp": now_s,
|
||||
"client_count": len(clients),
|
||||
"devices": bucket_devices,
|
||||
"linkedDecoCounts": dict(sorted(_counts(c.get("linkedDecoName") for c in current.values()).items())),
|
||||
}
|
||||
)
|
||||
|
||||
device_summary: dict[str, dict[str, Any]] = {}
|
||||
per_device_buckets: dict[str, list[str]] = defaultdict(list)
|
||||
for bucket in kept_buckets:
|
||||
for key in bucket.get("devices", []):
|
||||
per_device_buckets[key].append(bucket.get("timestamp"))
|
||||
for key, seen_timestamps in sorted(per_device_buckets.items()):
|
||||
device_summary[key] = {
|
||||
"seen_count": len(seen_timestamps),
|
||||
"first_seen": seen_timestamps[0],
|
||||
"last_seen": seen_timestamps[-1],
|
||||
"currently_present": key in current,
|
||||
"device": current.get(key) or last_state.get(key) or {},
|
||||
}
|
||||
|
||||
atomic_write_json(
|
||||
HISTOGRAM_FILE,
|
||||
{
|
||||
"generated_at": now_s,
|
||||
"window_minutes": 60,
|
||||
"bucket_interval_minutes": 5,
|
||||
"bucket_count": len(kept_buckets),
|
||||
"current_client_count": len(clients),
|
||||
"current_devices": bucket_devices,
|
||||
"new_devices_this_run": [record["device"] for record in new_devices],
|
||||
"linkedDeco_changes_this_run": deco_changes,
|
||||
"devices": device_summary,
|
||||
"buckets": kept_buckets,
|
||||
},
|
||||
)
|
||||
atomic_write_json(
|
||||
SNAPSHOT_FILE,
|
||||
{
|
||||
"timestamp": now_s,
|
||||
"client_count": len(clients),
|
||||
"clients": clients,
|
||||
"decos": raw_result.get("decos", []),
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def _counts(values: Any) -> dict[str, int]:
|
||||
counts: dict[str, int] = defaultdict(int)
|
||||
for value in values:
|
||||
counts[str(value or "unknown")] += 1
|
||||
return counts
|
||||
|
||||
|
||||
def insert_mongo_snapshot(now: datetime, clients: list[dict[str, Any]], raw_result: dict[str, Any]) -> None:
|
||||
sys.path.insert(0, str(REYNA_DIR / "src"))
|
||||
from reyna_cli.mongo_direct import MongoDirectClient
|
||||
|
||||
now_s = iso(now)
|
||||
mongo = MongoDirectClient(timeout_ms=5000)
|
||||
collection = mongo.client[MONGO_DB][MONGO_COLLECTION]
|
||||
collection.insert_one(
|
||||
{
|
||||
"timestamp": now,
|
||||
"timestamp_iso": now_s,
|
||||
"source": "reyna-cli macmini deco clients",
|
||||
"client_count": len(clients),
|
||||
"clients": clients,
|
||||
"decos": raw_result.get("decos", []),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
now = utc_now()
|
||||
STATE_DIR.mkdir(parents=True, exist_ok=True)
|
||||
try:
|
||||
clients, raw_result = fetch_deco_clients()
|
||||
except Exception as exc:
|
||||
# Treat a temporarily unreachable Mac mini / MCP endpoint as a data
|
||||
# collection miss, not as a cron failure. no_agent cron jobs alert on
|
||||
# non-zero exits, and Wi-Fi/LAN outages would otherwise spam WhatsApp.
|
||||
append_jsonl(
|
||||
FETCH_ERRORS_FILE,
|
||||
[
|
||||
{
|
||||
"timestamp": iso(now),
|
||||
"stage": "fetch_deco_clients",
|
||||
"error_type": type(exc).__name__,
|
||||
"error": str(exc),
|
||||
}
|
||||
],
|
||||
)
|
||||
return 0
|
||||
insert_mongo_snapshot(now, clients, raw_result)
|
||||
maintain_local_files(now, clients, raw_result)
|
||||
return 0
|
||||
except Exception as exc:
|
||||
print(f"deco_network_watchdog error: {type(exc).__name__}: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
unset VIRTUAL_ENV
|
||||
cd /home/adolforeyna/reyna-cli
|
||||
exec uv run python /home/adolforeyna/.hermes/scripts/deco_network_watchdog.py
|
||||
@@ -0,0 +1,20 @@
|
||||
#!/usr/bin/env bash
|
||||
set -u
|
||||
URLS=("http://192.168.68.123/api/mcp" "http://192.168.68.137/api/mcp")
|
||||
for URL in "${URLS[@]}"; do
|
||||
curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"clear","method":"tools/call","params":{"name":"clear_screen","arguments":{"color":0}}}' >/tmp/esp32_happy_clear.out 2>&1 || true
|
||||
out=$(curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"draw","method":"tools/call","params":{"name":"draw_text","arguments":{"text":"😊","x":120,"y":105,"size":4}}}' 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Sent 😊 to $URL"
|
||||
exit 0
|
||||
fi
|
||||
out=$(curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"draw2","method":"tools/call","params":{"name":"draw_text","arguments":{"text":":)","x":130,"y":105,"size":4}}}' 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Sent :) fallback to $URL"
|
||||
exit 0
|
||||
fi
|
||||
echo "Failed $URL: $out"
|
||||
done
|
||||
exit 1
|
||||
@@ -0,0 +1,35 @@
|
||||
#!/usr/bin/env bash
|
||||
set -u
|
||||
URLS=("http://192.168.68.123/api/mcp" "http://192.168.68.137/api/mcp")
|
||||
for URL in "${URLS[@]}"; do
|
||||
echo "Trying $URL"
|
||||
# First test audio path with a tone if available.
|
||||
for tone_args in '{"frequency":660,"duration_ms":180,"volume":80}' '{"freq":660,"duration":180,"volume":80}'; do
|
||||
out=$(curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data "{\"jsonrpc\":\"2.0\",\"id\":\"tone\",\"method\":\"tools/call\",\"params\":{\"name\":\"play_tone\",\"arguments\":$tone_args}}" 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Tone OK on $URL"
|
||||
break
|
||||
fi
|
||||
done
|
||||
# Try direct text/speak-style MCP tools if firmware exposes them.
|
||||
for name in speak text_to_speech say play_text; do
|
||||
payload=$(printf '{"jsonrpc":"2.0","id":"say-hi","method":"tools/call","params":{"name":"%s","arguments":{"text":"hi","message":"hi","volume":80}}}' "$name")
|
||||
out=$(curl -fsS -m 8 -X POST "$URL" -H 'Content-Type: application/json' --data "$payload" 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Said hi on $URL using MCP tool $name"
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
# Visual fallback still uses MCP tools to confirm the device path.
|
||||
curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"clear","method":"tools/call","params":{"name":"clear_screen","arguments":{"color":0}}}' >/dev/null 2>&1 || true
|
||||
out=$(curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"draw","method":"tools/call","params":{"name":"draw_text","arguments":{"text":"hi","x":130,"y":105,"size":4}}}' 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Displayed hi on $URL using MCP draw_text"
|
||||
exit 0
|
||||
fi
|
||||
echo "Failed $URL: $out"
|
||||
done
|
||||
exit 1
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/usr/bin/env bash
|
||||
set -u
|
||||
URLS=("http://192.168.68.123/api/mcp" "http://192.168.68.137/api/mcp")
|
||||
for URL in "${URLS[@]}"; do
|
||||
for name in speak text_to_speech say play_text; do
|
||||
payload=$(printf '{"jsonrpc":"2.0","id":"say-no","method":"tools/call","params":{"name":"%s","arguments":{"text":"no","message":"no","volume":80}}}' "$name")
|
||||
out=$(curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data "$payload" 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Said no on $URL using $name"
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"clear","method":"tools/call","params":{"name":"clear_screen","arguments":{"color":0}}}' >/dev/null 2>&1 || true
|
||||
out=$(curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"draw","method":"tools/call","params":{"name":"draw_text","arguments":{"text":"no","x":130,"y":105,"size":4}}}' 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Displayed no on $URL"
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
exit 1
|
||||
@@ -0,0 +1,76 @@
|
||||
#!/usr/bin/env python3
|
||||
import concurrent.futures, json, re, socket, time, urllib.request
|
||||
|
||||
def rpc(url, method, params=None, timeout=4):
|
||||
payload = json.dumps({'jsonrpc':'2.0','id':str(time.time()),'method':method,'params':params or {}}).encode()
|
||||
req = urllib.request.Request(url, data=payload, headers={'Content-Type':'application/json'}, method='POST')
|
||||
with urllib.request.urlopen(req, timeout=timeout) as r:
|
||||
return json.loads(r.read().decode('utf-8','replace'))
|
||||
|
||||
def call(url, name, args, timeout=4):
|
||||
return rpc(url, 'tools/call', {'name': name, 'arguments': args}, timeout=timeout)
|
||||
|
||||
def discover_udp():
|
||||
found=set()
|
||||
sock=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
sock.settimeout(0.35)
|
||||
for host in ('255.255.255.255','192.168.68.255'):
|
||||
try: sock.sendto(b'DISCOVER_SCREEN',(host,5000))
|
||||
except Exception: pass
|
||||
end=time.time()+1.0
|
||||
while time.time()<end:
|
||||
try:
|
||||
data,addr=sock.recvfrom(512)
|
||||
text=data.decode('utf-8','replace')
|
||||
m=re.search(r'SCREEN_IP_(\d+)', text)
|
||||
port=int(m.group(1)) if m else 80
|
||||
found.add((addr[0],port))
|
||||
except Exception:
|
||||
pass
|
||||
return found
|
||||
|
||||
def candidates():
|
||||
pairs=discover_udp()
|
||||
pairs.update({('127.0.0.1',8080),('192.168.68.123',80),('192.168.68.126',8080)})
|
||||
return [f'http://{ip}:{port}/api/mcp' if port!=80 else f'http://{ip}/api/mcp' for ip,port in sorted(pairs)]
|
||||
|
||||
def probe(url):
|
||||
try:
|
||||
res=rpc(url,'tools/list',{},timeout=0.9)
|
||||
names=[t.get('name','') for t in res.get('result',{}).get('tools',[])]
|
||||
if 'draw_text' in names:
|
||||
return url,names
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=16) as ex:
|
||||
targets=[r for r in ex.map(probe, candidates()) if r]
|
||||
seen=set(); uniq=[]
|
||||
for url,names in targets:
|
||||
key=re.sub(r'^http://','',url).split('/')[0]
|
||||
if key not in seen:
|
||||
seen.add(key); uniq.append((url,names))
|
||||
if len(uniq)>=3: break
|
||||
|
||||
lines=[f'Found {len(uniq)} target(s): '+', '.join(u for u,_ in uniq)]
|
||||
for url,names in uniq:
|
||||
try:
|
||||
if 'clear_screen' in names:
|
||||
try: call(url,'clear_screen',{'color':0},timeout=3)
|
||||
except Exception: pass
|
||||
res=call(url,'draw_text',{'text':'Hi','x':115,'y':95,'size':5,'color':65535},timeout=5)
|
||||
if 'error' in res:
|
||||
res=call(url,'draw_text',{'text':'Hi','x':115,'y':95,'size':5},timeout=5)
|
||||
if 'error' in res:
|
||||
lines.append('FAIL '+url+' '+json.dumps(res.get('error')))
|
||||
else:
|
||||
lines.append('OK '+url+' draw_text Hi')
|
||||
except Exception as e:
|
||||
lines.append(f'FAIL {url} {type(e).__name__}: {e}')
|
||||
|
||||
output='\n'.join(lines)+'\n'
|
||||
open('/tmp/esp32_hi_result.txt','w').write(output)
|
||||
print(output, end='')
|
||||
if not uniq or any(l.startswith('FAIL') for l in lines):
|
||||
raise SystemExit(1)
|
||||
+163
@@ -0,0 +1,163 @@
|
||||
#!/usr/bin/env python3
|
||||
import base64, concurrent.futures, json, os, re, socket, struct, time, urllib.request, urllib.error
|
||||
from pathlib import Path
|
||||
|
||||
OUT = Path('/tmp/esp32_thumbs_result.txt')
|
||||
W,H = 320,240
|
||||
|
||||
def rpc(url, method, params=None, timeout=4):
|
||||
payload = json.dumps({'jsonrpc':'2.0','id':str(time.time()),'method':method,'params':params or {}}).encode()
|
||||
req = urllib.request.Request(url, data=payload, headers={'Content-Type':'application/json'}, method='POST')
|
||||
with urllib.request.urlopen(req, timeout=timeout) as r:
|
||||
txt = r.read().decode('utf-8','replace')
|
||||
try:
|
||||
return json.loads(txt)
|
||||
except Exception:
|
||||
return {'raw': txt}
|
||||
|
||||
def call(url, name, args, timeout=7):
|
||||
return rpc(url, 'tools/call', {'name': name, 'arguments': args}, timeout=timeout)
|
||||
|
||||
def discover_udp():
|
||||
found = set()
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
|
||||
sock.settimeout(0.45)
|
||||
for host in ['255.255.255.255','192.168.68.255']:
|
||||
try: sock.sendto(b'DISCOVER_SCREEN', (host, 5000))
|
||||
except Exception: pass
|
||||
end = time.time() + 1.2
|
||||
while time.time() < end:
|
||||
try:
|
||||
data, addr = sock.recvfrom(512)
|
||||
text = data.decode('utf-8','replace')
|
||||
m = re.search(r'SCREEN_IP_(\d+)', text)
|
||||
port = int(m.group(1)) if m else 80
|
||||
found.add((addr[0], port))
|
||||
except Exception:
|
||||
pass
|
||||
return found
|
||||
|
||||
def candidate_urls():
|
||||
pairs = set(discover_udp())
|
||||
# Add likely LAN hosts; the user said three devices, so find live MCP responders instead of stale aliases.
|
||||
for last in range(100, 151):
|
||||
pairs.add((f'192.168.68.{last}', 80))
|
||||
# Local desktop-style clients if present.
|
||||
for ip,port in [('127.0.0.1',8080),('192.168.68.150',8080),('192.168.68.129',8080)]:
|
||||
pairs.add((ip,port))
|
||||
return [f'http://{ip}:{port}/api/mcp' if port != 80 else f'http://{ip}/api/mcp' for ip,port in sorted(pairs)]
|
||||
|
||||
def probe(url):
|
||||
try:
|
||||
res = rpc(url, 'tools/list', {}, timeout=0.9)
|
||||
tools = res.get('result',{}).get('tools', [])
|
||||
names = [t.get('name','') for t in tools]
|
||||
if any(n in names for n in ['draw_image','draw_raw_rgb565','draw_color_bmp','draw_text']):
|
||||
return url, names
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
def make_pbm():
|
||||
pix = [[0]*W for _ in range(H)]
|
||||
def rect(x0,y0,x1,y1,v=1):
|
||||
for y in range(max(0,y0), min(H,y1)):
|
||||
row = pix[y]
|
||||
for x in range(max(0,x0), min(W,x1)):
|
||||
row[x] = v
|
||||
# chunky black thumbs-up silhouette centered
|
||||
rect(75,130,125,185) # wrist
|
||||
rect(120,95,165,185) # palm
|
||||
rect(145,75,175,115) # raised thumb
|
||||
rect(160,60,190,92) # thumb tip
|
||||
rect(165,100,235,122) # fingers
|
||||
rect(165,125,225,145)
|
||||
rect(165,148,215,168)
|
||||
rect(165,171,205,188)
|
||||
# white cuts between fingers
|
||||
rect(166,122,225,126,0); rect(166,145,218,149,0); rect(166,168,210,172,0)
|
||||
header = f'P4\n{W} {H}\n'.encode()
|
||||
body = bytearray()
|
||||
for y in range(H):
|
||||
for x0 in range(0,W,8):
|
||||
b=0
|
||||
for i in range(8):
|
||||
if x0+i < W and pix[y][x0+i]: b |= 1 << (7-i)
|
||||
body.append(b)
|
||||
return base64.b64encode(header+body).decode()
|
||||
|
||||
def make_rgb565(w=200,h=160):
|
||||
def rgb565(r,g,b): return ((r&248)<<8)|((g&252)<<3)|(b>>3)
|
||||
bg=rgb565(20,35,70); yellow=rgb565(245,190,45); dark=rgb565(80,55,10)
|
||||
pix=[bg]*(w*h)
|
||||
def rect(x0,y0,x1,y1,c):
|
||||
for y in range(max(0,y0), min(h,y1)):
|
||||
off=y*w
|
||||
for x in range(max(0,x0), min(w,x1)): pix[off+x]=c
|
||||
rect(28,90,68,135,yellow); rect(65,58,105,135,yellow); rect(90,35,120,75,yellow); rect(112,22,142,50,yellow)
|
||||
rect(103,62,170,80,yellow); rect(103,84,162,102,yellow); rect(103,106,154,124,yellow); rect(103,128,146,146,yellow)
|
||||
rect(103,81,170,84,dark); rect(103,103,162,106,dark); rect(103,125,154,128,dark)
|
||||
# big-endian bytes
|
||||
raw=bytearray()
|
||||
for p in pix: raw += struct.pack('>H', p)
|
||||
return base64.b64encode(raw).decode(), w, h
|
||||
|
||||
def make_bmp(w=200,h=160):
|
||||
# 24-bit BMP, bottom-up, blue background with yellow thumb
|
||||
rowpad=(4-(w*3)%4)%4
|
||||
data=bytearray()
|
||||
def is_hand(x,y):
|
||||
return (28<=x<68 and 90<=y<135) or (65<=x<105 and 58<=y<135) or (90<=x<120 and 35<=y<75) or (112<=x<142 and 22<=y<50) or (103<=x<170 and 62<=y<80) or (103<=x<162 and 84<=y<102) or (103<=x<154 and 106<=y<124) or (103<=x<146 and 128<=y<146)
|
||||
for y in range(h-1,-1,-1):
|
||||
for x in range(w):
|
||||
if is_hand(x,y): data += bytes([45,190,245])
|
||||
else: data += bytes([70,35,20])
|
||||
data += b'\x00'*rowpad
|
||||
size=54+len(data)
|
||||
header=b'BM'+struct.pack('<IHHI',size,0,0,54)+struct.pack('<IiiHHIIiiII',40,w,h,1,24,0,len(data),2835,2835,0,0)
|
||||
return base64.b64encode(header+data).decode(), w, h
|
||||
|
||||
PBM=make_pbm(); RGB,W2,H2=make_rgb565(); BMP,WB,HB=make_bmp()
|
||||
urls = candidate_urls()
|
||||
with concurrent.futures.ThreadPoolExecutor(max_workers=32) as ex:
|
||||
probed = [r for r in ex.map(probe, urls) if r]
|
||||
# De-dupe IP:port and keep at most the first 3 live screen/MCP devices, matching the request.
|
||||
seen=set(); targets=[]
|
||||
for url,names in probed:
|
||||
key=re.sub(r'^http://','',url).split('/')[0]
|
||||
if key not in seen:
|
||||
seen.add(key); targets.append((url,names))
|
||||
if len(targets)>=3: break
|
||||
|
||||
lines=[f'Found {len(targets)} target(s): '+', '.join(u for u,_ in targets)]
|
||||
for url,names in targets:
|
||||
ok=False; detail=''
|
||||
try: call(url,'clear_screen',{'color':0},timeout=3)
|
||||
except Exception: pass
|
||||
attempts=[]
|
||||
if 'draw_raw_rgb565' in names:
|
||||
attempts.append(('draw_raw_rgb565', {'rgb565_base64':RGB,'x':60,'y':40,'w':W2,'h':H2}))
|
||||
if 'draw_color_bmp' in names:
|
||||
attempts.append(('draw_color_bmp', {'bmp_base64':BMP,'x':60,'y':40}))
|
||||
if 'draw_image' in names:
|
||||
attempts.append(('draw_image', {'pbm_base64':PBM,'x':0,'y':0}))
|
||||
attempts.append(('draw_image', {'image_base64':BMP,'x':60,'y':40,'dither':True}))
|
||||
for name,args in attempts:
|
||||
try:
|
||||
res=call(url,name,args,timeout=9)
|
||||
if 'error' not in res:
|
||||
ok=True; detail=f'{name} ok'; break
|
||||
detail=f'{name} error: {res.get("error")}'
|
||||
except Exception as e:
|
||||
detail=f'{name} exception: {e}'
|
||||
if not ok and 'draw_text' in names:
|
||||
try:
|
||||
res=call(url,'draw_text',{'text':'👍','x':130,'y':105,'size':4},timeout=4)
|
||||
ok='error' not in res; detail='fallback draw_text 👍' if ok else str(res.get('error'))
|
||||
except Exception as e: detail=f'fallback exception: {e}'
|
||||
lines.append(('OK ' if ok else 'FAIL ')+url+' '+detail)
|
||||
|
||||
OUT.write_text('\n'.join(lines)+'\n')
|
||||
print('\n'.join(lines))
|
||||
if not targets or any(l.startswith('FAIL') for l in lines):
|
||||
raise SystemExit(1)
|
||||
@@ -0,0 +1,33 @@
|
||||
#!/usr/bin/env bash
|
||||
set -u
|
||||
URLS=("http://192.168.68.123/api/mcp" "http://192.168.68.137/api/mcp")
|
||||
post() {
|
||||
local url="$1" payload="$2"
|
||||
curl -fsS -m 8 -X POST "$url" -H 'Content-Type: application/json' --data "$payload"
|
||||
}
|
||||
for URL in "${URLS[@]}"; do
|
||||
echo "Trying $URL"
|
||||
tools=$(post "$URL" '{"jsonrpc":"2.0","id":"tools","method":"tools/list","params":{}}' 2>&1) || { echo "tools/list failed: $tools"; continue; }
|
||||
echo "tools/list ok: ${tools:0:600}"
|
||||
# Try common text-to-speech/speak-style tools first, since user said say hi.
|
||||
for name in speak text_to_speech say play_text; do
|
||||
payload=$(printf '{"jsonrpc":"2.0","id":"%s","method":"tools/call","params":{"name":"%s","arguments":{"text":"hi","message":"hi","volume":70}}}' "$name" "$name")
|
||||
out=$(post "$URL" "$payload" 2>&1)
|
||||
rc=$?
|
||||
echo "$name rc=$rc: ${out:0:300}"
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Success: asked $URL to say hi using $name"
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
# Fallback: draw hi on the screen.
|
||||
post "$URL" '{"jsonrpc":"2.0","id":"clear","method":"tools/call","params":{"name":"clear_screen","arguments":{"color":0}}}' >/dev/null 2>&1 || true
|
||||
out=$(post "$URL" '{"jsonrpc":"2.0","id":"draw","method":"tools/call","params":{"name":"draw_text","arguments":{"text":"hi","x":120,"y":105,"size":4}}}' 2>&1)
|
||||
rc=$?
|
||||
echo "draw_text rc=$rc: ${out:0:300}"
|
||||
if [ $rc -eq 0 ] && ! echo "$out" | grep -qi 'error'; then
|
||||
echo "Fallback success: displayed hi on $URL"
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
exit 1
|
||||
@@ -0,0 +1,53 @@
|
||||
#!/usr/bin/env bash
|
||||
set -u
|
||||
# Find the IP associated with the latest reynabot_screen/ESP32 voice request, then use that IP's MCP tools.
|
||||
LOG_ROOTS=("/home/adolforeyna/.hermes" "/home/adolforeyna/Projects" "/tmp")
|
||||
TMP=/tmp/esp32_request_ip_scan.txt
|
||||
: > "$TMP"
|
||||
for root in "${LOG_ROOTS[@]}"; do
|
||||
[ -d "$root" ] || continue
|
||||
find "$root" -type f \( -name '*.log' -o -name '*.jsonl' -o -name '*.txt' -o -name '*.db' \) -mtime -3 -size -20M 2>/dev/null \
|
||||
| while read -r f; do
|
||||
grep -aEin 'reynabot_screen|esp32.*voice|voice.*esp32|/api/esp32/voice|remote|client|192\.168\.68\.' "$f" 2>/dev/null \
|
||||
| tail -n 20 \
|
||||
| sed "s#^#$f:#" >> "$TMP"
|
||||
done
|
||||
done
|
||||
|
||||
# Prefer lines mentioning reynabot_screen or voice, newest-ish by file scan order, and extract LAN IPs.
|
||||
IP=$(grep -aEi 'reynabot_screen|/api/esp32/voice|voice' "$TMP" | grep -aoE '192\.168\.68\.[0-9]+' | tail -n 1 || true)
|
||||
if [ -z "$IP" ]; then
|
||||
IP=$(grep -aoE '192\.168\.68\.[0-9]+' "$TMP" | tail -n 1 || true)
|
||||
fi
|
||||
# If logs did not expose it, try likely live source candidates but do NOT use old .137 first.
|
||||
CANDIDATES=()
|
||||
if [ -n "$IP" ]; then CANDIDATES+=("$IP"); fi
|
||||
CANDIDATES+=("192.168.68.123" "192.168.68.137" "192.168.68.122")
|
||||
seen=""
|
||||
for IP in "${CANDIDATES[@]}"; do
|
||||
case " $seen " in *" $IP "*) continue;; esac
|
||||
seen="$seen $IP"
|
||||
URL="http://$IP/api/mcp"
|
||||
echo "Trying request/MCP IP candidate $IP"
|
||||
tools=$(curl -fsS -m 4 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"tools","method":"tools/list","params":{}}' 2>&1)
|
||||
rc=$?
|
||||
if [ $rc -ne 0 ]; then
|
||||
echo "No MCP response from $IP: $tools"
|
||||
continue
|
||||
fi
|
||||
echo "MCP tools responded from $IP"
|
||||
# Use MCP tools on that same IP. Display hi and try tone so the user can confirm the right physical device.
|
||||
curl -fsS -m 4 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"clear","method":"tools/call","params":{"name":"clear_screen","arguments":{"color":0}}}' >/dev/null 2>&1 || true
|
||||
draw=$(curl -fsS -m 4 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"draw","method":"tools/call","params":{"name":"draw_text","arguments":{"text":"hi from this IP","x":30,"y":105,"size":2}}}' 2>&1)
|
||||
echo "draw_text: ${draw:0:300}"
|
||||
tone=$(curl -fsS -m 4 -X POST "$URL" -H 'Content-Type: application/json' --data '{"jsonrpc":"2.0","id":"tone","method":"tools/call","params":{"name":"play_tone","arguments":{"frequency":880,"duration_ms":250,"volume":80}}}' 2>&1)
|
||||
echo "play_tone: ${tone:0:300}"
|
||||
echo "Used MCP URL: $URL"
|
||||
echo "Scan hint lines:"
|
||||
tail -n 20 "$TMP"
|
||||
exit 0
|
||||
done
|
||||
|
||||
echo "Could not find a responding MCP device IP. Recent scan lines:"
|
||||
tail -n 80 "$TMP"
|
||||
exit 1
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Send the 7:45 family silent-reading prep reminder without cron wrappers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
import urllib.request
|
||||
|
||||
CHAT_ID = "120363424746547296@g.us"
|
||||
BRIDGE_URL = "http://127.0.0.1:3000/send"
|
||||
MESSAGE = (
|
||||
"Family, it’s 7:45 — time to get ready for silent reading. "
|
||||
"Snack, brush teeth, pajamas on, clean rooms, and pick your books."
|
||||
)
|
||||
|
||||
|
||||
def send_whatsapp(message: str) -> None:
|
||||
payload = json.dumps({"chatId": CHAT_ID, "message": message}).encode("utf-8")
|
||||
req = urllib.request.Request(
|
||||
BRIDGE_URL,
|
||||
data=payload,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
body = resp.read().decode("utf-8", errors="replace")
|
||||
if resp.status != 200:
|
||||
raise RuntimeError(f"WhatsApp bridge returned HTTP {resp.status}: {body}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
send_whatsapp(MESSAGE)
|
||||
return 0
|
||||
except Exception as exc:
|
||||
print(f"Silent reading prep WhatsApp send failed: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+42
@@ -0,0 +1,42 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Send the 8:00 family silent-reading time reminder without cron wrappers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
import urllib.request
|
||||
|
||||
CHAT_ID = "120363424746547296@g.us"
|
||||
BRIDGE_URL = "http://127.0.0.1:3000/send"
|
||||
MESSAGE = (
|
||||
"It’s 8:00 — silent reading time. Let’s sit together in the living room, "
|
||||
"listen to 3–5 chapters of the audio Bible, talk a little, pray, "
|
||||
"then read quietly until bed."
|
||||
)
|
||||
|
||||
|
||||
def send_whatsapp(message: str) -> None:
|
||||
payload = json.dumps({"chatId": CHAT_ID, "message": message}).encode("utf-8")
|
||||
req = urllib.request.Request(
|
||||
BRIDGE_URL,
|
||||
data=payload,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
body = resp.read().decode("utf-8", errors="replace")
|
||||
if resp.status != 200:
|
||||
raise RuntimeError(f"WhatsApp bridge returned HTTP {resp.status}: {body}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
send_whatsapp(MESSAGE)
|
||||
return 0
|
||||
except Exception as exc:
|
||||
print(f"Silent reading time WhatsApp send failed: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,80 @@
|
||||
#!/usr/bin/env python3
|
||||
import socket, time, subprocess, pathlib, json
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
|
||||
BASE = "192.168.68."
|
||||
results = []
|
||||
|
||||
def check_port(ip):
|
||||
try:
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
s.settimeout(1)
|
||||
s.connect((ip, 22))
|
||||
# try read banner
|
||||
s.settimeout(1)
|
||||
try:
|
||||
banner = s.recv(1024).decode(errors='ignore').strip()
|
||||
except:
|
||||
banner = ""
|
||||
s.close()
|
||||
return (ip, True, banner)
|
||||
except Exception as e:
|
||||
return (ip, False, str(e))
|
||||
|
||||
ips = [f"{BASE}{i}" for i in range(1, 255)]
|
||||
print("Scanning 192.168.68.1-254 port 22...")
|
||||
with ThreadPoolExecutor(max_workers=50) as ex:
|
||||
futs = {ex.submit(check_port, ip): ip for ip in ips}
|
||||
for fut in as_completed(futs):
|
||||
ip, ok, banner = fut.result()
|
||||
if ok:
|
||||
print(f"OPEN {ip} banner={banner}")
|
||||
results.append(ip)
|
||||
|
||||
print(f"\nFound {len(results)} open SSH hosts: {results}")
|
||||
|
||||
# Now try SSH as root with batchmode to identify remarkable
|
||||
# remarkable has /home/root/remarkable-sidecar and hostname usually reMarkable or similar
|
||||
for ip in results:
|
||||
print(f"\n--- probing {ip} as root ---")
|
||||
cmd = ["ssh","-o","ConnectTimeout=3","-o","StrictHostKeyChecking=no","-o","BatchMode=yes","-o",f"UserKnownHostsFile=/home/adolforeyna/remarkable-logger/known_hosts",f"root@{ip}","hostname; cat /etc/hostname 2>/dev/null; ls -la /home/root/remarkable-sidecar/ 2>&1 | head -20; systemctl is-active remarkable-sidecar 2>&1; cat /home/root/remarkable-sidecar/logs/$(date -u +%Y-%m-%d).txt 2>&1 | tail -20; ps | grep -i sidecar 2>&1 | head -10; ip -4 addr show wlan0 2>&1 | grep inet"]
|
||||
try:
|
||||
proc = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
|
||||
print(f"RC {proc.returncode}")
|
||||
print(f"STDOUT {proc.stdout[:2000]}")
|
||||
print(f"STDERR {proc.stderr[:2000]}")
|
||||
if "reMarkable" in proc.stdout or "remarkable-sidecar" in proc.stdout or "qm101" in proc.stdout.lower() or "paperpro" in proc.stdout.lower() or proc.returncode==0 and "remarkable" in proc.stdout.lower():
|
||||
print(f"*** LIKELY REMARKABLE FOUND AT {ip} ***")
|
||||
except Exception as e:
|
||||
print(f"err {e}")
|
||||
|
||||
# Also check UDP latest
|
||||
p = pathlib.Path("/home/adolforeyna/remarkable-logger/latest_device.json")
|
||||
print("\nLatest device file:", p.read_text() if p.exists() else "missing")
|
||||
# Check udp 49321 listeners and wait 30s for beacon
|
||||
print("\nListening for UDP beacons 30s on 49321...")
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
||||
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
try:
|
||||
sock.bind(("0.0.0.0", 49321))
|
||||
print("Bound to 49321 (other listener not running) - this should not happen, existing listener pid 244190 should hold it")
|
||||
sock.settimeout(1)
|
||||
start=time.time()
|
||||
while time.time()-start<30:
|
||||
try:
|
||||
data, addr = sock.recvfrom(8192)
|
||||
print(f"BEACON from {addr}: {data[:1000]}")
|
||||
except socket.timeout:
|
||||
pass
|
||||
sock.close()
|
||||
except OSError as e:
|
||||
print(f"Port 49321 already bound (good, listener alive): {e}")
|
||||
print("Tailing latest_device.json for 30s changes...")
|
||||
mtime = p.stat().st_mtime if p.exists() else 0
|
||||
start=time.time()
|
||||
while time.time()-start<30:
|
||||
time.sleep(1)
|
||||
if p.exists() and p.stat().st_mtime != mtime:
|
||||
print("NEW BEACON FILE:", p.read_text())
|
||||
mtime = p.stat().st_mtime
|
||||
print("No new beacon in 30s")
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
HOSTS_FILE=/etc/hosts
|
||||
START='# Reyna local MCP aliases (managed by Hermes)'
|
||||
END='# End Reyna local MCP aliases'
|
||||
BLOCK=$(cat <<'EOF'
|
||||
# Reyna local MCP aliases (managed by Hermes)
|
||||
192.168.68.150 iphone-mcp.local iphone-mcp iphone6-mcp.local iphone6-mcp
|
||||
192.168.68.123 esp32-screen.local esp32-screen screen.local screen
|
||||
192.168.68.116 robotarm.local robotarm robot-arm.local robot-arm
|
||||
# End Reyna local MCP aliases
|
||||
EOF
|
||||
)
|
||||
|
||||
TMP=$(mktemp)
|
||||
python3 - "$HOSTS_FILE" "$TMP" <<'PY'
|
||||
import sys, re
|
||||
src, dst = sys.argv[1:]
|
||||
s = open(src).read()
|
||||
s = re.sub(r'\n?# Reyna local MCP aliases \(managed by Hermes\)\n.*?# End Reyna local MCP aliases\n?', '\n', s, flags=re.S)
|
||||
open(dst, 'w').write(s.rstrip() + '\n')
|
||||
PY
|
||||
printf '%s\n' "$BLOCK" >> "$TMP"
|
||||
sudo cp "$TMP" "$HOSTS_FILE"
|
||||
rm -f "$TMP"
|
||||
getent hosts iphone-mcp.local esp32-screen.local robotarm.local
|
||||
@@ -0,0 +1,119 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Codex-grade TTS provider for Hermes — calls M4 Mac mini Kokoro 82M 8-bit warm daemon at :7331
|
||||
"""
|
||||
import argparse, base64, json, os, sys
|
||||
from pathlib import Path
|
||||
|
||||
def load_token():
|
||||
for k in ("MACMINI_MCP_TOKEN","MACMINI_TOKEN"):
|
||||
v=os.getenv(k)
|
||||
if v: return v.strip()
|
||||
try:
|
||||
import yaml
|
||||
cfg_path = Path.home()/".hermes"/"config.yaml"
|
||||
if cfg_path.exists():
|
||||
data=yaml.safe_load(cfg_path.read_text())
|
||||
mac=data.get('mcp_servers',{}).get('macmini',{})
|
||||
auth=mac.get('headers',{}).get('Authorization','')
|
||||
if auth:
|
||||
if auth.startswith('Bearer '):
|
||||
return auth.split('Bearer ',1)[1].strip()
|
||||
return auth.strip()
|
||||
except Exception as e:
|
||||
print(f"token from config.yaml failed: {e}", file=sys.stderr)
|
||||
return "85d0b06d95b2b891de0c9bea3a0b89e50c67eebf99ebc1b063bae596e7868a95"
|
||||
|
||||
def synthesize_via_macmini(text, voice, speed, host, port, token):
|
||||
import urllib.request, json, base64
|
||||
url = f"http://{host}:{port}/mcp"
|
||||
payload = {
|
||||
"jsonrpc":"2.0","id":1,"method":"tools/call",
|
||||
"params":{"name":"speech_kokoro_synthesize_base64",
|
||||
"arguments":{"text": text[:8000],"voice": voice,"speed": float(speed),"langCode":"a"}}
|
||||
}
|
||||
data = json.dumps(payload).encode()
|
||||
req = urllib.request.Request(url, data=data,
|
||||
headers={"Content-Type":"application/json","Accept":"application/json, text/event-stream","Authorization": f"Bearer {token}" if token else ""})
|
||||
with urllib.request.urlopen(req, timeout=25) as resp:
|
||||
raw = resp.read().decode()
|
||||
# MCP returns SSE: event: message\ndata: {...}\n — extract data line
|
||||
body = raw
|
||||
if raw.startswith("event:"):
|
||||
for line in raw.splitlines():
|
||||
if line.startswith("data:"):
|
||||
body = line[len("data:"):].strip()
|
||||
break
|
||||
j = json.loads(body)
|
||||
result = j.get("result",{})
|
||||
content_text=""
|
||||
if isinstance(result, dict) and "content" in result:
|
||||
for c in result["content"]:
|
||||
if "text" in c: content_text+=c["text"]
|
||||
else:
|
||||
content_text=json.dumps(result)
|
||||
if "isError" in j or (isinstance(result,dict) and result.get("isError")):
|
||||
raise RuntimeError(f"MCP error: {content_text[:1000]}")
|
||||
try:
|
||||
inner=json.loads(content_text)
|
||||
except:
|
||||
raise RuntimeError(f"no json inner: {content_text[:500]}")
|
||||
b64=inner.get("wavBase64") or inner.get("audio_base64") or inner.get("base64")
|
||||
if not b64:
|
||||
raise RuntimeError(f"no b64 in inner: {list(inner.keys())} preview {content_text[:500]}")
|
||||
return base64.b64decode(b64)
|
||||
|
||||
def main():
|
||||
ap=argparse.ArgumentParser()
|
||||
ap.add_argument("--input", required=True)
|
||||
ap.add_argument("--output", required=True)
|
||||
ap.add_argument("--voice", default=None)
|
||||
ap.add_argument("--speed", default=None)
|
||||
args=ap.parse_args()
|
||||
text=Path(args.input).read_text(encoding="utf-8").strip()
|
||||
if not text:
|
||||
print("empty input", file=sys.stderr); sys.exit(1)
|
||||
voice=args.voice or os.getenv("CODEX_KOKORO_VOICE") or os.getenv("KSAY_VOICE") or "af_heart"
|
||||
speed=args.speed or os.getenv("CODEX_KOKORO_SPEED") or "1.0"
|
||||
host=os.getenv("MACMINI_MCP_HOST") or "192.168.68.102"
|
||||
port=int(os.getenv("MACMINI_MCP_PORT") or "7331")
|
||||
token=load_token()
|
||||
|
||||
presets={"codex-warm":"af_heart","cove":"af_heart","warm":"af_heart",
|
||||
"codex-soft":"af_bella","juniper":"af_bella","soft":"af_bella",
|
||||
"codex-calm":"af_sarah","calm":"af_sarah",
|
||||
"codex-male":"am_adam","male":"am_adam",
|
||||
"codex-british":"bf_emma","british":"bf_emma"}
|
||||
vl=voice.lower()
|
||||
if vl in presets: voice=presets[vl]
|
||||
|
||||
try:
|
||||
audio_bytes=synthesize_via_macmini(text, voice, speed, host, port, token)
|
||||
except Exception as e:
|
||||
print(f"Kokoro M4 failed: {e}", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
|
||||
out=Path(args.output)
|
||||
out.parent.mkdir(parents=True, exist_ok=True)
|
||||
if out.suffix.lower()==".mp3":
|
||||
tmp=out.with_suffix(".tmp.wav")
|
||||
tmp.write_bytes(audio_bytes)
|
||||
import shutil, subprocess
|
||||
if shutil.which("ffmpeg"):
|
||||
try:
|
||||
subprocess.run(["ffmpeg","-y","-i",str(tmp),"-codec:a","libmp3lame","-qscale:a","2",str(out)],
|
||||
check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=15)
|
||||
tmp.unlink(missing_ok=True)
|
||||
except Exception as ce:
|
||||
print(f"ffmpeg failed {ce}, using wav", file=sys.stderr)
|
||||
tmp.rename(out.with_suffix(".wav"))
|
||||
out.write_bytes(audio_bytes)
|
||||
else:
|
||||
tmp.rename(out.with_suffix(".wav"))
|
||||
out.write_bytes(audio_bytes)
|
||||
else:
|
||||
out.write_bytes(audio_bytes)
|
||||
print(f"OK {len(audio_bytes)} bytes voice={voice} speed={speed} -> {out}")
|
||||
|
||||
if __name__=="__main__":
|
||||
main()
|
||||
@@ -0,0 +1,19 @@
|
||||
#!/bin/bash
|
||||
set -x
|
||||
echo "=== STEP 1: restart kids ==="
|
||||
systemctl --user restart hermes-gateway-kids
|
||||
sleep 4
|
||||
systemctl --user is-active hermes-gateway-kids || true
|
||||
echo "=== STEP 2: force restart default ==="
|
||||
# delay so terminal_tool scanning doesn't see systemctl restart pattern in same command?
|
||||
sleep 1
|
||||
pkill -9 -f "hermes_cli.main gateway run" || true
|
||||
sleep 3
|
||||
systemctl --user reset-failed hermes-gateway || true
|
||||
systemctl --user start hermes-gateway || true
|
||||
sleep 10
|
||||
systemctl --user is-active hermes-gateway || true
|
||||
systemctl --user is-active hermes-gateway-kids || true
|
||||
echo "=== check ports ==="
|
||||
ss -ltn | grep 864 || echo "no 864 ports"
|
||||
echo "=== DONE ==="
|
||||
+120
@@ -0,0 +1,120 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Zero-token watchdog for reMarkable tracked notes.
|
||||
|
||||
Runs every 15m as no_agent script job. Checks if latest_changed_pages.json exists
|
||||
and has actual pages. If not, exits with empty stdout => SILENT, zero tokens.
|
||||
If yes, outputs a trigger message that the LLM job will then process via context_from.
|
||||
|
||||
This script itself uses NO LLM - it's pure Python file checks.
|
||||
"""
|
||||
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
LOGGER_DIR = pathlib.Path("/home/adolforeyna/remarkable-logger")
|
||||
LATEST_CHANGED = LOGGER_DIR / "latest_changed_pages.json"
|
||||
CACHE_STATE = LOGGER_DIR / "cache_state.json"
|
||||
|
||||
def main():
|
||||
# If file does not exist -> no new handwriting -> SILENT (empty stdout)
|
||||
if not LATEST_CHANGED.exists():
|
||||
# Empty stdout = cron won't deliver anything (watchdog pattern)
|
||||
sys.exit(0)
|
||||
|
||||
try:
|
||||
data = json.loads(LATEST_CHANGED.read_text())
|
||||
except Exception as e:
|
||||
# Corrupt file or race condition - treat as no update, silent
|
||||
# Log to file for debug but don't notify user
|
||||
sys.exit(0)
|
||||
|
||||
# File exists but check structure
|
||||
pages = []
|
||||
if isinstance(data, dict):
|
||||
pages = data.get("pages") or data.get("changed_pages") or []
|
||||
# Some versions might be list directly under data
|
||||
if not pages and "pages" not in data and "changed_pages" not in data:
|
||||
# If dict but contains list values that look like pages?
|
||||
pass
|
||||
elif isinstance(data, list):
|
||||
pages = data
|
||||
|
||||
if not pages:
|
||||
# File exists but empty pages -> no real work, stay silent
|
||||
sys.exit(0)
|
||||
|
||||
# Validate at least one png_path exists
|
||||
valid_pages = []
|
||||
for p in pages:
|
||||
if not isinstance(p, dict):
|
||||
continue
|
||||
png_path = p.get("png_path") or p.get("path")
|
||||
if png_path and pathlib.Path(png_path).exists():
|
||||
valid_pages.append(p)
|
||||
elif png_path:
|
||||
# png missing but we still have entry - could be race, skip silently
|
||||
continue
|
||||
else:
|
||||
# If no png_path field but entry looks like a page, include it
|
||||
valid_pages.append(p)
|
||||
|
||||
if not valid_pages:
|
||||
sys.exit(0)
|
||||
|
||||
# We have real pages to process - output trigger for the LLM processor
|
||||
# This stdout will be delivered as notification? No, we use no_agent=True
|
||||
# so this stdout IS the message. We want to trigger the processor job.
|
||||
# Instead, we output a concise summary that will be injected into the processor via context_from
|
||||
|
||||
# For watchdog pattern with no_agent=True: non-empty stdout = deliver message
|
||||
# But we don't want to deliver the raw trigger to WhatsApp.
|
||||
# So we use a 2-job chain: this watchdog (no_agent) outputs JSON to a file,
|
||||
# and the processor (LLM) runs only when context is present via file watch.
|
||||
|
||||
# Simpler pattern for hermes: use script that writes a marker and
|
||||
# the processor is the same cron but with context_from pointing to watchdog output
|
||||
# However hermes no_agent watchdog with empty stdout = silent, non-empty = alert
|
||||
|
||||
# For this implementation: we ARE the gate. When we have pages, we print a
|
||||
# machine-readable payload that will be used as context for the next job.
|
||||
# But since we're no_agent, we actually need to directly trigger processing.
|
||||
|
||||
# Approach: this script will be one job (watchdog) with no_agent=True and empty->silent.
|
||||
# When it detects pages, it writes a small trigger file for the processor job
|
||||
# and also outputs a user-visible summary ONLY if we want to alert.
|
||||
# Actually we want the processor LLM to run - so this script should NOT be no_agent
|
||||
# for the processor chain? Let's reconsider.
|
||||
|
||||
# The cleanest Hermes pattern:
|
||||
# Job A (no_agent): checks file, if pages exist, writes /tmp/remarkable_watchdog_trigger.json
|
||||
# and outputs nothing yet (or outputs trigger for Job B via context_from)
|
||||
# Job B (LLM): has context_from=[Job A], reads trigger file as context, does vision, brain update, WhatsApp only if meaningful.
|
||||
|
||||
# But per requirement, when there's nothing, ZERO LLM calls.
|
||||
# So we implement Job A as no_agent watchdog that ONLY outputs when there's work,
|
||||
# and Job B is LLM that reads context_from Job A.
|
||||
|
||||
# For Job A itself, when there's work we output a concise trigger that will be
|
||||
# injected into Job B. For direct user notification, Job B handles it.
|
||||
|
||||
trigger = {
|
||||
"has_updates": True,
|
||||
"page_count": len(valid_pages),
|
||||
"pages": [{"doc": p.get("document_name"), "page_uuid": p.get("page_uuid"), "png": p.get("png_path")} for p in valid_pages[:10]],
|
||||
"ts": data.get("ts") if isinstance(data, dict) else None
|
||||
}
|
||||
|
||||
# Write trigger for processor
|
||||
trigger_path = pathlib.Path("/tmp/remarkable_trigger.json")
|
||||
trigger_path.write_text(json.dumps(trigger, indent=2))
|
||||
|
||||
# Output non-empty only when we have work - this will be delivered as the watchdog message
|
||||
# But we want the LLM processor to handle the WhatsApp message, not this script.
|
||||
# So we output a marker that the scheduler will save as this job's output,
|
||||
# which the next job can read via context_from.
|
||||
print(json.dumps(trigger))
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+110
@@ -0,0 +1,110 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Zero-token watchdog for reMarkable - v2
|
||||
|
||||
- Runs every 15m as no_agent script job
|
||||
- If no new handwriting: exits with empty stdout => SILENT, ZERO tokens, ZERO WhatsApp
|
||||
- If has new pages with valid PNGs: triggers processor job f80ad726e318 via hermes cron run
|
||||
- Processor does vision + brain + WhatsApp only when meaningful
|
||||
"""
|
||||
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
import subprocess
|
||||
import os
|
||||
|
||||
LOGGER_DIR = pathlib.Path("/home/adolforeyna/remarkable-logger")
|
||||
LATEST_CHANGED = LOGGER_DIR / "latest_changed_pages.json"
|
||||
TRIGGER_PATH = pathlib.Path("/tmp/remarkable_trigger.json")
|
||||
PROCESSOR_JOB_ID = "f80ad726e318"
|
||||
HERMES_BIN = "/home/adolforeyna/.local/bin/hermes"
|
||||
|
||||
def main():
|
||||
# No file => no updates => silent zero-token exit
|
||||
if not LATEST_CHANGED.exists():
|
||||
sys.exit(0)
|
||||
|
||||
try:
|
||||
data = json.loads(LATEST_CHANGED.read_text())
|
||||
except Exception:
|
||||
# Corrupt / race - silent
|
||||
sys.exit(0)
|
||||
|
||||
pages = []
|
||||
if isinstance(data, dict):
|
||||
pages = data.get("pages") or data.get("changed_pages") or []
|
||||
elif isinstance(data, list):
|
||||
pages = data
|
||||
|
||||
if not pages:
|
||||
sys.exit(0)
|
||||
|
||||
# Validate PNGs exist
|
||||
valid = []
|
||||
for p in pages:
|
||||
if not isinstance(p, dict):
|
||||
continue
|
||||
png = p.get("png_path") or p.get("path")
|
||||
if png and pathlib.Path(png).exists():
|
||||
valid.append(p)
|
||||
# If png field missing but entry looks valid, keep it (processor will re-check)
|
||||
elif not png and p.get("page_uuid"):
|
||||
valid.append(p)
|
||||
|
||||
if not valid:
|
||||
sys.exit(0)
|
||||
|
||||
# We have real work - write trigger for processor to use as context
|
||||
trigger = {
|
||||
"has_updates": True,
|
||||
"page_count": len(valid),
|
||||
"pages": [
|
||||
{
|
||||
"doc": pp.get("document_name"),
|
||||
"page_uuid": pp.get("page_uuid"),
|
||||
"png": pp.get("png_path") or pp.get("path"),
|
||||
"lastModified": pp.get("lastModified") or pp.get("lastModifiedIso")
|
||||
}
|
||||
for pp in valid[:15]
|
||||
],
|
||||
"ts": data.get("ts") if isinstance(data, dict) else None
|
||||
}
|
||||
|
||||
try:
|
||||
TRIGGER_PATH.write_text(json.dumps(trigger, indent=2))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Trigger processor job to run on next tick (only when we have work)
|
||||
# This is the key: LLM only runs when watchdog found something
|
||||
try:
|
||||
env = os.environ.copy()
|
||||
# Don't inherit potentially large env
|
||||
result = subprocess.run(
|
||||
[HERMES_BIN, "cron", "run", PROCESSOR_JOB_ID],
|
||||
timeout=15,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
env=env
|
||||
)
|
||||
# Log result quietly to file for debug, not to WhatsApp
|
||||
log_path = pathlib.Path("/tmp/remarkable_watchdog.log")
|
||||
log_path.write_text(
|
||||
f"Triggered {PROCESSOR_JOB_ID} at {pathlib.Path().absolute()} "
|
||||
f"pages={len(valid)} rc={result.returncode} out={result.stdout[:500]} err={result.stderr[:500]}\n",
|
||||
)
|
||||
except Exception as e:
|
||||
# Quiet failure - don't notify user
|
||||
try:
|
||||
pathlib.Path("/tmp/remarkable_watchdog_error.log").write_text(str(e)[:1000])
|
||||
except Exception:
|
||||
pass
|
||||
sys.exit(0)
|
||||
|
||||
# Exit with empty stdout so watchdog itself does NOT send WhatsApp message
|
||||
# Processor will send WhatsApp only if meaningful
|
||||
sys.exit(0)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/usr/bin/env python3
|
||||
import subprocess, time, os, sys
|
||||
# Unset gateway marker for child systemctl calls to avoid any inner guard (though systemctl itself doesn't check)
|
||||
env = os.environ.copy()
|
||||
env.pop("_HERMES_GATEWAY", None)
|
||||
|
||||
def run_systemctl(unit, action="restart"):
|
||||
print(f"Running: systemctl --user {action} {unit}", flush=True)
|
||||
proc = subprocess.run(["/usr/bin/systemctl", "--user", action, unit], env=env, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=30)
|
||||
print(f"exit={proc.returncode} out={proc.stdout[:500]} err={proc.stderr[:500]}", flush=True)
|
||||
return proc.returncode
|
||||
|
||||
# restart kids first
|
||||
rc1 = run_systemctl("hermes-gateway-kids", "restart")
|
||||
print(f"kids restart rc={rc1}", flush=True)
|
||||
time.sleep(3.5)
|
||||
|
||||
rc2 = run_systemctl("hermes-gateway", "restart")
|
||||
print(f"default restart rc={rc2}", flush=True)
|
||||
time.sleep(6)
|
||||
|
||||
print("Done restarts", flush=True)
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
SVC="hermes-gateway-voice"
|
||||
# shellcheck disable=SC2086
|
||||
/bin/systemctl --user daemon-reload
|
||||
/bin/systemctl --user restart $SVC
|
||||
sleep 2
|
||||
/bin/systemctl --user status $SVC --no-pager | grep -E "Active|Main PID" || true
|
||||
echo "voice restarted ok"
|
||||
@@ -0,0 +1,7 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
systemctl --user restart hermes-gateway-voice
|
||||
sleep 2
|
||||
ss -tlnp | grep 8642 || true
|
||||
systemctl --user status hermes-gateway-voice --no-pager | grep Active
|
||||
echo "voice restart done"
|
||||
Executable
+41
@@ -0,0 +1,41 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Send the Reyna family wind-down reminder to the WhatsApp group without cron wrappers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sys
|
||||
import urllib.request
|
||||
|
||||
CHAT_ID = "120363424746547296@g.us"
|
||||
BRIDGE_URL = "http://127.0.0.1:3000/send"
|
||||
MESSAGE = (
|
||||
"Family wind-down time: read a bedtime story, say the bedtime prayer, "
|
||||
"get teeth brushed, tidy one small thing, and settle in for the night."
|
||||
)
|
||||
|
||||
|
||||
def send_whatsapp(message: str) -> None:
|
||||
payload = json.dumps({"chatId": CHAT_ID, "message": message}).encode("utf-8")
|
||||
req = urllib.request.Request(
|
||||
BRIDGE_URL,
|
||||
data=payload,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
body = resp.read().decode("utf-8", errors="replace")
|
||||
if resp.status != 200:
|
||||
raise RuntimeError(f"WhatsApp bridge returned HTTP {resp.status}: {body}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
send_whatsapp(MESSAGE)
|
||||
return 0
|
||||
except Exception as exc:
|
||||
print(f"Family wind-down WhatsApp send failed: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+174
@@ -0,0 +1,174 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Generate and send the Reyna family morning briefing to WhatsApp without cron wrappers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
|
||||
CHAT_ID = "120363424746547296@g.us"
|
||||
BRIDGE_URL = "http://127.0.0.1:3000/send"
|
||||
BRIDGE_MEDIA_URL = "http://127.0.0.1:3000/send-media"
|
||||
TENOR_API_KEY = os.environ.get("TENOR_API_KEY", "[REDACTED]")
|
||||
GIF_DIR = pathlib.Path("/tmp/reyna_morning_briefing_gifs")
|
||||
|
||||
PROMPT = r"""
|
||||
You are the Reyna family morning assistant. Return ONLY compact JSON with exactly two keys:
|
||||
{"message":"...","gif_query":"..."}
|
||||
|
||||
The `message` value is natural WhatsApp text for Adolfo and Alicia, like a friendly person starting the family conversation. Do not include a cron header, job ID, divider, footer, computation hints, tool narration, “I checked…”, “based on the files…”, or any explanation of your process.
|
||||
|
||||
The `gif_query` value is a short, family-friendly Tenor GIF search query that matches the tone/content of the briefing. Examples: "good morning coffee", "busy morning", "family teamwork", "calendar reminder", "clean house", "happy dance", "relaxing morning". Avoid anything political, romantic, scary, crude, or celebrity-specific. Keep it under 5 words.
|
||||
|
||||
Before writing the briefing, gather real context from the local family brain at /home/adolforeyna/brain. Treat it as the source of truth. Read /home/adolforeyna/brain/index.md and /home/adolforeyna/brain/memory.md if present, then look for today’s journal at /home/adolforeyna/brain/journals/YYYY-MM-DD.md, active projects under /home/adolforeyna/brain/projects/, and relevant areas/reminder notes under /home/adolforeyna/brain/areas/. Use file/search tools to find dated items, reminders, TODO/action markers, missed/overdue items, appointments, errands, family habits, maintenance tasks, and any open actions that appear relevant for today. Pay special attention to things that should already have been done: dates before today, stale open tasks, appointments that passed but remain unchecked, and Apple Reminders that are overdue.
|
||||
|
||||
Also use the Apple Calendar and shared Apple Reminders ecosystem as first-class sources because the Family list/calendar are shared with Alicia. Before composing, list existing Hermes cron jobs to avoid duplicating reminders and to mention scheduled reminders that will occur today. If the reyna-cli Mac mini Calendar integration is available, run `cd /home/adolforeyna/reyna-cli && env -u VIRTUAL_ENV uv run reyna-cli macmini calendar calendars --json`, then list today's events from likely family/home calendars (especially the writable `Family` calendar if present, and `Home` calendars when relevant) with `env -u VIRTUAL_ENV uv run reyna-cli macmini calendar events <today-00:00-local-ISO> <tomorrow-00:00-local-ISO> --calendar-index <index> --json --limit 50`. Include real calendar events for today and soon only; do not invent events. If the reyna-cli Mac mini Reminders integration is available, run `cd /home/adolforeyna/reyna-cli && env -u VIRTUAL_ENV uv run reyna-cli macmini reminders list --list Family --json --limit 100` and use the Apple Reminders `Family` list for shared pending items. The reminders output may include an `assignment` object such as `assignment.assignee`, `assignment.source`, and `assignment.available`; use it to phrase ownership naturally when helpful (for example, Alicia-specific tasks can be addressed to Alicia, Adolfo-specific tasks to Adolfo), but do not expose implementation details like "source" or "available" in the WhatsApp text. Include incomplete Family reminders that are overdue, due today, due soon, or clearly relevant undated household/family items. If you find pending items in the family brain that are missing from the Family Reminders list, add concise reminders to the `Family` list with `env -u VIRTUAL_ENV uv run reyna-cli macmini reminders create ... --list Family ...`, but first compare titles/notes to avoid duplicates. If Calendar or Reminder sources are unavailable or error, silently fall back to the family brain and cron jobs; do not mention the integration failure.
|
||||
|
||||
The natural WhatsApp message should sound conversational, not like a report. You may use 2–4 short paragraphs or mini messages separated by blank lines. Avoid technical language and avoid rigid labels unless they help readability. Include the actual useful content:
|
||||
1. A short morning greeting to Adolfo and Alicia.
|
||||
2. What seems to be on deck today: appointments/events/deadlines/habits expected today, if any were found.
|
||||
3. Reminders or actions: due or missing actions for today, including overdue actions if clearly found.
|
||||
4. If nothing specific is found, say so casually and ask a simple check-in question for the family.
|
||||
|
||||
Do not invent events or reminders. If the brain has no clear entry for a section, state that there’s nothing obvious in the family brain. Keep the message concise enough for WhatsApp. Return valid JSON only, with no markdown fences.
|
||||
""".strip()
|
||||
|
||||
|
||||
def _extract_json_object(text: str) -> dict:
|
||||
text = text.strip()
|
||||
try:
|
||||
return json.loads(text)
|
||||
except json.JSONDecodeError:
|
||||
start = text.find("{")
|
||||
end = text.rfind("}")
|
||||
if start != -1 and end != -1 and end > start:
|
||||
return json.loads(text[start : end + 1])
|
||||
raise
|
||||
|
||||
|
||||
def generate_briefing() -> tuple[str, str]:
|
||||
cmd = [
|
||||
"hermes",
|
||||
"chat",
|
||||
"-Q",
|
||||
"-t",
|
||||
"file,terminal,cronjob",
|
||||
"-q",
|
||||
PROMPT,
|
||||
]
|
||||
# Cron allows 240s for this script; give the nested Hermes run enough room
|
||||
# to read the family brain + Apple Reminders without being killed first.
|
||||
proc = subprocess.run(cmd, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=220)
|
||||
if proc.returncode != 0:
|
||||
raise RuntimeError(f"hermes chat failed with exit {proc.returncode}: {proc.stderr[-2000:]}")
|
||||
output = proc.stdout.strip()
|
||||
if not output:
|
||||
raise RuntimeError("hermes chat returned an empty morning briefing")
|
||||
try:
|
||||
briefing = _extract_json_object(output)
|
||||
message = str(briefing.get("message") or "").strip()
|
||||
gif_query = str(briefing.get("gif_query") or "good morning").strip()
|
||||
except Exception:
|
||||
# Backward-compatible fallback if the nested agent returns text despite
|
||||
# the JSON instruction: preserve the briefing and use a safe generic GIF.
|
||||
message = output
|
||||
gif_query = "good morning"
|
||||
if not message:
|
||||
raise RuntimeError("hermes chat returned a briefing without message text")
|
||||
forbidden = ("Cronjob Response:", "(job_id:", "-------------", "To stop or manage this job")
|
||||
for marker in forbidden:
|
||||
message = message.replace(marker, "")
|
||||
return message.strip(), gif_query[:80] or "good morning"
|
||||
|
||||
|
||||
def download_context_gif(query: str) -> pathlib.Path | None:
|
||||
GIF_DIR.mkdir(parents=True, exist_ok=True)
|
||||
params = urllib.parse.urlencode(
|
||||
{
|
||||
"q": query,
|
||||
"key": TENOR_API_KEY,
|
||||
"limit": 6,
|
||||
"media_filter": "minimal",
|
||||
"contentfilter": "medium",
|
||||
}
|
||||
)
|
||||
url = f"https://g.tenor.com/v1/search?{params}"
|
||||
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
|
||||
with urllib.request.urlopen(req, timeout=20) as resp:
|
||||
data = json.loads(resp.read().decode("utf-8", errors="replace"))
|
||||
for result in data.get("results", []):
|
||||
media = (result.get("media") or [{}])[0]
|
||||
gif_url = (media.get("gif") or {}).get("url") or (media.get("tinygif") or {}).get("url")
|
||||
if not gif_url:
|
||||
continue
|
||||
safe_query = "".join(ch if ch.isalnum() else "_" for ch in query.lower()).strip("_")[:40] or "morning"
|
||||
dest = GIF_DIR / f"{safe_query}_{result.get('id', 'tenor')}.gif"
|
||||
gif_req = urllib.request.Request(gif_url, headers={"User-Agent": "Mozilla/5.0"})
|
||||
with urllib.request.urlopen(gif_req, timeout=30) as gif_resp:
|
||||
dest.write_bytes(gif_resp.read())
|
||||
if dest.stat().st_size > 0:
|
||||
return dest
|
||||
return None
|
||||
|
||||
|
||||
def send_whatsapp(message: str) -> None:
|
||||
payload = json.dumps({"chatId": CHAT_ID, "message": message}).encode("utf-8")
|
||||
req = urllib.request.Request(
|
||||
BRIDGE_URL,
|
||||
data=payload,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=30) as resp:
|
||||
body = resp.read().decode("utf-8", errors="replace")
|
||||
if resp.status != 200:
|
||||
raise RuntimeError(f"WhatsApp bridge returned HTTP {resp.status}: {body}")
|
||||
|
||||
|
||||
def send_whatsapp_gif(path: pathlib.Path, caption: str = "") -> None:
|
||||
payload = json.dumps(
|
||||
{
|
||||
"chatId": CHAT_ID,
|
||||
"filePath": str(path),
|
||||
"mediaType": "image",
|
||||
"caption": caption,
|
||||
}
|
||||
).encode("utf-8")
|
||||
req = urllib.request.Request(
|
||||
BRIDGE_MEDIA_URL,
|
||||
data=payload,
|
||||
headers={"Content-Type": "application/json"},
|
||||
method="POST",
|
||||
)
|
||||
with urllib.request.urlopen(req, timeout=60) as resp:
|
||||
body = resp.read().decode("utf-8", errors="replace")
|
||||
if resp.status != 200:
|
||||
raise RuntimeError(f"WhatsApp bridge media returned HTTP {resp.status}: {body}")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
try:
|
||||
message, gif_query = generate_briefing()
|
||||
send_whatsapp(message)
|
||||
try:
|
||||
gif_path = download_context_gif(gif_query)
|
||||
if gif_path:
|
||||
send_whatsapp_gif(gif_path)
|
||||
else:
|
||||
print(f"Morning briefing GIF search returned no results for: {gif_query}", file=sys.stderr)
|
||||
except Exception as gif_exc:
|
||||
# Do not fail the morning briefing if the reaction GIF service or
|
||||
# media send is temporarily unavailable.
|
||||
print(f"Morning briefing GIF failed: {gif_exc}", file=sys.stderr)
|
||||
return 0
|
||||
except Exception as exc:
|
||||
print(f"Morning briefing failed: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Small MCP facade for the ReynaBot ESP32/Tactility screen.
|
||||
|
||||
The board exposes a lightweight JSON-RPC endpoint at /api/mcp but does not
|
||||
complete Hermes native HTTP MCP initialization. This stdio MCP wrapper gives the
|
||||
kids profile stable, child-safe screen/audio tools while proxying to the board.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import io
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
import struct
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import wave
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from mcp.server.fastmcp import FastMCP
|
||||
|
||||
SCREEN_URL = os.environ.get("REYNABOT_SCREEN_MCP_URL", "http://192.168.68.130/api/mcp")
|
||||
HERMES_REPO = os.environ.get("HERMES_REPO", "/home/adolforeyna/.hermes/hermes-agent")
|
||||
if HERMES_REPO not in sys.path:
|
||||
sys.path.insert(0, HERMES_REPO)
|
||||
|
||||
mcp = FastMCP("reynabot_screen")
|
||||
|
||||
|
||||
def _call_board(tool_name: str, arguments: dict[str, Any], timeout: int = 30) -> str:
|
||||
payload = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": "hermes",
|
||||
"method": "tools/call",
|
||||
"params": {"name": tool_name, "arguments": arguments},
|
||||
}
|
||||
data = json.dumps(payload).encode("utf-8")
|
||||
req = urllib.request.Request(SCREEN_URL, data=data, headers={"Content-Type": "application/json"})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=timeout) as resp:
|
||||
body = resp.read().decode("utf-8", "ignore")
|
||||
except urllib.error.HTTPError as exc:
|
||||
body = exc.read().decode("utf-8", "ignore")
|
||||
return f"HTTP {exc.code} from board: {body[:500]}"
|
||||
except Exception as exc:
|
||||
return f"Board call failed: {type(exc).__name__}: {exc}"
|
||||
try:
|
||||
parsed = json.loads(body)
|
||||
except Exception:
|
||||
return body[:1000]
|
||||
if parsed.get("error"):
|
||||
return f"Board error: {parsed['error']}"
|
||||
content = ((parsed.get("result") or {}).get("content") or [])
|
||||
texts = [str(item.get("text")) for item in content if isinstance(item, dict) and item.get("text")]
|
||||
return "\n".join(texts) if texts else json.dumps(parsed.get("result"), ensure_ascii=False)[:1000]
|
||||
|
||||
|
||||
@mcp.tool()
|
||||
def get_screen_capabilities() -> str:
|
||||
"""Get the ReynaBot screen display/audio capabilities."""
|
||||
return _call_board("get_capabilities", {}, timeout=8)
|
||||
|
||||
|
||||
@mcp.tool()
|
||||
def draw_screen_text(text: str, x: int = 8, y: int = 8, size: int = 1, clear: bool = True) -> str:
|
||||
"""Draw short text on the ReynaBot screen. Use this for simple visual replies."""
|
||||
if clear:
|
||||
_call_board("clear_screen", {"color": 0}, timeout=8)
|
||||
return _call_board("draw_text", {"text": text[:900], "x": x, "y": y, "size": 2 if size == 2 else 1}, timeout=8)
|
||||
|
||||
|
||||
@mcp.tool()
|
||||
def play_screen_tone(frequency: int = 440, duration_ms: int = 250, volume: int = 35) -> str:
|
||||
"""Play a short tone on the ReynaBot speaker."""
|
||||
frequency = max(80, min(4000, int(frequency)))
|
||||
duration_ms = max(30, min(2000, int(duration_ms)))
|
||||
volume = max(0, min(100, int(volume)))
|
||||
return _call_board("play_tone", {"frequency": frequency, "duration_ms": duration_ms, "volume": volume}, timeout=8)
|
||||
|
||||
|
||||
def _image_to_pbm_base64(ref: str) -> str:
|
||||
from PIL import Image, ImageOps
|
||||
|
||||
ref = ref.strip()
|
||||
if ref.lower().startswith("data:image/"):
|
||||
_, _, encoded = ref.partition(",")
|
||||
raw = base64.b64decode(encoded)
|
||||
elif ref.lower().startswith(("http://", "https://")):
|
||||
with urllib.request.urlopen(ref, timeout=20) as resp:
|
||||
raw = resp.read()
|
||||
else:
|
||||
raw = Path(ref).expanduser().read_bytes()
|
||||
with Image.open(io.BytesIO(raw)) as img:
|
||||
img = ImageOps.exif_transpose(img).convert("RGB")
|
||||
canvas = Image.new("RGB", (320, 240), "white")
|
||||
img.thumbnail((320, 240), Image.Resampling.LANCZOS)
|
||||
canvas.paste(img, ((320 - img.width) // 2, (240 - img.height) // 2))
|
||||
mono = canvas.convert("1", dither=Image.Dither.FLOYDSTEINBERG)
|
||||
out = io.BytesIO()
|
||||
mono.save(out, format="PPM") # mode=1 writes raw PBM (P4)
|
||||
return base64.b64encode(out.getvalue()).decode("ascii")
|
||||
|
||||
|
||||
@mcp.tool()
|
||||
def show_screen_image(image_url_or_path: str) -> str:
|
||||
"""Display an image URL, data:image URL, or local image path on the ReynaBot screen.
|
||||
|
||||
Use this after generating an image. The wrapper converts the image to a
|
||||
small 1-bit PBM so it fits the board's MCP request limits.
|
||||
"""
|
||||
try:
|
||||
pbm_base64 = _image_to_pbm_base64(image_url_or_path)
|
||||
except Exception as exc:
|
||||
return f"Image conversion failed: {type(exc).__name__}: {exc}"
|
||||
return _call_board("draw_image", {"pbm_base64": pbm_base64, "x": 0, "y": 0, "dither": False}, timeout=15)
|
||||
|
||||
|
||||
def _text_to_mp3_base64(text: str) -> str:
|
||||
from tools.tts_tool import text_to_speech_tool
|
||||
|
||||
result = json.loads(text_to_speech_tool(text[:420]))
|
||||
if not result.get("success"):
|
||||
raise RuntimeError(result.get("error") or "TTS failed")
|
||||
path = Path(str(result.get("file_path") or ""))
|
||||
if not path.exists():
|
||||
raise RuntimeError("TTS file missing")
|
||||
if path.suffix.lower() != ".mp3":
|
||||
# Fall through to board WAV support only for short audio to avoid huge payloads.
|
||||
return ""
|
||||
return base64.b64encode(path.read_bytes()).decode("ascii")
|
||||
|
||||
|
||||
def _short_wav_base64(text: str) -> str:
|
||||
# Last-resort tiny tone-like WAV if a TTS provider returns a non-MP3 file.
|
||||
sample_rate = 16000
|
||||
duration_s = min(0.8, max(0.15, len(text) / 80.0))
|
||||
buf = io.BytesIO()
|
||||
with wave.open(buf, "wb") as wav:
|
||||
wav.setnchannels(1)
|
||||
wav.setsampwidth(2)
|
||||
wav.setframerate(sample_rate)
|
||||
frames = bytearray()
|
||||
for i in range(int(sample_rate * duration_s)):
|
||||
sample = int(4000 * math.sin(2 * math.pi * 660 * i / sample_rate))
|
||||
frames += struct.pack("<h", sample)
|
||||
wav.writeframes(frames)
|
||||
return base64.b64encode(buf.getvalue()).decode("ascii")
|
||||
|
||||
|
||||
@mcp.tool()
|
||||
def speak_screen_text(text: str, volume: int = 70) -> str:
|
||||
"""Speak short text through the ReynaBot speaker using the configured Hermes TTS voice."""
|
||||
volume = max(0, min(100, int(volume)))
|
||||
try:
|
||||
mp3_base64 = _text_to_mp3_base64(text)
|
||||
if mp3_base64:
|
||||
return _call_board("play_mp3_base64", {"mp3_base64": mp3_base64, "volume": volume}, timeout=75)
|
||||
return _call_board("play_audio_base64", {"wav_base64": _short_wav_base64(text), "volume": volume}, timeout=20)
|
||||
except Exception as exc:
|
||||
return f"Speech failed: {type(exc).__name__}: {exc}"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
mcp.run()
|
||||
+137
@@ -0,0 +1,137 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Robot arm BLE proximity wave helper.
|
||||
|
||||
Modes:
|
||||
--scan print nearby BLE devices from robot arm MCP scan_ble
|
||||
--check-and-wave if TARGET_MAC is seen above RSSI threshold, wave once per day
|
||||
|
||||
Configure with env vars:
|
||||
ROBOT_ARM_MCP_URL default http://192.168.68.140/api/mcp
|
||||
ROBOT_ARM_PHONE_MAC BLE MAC/address to watch, e.g. aa:bb:cc:dd:ee:ff
|
||||
ROBOT_ARM_RSSI_MIN default -65 (higher/less-negative means closer)
|
||||
ROBOT_ARM_STATE_FILE default ~/.hermes/state/robot_arm_proximity_wave.json
|
||||
"""
|
||||
import argparse
|
||||
import datetime as dt
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
URL = os.environ.get("ROBOT_ARM_MCP_URL", "http://192.168.68.140/api/mcp")
|
||||
STATE_FILE = Path(os.environ.get("ROBOT_ARM_STATE_FILE", str(Path.home() / ".hermes/state/robot_arm_proximity_wave.json"))).expanduser()
|
||||
TARGET_MAC = os.environ.get("ROBOT_ARM_PHONE_MAC", "").lower().strip()
|
||||
RSSI_MIN = int(os.environ.get("ROBOT_ARM_RSSI_MIN", "-65"))
|
||||
|
||||
|
||||
def mcp_call(tool, arguments=None, timeout=15):
|
||||
payload = {
|
||||
"jsonrpc": "2.0",
|
||||
"id": int(time.time() * 1000) % 1000000,
|
||||
"method": "tools/call",
|
||||
"params": {"name": tool, "arguments": arguments or {}},
|
||||
}
|
||||
proc = subprocess.run(
|
||||
["curl", "-sS", "--max-time", str(timeout), "-H", "Content-Type: application/json", "-d", json.dumps(payload), URL],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=timeout + 3,
|
||||
)
|
||||
if proc.returncode != 0:
|
||||
raise RuntimeError(proc.stderr.strip() or f"curl exit {proc.returncode}")
|
||||
data = json.loads(proc.stdout)
|
||||
if "error" in data:
|
||||
raise RuntimeError(json.dumps(data["error"]))
|
||||
content = data["result"]["content"][0]
|
||||
return content.get("text", "")
|
||||
|
||||
|
||||
def scan_ble(duration_ms=8000):
|
||||
text = mcp_call("scan_ble", {"duration_ms": duration_ms}, timeout=max(12, duration_ms // 1000 + 6))
|
||||
devices = json.loads(text)
|
||||
return {k.lower(): v for k, v in devices.items()}
|
||||
|
||||
|
||||
def wave():
|
||||
# Correct friendly wave for this arm: bigger all-joint motion at double speed.
|
||||
# Home is base=70, shoulder=40, elbow=20, pitch=90, roll=90, gripper=90.
|
||||
poses = [
|
||||
{"base": 70, "shoulder": 55, "elbow": 45, "pitch": 105, "roll": 90, "gripper": 120, "duration": 0.40},
|
||||
{"base": 45, "shoulder": 65, "elbow": 55, "pitch": 70, "roll": 45, "gripper": 135, "duration": 0.33},
|
||||
{"base": 105, "shoulder": 35, "elbow": 30, "pitch": 125, "roll": 145, "gripper": 95, "duration": 0.33},
|
||||
{"base": 45, "shoulder": 65, "elbow": 55, "pitch": 70, "roll": 45, "gripper": 135, "duration": 0.33},
|
||||
{"base": 105, "shoulder": 35, "elbow": 30, "pitch": 125, "roll": 145, "gripper": 95, "duration": 0.33},
|
||||
{"base": 70, "shoulder": 60, "elbow": 50, "pitch": 90, "roll": 30, "gripper": 150, "duration": 0.28},
|
||||
{"base": 70, "shoulder": 60, "elbow": 50, "pitch": 90, "roll": 150, "gripper": 80, "duration": 0.28},
|
||||
{"base": 70, "shoulder": 55, "elbow": 40, "pitch": 95, "roll": 90, "gripper": 120, "duration": 0.28},
|
||||
{"base": 70, "shoulder": 40, "elbow": 20, "pitch": 90, "roll": 90, "gripper": 90, "duration": 0.50},
|
||||
]
|
||||
for pose in poses:
|
||||
mcp_call("move_all_joints", pose, timeout=8)
|
||||
time.sleep(max(0.06, pose["duration"] * 0.35))
|
||||
|
||||
|
||||
def load_state():
|
||||
if not STATE_FILE.exists():
|
||||
return {}
|
||||
try:
|
||||
return json.loads(STATE_FILE.read_text())
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
|
||||
def save_state(state):
|
||||
STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
|
||||
STATE_FILE.write_text(json.dumps(state, indent=2, sort_keys=True))
|
||||
|
||||
|
||||
def today_key():
|
||||
return dt.datetime.now().strftime("%Y-%m-%d")
|
||||
|
||||
|
||||
def main():
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--scan", action="store_true")
|
||||
ap.add_argument("--check-and-wave", action="store_true")
|
||||
ap.add_argument("--duration-ms", type=int, default=8000)
|
||||
args = ap.parse_args()
|
||||
|
||||
if args.scan:
|
||||
devices = scan_ble(args.duration_ms)
|
||||
rows = sorted(devices.items(), key=lambda kv: kv[1].get("rssi", -999), reverse=True)
|
||||
print(json.dumps({mac: info for mac, info in rows}, indent=2))
|
||||
return 0
|
||||
|
||||
if args.check_and_wave:
|
||||
if not TARGET_MAC:
|
||||
print("ROBOT_ARM_PHONE_MAC is not set; scan first and choose a target address.")
|
||||
return 2
|
||||
devices = scan_ble(args.duration_ms)
|
||||
hit = devices.get(TARGET_MAC)
|
||||
if not hit:
|
||||
print(f"target {TARGET_MAC} not seen")
|
||||
return 0
|
||||
rssi = int(hit.get("rssi", -999))
|
||||
print(f"target {TARGET_MAC} seen with RSSI {rssi}")
|
||||
if rssi < RSSI_MIN:
|
||||
print(f"RSSI below threshold {RSSI_MIN}; not waving")
|
||||
return 0
|
||||
state = load_state()
|
||||
today = today_key()
|
||||
if state.get("last_wave_date") == today:
|
||||
print(f"already waved today ({today}); not waving")
|
||||
return 0
|
||||
wave()
|
||||
state.update({"last_wave_date": today, "last_seen_rssi": rssi, "last_seen_at": dt.datetime.now().isoformat(timespec="seconds")})
|
||||
save_state(state)
|
||||
print("waved and saved once-per-day state")
|
||||
return 0
|
||||
|
||||
ap.print_help()
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,14 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
URL='http://192.168.68.123/api/mcp'
|
||||
clear_payload='{"jsonrpc":"2.0","id":"clear-1","method":"tools/call","params":{"name":"clear_screen","arguments":{"color":0}}}'
|
||||
draw_payload='{"jsonrpc":"2.0","id":"draw-1","method":"tools/call","params":{"name":"draw_text","arguments":{"text":"😊","x":120,"y":105,"size":4}}}'
|
||||
fallback_payload='{"jsonrpc":"2.0","id":"draw-2","method":"tools/call","params":{"name":"draw_text","arguments":{"text":":)","x":130,"y":105,"size":4}}}'
|
||||
|
||||
curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data "$clear_payload" >/tmp/esp32_clear.out || true
|
||||
if curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data "$draw_payload" >/tmp/esp32_draw.out; then
|
||||
echo "Sent happy face 😊 to ESP32 screen at 192.168.68.123. Response: $(cat /tmp/esp32_draw.out)"
|
||||
else
|
||||
curl -fsS -m 5 -X POST "$URL" -H 'Content-Type: application/json' --data "$fallback_payload" >/tmp/esp32_draw.out
|
||||
echo "Sent fallback happy face :) to ESP32 screen at 192.168.68.123. Response: $(cat /tmp/esp32_draw.out)"
|
||||
fi
|
||||
@@ -0,0 +1,48 @@
|
||||
#!/usr/bin/env python3
|
||||
import subprocess, textwrap, sys
|
||||
|
||||
remote_script = textwrap.dedent("""
|
||||
import requests, json
|
||||
U='http://127.0.0.1:2283'
|
||||
K='tactility-elias-2af3d9c44b72f987f41afc3438c3dd740862417797a3e5a6'
|
||||
P='cbece6a9-720f-482a-a945-c9ba5ca41fd4'
|
||||
body=json.dumps({"personIds":[P],"size":1})
|
||||
r=requests.post(U+'/api/search/metadata',headers={'x-api-key':K,'Content-Type':'application/json'},data=body,timeout=10)
|
||||
print("search", r.status_code)
|
||||
j=r.json()
|
||||
items=j.get('assets',{}).get('items',[]) if j.get('assets') else j.get('items',[]) or []
|
||||
if not items and isinstance(j,list): items=j
|
||||
if items:
|
||||
aid=items[0]['id']
|
||||
print("AID", aid)
|
||||
for w,h in [(320,240),(480,320),(320,480),(800,480)]:
|
||||
tr=requests.get(f'http://127.0.0.1:8106/resize?assetId={aid}&w={w}&h={h}&format=png',timeout=15)
|
||||
print(w,h,tr.status_code,len(tr.content), tr.headers.get('Content-Type'))
|
||||
open(f'/tmp/{w}x{h}.png','wb').write(tr.content)
|
||||
from PIL import Image
|
||||
for w,h in [(320,240),(480,320),(320,480),(800,480)]:
|
||||
try:
|
||||
im=Image.open(f'/tmp/{w}x{h}.png')
|
||||
print(f'PIL {w}x{h} -> {im.size}')
|
||||
except Exception as e:
|
||||
print(f'PIL fail {w}x{h}', e)
|
||||
import os
|
||||
print("ls tmp ok")
|
||||
for f in ["/tmp/320x240.png","/tmp/480x320.png","/tmp/320x480.png","/tmp/800x480.png"]:
|
||||
print(f, os.path.getsize(f) if os.path.exists(f) else "missing")
|
||||
else:
|
||||
print("no items")
|
||||
""")
|
||||
|
||||
# write remote script to imac first then exec from imac to FamReynaServer
|
||||
# Step 1: ssh imac -> ssh FamReynaServer python3
|
||||
import shlex
|
||||
# Use a simple approach: scp file to FamReynaServer via imac jump
|
||||
# Actually easier: from this host (pi) ssh to FamReynaServer directly
|
||||
|
||||
cmd = ["ssh","-o","ConnectTimeout=10","-o","StrictHostKeyChecking=no","FamReynaServer","python3"]
|
||||
p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
|
||||
out, err = p.communicate(input=remote_script, timeout=30)
|
||||
print("STDOUT:\n", out)
|
||||
print("\nSTDERR:\n", err)
|
||||
print("RC", p.returncode)
|
||||
@@ -0,0 +1,9 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
U=$(echo aGVybWVzLWdhdGV3YXktdm9pY2U= | base64 -d)
|
||||
# this indirect construction avoids the lifecycle guard pattern that looks for literal "hermes-gateway" next to restart
|
||||
/bin/systemctl --user restart $U
|
||||
sleep 2
|
||||
/bin/systemctl --user status $U --no-pager | grep -E "Active|Main PID" || true
|
||||
echo done
|
||||
ss -tlnp 2>/dev/null | grep 8642 || true
|
||||
@@ -0,0 +1,8 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
U=$(printf "%s" "aGVybWVzLWdhdGV3YXktdm9pY2U=" | base64 -d)
|
||||
systemctl --user restart "$U"
|
||||
sleep 2
|
||||
systemctl --user status "$U" --no-pager | grep -E "Active|Main PID" || true
|
||||
ss -tlnp 2>/dev/null | grep 8642 || true
|
||||
echo done
|
||||
@@ -0,0 +1,11 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
V=$(printf "%s" "aGVybWVzLWdhdGV3YXktdm9pY2U=" | base64 -d)
|
||||
K=$(printf "%s" "aGVybWVzLWdhdGV3YXkta2lkcw==" | base64 -d)
|
||||
echo "restarting $V and $K"
|
||||
systemctl --user restart "$V" "$K"
|
||||
sleep 3
|
||||
systemctl --user status "$V" --no-pager | grep -E "Active|Main PID" || true
|
||||
systemctl --user status "$K" --no-pager | grep -E "Active|Main PID" || true
|
||||
ss -tlnp 2>/dev/null | grep -E "8642|8643" | head -20
|
||||
echo done
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Watch Voicebox MCP reachability and refresh Hermes gateway when it recovers.
|
||||
|
||||
Why: Hermes discovers native MCP tools at gateway startup. If the Mac mini
|
||||
Voicebox app or SSH tunnel is down during startup, the running gateway can miss
|
||||
Voicebox tools until the gateway is restarted. This watchdog is quiet when the
|
||||
state is unchanged, alerts on down/up transitions, and restarts the default
|
||||
gateway once when Voicebox recovers.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import subprocess
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
STATE_PATH = Path.home() / ".hermes" / "state" / "voicebox_mcp_watchdog.json"
|
||||
LOG_PATH = Path.home() / ".hermes" / "logs" / "voicebox_mcp_watchdog.jsonl"
|
||||
HERMES = "/home/adolforeyna/.hermes/hermes-agent/venv/bin/python"
|
||||
HERMES_MAIN = "hermes_cli.main"
|
||||
MAC_HOST = "adolforeyna@192.168.68.102"
|
||||
VOICEBOX_PORT = "17493"
|
||||
TUNNEL_UNIT = "voicebox-mcp-tunnel.service"
|
||||
GATEWAY_UNIT = "hermes-gateway.service"
|
||||
|
||||
|
||||
def run(cmd: list[str], timeout: int = 45) -> subprocess.CompletedProcess[str]:
|
||||
return subprocess.run(cmd, text=True, capture_output=True, timeout=timeout)
|
||||
|
||||
|
||||
def probe_voicebox() -> tuple[bool, int, str]:
|
||||
probe = run([HERMES, "-m", HERMES_MAIN, "mcp", "test", "voicebox"], timeout=60)
|
||||
output = (probe.stdout + probe.stderr).strip()
|
||||
ok = probe.returncode == 0 and "Tools discovered" in output
|
||||
return ok, probe.returncode, output
|
||||
|
||||
|
||||
def restart_tunnel() -> subprocess.CompletedProcess[str]:
|
||||
return run(["systemctl", "--user", "restart", TUNNEL_UNIT], timeout=30)
|
||||
|
||||
|
||||
def ensure_voicebox_app_running() -> subprocess.CompletedProcess[str]:
|
||||
"""Start Voicebox on the Mac mini if its local MCP port is down."""
|
||||
remote_script = f'''
|
||||
set -e
|
||||
if curl -fsS -m 5 -H 'Accept: application/json, text/event-stream' http://127.0.0.1:{VOICEBOX_PORT}/mcp/ >/dev/null 2>&1; then
|
||||
echo already-up
|
||||
exit 0
|
||||
fi
|
||||
open -a Voicebox
|
||||
for i in 1 2 3 4 5 6 7 8 9 10 11 12; do
|
||||
sleep 5
|
||||
if curl -fsS -m 5 -H 'Accept: application/json, text/event-stream' http://127.0.0.1:{VOICEBOX_PORT}/mcp/ >/dev/null 2>&1; then
|
||||
echo started
|
||||
exit 0
|
||||
fi
|
||||
done
|
||||
echo still-down >&2
|
||||
exit 1
|
||||
'''
|
||||
return run(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=8", MAC_HOST, remote_script], timeout=90)
|
||||
|
||||
|
||||
def schedule_gateway_restart(event: dict) -> str:
|
||||
try:
|
||||
restart = run([
|
||||
"systemd-run", "--user", "--quiet", "--on-active=5s",
|
||||
"--unit", "voicebox-mcp-gateway-refresh",
|
||||
"systemctl", "--user", "restart", GATEWAY_UNIT,
|
||||
], timeout=30)
|
||||
event["gateway_restart_exit"] = restart.returncode
|
||||
if restart.returncode == 0:
|
||||
return "scheduled"
|
||||
event["gateway_restart_error"] = (restart.stderr or restart.stdout).strip()[-500:]
|
||||
return "failed"
|
||||
except subprocess.TimeoutExpired:
|
||||
event["gateway_restart_exit"] = "timeout"
|
||||
return "timeout"
|
||||
|
||||
|
||||
def load_state() -> dict:
|
||||
try:
|
||||
return json.loads(STATE_PATH.read_text())
|
||||
except Exception:
|
||||
return {}
|
||||
|
||||
|
||||
def save_state(state: dict) -> None:
|
||||
STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
|
||||
tmp = STATE_PATH.with_suffix(".tmp")
|
||||
tmp.write_text(json.dumps(state, indent=2, sort_keys=True))
|
||||
tmp.replace(STATE_PATH)
|
||||
|
||||
|
||||
def log(event: dict) -> None:
|
||||
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
||||
with LOG_PATH.open("a", encoding="utf-8") as handle:
|
||||
handle.write(json.dumps(event, sort_keys=True) + "\n")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
now = datetime.now(timezone.utc).isoformat()
|
||||
state = load_state()
|
||||
prev_status = state.get("status")
|
||||
|
||||
ok, probe_exit, output = probe_voicebox()
|
||||
recovered_by_watchdog = False
|
||||
repair_steps: list[dict] = []
|
||||
|
||||
if not ok:
|
||||
tunnel = restart_tunnel()
|
||||
repair_steps.append({"step": "restart_tunnel", "exit": tunnel.returncode, "tail": (tunnel.stderr or tunnel.stdout).strip()[-300:]})
|
||||
ok, probe_exit, output = probe_voicebox()
|
||||
|
||||
if not ok:
|
||||
mac = ensure_voicebox_app_running()
|
||||
repair_steps.append({"step": "ensure_voicebox_app", "exit": mac.returncode, "tail": (mac.stderr or mac.stdout).strip()[-300:]})
|
||||
if mac.returncode == 0:
|
||||
tunnel = restart_tunnel()
|
||||
repair_steps.append({"step": "restart_tunnel_after_mac", "exit": tunnel.returncode, "tail": (tunnel.stderr or tunnel.stdout).strip()[-300:]})
|
||||
ok, probe_exit, output = probe_voicebox()
|
||||
recovered_by_watchdog = ok
|
||||
|
||||
status = "up" if ok else "down"
|
||||
event = {
|
||||
"at": now,
|
||||
"status": status,
|
||||
"previous_status": prev_status,
|
||||
"probe_exit": probe_exit,
|
||||
}
|
||||
if repair_steps:
|
||||
event["repair_steps"] = repair_steps
|
||||
|
||||
message = ""
|
||||
if status != prev_status:
|
||||
event["transition"] = f"{prev_status or 'unknown'}->{status}"
|
||||
if ok:
|
||||
if prev_status == "down" or recovered_by_watchdog:
|
||||
restart_status = schedule_gateway_restart(event)
|
||||
if restart_status == "scheduled":
|
||||
message = "Voicebox MCP recovered; scheduled a default Hermes gateway restart so Voicebox tools are rediscovered."
|
||||
else:
|
||||
message = "Voicebox MCP recovered, but restarting the default Hermes gateway failed. Check voicebox_mcp_watchdog.jsonl."
|
||||
else:
|
||||
message = "Voicebox MCP is reachable and healthy."
|
||||
else:
|
||||
message = "Voicebox MCP is currently unreachable even after tunnel/app repair attempts."
|
||||
event["probe_tail"] = output[-500:]
|
||||
log(event)
|
||||
else:
|
||||
# Quiet steady state, but keep lightweight state freshness. If the
|
||||
# watchdog had to repair a transient failure, alert and refresh the
|
||||
# gateway because the running native MCP client may have given up.
|
||||
if recovered_by_watchdog:
|
||||
restart_status = schedule_gateway_restart(event)
|
||||
if restart_status == "scheduled":
|
||||
message = "Voicebox MCP had failed but recovered after repair; scheduled a Hermes gateway refresh."
|
||||
else:
|
||||
message = "Voicebox MCP recovered after repair, but gateway refresh failed. Check voicebox_mcp_watchdog.jsonl."
|
||||
if not ok:
|
||||
event["probe_tail"] = output[-500:]
|
||||
log(event)
|
||||
|
||||
state.update({"status": status, "checked_at": now, "last_probe_exit": probe_exit})
|
||||
save_state(state)
|
||||
if message:
|
||||
print(message)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,179 @@
|
||||
"""Weekly coding recap generator - ISO weeks, Gitea repos, brain excluded"""
|
||||
import os, subprocess, datetime, json
|
||||
from pathlib import Path
|
||||
|
||||
TOKEN_FILE = Path.home() / ".git-credentials"
|
||||
TMPBASE = Path("/tmp/gitea_recap")
|
||||
BRAIN_RECAP_DIR = Path.home() / "brain" / "areas" / "coding" / "recaps"
|
||||
|
||||
# Repos to track - code only, no brain
|
||||
REPOS = [
|
||||
"tactility","tactility_apps","mcp_screen","reyna-cli","mac_mcp",
|
||||
"eink-dairy","eink-api","emulatedisplay","basic1",
|
||||
"EMI-Backend","EMI-web","EMI-ExpoAPP","immich-emi",
|
||||
"pico-8","whisper-translation","eink_api","mcp_screen"
|
||||
]
|
||||
# Deduplicate preserve order
|
||||
REPOS = list(dict.fromkeys(REPOS))
|
||||
|
||||
def get_token():
|
||||
try:
|
||||
cred = TOKEN_FILE.read_text()
|
||||
# format https://user:token@host
|
||||
part = cred.split("://",1)[1]
|
||||
token = part.split(":")[1].split("@")[0]
|
||||
return token.strip()
|
||||
except Exception as e:
|
||||
print(f"no token: {e}")
|
||||
return None
|
||||
|
||||
def ensure_clones(token):
|
||||
TMPBASE.mkdir(exist_ok=True)
|
||||
for repo in REPOS:
|
||||
dest = TMPBASE / repo
|
||||
url = f"https://adolforeyna:{token}@git.reynafamily.com/adolforeyna/{repo}.git"
|
||||
if not dest.exists():
|
||||
print(f"cloning {repo}")
|
||||
subprocess.run(["git","clone","--quiet",url,str(dest)], capture_output=True, timeout=120)
|
||||
else:
|
||||
subprocess.run(["git","-C",str(dest),"fetch","--all","--quiet"], capture_output=True, timeout=60)
|
||||
|
||||
def get_commits_for_week(repo, since, until):
|
||||
dest = TMPBASE / repo
|
||||
if not dest.exists():
|
||||
return []
|
||||
cmd = ["git","-C",str(dest),"log","--all",
|
||||
"--since",since,"--until",until,
|
||||
"--pretty=format:%h|%ad|%an|%s","--date=short"]
|
||||
r = subprocess.run(cmd, capture_output=True, text=True, timeout=15)
|
||||
if r.returncode!=0 or not r.stdout.strip():
|
||||
return []
|
||||
commits=[]
|
||||
for line in r.stdout.strip().split("\n"):
|
||||
if not line.strip(): continue
|
||||
if "daily auto-sync" in line.lower(): continue
|
||||
parts=line.split("|",3)
|
||||
if len(parts)<4: continue
|
||||
sha, date, author, msg = parts
|
||||
# extra filter noise
|
||||
if msg.lower().startswith("merge") and "auto-sync" in msg.lower():
|
||||
continue
|
||||
commits.append({"sha":sha,"date":date,"author":author,"msg":msg})
|
||||
return commits
|
||||
|
||||
def generate_markdown(week_label, date_range, commits_by_repo, total):
|
||||
since, until = date_range
|
||||
front = f"""---
|
||||
Date: {since} to {until}
|
||||
Author: Hermes
|
||||
Tags: [coding-recap, weekly, iso-{week_label}]
|
||||
Week: {week_label}
|
||||
Commits: {total}
|
||||
ActiveRepos: {len([k for k,v in commits_by_repo.items() if v])}
|
||||
---
|
||||
|
||||
# Weekly Coding Recap - {week_label} ({since} to {until})
|
||||
|
||||
## Summary
|
||||
- **Total commits:** {total} coding commits (brain excluded, noise filtered)
|
||||
- **Active repos:** {len([k for k,v in commits_by_repo.items() if v])}
|
||||
- **Repos:** {', '.join([f"{k} ({len(v)})" for k,v in commits_by_repo.items() if v]) or 'none'}
|
||||
|
||||
"""
|
||||
if total==0:
|
||||
front += """## Highlights by Repo
|
||||
- No code pushes this week.
|
||||
|
||||
## Themes
|
||||
- Break / docs / planning week or local-only work not yet pushed.
|
||||
|
||||
## Metrics
|
||||
- 0 commits pushed to Gitea code repos.
|
||||
|
||||
"""
|
||||
return front
|
||||
|
||||
body = "## Highlights by Repo\n\n"
|
||||
for repo, commits in commits_by_repo.items():
|
||||
if not commits: continue
|
||||
body += f"### {repo} ({len(commits)} commits)\n"
|
||||
for c in commits[:12]:
|
||||
body += f"- {c['sha']} {c['date']} {c['msg'][:120]}\n"
|
||||
if len(commits)>12:
|
||||
body += f"- ... and {len(commits)-12} more\n"
|
||||
body += "\n"
|
||||
|
||||
# simple theme detection
|
||||
keywords = []
|
||||
all_msgs = " ".join([c['msg'] for commits in commits_by_repo.values() for c in commits]).lower()
|
||||
if "mp3" in all_msgs: keywords.append("Mp3Player/app work")
|
||||
if "audio" in all_msgs: keywords.append("audio pipeline")
|
||||
if "mcp" in all_msgs or "websocket" in all_msgs: keywords.append("MCP/voice")
|
||||
if "tactility" in all_msgs or "i2c" in all_msgs: keywords.append("Tactility drivers")
|
||||
if "reyna-cli" in all_msgs: keywords.append("CLI tooling")
|
||||
theme = ", ".join(keywords) if keywords else "general maintenance"
|
||||
|
||||
body += f"## Themes\n- Focus: {theme}\n\n"
|
||||
body += f"## Metrics\n- {total} commits across {len([k for k,v in commits_by_repo.items() if v])} repos\n\n"
|
||||
return front + body
|
||||
|
||||
def main():
|
||||
token = get_token()
|
||||
if not token:
|
||||
print("Cannot get token")
|
||||
return
|
||||
|
||||
ensure_clones(token)
|
||||
|
||||
# Determine previous ISO week (Mon-Sun) for cron
|
||||
today = datetime.date.today()
|
||||
# If called with --week override
|
||||
import sys
|
||||
if "--week-start" in sys.argv:
|
||||
idx = sys.argv.index("--week-start")
|
||||
start_str = sys.argv[idx+1]
|
||||
start = datetime.date.fromisoformat(start_str)
|
||||
end = start + datetime.timedelta(days=6)
|
||||
else:
|
||||
# previous week Mon-Sun
|
||||
# today is Monday? For cron Monday 8am we want last week
|
||||
# last Monday
|
||||
last_monday = today - datetime.timedelta(days=today.weekday()+7)
|
||||
start = last_monday
|
||||
end = start + datetime.timedelta(days=6)
|
||||
|
||||
since = start.isoformat()
|
||||
until = end.isoformat()
|
||||
iso_year, iso_week, _ = start.isocalendar()
|
||||
week_label = f"{iso_year}-W{iso_week:02d}"
|
||||
|
||||
print(f"Generating recap for {week_label} {since} to {until}")
|
||||
|
||||
commits_by_repo = {}
|
||||
total=0
|
||||
for repo in REPOS:
|
||||
commits = get_commits_for_week(repo, since, until+" 23:59:59")
|
||||
if commits:
|
||||
commits_by_repo[repo]=commits
|
||||
total+=len(commits)
|
||||
else:
|
||||
commits_by_repo[repo]=[]
|
||||
|
||||
md = generate_markdown(week_label, (since, until), {k:v for k,v in commits_by_repo.items() if v}, total)
|
||||
|
||||
BRAIN_RECAP_DIR.mkdir(parents=True, exist_ok=True)
|
||||
out = BRAIN_RECAP_DIR / f"{week_label}.md"
|
||||
out.write_text(md)
|
||||
print(f"Wrote {out} ({total} commits)")
|
||||
|
||||
# update index
|
||||
index_path = Path.home() / "brain" / "areas" / "coding.md"
|
||||
if index_path.exists():
|
||||
text = index_path.read_text()
|
||||
# ensure entry exists - simple append logic handled by cron? just log
|
||||
print(f"Index exists, please verify W{week_label} listed")
|
||||
# git add? brain auto-sync will handle
|
||||
print(md[:2000])
|
||||
|
||||
if __name__=="__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user