adolforeyna/reyna-cli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: archive mac mini automation baseline

Browse Source
This commit is contained in:
Adolfo Reyna
2026-08-03 11:47:09 -04:00
parent a0a26565f0
commit 6e2117188e
93 changed files with 10005 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backup/macmini-automation-baseline-2026-08-03/README.md
+28
View File
@@ -0,0 +1,28 @@
# Mac mini automation baseline — 2026-08-03
This is a source-only recovery reference captured before the Reyna CLI privacy-host consolidation.
## Included
- `hermes-scripts/` — the current Hermes scheduled/orchestration scripts. One historical file, `v_restart.py`, contains shell syntax despite its `.py` suffix; it is preserved verbatim for recovery reference and must be treated as a shell script, not compiled as Python.
- `browser/` — the dedicated ReynaFamilyBot Chrome launcher and LAN observer bridge source.
- `launch-agents/` — active Reyna/Hermes/MacMiniMCP/Kokoro/reMarkable LaunchAgent definitions with no credential values.
- `macmini-mcp/` — source, tests, package metadata, and service helper scripts for the current Node MCP and warm Kokoro setup. Dependencies, environment files, generated output, logs, and Git metadata are excluded.
## Deliberately excluded
- Browser profiles, cookies, Chrome session data, and passwords.
- `.env` files, credentials, tokens, API keys, auth databases, SSH keys, and generated logs/media.
- Third-party/inactive service definitions that contain or may contain credentials. In particular, legacy OpenClaw launch agents are **not** copied; if that legacy stack is retired, rotate its credential material rather than preserving it in Git.
- Hermes configuration, session transcripts, and WhatsApp state.
## Restore boundary
This folder is a debugging/reference snapshot, **not** an install script and not a declaration that these services should be restarted. The replacement target is the Reyna CLI single privacy host described in `.hermes/plans/2026-08-03_113451-reyna-cli-single-privacy-host.md`.
## Current architecture captured
- MacMiniMCP: Node HTTP/MCP service (historically LAN-bound/authenticated).
- Kokoro: warm local TTS HTTP server, historically loopback-bound.
- Browser: visible Mac-mini Chrome using the fixed `Profile 1` / ReynaFamilyBot profile, with CDP loopback-only and a narrow trusted-LAN observer bridge.
- reMarkable: native Reyna CLI LaunchAgents are included as the current service definitions.
backup/macmini-automation-baseline-2026-08-03/browser/hermes-browser
Executable
+75
View File
@@ -0,0 +1,75 @@
#!/bin/bash
set -euo pipefail
CHROME="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
SOURCE="$HOME/Library/Application Support/Google/Chrome"
PROFILE="$HOME/Library/Application Support/Google/Chrome-Hermes"
AGENT_BROWSER="$HOME/.hermes/hermes-agent/node_modules/.bin/agent-browser"
CDP_PORT=9222
DASHBOARD_PORT=4848
# Browser automation deliberately never uses Default/Adolfo's Chrome profile.
CHROME_PROFILE="Profile 1"
require_tools() {
test -x "$CHROME"
test -x "$AGENT_BROWSER"
}
clone_profile_once() {
if test -f "$PROFILE/Local State"; then
return
fi
mkdir -p "$PROFILE"
rsync -a \
--exclude='Cache' \
--exclude='Code Cache' \
--exclude='GPUCache' \
--exclude='GrShaderCache' \
--exclude='ShaderCache' \
--exclude='Service Worker/CacheStorage' \
--exclude='Service Worker/ScriptCache' \
--exclude='Media Cache' \
--exclude='Singleton*' \
--exclude='LOCK' \
--exclude='*.lock' \
"$SOURCE/" "$PROFILE/"
}
start() {
require_tools
clone_profile_once
if ! curl -fsS --max-time 2 "http://127.0.0.1:${CDP_PORT}/json/version" >/dev/null; then
open -na "Google Chrome" --args \
--remote-debugging-address=127.0.0.1 \
--remote-debugging-port="$CDP_PORT" \
--remote-allow-origins='*' \
--user-data-dir="$PROFILE" \
--profile-directory="$CHROME_PROFILE" \
--no-first-run \
--no-default-browser-check \
--disable-search-engine-choice-screen \
--new-window about:blank
for _ in $(seq 1 20); do
curl -fsS --max-time 1 "http://127.0.0.1:${CDP_PORT}/json/version" >/dev/null && break
sleep 1
done
fi
curl -fsS --max-time 2 "http://127.0.0.1:${CDP_PORT}/json/version" >/dev/null
"$AGENT_BROWSER" dashboard start --port "$DASHBOARD_PORT" >/dev/null 2>&1 || true
"$AGENT_BROWSER" connect "$CDP_PORT" --session hermes-visible >/dev/null
printf 'Browser automation ready. Dashboard: http://127.0.0.1:%s\n' "$DASHBOARD_PORT"
}
status() {
printf 'CDP: '
curl -fsS --max-time 2 "http://127.0.0.1:${CDP_PORT}/json/version" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(d.get("Browser", "up"))' || echo 'down'
printf 'Dashboard: '
curl -fsS --max-time 2 -o /dev/null -w '%{http_code}\n' "http://127.0.0.1:${DASHBOARD_PORT}/" || echo 'down'
printf 'Profile: %s\n' "$PROFILE"
}
case "${1:-}" in
start) start ;;
status) status ;;
*) echo "Usage: $(basename "$0") {start|status}" >&2; exit 2 ;;
esac
backup/macmini-automation-baseline-2026-08-03/browser/hermes-browser-dashboard-proxy.py
Executable
+108
View File
@@ -0,0 +1,108 @@
#!/usr/bin/env python3
"""Trusted-LAN observer bridge for agent-browser's localhost-only dashboard/stream."""
from http.client import HTTPConnection
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import re
import socket
import threading
DASHBOARD_LISTEN = ("0.0.0.0", 4849)
DASHBOARD_TARGET = ("127.0.0.1", 4848)
STREAM_LISTEN = ("0.0.0.0", 4851)
STREAM_TARGET = ("127.0.0.1", 4850)
# The bundled dashboard renders this literal and otherwise asks a laptop to
# connect to its own localhost. Route it back through this LAN bridge instead.
LOCAL_STREAM_LITERAL = b"ws://localhost:${e}"
LAN_STREAM_LITERAL = b"ws://${window.location.hostname}:4851"
class DashboardProxy(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def _forward(self):
body_length = int(self.headers.get("Content-Length", "0"))
body = self.rfile.read(body_length) if body_length else None
headers = {key: value for key, value in self.headers.items() if key.lower() not in {"host", "connection"}}
upstream = HTTPConnection(*DASHBOARD_TARGET, timeout=15)
try:
upstream.request(self.command, self.path, body=body, headers=headers)
response = upstream.getresponse()
payload = response.read()
content_type = response.getheader("Content-Type", "")
if "javascript" in content_type or "text/html" in content_type:
payload = payload.replace(LOCAL_STREAM_LITERAL, LAN_STREAM_LITERAL)
self.send_response(response.status, response.reason)
for key, value in response.getheaders():
if key.lower() not in {"content-length", "connection", "transfer-encoding"}:
self.send_header(key, value)
self.send_header("Content-Length", str(len(payload)))
self.send_header("Connection", "close")
self.end_headers()
self.wfile.write(payload)
finally:
upstream.close()
do_GET = _forward
do_POST = _forward
do_PUT = _forward
do_DELETE = _forward
def log_message(self, *_):
pass
def pipe(source, destination):
try:
while data := source.recv(65536):
destination.sendall(data)
except OSError:
pass
finally:
try:
destination.shutdown(socket.SHUT_WR)
except OSError:
pass
def handle_stream(client):
try:
upstream = socket.create_connection(STREAM_TARGET, timeout=5)
# agent-browser accepts its own localhost dashboard as the WebSocket
# origin. Preserve that trust boundary when a LAN viewer connects via
# this narrow proxy, rather than exposing the stream server directly.
request = bytearray()
while b"\r\n\r\n" not in request and len(request) < 65536:
chunk = client.recv(4096)
if not chunk:
client.close()
upstream.close()
return
request.extend(chunk)
rewritten = re.sub(
rb"(?im)^Origin: [^\r\n]*\r?$",
b"Origin: http://localhost:4848\r",
bytes(request),
)
upstream.sendall(rewritten)
except OSError:
client.close()
return
threading.Thread(target=pipe, args=(client, upstream), daemon=True).start()
pipe(upstream, client)
client.close()
upstream.close()
def run_stream_proxy():
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(STREAM_LISTEN)
server.listen(50)
while True:
client, _ = server.accept()
threading.Thread(target=handle_stream, args=(client,), daemon=True).start()
threading.Thread(target=run_stream_proxy, daemon=True).start()
ThreadingHTTPServer(DASHBOARD_LISTEN, DashboardProxy).serve_forever()
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/calendar_ics_fallback_fetch.py
+20
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/chiapas_flight_price_monitor.py
Executable
+148
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/deco_network_watchdog.py
Executable
+263
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/deco_network_watchdog.sh
Executable
+5
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_happy_face_now.sh
+20
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_mcp_say_hi_test.sh
+35
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_say_no_now.sh
+22
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_send_hi_all.py
+76
View File
@@ -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)
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_send_thumbs_all.py
+163
View File
@@ -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)
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_try_say_hi.sh
+33
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/esp32_use_request_ip.sh
+53
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/family_silent_reading_get_ready_745.py
+41
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/family_silent_reading_time_800.py
+42
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/find_remarkable.py
+80
View File
@@ -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")
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/install_local_mcp_hosts.sh
Executable
+27
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/kokoro_codex_tts.py
+119
View File
@@ -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()
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/reload-gw.sh
+19
View File
@@ -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 ==="
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/remarkable_watchdog.py
Executable
+120
View File
@@ -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()
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/remarkable_watchdog_v2.py
+110
View File
@@ -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()
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/restart_gw.py
+22
View File
@@ -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)
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/restart_voice_safe.sh
Executable
+9
View File
@@ -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"
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/restart_voice_v2.sh
+7
View File
@@ -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"
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/reyna_family_wind_down_whatsapp.py
Executable
+41
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/reyna_morning_briefing_whatsapp.py
+174
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/reynabot_screen_mcp.py
Executable
+167
View File
@@ -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()
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/robot_arm_proximity_wave.py
Executable
+137
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/send_esp32_happy_face.sh
+14
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/test_resize_proxy.py
+48
View File
@@ -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)
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/v_restart.py
+9
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/v_restart.sh
Executable
+8
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/vk_restart.sh
Executable
+11
View File
@@ -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
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/voicebox_mcp_watchdog.py
Executable
+172
View File
@@ -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())
backup/macmini-automation-baseline-2026-08-03/hermes-scripts/weekly_coding_recap.py
+179
View File
@@ -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()
backup/macmini-automation-baseline-2026-08-03/launch-agents/ai.hermes.gateway.plist
+59
View File
@@ -0,0 +1,59 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>ai.hermes.gateway</string>
<key>ProgramArguments</key>
<array>
<string>/Users/adolforeyna/.hermes/hermes-agent/venv/bin/python</string>
<string>-m</string>
<string>hermes_cli.main</string>
<string>gateway</string>
<string>run</string>
<string>--replace</string>
</array>
<key>WorkingDirectory</key>
<string>/Users/adolforeyna/.hermes</string>
<key>EnvironmentVariables</key>
<dict>
<key>PATH</key>
<string>/Users/adolforeyna/.hermes/hermes-agent/venv/bin:/Users/adolforeyna/.hermes/hermes-agent/node_modules/.bin:/Users/adolforeyna/.nvm/versions/node/v22.22.0/bin:/usr/local/bin:/System/Cryptexes/App/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/local/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/bin:/var/run/com.apple.security.cryptexd/codex.system/bootstrap/usr/appleinternal/bin:/pkg/env/global/bin:/Library/Apple/usr/bin:/opt/homebrew/opt/ruby/bin:/Users/adolforeyna/.local/bin:/opt/homebrew/bin:/opt/homebrew/sbin:/Applications/Docker.app/Contents/Resources/bin/:/usr/local/sbin:/Users/adolforeyna/.hermes/bin</string>
<key>VIRTUAL_ENV</key>
<string>/Users/adolforeyna/.hermes/hermes-agent/venv</string>
<key>HERMES_HOME</key>
<string>/Users/adolforeyna/.hermes</string>
</dict>
<key>LimitLoadToSessionType</key>
<array>
<string>Aqua</string>
<string>Background</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<!-- ThrottleInterval raises launchd's default 10s minimum respawn interval
to 30s so a crash-looping gateway can't hammer launchd into a rapid
respawn storm; ExitTimeOut gives the gateway 25s of graceful-drain
headroom before launchd escalates from SIGTERM to SIGKILL on stop. -->
<key>ThrottleInterval</key>
<integer>30</integer>
<key>ExitTimeOut</key>
<integer>25</integer>
<key>StandardOutPath</key>
<string>/Users/adolforeyna/.hermes/logs/gateway.log</string>
<key>StandardErrorPath</key>
<string>/Users/adolforeyna/.hermes/logs/gateway.error.log</string>
</dict>
</plist>
backup/macmini-automation-baseline-2026-08-03/launch-agents/com.local.ksay-kokoro.plist
+25
View File
@@ -0,0 +1,25 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.local.ksay-kokoro</string>
<key>ProgramArguments</key>
<array>
<string>/Users/adolforeyna/Projects/MacMiniMCP/.venv/bin/python</string>
<string>/Users/adolforeyna/Projects/MacMiniMCP/scripts/ksay_server.py</string>
</array>
<key>WorkingDirectory</key>
<string>/Users/adolforeyna/Projects/MacMiniMCP</string>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>2</integer>
<key>StandardOutPath</key>
<string>/Users/adolforeyna/Projects/MacMiniMCP/.logs/ksay.out.log</string>
<key>StandardErrorPath</key>
<string>/Users/adolforeyna/Projects/MacMiniMCP/.logs/ksay.err.log</string>
</dict>
</plist>
backup/macmini-automation-baseline-2026-08-03/launch-agents/com.local.macmini-mcp.plist
+26
View File
@@ -0,0 +1,26 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.local.macmini-mcp</string>
<key>ProgramArguments</key>
<array>
<string>/Users/adolforeyna/.nvm/versions/node/v22.22.0/bin/node</string>
<string>--watch</string>
<string>src/http.js</string>
</array>
<key>WorkingDirectory</key>
<string>/Users/adolforeyna/Projects/MacMiniMCP</string>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>2</integer>
<key>StandardOutPath</key>
<string>/Users/adolforeyna/Projects/MacMiniMCP/.logs/service.out.log</string>
<key>StandardErrorPath</key>
<string>/Users/adolforeyna/Projects/MacMiniMCP/.logs/service.err.log</string>
</dict>
</plist>
backup/macmini-automation-baseline-2026-08-03/launch-agents/com.reyna.hermes-browser-dashboard-proxy.plist
+21
View File
@@ -0,0 +1,21 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>com.reyna.hermes-browser-dashboard-proxy</string>
<key>ProgramArguments</key>
<array>
<string>/usr/bin/python3</string>
<string>/Users/adolforeyna/bin/hermes-browser-dashboard-proxy.py</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>StandardOutPath</key>
<string>/Users/adolforeyna/Library/Logs/hermes-browser-dashboard-proxy.log</string>
<key>StandardErrorPath</key>
<string>/Users/adolforeyna/Library/Logs/hermes-browser-dashboard-proxy.error.log</string>
</dict>
</plist>
backup/macmini-automation-baseline-2026-08-03/launch-agents/com.reynafamily.reyna-cli.remarkable-listener.plist
+29
View File
@@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>EnvironmentVariables</key>
<dict>
<key>REYNA_REMARKABLE_ROOT</key>
<string>/Users/adolforeyna/Library/Application Support/reyna-cli/remarkable</string>
</dict>
<key>KeepAlive</key>
<true/>
<key>Label</key>
<string>com.reynafamily.reyna-cli.remarkable-listener</string>
<key>ProgramArguments</key>
<array>
<string>/Users/adolforeyna/.local/share/uv/tools/reyna-cli/bin/python</string>
<string>-m</string>
<string>reyna_cli.cli</string>
<string>remarkable</string>
<string>listen</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>StandardErrorPath</key>
<string>/Users/adolforeyna/Library/Application Support/reyna-cli/remarkable/listener.error.log</string>
<key>StandardOutPath</key>
<string>/Users/adolforeyna/Library/Application Support/reyna-cli/remarkable/listener.log</string>
</dict>
</plist>
backup/macmini-automation-baseline-2026-08-03/launch-agents/com.reynafamily.reyna-cli.remarkable-sync.plist
+29
View File
@@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>EnvironmentVariables</key>
<dict>
<key>REYNA_REMARKABLE_ROOT</key>
<string>/Users/adolforeyna/Library/Application Support/reyna-cli/remarkable</string>
</dict>
<key>Label</key>
<string>com.reynafamily.reyna-cli.remarkable-sync</string>
<key>ProgramArguments</key>
<array>
<string>/Users/adolforeyna/.local/share/uv/tools/reyna-cli/bin/python</string>
<string>-m</string>
<string>reyna_cli.cli</string>
<string>remarkable</string>
<string>sync</string>
</array>
<key>RunAtLoad</key>
<true/>
<key>StandardErrorPath</key>
<string>/Users/adolforeyna/Library/Application Support/reyna-cli/remarkable/sync.error.log</string>
<key>StandardOutPath</key>
<string>/Users/adolforeyna/Library/Application Support/reyna-cli/remarkable/sync.log</string>
<key>StartInterval</key>
<integer>30</integer>
</dict>
</plist>
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/.gitignore
+7
View File
@@ -0,0 +1,7 @@
node_modules/
.venv/
.env
*.log
.logs/
.DS_Store
coverage/
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/README.md
+233
View File
@@ -0,0 +1,233 @@
# MacMini MCP
A local Model Context Protocol server that exposes selected macOS app actions to
an AI harness. It uses Apple's scripting interfaces through `/usr/bin/osascript`
and stays on the local machine.
## Available tools
| Tool | Action |
| --- | --- |
| `notes_list` | Search notes; returns titles and metadata unless previews are explicitly requested |
| `notes_read` | Read a note by the ID returned by `notes_list` |
| `notes_create` | Create a plaintext-backed note |
| `mail_accounts` | List configured Apple Mail accounts (read-only) |
| `mail_list_mailboxes` | List Apple Mail's top-level mailboxes (read-only) |
| `mail_list_messages` | List metadata from one selected account and mailbox (read-only) |
| `mail_read_message` | Read a selected Apple Mail message (read-only) |
| `calendar_list_calendars` | List calendar indexes, names, and write capability |
| `calendar_list_events` | List events in an ISO-8601 time window from the focused `Home` calendar |
| `calendar_create_event` | Create an event in the focused `Home` calendar |
| `reminders_list_lists` | List reminder lists with account context and assignment metadata availability |
| `reminders_list` | List reminders, including assignment details or assignment hints for shared-list reminders |
| `reminders_create` | Create a reminder |
| `contacts_search` | Search contact names and organizations without disclosing contact methods |
| `contacts_read` | Read phone and email details for one selected contact |
| `contacts_create` | Create a contact with optional email and phone details |
| `deco_get_config_status` | Show Deco connection config without revealing the password |
| `deco_get_overview` | Read TP-Link Deco overview stats and firmware |
| `deco_list_clients` | List online Deco clients, current traffic speeds, and linked mesh node when available |
| `deco_get_ipv4_status` | Read WAN/LAN IPv4 status |
| `deco_get_firmware` | Read Deco model and firmware version |
| `system_get_info` | Get macOS version (sw_vers), hardware model, and SpeechAnalyzer availability |
| `system_speech_api_status` | Full check for Apple SpeechAnalyzer/SpeechTranscriber (macOS 26+) |
| `speech_kokoro_status` | Check the warm `ksay` Kokoro TTS daemon |
| `speech_kokoro_synthesize` | Generate fast Kokoro speech to a local WAV file |
| `speech_kokoro_synthesize_base64` | Generate fast Kokoro speech and return WAV base64 |
| `codex_image_get_config_status` | Show local Codex CLI image generation config |
| `codex_image_generate` | Generate an image with this Mac's Codex CLI and save it locally |
| `gemini_image_get_config_status` | Show Gemini image generation config without revealing the API key |
| `gemini_image_generate` | Generate an image with the Gemini API and save it locally |
| `gemini_chrome_prompt_get_config_status` | Show config for the Codex Chrome-skill Gemini image prompt builder |
| `gemini_chrome_prompt_build` | Build a ready-to-run Codex prompt for Gemini web-app image generation |
There are no destructive tools in the initial server.
Calendar names can repeat across accounts. This server is focused on the
event-rich `Home` calendar discovered during setup (`calendarIndex: 2`) and
verifies the selected index is still named `Home` before operating on it.
Calendar selector parameters remain available as advanced overrides.
Reminder assignment data is exposed on `reminders_list` as an `assignment`
object. Apple Reminders automation does not currently publish shared-list
participant metadata directly, so the tool first checks for any native assignee
field macOS exposes and then falls back to assignment hints embedded in the
reminder title or notes, such as `(Alicia)` or `Captured 2026-05-18, Alicia;`.
**macOS 26 note:** This Mac is on macOS 26.5.2 (Mac16,10 M4) — so `system_speech_api_status`
confirms SpeechAnalyzer/SpeechTranscriber is available. Apple's new engine beats Whisper
Small 2.12% vs 3.74% WER per Inscribe benchmark (2026-07-13).
## Setup
Requires macOS and Node.js 20 or newer.
```sh
npm install
npm run python:install
npm run check
npm run service:install
npm run ksay:install
```
The service defaults to a same-Mac endpoint:
```text
http://127.0.0.1:7331/mcp
```
Health check:
```sh
curl -s http://127.0.0.1:7331/health
```
`launchd` runs `node --watch src/http.js`, so edits to the server or imported
modules cause it to restart automatically while the agent remains installed.
After changing installed dependencies or service configuration, run:
```sh
npm install
npm run service:install
```
Operational commands:
```sh
npm run service:status
npm run service:restart
npm run service:uninstall
npm run ksay:restart
```
Service logs are stored in `.logs/`.
## Fast Kokoro speech with `ksay`
This repo includes a warm Kokoro TTS daemon backed by `mlx-audio`, plus
`bin/ksay`, a console command intended as a neural replacement for macOS `say`.
The launchd service preloads the model and keeps it resident, so normal calls
only pay generation and playback time.
Install Python dependencies and the warm service:
```sh
npm run python:install
npm run ksay:install
```
Add the repo's `bin` directory to your shell path:
```sh
export PATH="/Users/adolforeyna/Projects/MacMiniMCP/bin:$PATH"
```
Examples:
```sh
ksay "Hello from Kokoro."
ksay -v af_bella --speed 1.15 "Fast, warm speech."
echo "Piped text works too." | ksay
ksay --no-play -o /tmp/hello.wav "Write a wav without playback."
ksay --status
```
Defaults can be overridden with environment variables:
```text
KSAY_MODEL=mlx-community/Kokoro-82M-8bit
KSAY_VOICE=af_heart
KSAY_LANG_CODE=a
KSAY_PORT=7332
KSAY_OUTPUT_DIR=/Users/adolforeyna/Projects/MacMiniMCP/generated-audio
```
Useful Kokoro voices include `af_heart`, `af_bella`, `af_nova`, `af_sky`,
`am_adam`, `am_echo`, `bf_alice`, `bf_emma`, `bm_daniel`, and `bm_george`.
Use language code `a` for American English and `b` for British English.
## Harness configuration
For a harness that supports Streamable HTTP, configure the local MCP URL as
`http://127.0.0.1:7331/mcp`.
For a trusted local-network harness such as a Raspberry Pi, set
`MACMINI_MCP_HOST` in `.env` to the Mac's LAN IP and set a strong
`MACMINI_MCP_TOKEN`. Then configure the remote MCP client with:
```text
URL: http://<mac-lan-ip>:7331/mcp
Authorization: Bearer <MACMI...KEN>
```
Restart after changing `.env`:
```sh
npm run service:restart
```
For TP-Link Deco tools, install Python dependencies with `npm run
python:install`, then set `DECO_HOST`, `DECO_USERNAME=admin`, `DECO_PASSWORD`,
and optionally `DECO_VERIFY_SSL=false` in `.env`.
For Codex image generation, make sure the Mac is logged in with `codex login`.
Generated files are saved to `generated-images/` by default; override this with
`CODEX_IMAGE_OUTPUT_DIR`. Set `CODEX_IMAGE_MODEL` or `CODEX_IMAGE_TIMEOUT_MS` or
`CODEX_CLI_PATH` to the absolute `codex` path.
For Gemini image generation, set `GEMINI_API_KEY` in `.env`. Generated files are
saved to `generated-images/` by default; override this with
`GEMINI_IMAGE_OUTPUT_DIR`. The Gemini image tool calls the Gemini API directly
and does not expose browser navigation, page inspection, or screenshot tools.
For Gemini image generation through the signed-in Chrome web app, use
`gemini_chrome_prompt_build` to create a ready-to-run Codex prompt. The MCP
service does not control Chrome directly; the Chrome skill is only available
inside an active Codex session. The generated prompt verifies the Chrome profile
name is `ReynaFamilyBot`, opens only `https://gemini.google.com/app`, submits the
image prompt, downloads the generated image, and copies it to
`generated-images/`. Override the expected Chrome profile with
`GEMINI_CHROME_PROFILE_NAME` and the output directory with
`GEMINI_CHROME_IMAGE_OUTPUT_DIR`.
For a harness that launches stdio servers, use:
```json
{
"mcpServers": {
"macmini": {
"command": "/Users/adolforeyna/.nvm/versions/node/v22.22.0/bin/node",
"args": ["/Users/adolforeyna/Projects/MacMiniMCP/src/stdio.js"]
}
}
}
```
## Permissions and security
On first use of a Notes, Calendar, Reminders, or Contacts tool, macOS may ask for
Automation access for Node. Permit only the applications you want the server
to control under **System Settings > Privacy & Security > Automation**.
The HTTP service binds to `127.0.0.1` by default. When configured to bind to a
LAN address, it refuses to start without `MACMINI_MCP_TOKEN`; clients must send
`Authorization: Bearer *** This is HTTP bearer authentication on your
local network, not encrypted transport. Use it only on a trusted LAN or put it
behind a private encrypted network such as a VPN.
## Development
```sh
npm run check
npm run dev
```
The MCP transport follows the official TypeScript SDK Streamable HTTP server
approach: [Model Context Protocol TypeScript SDK](https://github.com/modelcontextprotocol/typescript-sdk).
## Image generation
This server exposes Codex-backed and Gemini-backed image generation tools.
Gemini image generation uses the Gemini API directly, not browser automation.
Image Playground was tried and removed because the macOS app does not expose a
scriptable prompt-to-file action through AppleScript or Shortcuts/App Intents.
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/WatchHermes/AudioCaptureManager.swift
+127
View File
@@ -0,0 +1,127 @@
import AVFoundation
import Foundation
enum AudioCaptureState: Equatable {
case idle
case starting
case recording
case failed(String)
}
@MainActor
final class AudioCaptureManager: ObservableObject {
@Published private(set) var state: AudioCaptureState = .idle
var onPCMChunk: ((Data) -> Void)?
private let engine = AVAudioEngine()
private var converter: AVAudioConverter?
private var inputFormat: AVAudioFormat?
private let targetFormat = AVAudioFormat(
commonFormat: .pcmFormatInt16,
sampleRate: 16_000,
channels: 1,
interleaved: true
)!
func requestPermission() async -> Bool {
await withCheckedContinuation { continuation in
AVAudioSession.sharedInstance().requestRecordPermission { granted in
continuation.resume(returning: granted)
}
}
}
func startRecording() async {
guard state != .recording && state != .starting else { return }
state = .starting
guard await requestPermission() else {
state = .failed("Microphone permission was denied.")
return
}
do {
try configureSession()
try configureEngine()
try engine.start()
state = .recording
} catch {
stopRecording()
state = .failed(error.localizedDescription)
}
}
func stopRecording() {
guard state == .recording || state == .starting else { return }
engine.inputNode.removeTap(onBus: 0)
engine.stop()
converter = nil
inputFormat = nil
state = .idle
}
private func configureSession() throws {
let session = AVAudioSession.sharedInstance()
try session.setCategory(.playAndRecord, mode: .voiceChat, options: [.defaultToSpeaker])
try session.setPreferredSampleRate(16_000)
try session.setPreferredIOBufferDuration(0.02)
try session.setActive(true)
}
private func configureEngine() throws {
let inputNode = engine.inputNode
let hardwareFormat = inputNode.outputFormat(forBus: 0)
inputFormat = hardwareFormat
converter = AVAudioConverter(from: hardwareFormat, to: targetFormat)
inputNode.removeTap(onBus: 0)
inputNode.installTap(onBus: 0, bufferSize: 1024, format: hardwareFormat) { [weak self] buffer, _ in
Task { @MainActor in
guard let self else { return }
guard let data = self.convertToTargetPCM(buffer) else { return }
self.onPCMChunk?(data)
}
}
engine.prepare()
}
private func convertToTargetPCM(_ inputBuffer: AVAudioPCMBuffer) -> Data? {
guard let converter else { return nil }
let ratio = targetFormat.sampleRate / inputBuffer.format.sampleRate
let targetFrameCapacity = AVAudioFrameCount(Double(inputBuffer.frameLength) * ratio) + 1
guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: targetFrameCapacity) else {
return nil
}
var didProvideInput = false
var conversionError: NSError?
converter.convert(to: outputBuffer, error: &conversionError) { _, status in
if didProvideInput {
status.pointee = .noDataNow
return nil
}
didProvideInput = true
status.pointee = .haveData
return inputBuffer
}
guard conversionError == nil else { return nil }
return outputBuffer.interleavedPCMData()
}
}
private extension AVAudioPCMBuffer {
func interleavedPCMData() -> Data? {
let audioBuffer = audioBufferList.pointee.mBuffers
guard let source = audioBuffer.mData else { return nil }
return Data(bytes: source, count: Int(audioBuffer.mDataByteSize))
}
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/WatchHermes/AudioStreamManager.swift
+202
View File
@@ -0,0 +1,202 @@
import AVFoundation
import Foundation
enum HermesConnectionState: Equatable {
case disconnected
case connecting
case connected
case failed(String)
}
enum HermesPlaybackState: Equatable {
case idle
case playing
case failed(String)
}
@MainActor
final class AudioStreamManager: NSObject, ObservableObject {
@Published private(set) var connectionState: HermesConnectionState = .disconnected
@Published private(set) var playbackState: HermesPlaybackState = .idle
private let endpoint: URL
private let session: URLSession
private var task: URLSessionWebSocketTask?
private var avPlayer: AVAudioPlayer?
private let rawPlaybackEngine = AVAudioEngine()
private let rawPlaybackNode = AVAudioPlayerNode()
private let rawPlaybackFormat = AVAudioFormat(
commonFormat: .pcmFormatInt16,
sampleRate: 16_000,
channels: 1,
interleaved: true
)!
init(endpoint: URL) {
self.endpoint = endpoint
self.session = URLSession(configuration: .default)
super.init()
configureRawPlaybackEngine()
}
func connect() {
guard task == nil else { return }
connectionState = .connecting
let task = session.webSocketTask(with: endpoint)
self.task = task
task.resume()
connectionState = .connected
receiveLoop()
}
func disconnect() {
task?.cancel(with: .goingAway, reason: nil)
task = nil
connectionState = .disconnected
}
func sendPCMChunk(_ data: Data) {
guard let task else { return }
task.send(.data(data)) { [weak self] error in
guard let error else { return }
Task { @MainActor in
self?.connectionState = .failed(error.localizedDescription)
}
}
}
func sendText(_ text: String) {
guard let task else { return }
task.send(.string(text)) { [weak self] error in
guard let error else { return }
Task { @MainActor in
self?.connectionState = .failed(error.localizedDescription)
}
}
}
/// Optional protocol hint for servers that distinguish press/release.
func sendControlEvent(_ name: String) {
sendText(#"{"type":"\#(name)"}"#)
}
private func receiveLoop() {
task?.receive { [weak self] result in
Task { @MainActor in
guard let self else { return }
switch result {
case .success(let message):
self.handle(message)
self.receiveLoop()
case .failure(let error):
self.task = nil
self.connectionState = .failed(error.localizedDescription)
}
}
}
}
private func handle(_ message: URLSessionWebSocketTask.Message) {
switch message {
case .data(let data):
if data.isWAV {
playWAV(data)
} else {
playRawPCMChunk(data)
}
case .string(let text):
handleControlMessage(text)
@unknown default:
break
}
}
private func handleControlMessage(_ text: String) {
if text == "done" || text.contains(#""type":"done""#) {
playbackState = .idle
}
}
private func playWAV(_ data: Data) {
do {
try configurePlaybackSession()
avPlayer = try AVAudioPlayer(data: data)
avPlayer?.delegate = self
avPlayer?.prepareToPlay()
avPlayer?.play()
playbackState = .playing
} catch {
playbackState = .failed(error.localizedDescription)
}
}
private func configureRawPlaybackEngine() {
rawPlaybackEngine.attach(rawPlaybackNode)
rawPlaybackEngine.connect(rawPlaybackNode, to: rawPlaybackEngine.mainMixerNode, format: rawPlaybackFormat)
}
private func playRawPCMChunk(_ data: Data) {
do {
try configurePlaybackSession()
if !rawPlaybackEngine.isRunning {
try rawPlaybackEngine.start()
}
if !rawPlaybackNode.isPlaying {
rawPlaybackNode.play()
}
guard let buffer = data.makePCMBuffer(format: rawPlaybackFormat) else { return }
rawPlaybackNode.scheduleBuffer(buffer, completionHandler: nil)
playbackState = .playing
} catch {
playbackState = .failed(error.localizedDescription)
}
}
private func configurePlaybackSession() throws {
let session = AVAudioSession.sharedInstance()
try session.setCategory(.playAndRecord, mode: .default, options: [.defaultToSpeaker])
try session.setActive(true)
}
}
extension AudioStreamManager: AVAudioPlayerDelegate {
nonisolated func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
Task { @MainActor in
self.playbackState = .idle
}
}
}
private extension Data {
var isWAV: Bool {
count >= 12 &&
self[0] == 0x52 && self[1] == 0x49 && self[2] == 0x46 && self[3] == 0x46 &&
self[8] == 0x57 && self[9] == 0x41 && self[10] == 0x56 && self[11] == 0x45
}
func makePCMBuffer(format: AVAudioFormat) -> AVAudioPCMBuffer? {
let bytesPerFrame = Int(format.streamDescription.pointee.mBytesPerFrame)
guard bytesPerFrame > 0 else { return nil }
let frameCount = AVAudioFrameCount(count / bytesPerFrame)
guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCount) else { return nil }
buffer.frameLength = frameCount
let audioBuffer = buffer.audioBufferList.pointee.mBuffers
guard let destination = audioBuffer.mData else { return nil }
withUnsafeBytes { rawBuffer in
guard let source = rawBuffer.baseAddress else { return }
destination.copyMemory(from: source, byteCount: Int(audioBuffer.mDataByteSize))
}
return buffer
}
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/WatchHermes/ContentView.swift
+135
View File
@@ -0,0 +1,135 @@
import SwiftUI
struct ContentView: View {
@StateObject private var streamManager: AudioStreamManager
@StateObject private var captureManager = AudioCaptureManager()
@State private var isPressing = false
init() {
let manager = AudioStreamManager(endpoint: URL(string: "ws://192.168.68.126:8642/stream")!)
_streamManager = StateObject(wrappedValue: manager)
}
var body: some View {
VStack(spacing: 14) {
Text("Hermes")
.font(.headline)
Text(statusText)
.font(.caption2)
.foregroundStyle(statusColor)
.lineLimit(2)
.multilineTextAlignment(.center)
.frame(minHeight: 28)
Circle()
.fill(buttonFill)
.overlay {
Image(systemName: isPressing ? "waveform" : "mic.fill")
.font(.system(size: 36, weight: .semibold))
.foregroundStyle(.white)
}
.overlay {
Circle()
.stroke(.white.opacity(isPressing ? 0.9 : 0.25), lineWidth: 3)
}
.frame(width: 112, height: 112)
.scaleEffect(isPressing ? 0.94 : 1.0)
.animation(.spring(response: 0.2, dampingFraction: 0.75), value: isPressing)
.gesture(
DragGesture(minimumDistance: 0)
.onChanged { _ in
guard !isPressing else { return }
isPressing = true
startPTT()
}
.onEnded { _ in
isPressing = false
stopPTT()
}
)
Text(isPressing ? "Release to send" : "Hold to talk")
.font(.caption2)
.foregroundStyle(.secondary)
}
.padding()
.onAppear {
streamManager.connect()
captureManager.onPCMChunk = { [streamManager] chunk in
streamManager.sendPCMChunk(chunk)
}
}
.onDisappear {
captureManager.stopRecording()
streamManager.disconnect()
}
}
private var statusText: String {
switch captureManager.state {
case .recording:
return "Listening"
case .starting:
return "Starting mic"
case .failed(let message):
return message
case .idle:
break
}
switch streamManager.playbackState {
case .playing:
return "Playing response"
case .failed(let message):
return message
case .idle:
break
}
switch streamManager.connectionState {
case .connected:
return "Ready"
case .connecting:
return "Connecting"
case .disconnected:
return "Disconnected"
case .failed(let message):
return message
}
}
private var statusColor: Color {
if case .failed = captureManager.state { return .red }
if case .failed = streamManager.connectionState { return .red }
if case .failed = streamManager.playbackState { return .red }
if captureManager.state == .recording { return .green }
if streamManager.playbackState == .playing { return .blue }
return .secondary
}
private var buttonFill: Color {
if captureManager.state == .recording { return .red }
if streamManager.playbackState == .playing { return .blue }
return .accentColor
}
private func startPTT() {
streamManager.connect()
streamManager.sendControlEvent("start")
Task {
await captureManager.startRecording()
}
}
private func stopPTT() {
captureManager.stopRecording()
streamManager.sendControlEvent("stop")
}
}
#Preview {
ContentView()
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/WatchHermes/InfoPlistAdditions.xml
+9
View File
@@ -0,0 +1,9 @@
<!-- Add these entries inside the top-level <dict> of the watchOS target Info.plist. -->
<key>NSMicrophoneUsageDescription</key>
<string>Hermes needs microphone access so you can hold the talk button and speak to your assistant.</string>
<key>NSLocalNetworkUsageDescription</key>
<string>Hermes connects to your local assistant server over your Wi-Fi network.</string>
<key>UIBackgroundModes</key>
<array>
<string>audio</string>
</array>
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/WatchHermes/README.md
+18
View File
@@ -0,0 +1,18 @@
# Hermes Watch PTT Foundation
These files are intended to be added to a standalone watchOS SwiftUI app target:
- `AudioCaptureManager.swift`: captures microphone audio with `AVAudioEngine`, converts it to 16 kHz, 16-bit, mono PCM, and emits raw `Data` chunks.
- `AudioStreamManager.swift`: opens a `URLSessionWebSocketTask`, sends binary PCM chunks, receives binary response audio, and plays either complete WAV blobs or raw 16 kHz PCM chunks.
- `ContentView.swift`: minimal push-to-talk UI using `DragGesture(minimumDistance: 0)` for press/release.
- `InfoPlistAdditions.xml`: exact plist entries for microphone, LAN access, and background audio.
The referenced ESP32 demo posts a complete WAV file to `http://192.168.68.126:8642/api/esp32/voice` with 16 kHz, 16-bit, mono PCM and receives WAV audio back. The watch implementation here follows your requested WebSocket model: it streams raw PCM chunks while the button is held, sends simple `{"type":"start"}` and `{"type":"stop"}` text control messages, and accepts either WAV or raw PCM binary responses.
Update the endpoint in `ContentView.init()`:
```swift
AudioStreamManager(endpoint: URL(string: "ws://YOUR_LOCAL_IP:PORT/stream")!)
```
If your Hermes WebSocket endpoint expects authentication headers, create a `URLRequest`, set the headers, and pass that request into `session.webSocketTask(with:)` in `AudioStreamManager.connect()`.
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/bin/ksay
Executable
+145
View File
@@ -0,0 +1,145 @@
#!/usr/bin/env python3
from __future__ import annotations
import argparse
import http.client
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request
DEFAULT_URL = os.environ.get("KSAY_URL", "http://127.0.0.1:7332")
LAUNCHD_LABEL = os.environ.get("KSAY_LAUNCHD_LABEL", "com.local.ksay-kokoro")
def read_stdin_if_needed(text_parts: list[str]) -> str:
if text_parts:
return " ".join(text_parts)
if not sys.stdin.isatty():
return sys.stdin.read()
return ""
def request_json(method: str, path: str, payload: dict | None = None) -> dict:
data = None
headers = {}
if payload is not None:
data = json.dumps(payload).encode("utf-8")
headers["content-type"] = "application/json"
req = urllib.request.Request(
f"{DEFAULT_URL}{path}",
data=data,
headers=headers,
method=method,
)
try:
with urllib.request.urlopen(req, timeout=120) as res:
return json.loads(res.read().decode("utf-8"))
except urllib.error.HTTPError as exc:
body = exc.read().decode("utf-8", errors="replace")
try:
return json.loads(body)
except json.JSONDecodeError:
raise RuntimeError(f"ksay server returned HTTP {exc.code}: {body}") from exc
def try_wake_service() -> None:
domain = f"gui/{os.getuid()}"
subprocess.run(
["launchctl", "kickstart", "-k", f"{domain}/{LAUNCHD_LABEL}"],
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
check=False,
)
def post_say(payload: dict) -> dict:
try:
return request_json("POST", "/say", payload)
except (
ConnectionError,
ConnectionResetError,
http.client.RemoteDisconnected,
urllib.error.URLError,
):
try_wake_service()
time.sleep(1.0)
return request_json("POST", "/say", payload)
def play_audio(path: str) -> None:
subprocess.run(["/usr/bin/afplay", path], check=True)
def main() -> int:
parser = argparse.ArgumentParser(
prog="ksay",
description="Fast warm Kokoro TTS, intended as a neural replacement for macOS say.",
)
parser.add_argument("text", nargs="*", help="Text to speak. Reads stdin when omitted.")
parser.add_argument("-v", "--voice", default=os.environ.get("KSAY_VOICE", "af_heart"))
parser.add_argument("-r", "--rate", type=float, default=None, help="Compatibility alias; maps words/minute-ish values to speed.")
parser.add_argument("--speed", type=float, default=None, help="Kokoro speed multiplier.")
parser.add_argument("--lang-code", default=os.environ.get("KSAY_LANG_CODE", "a"))
parser.add_argument("-o", "--output", help="Write WAV to this path.")
parser.add_argument("--no-play", action="store_true", help="Generate the file without playing it.")
parser.add_argument("--json", action="store_true", help="Print the server response as JSON.")
parser.add_argument("--status", action="store_true", help="Show warm server health.")
parser.add_argument("--start", action="store_true", help="Kick the launchd service and wait for health.")
args = parser.parse_args()
if args.status:
print(json.dumps(request_json("GET", "/health"), indent=2))
return 0
if args.start:
try_wake_service()
for _ in range(60):
try:
print(json.dumps(request_json("GET", "/health"), indent=2))
return 0
except Exception:
time.sleep(1)
print("ksay service did not become healthy within 60s.", file=sys.stderr)
return 1
text = read_stdin_if_needed(args.text).strip()
if not text:
parser.error("text is required, or pipe text on stdin")
speed = args.speed
if speed is None:
speed = 1.0
if args.rate:
speed = max(0.5, min(2.0, args.rate / 180.0))
result = post_say(
{
"text": text,
"voice": args.voice,
"speed": speed,
"langCode": args.lang_code,
"output": args.output,
}
)
if not result.get("ok"):
print(result.get("error", "ksay failed"), file=sys.stderr)
return 1
if args.json:
print(json.dumps(result, indent=2))
else:
print(result["filePath"])
if not args.no_play:
play_audio(result["filePath"])
return 0
if __name__ == "__main__":
raise SystemExit(main())
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/package-lock.json
Generated
+1160
View File
File diff suppressed because it is too large Load Diff
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/package.json
+28
View File
@@ -0,0 +1,28 @@
{
"name": "macmini-mcp",
"version": "0.1.0",
"private": true,
"description": "Local MCP server for approved macOS app automation.",
"type": "module",
"engines": {
"node": ">=20.0.0"
},
"scripts": {
"start": "node src/http.js",
"start:stdio": "node src/stdio.js",
"dev": "node --watch src/http.js",
"check": "node --check src/*.js && node --check src/integrations/*.js && node --test",
"python:install": "./scripts/setup-python.sh",
"service:install": "./scripts/install-service.sh",
"service:restart": "./scripts/restart-service.sh",
"service:status": "./scripts/status-service.sh",
"service:uninstall": "./scripts/uninstall-service.sh",
"ksay:install": "./scripts/install-ksay-service.sh",
"ksay:restart": "./scripts/restart-ksay-service.sh"
},
"dependencies": {
"@modelcontextprotocol/sdk": "^1.0.0",
"zod": "^3.25.0"
},
"devDependencies": {}
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/requirements.txt
+7
View File
@@ -0,0 +1,7 @@
tplinkrouterc6u==5.21.0
mlx-audio
misaki
num2words
spacy
phonemizer
https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/deco_bridge.py
Executable
+156
View File
@@ -0,0 +1,156 @@
#!/usr/bin/env python3
import json
import os
import subprocess
import sys
from tplinkrouterc6u import TPLinkDecoClient
def default_gateway():
try:
result = subprocess.run(
["/sbin/route", "-n", "get", "default"],
check=True,
capture_output=True,
text=True,
timeout=5,
)
except Exception:
return None
for line in result.stdout.splitlines():
key, _, value = line.partition(":")
if key.strip() == "gateway":
return value.strip()
return None
def config():
host = os.environ.get("DECO_HOST") or default_gateway()
password = os.environ.get("DECO_PASSWORD")
if not password:
raise RuntimeError("DECO_PASSWORD must be set in .env.")
if not host:
raise RuntimeError("DECO_HOST must be set in .env; default gateway detection failed.")
verify_ssl = os.environ.get("DECO_VERIFY_SSL", "true").lower() not in {
"0",
"false",
"no",
}
timeout = int(os.environ.get("DECO_TIMEOUT", "10"))
return {
"host": host,
"password": password,
"username": os.environ.get("DECO_USERNAME", "admin"),
"verify_ssl": verify_ssl,
"timeout": timeout,
}
def client():
return TPLinkDecoClient(**config())
def device_to_dict(device):
return {
"hostname": device.hostname,
"mac": device.macaddr,
"ip": device.ipaddr,
"connection": getattr(device.type, "value", str(device.type)),
"upSpeed": device.up_speed,
"downSpeed": device.down_speed,
"active": device.active,
}
def firmware_to_dict(firmware):
return {
"model": firmware.model,
"hardwareVersion": firmware.hardware_version,
"firmwareVersion": firmware.firmware_version,
}
def ipv4_to_dict(status):
return {
"wanMac": status.wan_macaddr,
"wanIp": status.wan_ipv4_ipaddr,
"wanGateway": status.wan_ipv4_gateway,
"wanConnectionType": status.wan_ipv4_conntype,
"wanNetmask": status.wan_ipv4_netmask,
"wanPrimaryDns": status.wan_ipv4_pridns,
"wanSecondaryDns": status.wan_ipv4_snddns,
"lanMac": status.lan_macaddr,
"lanIp": status.lan_ipv4_ipaddr,
"lanNetmask": status.lan_ipv4_netmask,
}
def status_to_dict(status, include_clients=True):
data = {
"wanMac": status.wan_macaddr,
"lanMac": status.lan_macaddr,
"wanIp": status.wan_ipv4_addr,
"lanIp": status.lan_ipv4_addr,
"wanGateway": status.wan_ipv4_gateway,
"connectionType": status.conn_type,
"cpuUsage": status.cpu_usage,
"memoryUsage": status.mem_usage,
"clientsTotal": status.clients_total,
"wiredClientsTotal": status.wired_total,
"wifiClientsTotal": status.wifi_clients_total,
"guestClientsTotal": status.guest_clients_total,
"iotClientsTotal": status.iot_clients_total,
"wifi": {
"host2g": status.wifi_2g_enable,
"host5g": status.wifi_5g_enable,
"host6g": status.wifi_6g_enable,
"guest2g": status.guest_2g_enable,
"guest5g": status.guest_5g_enable,
"guest6g": status.guest_6g_enable,
},
}
if include_clients:
data["clients"] = [device_to_dict(device) for device in status.devices]
return data
def run(action):
deco = client()
try:
if action == "overview":
status = deco.get_status()
firmware = deco.get_firmware()
return {
"status": status_to_dict(status, include_clients=False),
"firmware": firmware_to_dict(firmware),
}
if action == "clients":
status = deco.get_status()
return {"clients": [device_to_dict(device) for device in status.devices]}
if action == "ipv4":
return ipv4_to_dict(deco.get_ipv4_status())
if action == "firmware":
return firmware_to_dict(deco.get_firmware())
raise RuntimeError(f"Unknown action: {action}")
finally:
try:
deco.logout()
except Exception:
pass
def main():
if len(sys.argv) != 2:
raise RuntimeError("Usage: deco_bridge.py <overview|clients|ipv4|firmware>")
print(json.dumps(run(sys.argv[1]), indent=2))
if __name__ == "__main__":
try:
main()
except Exception as err:
print(json.dumps({"error": str(err)}), file=sys.stderr)
sys.exit(1)
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/deco_ha_bridge.py
+383
View File
@@ -0,0 +1,383 @@
#!/usr/bin/env python3
import base64
import hashlib
import json
import math
import os
import re
import secrets
import ssl
import subprocess
import sys
from urllib.parse import quote_plus
import requests
from Crypto.Cipher import AES, PKCS1_v1_5
from Crypto.PublicKey import RSA
from Crypto.Util.Padding import pad, unpad
from requests import RequestException
AES_KEY_BYTES = 16
MIN_AES_KEY = 10 ** (AES_KEY_BYTES - 1)
MAX_AES_KEY = (10**AES_KEY_BYTES) - 1
PKCS1_V1_5_HEADER_BYTES = 11
def load_env_file():
path = os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env")
try:
with open(path, "r", encoding="utf-8") as env_file:
for line in env_file:
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, value = line.split("=", 1)
os.environ.setdefault(key, value.strip().strip("\"'"))
except FileNotFoundError:
pass
def default_gateway():
try:
result = subprocess.run(
["/sbin/route", "-n", "get", "default"],
check=True,
capture_output=True,
text=True,
timeout=5,
)
except Exception:
return None
for line in result.stdout.splitlines():
key, _, value = line.partition(":")
if key.strip() == "gateway":
return value.strip()
return None
def config():
load_env_file()
host = os.environ.get("DECO_HOST") or default_gateway()
password = os.environ.get("DECO_PASSWORD")
if not password:
raise RuntimeError("DECO_PASSWORD must be set in .env.")
if not host:
raise RuntimeError("DECO_HOST must be set in .env; default gateway detection failed.")
if not host.startswith(("http://", "https://")):
host = f"http://{host}"
verify_ssl = os.environ.get("DECO_VERIFY_SSL", "true").lower() not in {
"0",
"false",
"no",
}
return {
"host": host.rstrip("/"),
"username": os.environ.get("DECO_USERNAME", "admin"),
"password": password,
"verify_ssl": verify_ssl,
"timeout": int(os.environ.get("DECO_TIMEOUT", "10")),
}
def byte_len(n):
return (int(math.log2(n)) + 8) >> 3
def rsa_encrypt(n, e, plaintext):
public_key = RSA.construct((n, e)).publickey()
encryptor = PKCS1_v1_5.new(public_key)
block_size = byte_len(n)
bytes_per_block = block_size - PKCS1_V1_5_HEADER_BYTES
encrypted_text = ""
for index in range(0, len(plaintext), bytes_per_block):
encrypted_text += encryptor.encrypt(plaintext[index:index + bytes_per_block]).hex()
return encrypted_text
def decode_name(value):
if not value:
return value
try:
return base64.b64decode(value).decode()
except Exception:
return value
def title_from_snake(value):
if not value:
return value
return " ".join(part.title() for part in value.split("_"))
def deco_name(device):
return (
decode_name(device.get("custom_nickname"))
or title_from_snake(device.get("nickname"))
or device.get("device_model")
or device.get("mac")
)
class DecoApi:
def __init__(self, host, username, password, verify_ssl, timeout):
self.host = host
self.username = username
self.password = password
self.verify_ssl = verify_ssl
self.timeout = timeout
self.session = requests.Session()
self.aes_key = None
self.aes_iv = None
self.password_rsa_n = None
self.password_rsa_e = None
self.sign_rsa_n = None
self.sign_rsa_e = None
self.seq = None
self.stok = None
self.cookie = None
def generate_aes_key_and_iv(self):
self.aes_key = str(secrets.randbelow(MAX_AES_KEY - MIN_AES_KEY) + MIN_AES_KEY).encode()
self.aes_iv = str(secrets.randbelow(MAX_AES_KEY - MIN_AES_KEY) + MIN_AES_KEY).encode()
def post(self, context, path, params, data):
headers = {"Content-Type": "application/json"}
cookies = {}
if self.cookie:
name, _, value = self.cookie.partition("=")
if name and value:
cookies[name] = value
try:
response = self.session.post(
f"{self.host}{path}",
params=params,
data=data,
headers=headers,
cookies=cookies,
verify=self.verify_ssl,
timeout=self.timeout,
)
except RequestException:
response = self.curl_post(path, params, data, cookies)
if response.status_code == 403:
self.clear_auth()
raise RuntimeError(f"{context}: forbidden")
response.raise_for_status()
for cookie in response.headers.get("Set-Cookie", "").split(","):
match = re.search(r"(sysauth=[A-Za-z0-9]+)", cookie)
if match:
self.cookie = match.group(1)
break
result = response.json()
error_code = result.get("error_code")
if error_code not in (None, "", 0):
raise RuntimeError(f"{context}: response error_code={error_code}")
return result
def curl_post(self, path, params, data, cookies):
url = f"{self.host}{path}"
if params:
query = "&".join(f"{key}={quote_plus(str(value))}" for key, value in params.items())
url = f"{url}?{query}"
command = [
"curl",
"-s",
"-i",
"--connect-timeout",
str(self.timeout),
"-X",
"POST",
url,
"-H",
"Content-Type: application/json",
"--data-raw",
data,
]
if not self.verify_ssl:
command.insert(2, "-k")
if cookies:
command.extend(["-H", "Cookie: " + "; ".join(f"{k}={v}" for k, v in cookies.items())])
result = subprocess.run(command, check=True, capture_output=True, text=True, timeout=self.timeout + 5)
head, separator, body = result.stdout.rpartition("\r\n\r\n")
if not separator:
head, _, body = result.stdout.rpartition("\n\n")
status_match = re.search(r"HTTP/\S+\s+(\d+)", head)
status = int(status_match.group(1)) if status_match else 200
response = requests.Response()
response.status_code = status
response._content = body.encode()
response.url = url
for line in head.splitlines():
if ":" not in line:
continue
key, value = line.split(":", 1)
response.headers[key.strip()] = value.strip()
return response
def fetch_keys(self):
response = self.post(
"Fetch keys",
"/cgi-bin/luci/;stok=/login",
{"form": "keys"},
json.dumps({"operation": "read"}),
)
keys = response["result"]["password"]
self.password_rsa_n = int(keys[0], 16)
self.password_rsa_e = int(keys[1], 16)
def fetch_auth(self):
response = self.post(
"Fetch auth",
"/cgi-bin/luci/;stok=/login",
{"form": "auth"},
json.dumps({"operation": "read"}),
)
auth = response["result"]
self.sign_rsa_n = int(auth["key"][0], 16)
self.sign_rsa_e = int(auth["key"][1], 16)
self.seq = auth["seq"]
def encode_payload(self, payload):
payload_json = json.dumps(payload, separators=(",", ":")).encode()
encrypted = AES.new(self.aes_key, AES.MODE_CBC, self.aes_iv).encrypt(
pad(payload_json, AES.block_size)
)
data = base64.b64encode(encrypted).decode()
sign = self.encode_sign(len(data))
return f"sign={sign}&data={quote_plus(data)}"
def encode_sign(self, data_len):
auth_hash = hashlib.md5(f"{self.username}{self.password}".encode()).hexdigest()
sign_text = (
f"k={self.aes_key.decode()}&i={self.aes_iv.decode()}&h={auth_hash}&s={self.seq + data_len}"
)
return rsa_encrypt(self.sign_rsa_n, self.sign_rsa_e, sign_text.encode())
def decrypt_data(self, context, data):
if not data:
self.clear_auth()
raise RuntimeError(f"{context}: empty data")
decrypted = AES.new(self.aes_key, AES.MODE_CBC, self.aes_iv).decrypt(
base64.b64decode(data)
)
return json.loads(unpad(decrypted, AES.block_size).decode())
def login(self):
if self.aes_key is None:
self.generate_aes_key_and_iv()
if self.password_rsa_n is None:
self.fetch_keys()
if self.seq is None:
self.fetch_auth()
encrypted_password = rsa_encrypt(
self.password_rsa_n,
self.password_rsa_e,
self.password.encode(),
)
response = self.post(
"Login",
"/cgi-bin/luci/;stok=/login",
{"form": "login"},
self.encode_payload({
"operation": "login",
"params": {"password": encrypted_password},
}),
)
data = self.decrypt_data("Login", response["data"])
if data.get("error_code") != 0:
result = data.get("result") or {}
attempts = result.get("attemptsAllowed", "unknown")
raise RuntimeError(f"Login failed: error_code={data.get('error_code')}; attempts={attempts}")
self.stok = data["result"]["stok"]
if not self.cookie:
raise RuntimeError("Login succeeded but no sysauth cookie was returned.")
def clear_auth(self):
self.seq = None
self.stok = None
self.cookie = None
def call(self, context, section, form, payload):
if not self.stok or not self.cookie:
self.login()
response = self.post(
context,
f"/cgi-bin/luci/;stok={self.stok}/admin/{section}",
{"form": form},
self.encode_payload(payload),
)
data = self.decrypt_data(context, response["data"])
error_code = data.get("error_code") or data.get("errorcode")
if error_code:
raise RuntimeError(f"{context}: decoded error_code={error_code}")
return data["result"]
def list_decos(self):
devices = self.call("List Devices", "device", "device_list", {"operation": "read"}).get("device_list", [])
return [
{
"name": deco_name(device),
"mac": device.get("mac"),
"ip": device.get("device_ip"),
"model": device.get("device_model"),
"hardwareVersion": device.get("hardware_ver"),
"firmwareVersion": device.get("software_ver"),
"role": device.get("role"),
"online": device.get("group_status") == "connected",
"connectionType": device.get("connection_type"),
}
for device in devices
]
def list_clients_for_deco(self, deco):
clients = self.call(
f"List Clients {deco['mac']}",
"client",
"client_list",
{"operation": "read", "params": {"device_mac": deco["mac"]}},
).get("client_list", [])
return [
{
"hostname": decode_name(client.get("name")),
"mac": client.get("mac"),
"ip": client.get("ip"),
"connection": client.get("connection_type"),
"interface": client.get("interface"),
"upSpeed": client.get("up_speed"),
"downSpeed": client.get("down_speed"),
"active": client.get("online"),
"linkedDecoMac": deco.get("mac"),
"linkedDecoName": deco.get("name"),
"linkedDecoRole": deco.get("role"),
}
for client in clients
if client.get("online")
]
def run():
if not config()["verify_ssl"]:
requests.packages.urllib3.disable_warnings()
ssl._create_default_https_context = ssl._create_unverified_context
deco = DecoApi(**config())
decos = deco.list_decos()
clients = {}
for node in decos:
if not node.get("mac"):
continue
for client in deco.list_clients_for_deco(node):
clients[client["mac"]] = client
return {"decos": decos, "clients": list(clients.values())}
if __name__ == "__main__":
try:
print(json.dumps(run(), indent=2))
except Exception as err:
print(json.dumps({"error": str(err)}), file=sys.stderr)
sys.exit(1)
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/install-ksay-service.sh
Executable
+64
View File
@@ -0,0 +1,64 @@
#!/bin/zsh
set -euo pipefail
LABEL="com.local.ksay-kokoro"
PROJECT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
PYTHON_BIN="$PROJECT_DIR/.venv/bin/python"
AGENT_DIR="$HOME/Library/LaunchAgents"
PLIST="$AGENT_DIR/$LABEL.plist"
LOG_DIR="$PROJECT_DIR/.logs"
DOMAIN="gui/$(id -u)"
CLI_LINK="/opt/homebrew/bin/ksay"
if [[ ! -x "$PYTHON_BIN" ]]; then
echo "Missing $PYTHON_BIN. Run npm run python:install first." >&2
exit 1
fi
mkdir -p "$AGENT_DIR" "$LOG_DIR"
cat > "$PLIST" <<PLIST
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>$LABEL</string>
<key>ProgramArguments</key>
<array>
<string>$PYTHON_BIN</string>
<string>$PROJECT_DIR/scripts/ksay_server.py</string>
</array>
<key>WorkingDirectory</key>
<string>$PROJECT_DIR</string>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>2</integer>
<key>StandardOutPath</key>
<string>$LOG_DIR/ksay.out.log</string>
<key>StandardErrorPath</key>
<string>$LOG_DIR/ksay.err.log</string>
</dict>
</plist>
PLIST
plutil -lint "$PLIST"
launchctl bootout "$DOMAIN" "$PLIST" 2>/dev/null || true
launchctl bootstrap "$DOMAIN" "$PLIST"
launchctl enable "$DOMAIN/$LABEL"
launchctl kickstart -k "$DOMAIN/$LABEL"
if [[ -d "$(dirname "$CLI_LINK")" && -w "$(dirname "$CLI_LINK")" ]]; then
ln -sf "$PROJECT_DIR/bin/ksay" "$CLI_LINK"
echo "Linked CLI: $CLI_LINK"
else
echo "Could not link $CLI_LINK. Add $PROJECT_DIR/bin to PATH or link bin/ksay manually." >&2
fi
echo "Installed $LABEL"
echo "Endpoint: http://127.0.0.1:7332"
echo "Try: ksay --start"
echo "Logs: $LOG_DIR/ksay.*.log"
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/install-service.sh
Executable
+51
View File
@@ -0,0 +1,51 @@
#!/bin/zsh
set -euo pipefail
LABEL="com.local.macmini-mcp"
PROJECT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
NODE_BIN="$(command -v node)"
AGENT_DIR="$HOME/Library/LaunchAgents"
PLIST="$AGENT_DIR/$LABEL.plist"
LOG_DIR="$PROJECT_DIR/.logs"
DOMAIN="gui/$(id -u)"
mkdir -p "$AGENT_DIR" "$LOG_DIR"
cat > "$PLIST" <<PLIST
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>Label</key>
<string>$LABEL</string>
<key>ProgramArguments</key>
<array>
<string>$NODE_BIN</string>
<string>--watch</string>
<string>src/http.js</string>
</array>
<key>WorkingDirectory</key>
<string>$PROJECT_DIR</string>
<key>RunAtLoad</key>
<true/>
<key>KeepAlive</key>
<true/>
<key>ThrottleInterval</key>
<integer>2</integer>
<key>StandardOutPath</key>
<string>$LOG_DIR/service.out.log</string>
<key>StandardErrorPath</key>
<string>$LOG_DIR/service.err.log</string>
</dict>
</plist>
PLIST
plutil -lint "$PLIST"
launchctl bootout "$DOMAIN" "$PLIST" 2>/dev/null || true
launchctl bootstrap "$DOMAIN" "$PLIST"
launchctl enable "$DOMAIN/$LABEL"
launchctl kickstart -k "$DOMAIN/$LABEL"
echo "Installed $LABEL"
echo "Endpoint: configured by .env (see the service log for the listening URL)"
echo "Logs: $LOG_DIR"
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/ksay_server.py
Executable
+210
View File
@@ -0,0 +1,210 @@
#!/usr/bin/env python3
from __future__ import annotations
import argparse
import json
import os
import signal
import sys
import time
import traceback
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from threading import Lock
from typing import Any
PROJECT_DIR = Path(__file__).resolve().parents[1]
OUTPUT_DIR = Path(os.environ.get("KSAY_OUTPUT_DIR", PROJECT_DIR / "generated-audio"))
DEFAULT_HOST = os.environ.get("KSAY_HOST", "127.0.0.1")
DEFAULT_PORT = int(os.environ.get("KSAY_PORT", "7332"))
DEFAULT_MODEL = os.environ.get("KSAY_MODEL", "mlx-community/Kokoro-82M-8bit")
DEFAULT_VOICE = os.environ.get("KSAY_VOICE", "af_heart")
DEFAULT_LANG_CODE = os.environ.get("KSAY_LANG_CODE", "a")
MAX_TEXT_CHARS = int(os.environ.get("KSAY_MAX_TEXT_CHARS", "8000"))
class KokoroEngine:
def __init__(self, model_name: str):
self.model_name = model_name
self.model = None
self.loaded_at = None
self.load_seconds = None
self.lock = Lock()
def load(self) -> None:
started = time.perf_counter()
from mlx_audio.tts.utils import load_model
self.model = load_model(self.model_name)
self.loaded_at = time.time()
self.load_seconds = time.perf_counter() - started
def synthesize(
self,
*,
text: str,
voice: str,
speed: float,
lang_code: str,
output: str | None,
) -> dict[str, Any]:
if self.model is None:
raise RuntimeError("Kokoro model is not loaded.")
clean_text = text.strip()
if not clean_text:
raise ValueError("text is required.")
clean_text = clean_text[:MAX_TEXT_CHARS]
output_path = resolve_output_path(output)
started = time.perf_counter()
with self.lock:
audio_chunks = []
sample_rate = None
for result in self.model.generate(
text=clean_text,
voice=voice,
speed=speed,
lang_code=lang_code,
):
audio_chunks.append(result.audio)
sample_rate = result.sample_rate
if not audio_chunks:
raise RuntimeError("Kokoro did not return audio.")
import mlx.core as mx
import numpy as np
from mlx_audio.audio_io import write as audio_write
audio = (
mx.concatenate(audio_chunks, axis=0)
if len(audio_chunks) > 1
else audio_chunks[0]
)
audio_write(str(output_path), np.array(audio), sample_rate, format="wav")
elapsed = time.perf_counter() - started
return {
"ok": True,
"filePath": str(output_path),
"model": self.model_name,
"voice": voice,
"speed": speed,
"langCode": lang_code,
"sampleRate": sample_rate,
"segments": len(audio_chunks),
"seconds": round(elapsed, 3),
"characters": len(clean_text),
}
def resolve_output_path(output: str | None) -> Path:
if output:
path = Path(output).expanduser()
if path.suffix.lower() != ".wav":
path = path.with_suffix(".wav")
if not path.is_absolute():
path = (Path.cwd() / path).resolve()
else:
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
path = OUTPUT_DIR / f"ksay-{int(time.time() * 1000)}-{uuid.uuid4().hex[:6]}.wav"
path.parent.mkdir(parents=True, exist_ok=True)
return path
def parse_json_body(handler: BaseHTTPRequestHandler) -> dict[str, Any]:
length = int(handler.headers.get("content-length", "0"))
if length <= 0:
return {}
body = handler.rfile.read(length)
return json.loads(body.decode("utf-8"))
def make_handler(engine: KokoroEngine):
class KsayHandler(BaseHTTPRequestHandler):
server_version = "ksay-kokoro/0.1"
def log_message(self, fmt: str, *args: Any) -> None:
sys.stderr.write("%s - %s\n" % (self.log_date_time_string(), fmt % args))
def write_json(self, status: int, value: dict[str, Any]) -> None:
body = json.dumps(value).encode("utf-8")
self.send_response(status)
self.send_header("content-type", "application/json")
self.send_header("content-length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def do_GET(self) -> None:
if self.path == "/health":
self.write_json(
200,
{
"ok": True,
"model": engine.model_name,
"loaded": engine.model is not None,
"loadedAt": engine.loaded_at,
"loadSeconds": engine.load_seconds,
"defaultVoice": DEFAULT_VOICE,
"defaultLangCode": DEFAULT_LANG_CODE,
},
)
return
self.write_json(404, {"ok": False, "error": "not found"})
def do_POST(self) -> None:
if self.path != "/say":
self.write_json(404, {"ok": False, "error": "not found"})
return
try:
payload = parse_json_body(self)
result = engine.synthesize(
text=str(payload.get("text", "")),
voice=str(payload.get("voice") or DEFAULT_VOICE),
speed=float(payload.get("speed") or 1.0),
lang_code=str(payload.get("langCode") or DEFAULT_LANG_CODE),
output=payload.get("output"),
)
self.write_json(200, result)
except Exception as exc:
traceback.print_exc()
self.write_json(500, {"ok": False, "error": str(exc)})
return KsayHandler
def main() -> int:
parser = argparse.ArgumentParser(description="Warm Kokoro TTS server for ksay.")
parser.add_argument("--host", default=DEFAULT_HOST)
parser.add_argument("--port", type=int, default=DEFAULT_PORT)
parser.add_argument("--model", default=DEFAULT_MODEL)
args = parser.parse_args()
engine = KokoroEngine(args.model)
print(f"Loading {args.model}...", flush=True)
engine.load()
print(
f"ksay Kokoro ready on http://{args.host}:{args.port} "
f"after {engine.load_seconds:.2f}s",
flush=True,
)
httpd = ThreadingHTTPServer((args.host, args.port), make_handler(engine))
def shutdown(_signum: int, _frame: Any) -> None:
httpd.shutdown()
signal.signal(signal.SIGTERM, shutdown)
signal.signal(signal.SIGINT, shutdown)
httpd.serve_forever()
return 0
if __name__ == "__main__":
raise SystemExit(main())
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/restart-ksay-service.sh
Executable
+8
View File
@@ -0,0 +1,8 @@
#!/bin/zsh
set -euo pipefail
LABEL="com.local.ksay-kokoro"
DOMAIN="gui/$(id -u)"
launchctl kickstart -k "$DOMAIN/$LABEL"
echo "Restarted $LABEL"
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/restart-service.sh
Executable
+8
View File
@@ -0,0 +1,8 @@
#!/bin/zsh
set -euo pipefail
LABEL="com.local.macmini-mcp"
DOMAIN="gui/$(id -u)"
launchctl kickstart -k "$DOMAIN/$LABEL"
echo "Restarted $LABEL"
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/setup-python.sh
Executable
+11
View File
@@ -0,0 +1,11 @@
#!/bin/zsh
set -euo pipefail
PROJECT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
cd "$PROJECT_DIR"
if [[ ! -x .venv/bin/python ]]; then
python3 -m venv .venv
fi
.venv/bin/python -m pip install -r requirements.txt
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/status-service.sh
Executable
+7
View File
@@ -0,0 +1,7 @@
#!/bin/zsh
set -euo pipefail
LABEL="com.local.macmini-mcp"
DOMAIN="gui/$(id -u)"
launchctl print "$DOMAIN/$LABEL"
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/scripts/uninstall-service.sh
Executable
+10
View File
@@ -0,0 +1,10 @@
#!/bin/zsh
set -euo pipefail
LABEL="com.local.macmini-mcp"
PLIST="$HOME/Library/LaunchAgents/$LABEL.plist"
DOMAIN="gui/$(id -u)"
launchctl bootout "$DOMAIN" "$PLIST" 2>/dev/null || true
rm -f "$PLIST"
echo "Uninstalled $LABEL"
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/apple-events.js
+49
View File
@@ -0,0 +1,49 @@
import { execFile } from "node:child_process";
import { promisify } from "node:util";
const execFileAsync = promisify(execFile);
export async function runJxa(script, input = {}) {
try {
const { stdout } = await execFileAsync(
"/usr/bin/osascript",
["-l", "JavaScript", "-e", script, "--", JSON.stringify(input)],
{
timeout: 30_000,
maxBuffer: 2 * 1024 * 1024,
},
);
const text = stdout.trim();
return text ? JSON.parse(text) : null;
} catch (error) {
const detail = error.stderr?.trim() || error.message;
throw new Error(
`macOS automation failed. Grant Automation access to the service if prompted. ${detail}`,
);
}
}
export function dateFromInput(value, fieldName) {
const date = new Date(value);
if (Number.isNaN(date.valueOf())) {
throw new Error(`${fieldName} must be a valid ISO-8601 date and time.`);
}
return date;
}
export function plainTextToNoteHtml(title, body) {
const escape = (text) =>
text
.replaceAll("&", "&amp;")
.replaceAll("<", "&lt;")
.replaceAll(">", "&gt;")
.replaceAll('"', "&quot;");
const paragraphs = body
.split(/\n{2,}/)
.map((paragraph) => `<div>${escape(paragraph).replaceAll("\n", "<br>")}</div>`)
.join("");
return `<h1>${escape(title)}</h1>${paragraphs}`;
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/config.js
+29
View File
@@ -0,0 +1,29 @@
import { loadEnvFile } from "node:process";
try {
loadEnvFile();
} catch (error) {
if (error.code !== "ENOENT") {
throw error;
}
}
export function getConfig() {
const port = Number.parseInt(process.env.MACMINI_MCP_PORT || "7331", 10);
if (!Number.isInteger(port) || port < 1 || port > 65535) {
throw new Error("MACMINI_MCP_PORT must be an integer between 1 and 65535.");
}
const config = {
host: process.env.MACMINI_MCP_HOST || "127.0.0.1",
port,
token: process.env.MACMINI_MCP_TOKEN || "",
};
const isLoopback = ["127.0.0.1", "::1", "localhost"].includes(config.host);
if (!isLoopback && !config.token) {
throw new Error("MACMINI_MCP_TOKEN is required when listening beyond localhost.");
}
return config;
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/http.js
+61
View File
@@ -0,0 +1,61 @@
import http from "node:http";
import { timingSafeEqual } from "node:crypto";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { getConfig } from "./config.js";
import { createMacMiniMcpServer } from "./server.js";
const config = getConfig();
function authorized(request) {
if (!config.token) {
return true;
}
const authorization = request.headers.authorization || "";
const expected = Buffer.from(`Bearer ${config.token}`);
const provided = Buffer.from(authorization);
return provided.length === expected.length && timingSafeEqual(provided, expected);
}
const service = http.createServer(async (request, response) => {
const pathname = new URL(request.url, `http://${request.headers.host || "localhost"}`).pathname;
if (pathname === "/health" && request.method === "GET") {
response.writeHead(200, { "content-type": "application/json" });
response.end(JSON.stringify({ ok: true, service: "macmini-mcp" }));
return;
}
if (pathname !== "/mcp") {
response.writeHead(404).end("Not found");
return;
}
if (!authorized(request)) {
response.writeHead(401, { "www-authenticate": "Bearer" }).end("Unauthorized");
return;
}
const server = createMacMiniMcpServer();
const transport = new StreamableHTTPServerTransport({
sessionIdGenerator: undefined,
});
response.on("close", () => {
transport.close();
server.close();
});
try {
await server.connect(transport);
await transport.handleRequest(request, response);
} catch (error) {
console.error("MCP HTTP request failed:", error);
if (!response.headersSent) {
response.writeHead(500).end("MCP request failed");
}
}
});
service.listen(config.port, config.host, () => {
console.error(`macmini-mcp listening on http://${config.host}:${config.port}/mcp`);
});
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/apple-llm.js
+433
View File
@@ -0,0 +1,433 @@
import { execFile, spawn } from "node:child_process";
import { promisify } from "node:util";
import { writeFile, rm, mkdtemp } from "node:fs/promises";
import path from "node:path";
import os from "node:os";
const execFileAsync = promisify(execFile);
function swiftSourceLLMPolish() {
// From whisper-translation/apple_speech/Sources/AppleLLMPolish/main.swift
// Added instant-reply mode + general conversation
return `
import Foundation
import FoundationModels
struct InMsg: Decodable {
var id: String?
var mode: String // "line" | "paragraph" | "check" | "quick_reply" | "chat"
var text: String?
var prev1: String?
var prev2: String?
var context: String?
var prevSource: String?
var language: String?
var instructions: String?
var history: String? // JSON array [{"role":"user","text":".."},...]
}
struct OutMsg: Encodable {
var id: String?
var ok: Bool
var text: String
var error: String?
var ms: Int?
var mode: String?
}
func log(_ s: String) { fputs(s+"\\n", stderr) }
@main
struct AppleLLMPolish {
static func main() async {
let args = CommandLine.arguments
if args.contains("--help") || args.contains("-h") {
fputs("Usage: apple-llm-polish [--check]\\nPipe JSONL in stdin, JSONL out\\nModes: line, paragraph, quick_reply, chat, check\\n", stderr); exit(0)
}
if args.contains("--check") { await runCheck(); return }
await runPipe()
}
static func runCheck() async {
let m = SystemLanguageModel.default
var pingText = "unavailable"
var ok = false
if m.isAvailable {
do {
let session = LanguageModelSession(model: m, instructions: "You are concise.")
let r = try await session.respond(to: "Say ok")
pingText = r.content
ok = true
} catch { pingText = error.localizedDescription }
}
let out: [String: Any] = [
"available": m.isAvailable,
"availability": "\\(m.availability)",
"ping": pingText,
"ok": ok,
"model": "SystemLanguageModel 3B ANE"
]
if let d = try? JSONSerialization.data(withJSONObject: out), let s = String(data: d, encoding: .utf8) { print(s) }
}
static func runPipe() async {
let m = SystemLanguageModel.default
guard m.isAvailable else {
let reason = "\\(m.availability)"
while let line = readLine() {
if line.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { continue }
var idv: String? = nil
if let data = line.data(using: .utf8), let dict = try? JSONSerialization.jsonObject(with: data) as? [String:Any] { idv = dict["id"] as? String }
let out = OutMsg(id: idv, ok: false, text: "", error: "model unavailable: \\(reason)", ms: nil, mode: "error")
if let d = try? JSONEncoder().encode(out), let s = String(data: d, encoding: .utf8) { print(s); fflush(stdout) }
}
return
}
// Keep sessions warm — separate useCases
let lineSession = LanguageModelSession(model: SystemLanguageModel(useCase: .general, guardrails: .permissiveContentTransformations), instructions: lineSystemPrompt())
let paraSession = LanguageModelSession(model: SystemLanguageModel(useCase: .general, guardrails: .permissiveContentTransformations), instructions: paraSystemPrompt())
let quickSession = LanguageModelSession(model: SystemLanguageModel(useCase: .general, guardrails: .permissiveContentTransformations), instructions: quickReplySystemPrompt())
let chatSession = LanguageModelSession(model: SystemLanguageModel(useCase: .general, guardrails: .permissiveContentTransformations), instructions: "You are Hermes, a concise helpful voice assistant for ESP32 devices. Keep replies under 40 words, warm and concrete, kid-safe.")
lineSession.prewarm()
paraSession.prewarm()
quickSession.prewarm()
chatSession.prewarm()
log("[apple-llm] ready, ANE-backed 3B")
while let line = readLine() {
let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
if trimmed.isEmpty { continue }
guard let data = line.data(using: .utf8), let req = try? JSONDecoder().decode(InMsg.self, from: data) else {
let out = OutMsg(id: nil, ok: false, text: "", error: "bad json", ms: nil, mode: "error")
if let d = try? JSONEncoder().encode(out), let s = String(data: d, encoding: .utf8) { print(s); fflush(stdout) }
continue
}
if req.mode == "check" {
let out = OutMsg(id: req.id, ok: m.isAvailable, text: "\\(m.availability)", error: nil, ms: 0, mode: "check")
if let d = try? JSONEncoder().encode(out), let s = String(data: d, encoding: .utf8) { print(s); fflush(stdout) }
continue
}
let t0 = Date()
do {
let (session, prompt, temp): (LanguageModelSession, String, Double)
switch req.mode {
case "paragraph":
session = paraSession
prompt = buildParagraphPrompt(context: req.context ?? "", prevSource: req.prevSource ?? "", newText: req.text ?? "")
temp = 0.2
case "quick_reply":
session = quickSession
prompt = buildQuickReplyPrompt(draft: req.text ?? "", context: req.context, instructions: req.instructions)
temp = 0.4
case "chat":
// For chat, rebuild prompt from history if provided, else use text directly
session = chatSession
if let hist = req.history, !hist.isEmpty {
prompt = buildChatPrompt(historyJSON: hist, newText: req.text ?? "", instructions: req.instructions)
} else {
prompt = req.text ?? ""
}
temp = 0.5
default: // line
session = lineSession
prompt = buildLinePrompt(text: req.text ?? "", prev1: req.prev1 ?? "", prev2: req.prev2 ?? "")
temp = 0.1
}
var opts = GenerationOptions()
opts.temperature = temp
let resp = try await session.respond(to: prompt, options: opts)
let ms = Int(Date().timeIntervalSince(t0)*1000)
let cleaned = resp.content.trimmingCharacters(in: .whitespacesAndNewlines)
let out = OutMsg(id: req.id, ok: true, text: cleaned.isEmpty ? (req.text ?? "") : cleaned, error: nil, ms: ms, mode: req.mode)
if let d = try? JSONEncoder().encode(out), let s = String(data: d, encoding: .utf8) { print(s); fflush(stdout) }
} catch {
let ms = Int(Date().timeIntervalSince(t0)*1000)
let out = OutMsg(id: req.id, ok: false, text: req.text ?? "", error: error.localizedDescription, ms: ms, mode: req.mode)
if let d = try? JSONEncoder().encode(out), let s = String(data: d, encoding: .utf8) { print(s); fflush(stdout) }
}
}
}
static func lineSystemPrompt() -> String {
return "You are a real-time caption polisher. Fix punctuation, casing, STT typos. Remove filler (uh, um). Keep meaning. Output one polished line only."
}
static func paraSystemPrompt() -> String {
return "You are a careful live transcript editor. Goal: most faithful readable English. NEW SOURCE TEXT is primary. PREVIOUS CONTEXT only if helps continuity. English only. No meta commentary. Return revised transcript only."
}
static func quickReplySystemPrompt() -> String {
return """
You are Hermes instant-reply for ESP32 voice devices (iPhone, Watch, kids). You get LIVE draft transcript from user, possibly partial with typos.
Goal: produce a super-short, HIGHLY CONTEXTUAL reply preview (max 20 words) that shows you actually understood their specific request, not generic.
Rules:
- Reference SPECIFIC keywords/entities from draft: names (Grace Priss/Rain), topics (Mac mini voice, weather, homework), intent.
- Sound human, warm, playful for kids, concise.
- If draft mentions Mac mini voice/boys voice/speech, acknowledge you'll use Mac mini voice.
- If draft mentions a name, use it.
- If draft asks something, hint at answer direction without fully answering (full answer comes next).
- Never say "Thinking on full answer" verbatim — too generic. Instead vary: "Let me check...", "One sec, pulling that...", "Nice name! Love it..."
- Under 20 words. Return ONLY reply text, no quotes.
Examples:
Draft: "what's the weather today" -> "Checking weather now — one sec..."
Draft: "Perfect. My first name is Grace Priss, and my other name is Grace Reign." -> "Wow, Grace Priss and Grace Reign — royal names! Love them!"
Draft: "Why you're not answering with boys voice?" -> "Got it — you want boy voice, switching to Mac mini voice now..."
Draft: "Can you use the Mac mini voice to generate answers?" -> "Yes! Using Mac mini voice for better audio, one sec..."
Draft: "tell me a joke" -> "Joke coming up..."
Draft: "Hey improvement I think now you should show quick response" -> "Nice! Quick response is live, working on full answer too..."
"""
}
static func buildLinePrompt(text: String, prev1: String, prev2: String) -> String {
var p = ""
if !prev2.isEmpty { p += "Previous 2: \\(prev2)\\n" }
if !prev1.isEmpty { p += "Previous 1: \\(prev1)\\n" }
p += "Current: \\(text)\\nPolished:"
return p
}
static func buildParagraphPrompt(context: String, prevSource: String, newText: String) -> String {
return "Edit this transcript.\\n[PREVIOUS CONTEXT]\\n\\(context)\\n[PREVIOUS SOURCE]\\n\\(prevSource)\\n[NEW]\\n\\(newText)"
}
static func buildQuickReplyPrompt(draft: String, context: String?, instructions: String?) -> String {
var p = "LIVE DRAFT from user speaking (may have typos, partial): \\\"\\(draft)\\\"\\n"
if let c = context, !c.isEmpty { p += "Previous full transcript: \\(c)\\n" }
if let i = instructions, !i.isEmpty { p += "Extra instructions: \\(i)\\n" }
p += "\\nTask: produce contextual instant reply (max 20 words) that references SPECIFIC words from draft, not generic. If draft unclear, fall back to 'Heard you — working on full answer...'"
return p
}
static func buildChatPrompt(historyJSON: String, newText: String, instructions: String?) -> String {
// history is JSON array serialized
return "Conversation history: \\(historyJSON)\\nUser says (draft/final): \\(newText)\\n\\(instructions != nil ? \"Instructions: \\(instructions!)\\n\" : \"\")Reply concisely for voice device (<40 words):"
}
}
`;
}
class AppleLLMSession {
constructor() {
this.proc = null;
this.tmpDir = null;
this.binFile = null;
this.ready = false;
this.reqId = 0;
this.pending = new Map();
this.lastActivity = Date.now();
}
async ensureBuilt() {
const tmpBase = path.join(os.tmpdir(), "apple-llm-");
this.tmpDir = await mkdtemp(tmpBase);
const swiftFile = path.join(this.tmpDir, "Main.swift");
this.binFile = path.join(this.tmpDir, "apple-llm-polish");
await writeFile(swiftFile, swiftSourceLLMPolish(), "utf8");
try {
await execFileAsync("/usr/bin/swiftc", ["-O", "-parse-as-library", swiftFile, "-o", this.binFile, "-framework", "Foundation", "-framework", "FoundationModels"], { timeout: 60000, maxBuffer: 20*1024*1024 });
} catch (e) {
throw new Error(`swiftc LLM build failed: ${e.stderr||e.message}`);
}
}
async start() {
if (this.proc && this.proc.exitCode === null && this.ready) return;
if (!this.binFile) await this.ensureBuilt();
return new Promise((resolve, reject) => {
this.proc = spawn(this.binFile, [], { stdio: ["pipe", "pipe", "pipe"] });
let stderrBuf = "";
let stdoutBuf = "";
this.proc.stderr.on("data", d => { stderrBuf += d.toString(); });
this.proc.stdout.on("data", d => {
const txt = d.toString();
stdoutBuf += txt;
// Parse lines for responses
let lines = stdoutBuf.split("\n");
stdoutBuf = lines.pop() || "";
for (let line of lines) {
line = line.trim();
if (!line) continue;
try {
const obj = JSON.parse(line);
const id = obj.id;
if (id && this.pending.has(id)) {
const {resolve} = this.pending.get(id);
this.pending.delete(id);
resolve(obj);
}
} catch {}
}
});
setTimeout(() => {
if (this.proc.exitCode !== null) {
reject(new Error(`apple-llm exited early code=${this.proc.exitCode} stderr=${stderrBuf.slice(0,2000)}`));
} else {
this.ready = true;
// Capture remaining stdout buffering setup
this._stdoutLeftover = "";
resolve();
}
}, 1500);
this.proc.on("error", reject);
});
}
// Ensure reader continues after initial start
_ensureReader() {
if (this._readerSetup) return;
this._readerSetup = true;
// Already setup in start() via stdout.on data - but need to handle leftover buffering for late responses
let buf = "";
if (this.proc) {
// Additional listener for any missed
this.proc.stdout.on("data", chunk => {
buf += chunk.toString();
let lines = buf.split("\n");
buf = lines.pop() || "";
for (let line of lines) {
line = line.trim();
if (!line) continue;
try {
const obj = JSON.parse(line);
const id = obj.id;
if (id && this.pending.has(id)) {
const {resolve} = this.pending.get(id);
this.pending.delete(id);
resolve(obj);
}
} catch {}
}
});
}
}
async call(args, timeoutMs = 10000) {
await this.start();
this._ensureReader();
const id = String(this.reqId++);
const payload = { id, ...args };
return new Promise((resolve, reject) => {
let timer = setTimeout(() => {
if (this.pending.has(id)) {
this.pending.delete(id);
resolve({ ok: false, text: args.text || "", error: `timeout ${timeoutMs}ms`, id, ms: timeoutMs });
}
}, timeoutMs);
this.pending.set(id, {
resolve: (obj) => {
clearTimeout(timer);
resolve(obj);
}
});
try {
this.proc.stdin.write(JSON.stringify(payload) + "\n");
} catch (e) {
clearTimeout(timer);
this.pending.delete(id);
reject(e);
}
});
}
async close() {
try {
if (this.proc) {
try { this.proc.stdin.end(); } catch {}
await new Promise(r => { this.proc.on("close", r); setTimeout(r, 1500); });
try { this.proc.kill(); } catch {}
}
} catch {}
try { if (this.tmpDir) await rm(this.tmpDir, {recursive:true, force:true}); } catch {}
this.proc = null;
this.ready = false;
}
}
// Singleton global session for all LLM calls (fast, keeps KV cache warm)
let globalSession = null;
async function getSession() {
if (!globalSession) {
globalSession = new AppleLLMSession();
await globalSession.start();
}
globalSession.lastActivity = Date.now();
return globalSession;
}
export async function appleLLMCheck() {
const s = await getSession();
const res = await s.call({ mode: "check", text: "check" }, 10000);
return {
ok: res.ok,
available: res.ok,
text: res.text || res.error || "",
ms: res.ms,
engine: "Apple FoundationModels 3B ANE"
};
}
export async function appleLLMPolish({ text, prev1, prev2, mode } = {}) {
if (!text) throw new Error("text required");
const s = await getSession();
const m = mode || "line";
const res = await s.call({ mode: m, text, prev1: prev1||"", prev2: prev2||"" }, 8000);
return {
ok: res.ok,
text: res.text || text,
original: text,
ms: res.ms,
mode: m,
error: res.error || undefined
};
}
export async function appleLLMQuickReply({ draft, context, instructions } = {}) {
if (!draft) throw new Error("draft required");
const s = await getSession();
const res = await s.call({ mode: "quick_reply", text: draft, context: context||"", instructions: instructions||"" }, 3000);
return {
ok: res.ok,
text: res.text || "Got it, working on it...",
draft,
ms: res.ms,
engine: "Apple FoundationModels 3B instant"
};
}
export async function appleLLMChat({ text, history, instructions } = {}) {
if (!text) throw new Error("text required");
const s = await getSession();
const histStr = history ? JSON.stringify(history) : "";
const res = await s.call({ mode: "chat", text, history: histStr, instructions: instructions||"" }, 5000);
return {
ok: res.ok,
text: res.text || "",
input: text,
ms: res.ms,
engine: "Apple FoundationModels 3B voice"
};
}
export async function appleLLMClose() {
if (globalSession) {
await globalSession.close();
globalSession = null;
}
return { ok: true, closed: true };
}
export async function appleLLMStatus() {
return {
active: !!globalSession,
ready: globalSession?.ready || false,
lastActivity: globalSession ? new Date(globalSession.lastActivity).toISOString() : null,
pid: globalSession?.proc?.pid || null
};
}
// Idle cleanup 2 min
setInterval(async () => {
if (globalSession && Date.now() - globalSession.lastActivity > 120000) {
try { await globalSession.close(); } catch {}
globalSession = null;
}
}, 20000);
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/calendar.js
+125
View File
@@ -0,0 +1,125 @@
import { dateFromInput, runJxa } from "../apple-events.js";
export const FOCUS_CALENDAR = Object.freeze({
calendarIndex: 2,
calendar: "Home",
});
const CALENDAR_LIST_SCRIPT = String.raw`
function run() {
const app = Application("/System/Applications/Calendar.app");
return JSON.stringify(app.calendars().map(function (calendar, index) {
return {
index: index,
name: String(calendar.name()),
writable: Boolean(calendar.writable())
};
}));
}`;
const EVENTS_LIST_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Calendar.app");
const start = new Date(input.start);
const end = new Date(input.end);
const calendars = app.calendars();
const found = [];
for (let c = 0; c < calendars.length; c++) {
const calendar = calendars[c];
const calendarName = String(calendar.name());
if (input.calendarIndex !== null && c !== input.calendarIndex) continue;
if (input.calendar && calendarName !== input.calendar) continue;
// Calendar's JXA bridge treats multi-property date tests inconsistently.
// Bound one indexed property here, then enforce overlap below.
const events = calendar.events.whose({
startDate: {_greaterThanEquals: start, _lessThanEquals: end}
})();
for (let e = 0; e < events.length; e++) {
const event = events[e];
const eventStart = event.startDate();
const eventEnd = event.endDate();
if (eventEnd < start || eventStart > end) continue;
found.push({
id: String(event.uid()),
calendarIndex: c,
calendar: calendarName,
title: String(event.summary()),
start: eventStart.toISOString(),
end: eventEnd.toISOString(),
allDay: Boolean(event.alldayEvent()),
location: String(event.location() || "")
});
}
}
found.sort(function (a, b) { return a.start.localeCompare(b.start); });
return JSON.stringify(found.slice(0, input.limit));
}`;
const EVENT_CREATE_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Calendar.app");
const calendars = app.calendars();
let destination = null;
let destinationIndex = null;
for (let c = 0; c < calendars.length; c++) {
const indexMatches = input.calendarIndex !== null && c === input.calendarIndex &&
(!input.calendar || String(calendars[c].name()) === input.calendar);
const nameMatches = input.calendarIndex === null && String(calendars[c].name()) === input.calendar;
if (indexMatches || nameMatches) {
destination = calendars[c];
destinationIndex = c;
break;
}
}
if (!destination) throw new Error("Calendar not found");
if (!destination.writable()) throw new Error("Calendar is read-only");
const event = app.Event({
summary: input.title,
startDate: new Date(input.start),
endDate: new Date(input.end),
alldayEvent: input.allDay,
description: input.notes || "",
location: input.location || ""
});
destination.events.push(event);
return JSON.stringify({
id: String(event.uid()),
calendarIndex: destinationIndex,
calendar: String(destination.name()),
title: String(event.summary()),
start: event.startDate().toISOString(),
end: event.endDate().toISOString()
});
}`;
export function listCalendars() {
return runJxa(CALENDAR_LIST_SCRIPT);
}
export function listEvents({ start, end, calendar, calendarIndex, limit }) {
dateFromInput(start, "start");
dateFromInput(end, "end");
if (new Date(start) > new Date(end)) {
throw new Error("start must occur before end.");
}
return runJxa(EVENTS_LIST_SCRIPT, {
start,
end,
calendar,
calendarIndex: calendarIndex ?? null,
limit,
});
}
export function createEvent(input) {
const start = dateFromInput(input.start, "start");
const end = dateFromInput(input.end, "end");
if (start >= end) {
throw new Error("start must occur before end.");
}
return runJxa(EVENT_CREATE_SCRIPT, input);
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/codex-image.js
+175
View File
@@ -0,0 +1,175 @@
import { spawn } from "node:child_process";
import { mkdir, stat } from "node:fs/promises";
import path from "node:path";
const DEFAULT_OUTPUT_DIR = new URL("../../generated-images", import.meta.url).pathname;
const DEFAULT_CODEX_PATH = "codex";
const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
function getOutputDir() {
return process.env.CODEX_IMAGE_OUTPUT_DIR || DEFAULT_OUTPUT_DIR;
}
function getCodexPath() {
return process.env.CODEX_CLI_PATH || DEFAULT_CODEX_PATH;
}
function safeFilename(filename) {
const fallback = `codex-${new Date().toISOString().replaceAll(/[:.]/g, "-")}.png`;
const base = path.basename(filename || fallback).replaceAll(/[^a-zA-Z0-9._-]/g, "-");
const trimmed = base.replaceAll(/-+/g, "-").replaceAll(/^\.+/g, "");
return trimmed || fallback;
}
function parseJsonFromOutput(output) {
const trimmed = output.trim();
if (!trimmed) {
return null;
}
try {
return JSON.parse(trimmed);
} catch {
const match = trimmed.match(/\{[\s\S]*\}$/);
if (!match) {
return null;
}
try {
return JSON.parse(match[0]);
} catch {
return null;
}
}
}
function runCodex(codexPath, args, timeoutMs) {
return new Promise((resolve, reject) => {
const child = spawn(codexPath, args, {
env: process.env,
stdio: ["pipe", "pipe", "pipe"],
});
let stdout = "";
let stderr = "";
let timedOut = false;
const timeout = setTimeout(() => {
timedOut = true;
child.kill("SIGTERM");
}, timeoutMs);
child.stdout.setEncoding("utf8");
child.stderr.setEncoding("utf8");
child.stdout.on("data", (chunk) => {
stdout += chunk;
});
child.stderr.on("data", (chunk) => {
stderr += chunk;
});
child.on("error", (error) => {
clearTimeout(timeout);
reject(error);
});
child.on("close", (code, signal) => {
clearTimeout(timeout);
if (timedOut) {
reject(new Error(`timed out after ${timeoutMs}ms. ${stderr.trim()}`));
return;
}
if (code !== 0) {
reject(new Error(stderr.trim() || stdout.trim() || `exited with ${signal || code}`));
return;
}
resolve({ stdout, stderr });
});
child.stdin.end();
});
}
export function getCodexImageConfigStatus() {
return {
codexCliPath: getCodexPath(),
outputDir: getOutputDir(),
model: process.env.CODEX_IMAGE_MODEL || "(Codex CLI default)",
timeoutMs: Number.parseInt(process.env.CODEX_IMAGE_TIMEOUT_MS || String(DEFAULT_TIMEOUT_MS), 10),
};
}
export async function generateCodexImage({
prompt,
filename,
size,
quality,
style,
referenceImage,
}) {
const outputDir = getOutputDir();
await mkdir(outputDir, { recursive: true });
const outputFilename = safeFilename(filename);
const outputPath = path.join(outputDir, outputFilename);
const codexPath = getCodexPath();
const timeoutMs = Number.parseInt(process.env.CODEX_IMAGE_TIMEOUT_MS || String(DEFAULT_TIMEOUT_MS), 10);
const details = [
size ? `Requested size/aspect: ${size}` : null,
quality ? `Requested quality: ${quality}` : null,
style ? `Requested style: ${style}` : null,
].filter(Boolean).join("\n");
const workerPrompt = [
"Use $imagegen to generate exactly one raster image.",
`Save the final image file at this exact absolute path: ${outputPath}`,
"Do not modify any other files.",
"After saving the file, respond only with JSON matching this shape:",
`{"ok":true,"path":"${outputPath.replaceAll("\\", "\\\\")}","note":"short description"}`,
details ? `Generation details:\n${details}` : null,
`Image prompt:\n${prompt}`,
].filter(Boolean).join("\n\n");
const args = [
"exec",
"--ephemeral",
"--sandbox",
"workspace-write",
"--enable",
"image_generation",
"-C",
new URL("../..", import.meta.url).pathname,
];
if (process.env.CODEX_IMAGE_MODEL) {
args.push("--model", process.env.CODEX_IMAGE_MODEL);
}
if (referenceImage) {
args.push("--image", referenceImage);
}
args.push(workerPrompt);
let stdout = "";
let stderr = "";
try {
const result = await runCodex(codexPath, args, timeoutMs);
stdout = result.stdout;
stderr = result.stderr;
} catch (error) {
throw new Error(`Codex image generation failed. ${error.message}`);
}
try {
const file = await stat(outputPath);
const parsed = parseJsonFromOutput(stdout);
return {
ok: true,
path: outputPath,
filename: outputFilename,
bytes: file.size,
codexCliPath: codexPath,
note: parsed?.note || null,
stderr: stderr.trim() || null,
};
} catch {
throw new Error(`Codex completed but did not create ${outputPath}. Output: ${stdout.trim() || "(empty)"}`);
}
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/contacts.js
+102
View File
@@ -0,0 +1,102 @@
import { runJxa } from "../apple-events.js";
const CONTACTS_SEARCH_SCRIPT = String.raw`
function text(value) {
try { return value ? String(value) : ""; } catch (_) { return ""; }
}
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Contacts.app");
const query = (input.query || "").toLowerCase();
const people = app.people();
const found = [];
for (let i = 0; i < people.length && found.length < input.limit; i++) {
const person = people[i];
const name = text(person.name());
const organization = text(person.organization());
if (query && (name + "\n" + organization).toLowerCase().indexOf(query) === -1) continue;
found.push({
id: String(person.id()),
name: name,
organization: organization,
modifiedAt: person.modificationDate().toISOString()
});
}
return JSON.stringify(found);
}`;
const CONTACTS_READ_SCRIPT = String.raw`
function text(value) {
try { return value ? String(value) : ""; } catch (_) { return ""; }
}
function items(values) {
return values.map(function (value) {
return { label: text(value.label()), value: text(value.value()) };
});
}
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Contacts.app");
const people = app.people();
for (let i = 0; i < people.length; i++) {
const person = people[i];
if (String(person.id()) !== input.id) continue;
return JSON.stringify({
id: String(person.id()),
name: text(person.name()),
firstName: text(person.firstName()),
lastName: text(person.lastName()),
organization: text(person.organization()),
jobTitle: text(person.jobTitle()),
emails: items(person.emails()),
phones: items(person.phones()),
modifiedAt: person.modificationDate().toISOString()
});
}
throw new Error("Contact not found");
}`;
const CONTACTS_CREATE_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Contacts.app");
const person = app.Person({
firstName: input.firstName || "",
lastName: input.lastName || "",
organization: input.organization || "",
jobTitle: input.jobTitle || "",
note: input.note || ""
});
app.people.push(person);
if (input.email) {
person.emails.push(app.Email({label: input.email.label, value: input.email.value}));
}
if (input.phone) {
person.phones.push(app.Phone({label: input.phone.label, value: input.phone.value}));
}
app.save();
return JSON.stringify({
id: String(person.id()),
name: String(person.name()),
organization: input.organization || ""
});
}`;
export function searchContacts(input) {
return runJxa(CONTACTS_SEARCH_SCRIPT, input);
}
export function readContact(id) {
return runJxa(CONTACTS_READ_SCRIPT, { id });
}
export function createContact(input) {
return runJxa(CONTACTS_CREATE_SCRIPT, input);
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/deco.js
+43
View File
@@ -0,0 +1,43 @@
import { execFile } from "node:child_process";
import { loadEnvFile } from "node:process";
import { promisify } from "node:util";
try {
loadEnvFile();
} catch (error) {
if (error.code !== "ENOENT") {
throw error;
}
}
const execFileAsync = promisify(execFile);
const PYTHON = new URL("../../.venv/bin/python", import.meta.url).pathname;
const BRIDGE = new URL("../../scripts/deco_bridge.py", import.meta.url).pathname;
const HA_CLIENTS_BRIDGE = new URL("../../scripts/deco_ha_bridge.py", import.meta.url).pathname;
export async function getDecoStats(action) {
try {
const args = action === "clients" ? [HA_CLIENTS_BRIDGE] : [BRIDGE, action];
const { stdout } = await execFileAsync(PYTHON, args, {
timeout: 90_000,
maxBuffer: 4 * 1024 * 1024,
env: process.env,
});
return JSON.parse(stdout);
} catch (error) {
const detail = error.stderr?.trim() || error.message;
throw new Error(`Deco stats request failed. ${detail}`);
}
}
export function getDecoConfigStatus() {
return {
host: process.env.DECO_HOST || "(default gateway)",
username: process.env.DECO_USERNAME || "admin",
passwordConfigured: Boolean(process.env.DECO_PASSWORD),
passwordLength: process.env.DECO_PASSWORD?.length || 0,
verifySsl: process.env.DECO_VERIFY_SSL ?? "true",
timeout: process.env.DECO_TIMEOUT || "10",
};
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/gemini-chrome-prompt.js
+67
View File
@@ -0,0 +1,67 @@
import path from "node:path";
const DEFAULT_OUTPUT_DIR = new URL("../../generated-images", import.meta.url).pathname;
const DEFAULT_PROFILE_NAME = "ReynaFamilyBot";
function getOutputDir() {
return process.env.GEMINI_CHROME_IMAGE_OUTPUT_DIR || process.env.CODEX_IMAGE_OUTPUT_DIR || DEFAULT_OUTPUT_DIR;
}
function getProfileName() {
return process.env.GEMINI_CHROME_PROFILE_NAME || DEFAULT_PROFILE_NAME;
}
function safeFilename(filename) {
const fallback = `gemini-chrome-${new Date().toISOString().replaceAll(/[:.]/g, "-")}.png`;
const base = path.basename(filename || fallback).replaceAll(/[^a-zA-Z0-9._-]/g, "-");
const trimmed = base.replaceAll(/-+/g, "-").replaceAll(/^\.+/g, "");
const name = trimmed || fallback;
return name.endsWith(".png") ? name : `${name}.png`;
}
function codexPrompt({ prompt, outputPath, profileName }) {
return [
"Use the Chrome skill, not Playwright and not MacMiniMCP browser tools.",
"",
"Goal: generate an image in Gemini using my Chrome profile named `" + profileName + "`, then save the downloaded image locally.",
"",
"Steps:",
"1. Connect to Chrome through the Codex Chrome Extension.",
"2. Verify the selected Chrome browser metadata has `profileName: \"" + profileName + "\"`. If not, stop and tell me.",
"3. Open or create a Gemini tab at https://gemini.google.com/app.",
"4. If Gemini shows the first-run notice, click `Got it`.",
"5. Submit this image prompt:",
"",
prompt,
"",
"6. Wait until Gemini finishes and shows `Download full size image`.",
"7. Click `Download full size image`.",
"8. Find the newest `Gemini_Generated_Image_*.png` in `/Users/adolforeyna/Downloads`.",
"9. Copy it to:",
" `" + outputPath + "`",
"10. Show me the saved path and render the image in the response.",
"",
"Do not expose browser control through MCP. Do not use arbitrary browsing. Only use Chrome for this Gemini image-generation task.",
].join("\n");
}
export function getGeminiChromePromptConfigStatus() {
return {
outputDir: getOutputDir(),
profileName: getProfileName(),
note: "This MCP tool builds a Codex prompt. It does not control Chrome itself because the Chrome skill is only available inside an active Codex session.",
};
}
export function buildGeminiChromePrompt({ prompt, filename } = {}) {
const outputFilename = safeFilename(filename);
const outputPath = path.join(getOutputDir(), outputFilename);
const profileName = getProfileName();
return {
prompt: codexPrompt({ prompt, outputPath, profileName }),
outputPath,
filename: outputFilename,
profileName,
};
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/gemini-image.js
+99
View File
@@ -0,0 +1,99 @@
import fs from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";
const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
const defaultOutputDir = path.join(projectRoot, "generated-images");
const defaultModel = "gemini-3.1-flash-image";
const interactionsUrl = "https://generativelanguage.googleapis.com/v1beta/interactions";
function outputDir() {
return process.env.GEMINI_IMAGE_OUTPUT_DIR || defaultOutputDir;
}
function apiKey() {
return process.env.GEMINI_API_KEY || "";
}
function safeFilename(name) {
const fallback = `gemini-${new Date().toISOString().replace(/[:.]/g, "-")}.png`;
const base = path.basename(name || fallback).replace(/[^a-zA-Z0-9._-]/g, "-");
if (!base) {
return fallback;
}
return base.endsWith(".png") ? base : `${base}.png`;
}
function buildResponseFormat({ aspectRatio, imageSize }) {
if (!aspectRatio && !imageSize) {
return undefined;
}
return {
type: "image",
mime_type: "image/png",
...(aspectRatio ? { aspect_ratio: aspectRatio } : {}),
...(imageSize ? { image_size: imageSize } : {}),
};
}
export function getGeminiImageConfigStatus() {
return {
configured: Boolean(apiKey()),
outputDir: outputDir(),
defaultModel,
};
}
export async function generateGeminiImage({
prompt,
filename,
model = defaultModel,
aspectRatio,
imageSize,
useGoogleSearch = false,
} = {}) {
const key = apiKey();
if (!key) {
throw new Error("GEMINI_API_KEY is required for gemini_image_generate.");
}
const responseFormat = buildResponseFormat({ aspectRatio, imageSize });
const body = {
model,
input: [{ type: "text", text: prompt }],
...(responseFormat ? { response_format: responseFormat } : {}),
...(useGoogleSearch ? { tools: [{ type: "google_search" }] } : {}),
};
const response = await fetch(interactionsUrl, {
method: "POST",
headers: {
"content-type": "application/json",
"x-goog-api-key": key,
},
body: JSON.stringify(body),
});
const data = await response.json().catch(() => null);
if (!response.ok) {
const message = data?.error?.message || response.statusText || "Gemini image generation failed.";
throw new Error(`Gemini API error ${response.status}: ${message}`);
}
const image = data?.output_image;
if (!image?.data) {
throw new Error("Gemini API did not return output_image.data.");
}
const destinationDir = outputDir();
await fs.mkdir(destinationDir, { recursive: true });
const destination = path.join(destinationDir, safeFilename(filename));
await fs.writeFile(destination, Buffer.from(image.data, "base64"));
return {
path: destination,
model,
mimeType: image.mime_type || "image/png",
interactionId: data.id,
};
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/kokoro-tts.js
+99
View File
@@ -0,0 +1,99 @@
import { readFile, stat } from "node:fs/promises";
const DEFAULT_KSAY_URL = process.env.KSAY_URL || "http://127.0.0.1:7332";
function cleanBaseUrl(url) {
return String(url || DEFAULT_KSAY_URL).replace(/\/+$/, "");
}
async function requestJson(path, { method = "GET", body } = {}) {
const url = `${cleanBaseUrl()}${path}`;
let response;
try {
response = await fetch(url, {
method,
headers: body ? { "content-type": "application/json" } : undefined,
body: body ? JSON.stringify(body) : undefined,
});
} catch (error) {
throw new Error(`Kokoro ksay daemon is not reachable at ${cleanBaseUrl()}: ${error.message}`);
}
const text = await response.text();
let value;
try {
value = text ? JSON.parse(text) : {};
} catch {
throw new Error(`Kokoro ksay daemon returned non-JSON response: ${text.slice(0, 500)}`);
}
if (!response.ok || value.ok === false) {
throw new Error(value.error || `Kokoro ksay daemon returned HTTP ${response.status}`);
}
return value;
}
function normalizeSpeed(speed) {
if (speed === undefined || speed === null) return 1.0;
const n = Number(speed);
if (!Number.isFinite(n) || n < 0.5 || n > 2.0) {
throw new Error("speed must be a number between 0.5 and 2.0.");
}
return n;
}
function normalizeVoice(voice) {
return String(voice || process.env.KSAY_VOICE || "af_heart").trim().slice(0, 100);
}
function normalizeLangCode(langCode) {
return String(langCode || process.env.KSAY_LANG_CODE || "a").trim().slice(0, 8);
}
export async function speechKokoroStatus() {
return requestJson("/health");
}
export async function speechKokoroSynthesize({ text, voice, speed, langCode, outputPath }) {
if (!text || !String(text).trim()) throw new Error("text required");
const cleanText = String(text).slice(0, 8000);
const result = await requestJson("/say", {
method: "POST",
body: {
text: cleanText,
voice: normalizeVoice(voice),
speed: normalizeSpeed(speed),
langCode: normalizeLangCode(langCode),
output: outputPath || undefined,
},
});
return {
...result,
text: cleanText,
format: "wav 24kHz mono",
fileSize: await stat(result.filePath).then((s) => s.size).catch(() => 0),
note: "Uses the warm ksay Kokoro daemon. Use speech_kokoro_synthesize_base64 when the caller needs audio bytes.",
};
}
export async function speechKokoroSynthesizeBase64({ text, voice, speed, langCode }) {
const result = await speechKokoroSynthesize({ text, voice, speed, langCode });
const buf = await readFile(result.filePath);
const wavBase64 = buf.toString("base64");
return {
ok: true,
text: result.text,
voice: result.voice,
speed: result.speed,
langCode: result.langCode,
model: result.model,
filePath: result.filePath,
wavBase64,
size: buf.length,
base64Length: wavBase64.length,
sampleRate: result.sampleRate,
seconds: result.seconds,
format: "wav 24kHz mono",
};
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/mail.js
+146
View File
@@ -0,0 +1,146 @@
import { runJxa } from "../apple-events.js";
const MAX_MESSAGES = 50;
const ACCOUNTS_SCRIPT = String.raw`
function stringList(value) {
if (!value) return [];
if (Array.isArray(value)) return value.map(String);
return [String(value)];
}
function run() {
const app = Application("/System/Applications/Mail.app");
return JSON.stringify(app.accounts().map(function (account) {
let addresses = [];
try { addresses = stringList(account.emailAddresses()); } catch (_) {}
return { id: String(account.id()), name: String(account.name()), emailAddresses: addresses };
}));
}`;
const MAILBOXES_SCRIPT = String.raw`
function addMailbox(found, role, mailbox) {
try { found.push({ role: role, name: String(mailbox.name()) }); } catch (_) {}
}
function run() {
const app = Application("/System/Applications/Mail.app");
const found = [];
addMailbox(found, "inbox", app.inbox());
addMailbox(found, "sent", app.sentMailbox());
addMailbox(found, "drafts", app.draftsMailbox());
addMailbox(found, "junk", app.junkMailbox());
addMailbox(found, "trash", app.trashMailbox());
return JSON.stringify(found);
}`;
const LIST_MESSAGES_SCRIPT = String.raw`
function isoDate(value) {
try { return value ? value.toISOString() : null; } catch (_) { return null; }
}
function globalMailbox(app, requestedName) {
const candidates = [app.inbox(), app.sentMailbox(), app.draftsMailbox(), app.junkMailbox(), app.trashMailbox()];
for (let i = 0; i < candidates.length; i++) {
try { if (String(candidates[i].name()) === requestedName) return candidates[i]; } catch (_) {}
}
throw new Error("Mailbox not found; use mail_list_mailboxes first");
}
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Mail.app");
const mailbox = globalMailbox(app, input.mailbox);
const messages = mailbox.messages();
const found = [];
for (let i = 0; i < messages.length && found.length < input.limit; i++) {
const message = messages[i];
let account = null;
try { account = message.mailbox().account(); } catch (_) { continue; }
if (String(account.id()) !== input.accountId) continue;
const read = Boolean(message.readStatus());
if (input.unreadOnly && read) continue;
found.push({
id: String(message.id()),
accountId: String(account.id()),
account: String(account.name()),
mailbox: String(mailbox.name()),
subject: String(message.subject() || ""),
sender: String(message.sender() || ""),
dateSent: isoDate(message.dateSent()),
read: read
});
}
return JSON.stringify(found);
}`;
const READ_MESSAGE_SCRIPT = String.raw`
function isoDate(value) {
try { return value ? value.toISOString() : null; } catch (_) { return null; }
}
function globalMailbox(app, requestedName) {
const candidates = [app.inbox(), app.sentMailbox(), app.draftsMailbox(), app.junkMailbox(), app.trashMailbox()];
for (let i = 0; i < candidates.length; i++) {
try { if (String(candidates[i].name()) === requestedName) return candidates[i]; } catch (_) {}
}
throw new Error("Mailbox not found; use mail_list_mailboxes first");
}
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Mail.app");
const mailbox = globalMailbox(app, input.mailbox);
let message;
try { message = mailbox.messages.byId(Number(input.id)); } catch (_) { throw new Error("Message not found in the selected mailbox"); }
let account;
try { account = message.mailbox().account(); } catch (_) { throw new Error("Message not found in the selected mailbox"); }
if (String(account.id()) !== input.accountId) throw new Error("Message does not belong to the selected account");
return JSON.stringify({
id: String(message.id()),
accountId: String(account.id()),
account: String(account.name()),
mailbox: String(mailbox.name()),
subject: String(message.subject() || ""),
sender: String(message.sender() || ""),
dateSent: isoDate(message.dateSent()),
read: Boolean(message.readStatus()),
body: String(message.content() || "")
});
}`;
function requireAccountId(value) {
if (typeof value !== "string" || !value.trim()) throw new Error("accountId is required");
return value;
}
function requireMailbox(value) {
if (typeof value !== "string" || !value.trim()) throw new Error("mailbox is required");
return value;
}
export function createMailClient(execute = runJxa) {
return {
accounts() {
return execute(ACCOUNTS_SCRIPT, {});
},
mailboxes({ accountId }) {
requireAccountId(accountId);
return execute(MAILBOXES_SCRIPT, {});
},
listMessages({ accountId, mailbox, limit = 10, unreadOnly = false }) {
if (!Number.isInteger(limit) || limit < 1 || limit > MAX_MESSAGES) throw new Error(`limit must be between 1 and ${MAX_MESSAGES}`);
return execute(LIST_MESSAGES_SCRIPT, { accountId: requireAccountId(accountId), mailbox: requireMailbox(mailbox), limit, unreadOnly: Boolean(unreadOnly) });
},
readMessage({ accountId, mailbox, id }) {
if (typeof id !== "string" || !id.trim()) throw new Error("id is required");
return execute(READ_MESSAGE_SCRIPT, { accountId: requireAccountId(accountId), mailbox: requireMailbox(mailbox), id });
},
};
}
const mail = createMailClient();
export const listMailAccounts = () => mail.accounts();
export const listMailboxes = (input) => mail.mailboxes(input);
export const listMailMessages = (input) => mail.listMessages(input);
export const readMailMessage = (input) => mail.readMessage(input);
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/notes.js
+109
View File
@@ -0,0 +1,109 @@
import { plainTextToNoteHtml, runJxa } from "../apple-events.js";
const NOTES_LIST_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Notes.app");
const query = (input.query || "").toLowerCase();
const folderName = input.folder || "";
const limit = input.limit;
const found = [];
const accounts = app.accounts();
for (let a = 0; a < accounts.length && found.length < limit; a++) {
const folders = accounts[a].folders();
for (let f = 0; f < folders.length && found.length < limit; f++) {
const folder = folders[f];
const currentFolder = String(folder.name());
if (folderName && currentFolder !== folderName) continue;
const notes = folder.notes();
for (let n = 0; n < notes.length && found.length < limit; n++) {
const note = notes[n];
let title = "";
let text = "";
try { title = String(note.name()); } catch (_) {}
try { text = String(note.plaintext()); } catch (_) {}
if (query && (title + "\n" + text).toLowerCase().indexOf(query) === -1) continue;
found.push({
id: String(note.id()),
title: title,
folder: currentFolder,
modifiedAt: note.modificationDate().toISOString(),
preview: input.includePreview ? text.slice(0, 180) : undefined
});
}
}
}
return JSON.stringify(found);
}`;
const NOTES_READ_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Notes.app");
const accounts = app.accounts();
for (let a = 0; a < accounts.length; a++) {
const folders = accounts[a].folders();
for (let f = 0; f < folders.length; f++) {
const notes = folders[f].notes();
for (let n = 0; n < notes.length; n++) {
const note = notes[n];
if (String(note.id()) === input.id) {
return JSON.stringify({
id: String(note.id()),
title: String(note.name()),
folder: String(folders[f].name()),
bodyHtml: String(note.body()),
plaintext: String(note.plaintext()),
createdAt: note.creationDate().toISOString(),
modifiedAt: note.modificationDate().toISOString()
});
}
}
}
}
throw new Error("Note not found");
}`;
const NOTES_CREATE_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Notes.app");
const accounts = app.accounts();
let destination = null;
for (let a = 0; a < accounts.length && !destination; a++) {
const folders = accounts[a].folders();
for (let f = 0; f < folders.length; f++) {
if (!input.folder || String(folders[f].name()) === input.folder) {
destination = folders[f];
break;
}
}
}
if (!destination) throw new Error("Notes destination folder not found");
const note = app.Note({body: input.html});
destination.notes.push(note);
return JSON.stringify({
id: String(note.id()),
title: String(note.name()),
folder: String(destination.name())
});
}`;
export function listNotes(input) {
return runJxa(NOTES_LIST_SCRIPT, input);
}
export function readNote(id) {
return runJxa(NOTES_READ_SCRIPT, { id });
}
export function createNote({ title, body, folder }) {
return runJxa(NOTES_CREATE_SCRIPT, {
folder,
html: plainTextToNoteHtml(title, body),
});
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/reminders.js
+171
View File
@@ -0,0 +1,171 @@
import { dateFromInput, runJxa } from "../apple-events.js";
const LISTS_SCRIPT = String.raw`
function run() {
const app = Application("/System/Applications/Reminders.app");
function stringValue(value) {
try {
return value === null || value === undefined ? null : String(value);
} catch (_) {
return null;
}
}
function accountName(list) {
try {
const container = list.container();
return stringValue(container.name ? container.name() : container);
} catch (_) {
return null;
}
}
return JSON.stringify(app.lists().map(function (list) {
return {
id: String(list.id()),
name: String(list.name()),
account: accountName(list),
shared: null,
assignmentMetadata: {
available: null,
note: "Apple Reminders automation does not expose shared-list participant metadata directly."
}
};
}));
}`;
const REMINDERS_LIST_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Reminders.app");
const lists = app.lists();
const found = [];
function stringValue(value) {
try {
return value === null || value === undefined ? null : String(value);
} catch (_) {
return null;
}
}
function compact(value) {
if (!value) return null;
const text = String(value).trim();
return text ? text : null;
}
function propertyValue(object, names) {
for (let i = 0; i < names.length; i++) {
try {
const getter = object[names[i]];
if (typeof getter !== "function") continue;
const value = getter.call(object);
const text = compact(stringValue(value));
if (text && !text.startsWith("[object ")) return text;
if (value && typeof value.name === "function") {
const name = compact(stringValue(value.name()));
if (name) return name;
}
} catch (_) {}
}
return null;
}
function assignmentHint(title, notes) {
const titleMatch = title.match(/\(([^()\n]{2,80})\)\s*$/);
if (titleMatch) return { assignee: titleMatch[1].trim(), source: "title" };
const explicit = notes.match(/\b(?:assigned to|assignee)\s*:\s*([^.;,\n]{2,80})/i);
if (explicit) return { assignee: explicit[1].trim(), source: "notes" };
const captured = notes.match(/\bCaptured\s+\d{4}-\d{2}-\d{2},\s*([^.;,\n]{2,80})\s*[.;]/i);
if (captured) return { assignee: captured[1].trim(), source: "notes" };
return { assignee: null, source: null };
}
function assignmentFor(reminder, title, notes) {
const nativeAssignee = propertyValue(reminder, [
"assignedTo",
"assignee",
"assignment",
"responsiblePerson",
"principal"
]);
if (nativeAssignee) {
return {
assignee: nativeAssignee,
source: "remindersAutomation",
available: true
};
}
const hint = assignmentHint(title, notes);
return {
assignee: hint.assignee,
source: hint.source,
available: hint.assignee !== null
};
}
for (let l = 0; l < lists.length && found.length < input.limit; l++) {
const list = lists[l];
const name = String(list.name());
if (input.list && name !== input.list) continue;
const reminders = list.reminders();
for (let r = 0; r < reminders.length && found.length < input.limit; r++) {
const reminder = reminders[r];
const completed = Boolean(reminder.completed());
if (input.completed !== null && completed !== input.completed) continue;
let due = null;
try {
const value = reminder.dueDate();
due = value ? value.toISOString() : null;
} catch (_) {}
const title = String(reminder.name());
const notes = String(reminder.body() || "");
found.push({
id: String(reminder.id()),
list: name,
title: title,
completed: completed,
due: due,
notes: notes,
assignment: assignmentFor(reminder, title, notes)
});
}
}
return JSON.stringify(found);
}`;
const REMINDER_CREATE_SCRIPT = String.raw`
function run(argv) {
const input = JSON.parse(argv[0]);
const app = Application("/System/Applications/Reminders.app");
const lists = app.lists();
let destination = null;
for (let l = 0; l < lists.length; l++) {
if (!input.list || String(lists[l].name()) === input.list) {
destination = lists[l];
break;
}
}
if (!destination) throw new Error("Reminders list not found");
const properties = {name: input.title, body: input.notes || ""};
if (input.due) properties.dueDate = new Date(input.due);
const reminder = app.Reminder(properties);
destination.reminders.push(reminder);
return JSON.stringify({
id: String(reminder.id()),
list: String(destination.name()),
title: String(reminder.name())
});
}`;
export function listReminderLists() {
return runJxa(LISTS_SCRIPT);
}
export function listReminders(input) {
return runJxa(REMINDERS_LIST_SCRIPT, input);
}
export function createReminder(input) {
if (input.due) {
dateFromInput(input.due, "due");
}
return runJxa(REMINDER_CREATE_SCRIPT, input);
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/speech-live.js
+281
View File
@@ -0,0 +1,281 @@
import { execFile, spawn } from "node:child_process";
import { promisify } from "node:util";
import { writeFile, readFile, stat, rm, mkdir, mkdtemp } from "node:fs/promises";
import path from "node:path";
import os from "node:os";
const execFileAsync = promisify(execFile);
function swiftSourcePipeTranscriber() {
return `
import AVFoundation
import Foundation
import Speech
func parseArgs() -> (String, Bool) {
var localeId = "en-US"
var verbose = false
var i = 1
let raw = CommandLine.arguments
while i < raw.count {
let a = raw[i]
if a == "--locale", i+1 < raw.count { localeId = raw[i+1]; i+=1 }
else if a == "-v" || a == "--verbose" { verbose = true }
i+=1
}
return (localeId, verbose)
}
func logv(_ msg: String, verbose: Bool) { if verbose { fputs("[apple-pipe] \\(msg)\\n", stderr) } }
@main
struct ApplePipeCLI {
static func main() async {
let (localeId, verbose) = parseArgs()
guard SpeechTranscriber.isAvailable else { fputs("Not available\\n", stderr); exit(1) }
let reqLocale = Locale(identifier: localeId)
let locale: Locale
if let sup = await SpeechTranscriber.supportedLocale(equivalentTo: reqLocale) { locale = sup }
else { locale = reqLocale }
// warm asset check
let warm = SpeechTranscriber(locale: locale, transcriptionOptions: [], reportingOptions: [.volatileResults], attributeOptions: [])
let status = await AssetInventory.status(forModules: [warm])
switch status {
case .installed: logv("Assets installed", verbose: verbose)
case .unsupported: fputs("Locale unsupported\\n", stderr); exit(2)
case .supported:
logv("Downloading assets...", verbose: true)
do { if let req = try await AssetInventory.assetInstallationRequest(supporting: [warm]) { try await req.downloadAndInstall() } }
catch { fputs("Asset download failed: \\(error)\\n", stderr); exit(3) }
case .downloading:
logv("Waiting assets...", verbose: true)
for _ in 0..<30 { try? await Task.sleep(nanoseconds: 1_000_000_000); if await AssetInventory.status(forModules: [warm]) == .installed { break } }
@unknown default: break
}
logv("Pipe ready locale=\\(locale.identifier)", verbose: true)
let stdinH = FileHandle.standardInput
var leftover = Data()
var chunkIdx = 0
func readExact(_ n: Int) -> Data? {
var out = Data(); out.reserveCapacity(n)
if leftover.count >= n { let d = leftover.prefix(n); leftover = leftover.dropFirst(n); return Data(d) }
if leftover.count > 0 { out.append(leftover); leftover = Data() }
while out.count < n {
let d = stdinH.readData(ofLength: n - out.count)
if d.isEmpty { if out.count==0 { return nil }; return nil }
out.append(d)
}
return out
}
while true {
guard let lenData = readExact(4) else { break }
let length = lenData.withUnsafeBytes { $0.load(as: UInt32.self).bigEndian }
if length == 0 { logv("Pipe EOF", verbose: true); break }
if length > 20_000_000 { fputs("Chunk too large \\(length)\\n", stderr); break }
guard let chunkData = readExact(Int(length)) else { fputs("Truncated expected \\(length)\\n", stderr); break }
chunkIdx += 1
let tmpURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("apple-pipe-\\(ProcessInfo.processInfo.processIdentifier)-\\(chunkIdx).wav")
do { try chunkData.write(to: tmpURL) } catch { fputs("Write err: \\(error)\\n", stderr); continue }
guard let audioFile = try? AVAudioFile(forReading: tmpURL) else { try? FileManager.default.removeItem(at: tmpURL); fputs("Open fail \\(chunkIdx)\\n", stderr); continue }
let t = SpeechTranscriber(locale: locale, transcriptionOptions: [], reportingOptions: [.volatileResults], attributeOptions: [.audioTimeRange])
guard let analyzer = try? await SpeechAnalyzer(inputAudioFile: audioFile, modules: [t], finishAfterFile: true) else { try? FileManager.default.removeItem(at: tmpURL); continue }
do {
for try await res in t.results {
let txt = String(res.text.characters).trimmingCharacters(in: .whitespacesAndNewlines)
if txt.isEmpty { continue }
let d: [String: Any] = [
"event": res.isFinal ? "final" : "draft",
"text": txt, "isFinal": res.isFinal,
"chunk": chunkIdx, "start": res.range.start.seconds,
"duration": res.range.duration.seconds
]
if let jd = try? JSONSerialization.data(withJSONObject: d), let s = String(data: jd, encoding: .utf8) {
print(s); fflush(stdout)
}
}
} catch { fputs("Results err \\(chunkIdx): \\(error)\\n", stderr) }
_ = analyzer
try? FileManager.default.removeItem(at: tmpURL)
}
logv("Pipe done \\(chunkIdx)", verbose: true)
}
}
`;
}
class ApplePipeSession {
constructor(locale) {
this.locale = locale;
this.proc = null;
this.tmpDir = null;
this.binFile = null;
this.ready = false;
this.chunkIdx = 0;
this.lastActivity = Date.now();
this._lineCallback = null;
}
async ensureBuilt() {
const tmpBase = path.join(os.tmpdir(), "speech-live-");
this.tmpDir = await mkdtemp(tmpBase);
const swiftFile = path.join(this.tmpDir, "Main.swift");
this.binFile = path.join(this.tmpDir, "apple-pipe-transcribe");
await writeFile(swiftFile, swiftSourcePipeTranscriber(), "utf8");
try {
await execFileAsync("/usr/bin/swiftc", ["-O", "-parse-as-library", swiftFile, "-o", this.binFile, "-framework", "AVFoundation", "-framework", "Speech"], { timeout: 60000, maxBuffer: 20*1024*1024 });
} catch (e) {
throw new Error(`swiftc build failed: ${e.stderr||e.message}`);
}
}
async start() {
if (this.proc && this.proc.exitCode === null && this.ready) return;
if (!this.binFile) await this.ensureBuilt();
return new Promise((resolve, reject) => {
const args = ["--locale", this.locale];
this.proc = spawn(this.binFile, args, { stdio: ["pipe", "pipe", "pipe"] });
let stderrBuf = "";
this.proc.stderr.on("data", d => { stderrBuf += d.toString(); });
setTimeout(() => {
if (this.proc.exitCode !== null) {
reject(new Error(`apple-pipe exited early code=${this.proc.exitCode} stderr=${stderrBuf.slice(0,2000)}`));
} else {
this.ready = true;
this._setupReader();
resolve();
}
}, 800);
this.proc.on("error", reject);
});
}
_setupReader() {
let buf = "";
this.proc.stdout.on("data", chunk => {
buf += chunk.toString("utf8");
let lines = buf.split("\n");
buf = lines.pop() || "";
for (let line of lines) {
line = line.trim();
if (!line) continue;
try {
const obj = JSON.parse(line);
if (this._lineCallback) this._lineCallback(obj);
} catch {}
}
});
}
async transcribeChunk(wavBytes, { timeoutMs = 6000 } = {}) {
await this.start();
this.chunkIdx++;
const myIdx = this.chunkIdx;
return new Promise((resolve, reject) => {
let drafts = [];
let finals = [];
let timer = null;
let done = false;
const cleanup = () => { done = true; if (timer) clearTimeout(timer); this._lineCallback = null; };
const finish = () => {
if (done) return;
cleanup();
const fullFinal = finals.map(f=>f.text).join(" ").trim();
const lastDraft = drafts.length ? drafts[drafts.length-1].text : "";
const text = fullFinal || lastDraft || "";
resolve({ text, finals, drafts, chunk: myIdx, isFinal: finals.length>0 });
};
this._lineCallback = (obj) => {
if (obj.chunk !== myIdx) return;
if (obj.isFinal || obj.event==="final") {
finals.push(obj);
if (timer) clearTimeout(timer);
timer = setTimeout(finish, 350);
} else {
drafts.push(obj);
if (timer) clearTimeout(timer);
timer = setTimeout(finish, 700);
}
};
timer = setTimeout(() => { if (!done) finish(); }, timeoutMs);
try {
const lenBuf = Buffer.alloc(4);
lenBuf.writeUInt32BE(wavBytes.length, 0);
this.proc.stdin.write(Buffer.concat([lenBuf, Buffer.from(wavBytes)]));
} catch (e) {
cleanup();
reject(e);
}
});
}
async close() {
try {
if (this.proc && this.proc.stdin.writable) {
const eof = Buffer.alloc(4); eof.writeUInt32BE(0,0);
this.proc.stdin.write(eof);
this.proc.stdin.end();
}
if (this.proc) {
await new Promise(r => { this.proc.on("close", r); setTimeout(r, 1500); });
try { this.proc.kill(); } catch {}
}
} catch {}
try { if (this.tmpDir) await rm(this.tmpDir, {recursive:true, force:true}); } catch {}
this.proc = null;
this.ready = false;
}
}
const sessions = new Map();
async function getOrCreateSession(locale) {
let s = sessions.get(locale);
if (!s) {
s = new ApplePipeSession(locale);
sessions.set(locale, s);
}
await s.start();
s.lastActivity = Date.now();
return s;
}
export async function speechLiveTranscribe({ audioBase64, locale } = {}) {
if (!audioBase64) throw new Error("audioBase64 required (WAV 16k mono base64)");
const wavBytes = Buffer.from(audioBase64, "base64");
const loc = locale || "en-US";
const session = await getOrCreateSession(loc);
const res = await session.transcribeChunk(wavBytes, { timeoutMs: 8000 });
return {
ok: true,
engine: "ApplePipeTranscriber/macOS26.5 --pipe volatile drafts",
locale: loc,
text: res.text,
isFinal: res.isFinal,
drafts: res.drafts,
finals: res.finals,
chunk: res.chunk,
realtime: true
};
}
export async function speechLiveClose({ locale } = {}) {
const loc = locale || "en-US";
const s = sessions.get(loc);
if (s) {
await s.close();
sessions.delete(loc);
}
return { ok: true, closed: loc };
}
export async function speechLiveStatus() {
const info = [];
for (let [loc, s] of sessions.entries()) {
info.push({ locale: loc, ready: s.ready, chunkIdx: s.chunkIdx, lastActivity: new Date(s.lastActivity).toISOString(), pid: s.proc?.pid || null });
}
return { sessions: info, count: info.length };
}
setInterval(async () => {
const now = Date.now();
for (let [loc, s] of sessions.entries()) {
if (now - s.lastActivity > 60000) {
try { await s.close(); } catch {}
sessions.delete(loc);
}
}
}, 15000);
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/speech-transcribe.js
+277
View File
@@ -0,0 +1,277 @@
import { execFile } from "node:child_process";
import { promisify } from "node:util";
import { writeFile, readFile, stat, rm, mkdir } from "node:fs/promises";
import path from "node:path";
import os from "node:os";
const execFileAsync = promisify(execFile);
const OUTPUT_BASE = path.join(os.homedir(), "Projects", "MacMiniMCP", "generated-transcriptions");
// Swift source for file transcription using the REAL macOS 26.5 API
// From swiftinterface: SpeechAnalyzer has init(inputAudioFile:modules:) and analyzeSequence(from:)
// No AssetInputSequenceProvider - it's direct AVAudioFile
function swiftSourceFileTranscriber() {
return `import Speech
import AVFoundation
import Foundation
@main
struct TranscribeCLI {
static func main() async {
let args = CommandLine.arguments
let audioPath = args.count > 1 ? args[1] : ""
let localeId = args.count > 2 ? args[2] : "en-US"
let jsonOut = args.count > 3 ? args[3] : ""
if audioPath.isEmpty {
fputs("Usage: transcriber <audioPath> [locale] [jsonOut]\\n", stderr)
exit(1)
}
let startTime = CFAbsoluteTimeGetCurrent()
guard FileManager.default.fileExists(atPath: audioPath) else {
fputs("ERROR: File not found \\(audioPath)\\n", stderr)
exit(3)
}
let audioURL = URL(fileURLWithPath: audioPath)
let requestedLocale = Locale(identifier: localeId)
let resolvedLocale: Locale
if let l = await SpeechTranscriber.supportedLocale(equivalentTo: requestedLocale) {
resolvedLocale = l
} else if let fb = await SpeechTranscriber.supportedLocale(equivalentTo: Locale(identifier: "en-US")) {
resolvedLocale = fb
} else {
fputs("ERROR: No supported locale for \\(localeId)\\n", stderr)
exit(2)
}
let isAvail = SpeechTranscriber.isAvailable
fputs("Locale \\(resolvedLocale.identifier) isAvailable=\\(isAvail)\\n", stderr)
let transcriber = SpeechTranscriber(locale: resolvedLocale, preset: .transcription)
// Assets
do {
if let req = try await AssetInventory.assetInstallationRequest(supporting: [transcriber]) {
fputs("Downloading assets for \\(resolvedLocale.identifier)...\\n", stderr)
try await req.downloadAndInstall()
fputs("Assets ready\\n", stderr)
} else {
fputs("No asset download needed\\n", stderr)
}
} catch {
fputs("Asset note (continuing): \\(error)\\n", stderr)
}
let avFile: AVAudioFile
do {
avFile = try AVAudioFile(forReading: audioURL)
fputs("File: frames=\\(avFile.length) sr=\\(avFile.processingFormat.sampleRate) fmt=\\(avFile.fileFormat)\\n", stderr)
} catch {
fputs("ERROR opening file: \\(error)\\n", stderr)
exit(4)
}
var allSegments: [String] = []
do {
// Use the new convenience: analyzer from audio file
let analyzer = try await SpeechAnalyzer(inputAudioFile: avFile, modules: [transcriber], finishAfterFile: true)
// Collect results - must be concurrent
let collector = Task {
do {
for try await r in transcriber.results {
let plain = String(r.text.characters)
if !plain.isEmpty {
allSegments.append(plain)
fputs("[result] \\(plain)\\n", stderr)
}
}
} catch {
fputs("Results error: \\(error)\\n", stderr)
}
}
// analysis was already started by init with finishAfterFile=true, just wait
// Alternatively use analyzeSequence(from:) pattern:
// But since init already starts with file, we just wait for collector
// The analyzer will finish automatically due to finishAfterFile:true
// Wait for collector - it finishes when analyzer finishes file and finalizes
await collector.value
let elapsed = CFAbsoluteTimeGetCurrent() - startTime
let full = allSegments.joined(separator: " ")
let durationSec = avFile.length > 0 ? Double(avFile.length) / avFile.processingFormat.sampleRate : 0
let installed = await SpeechTranscriber.installedLocales.map { $0.identifier }.sorted()
let payload: [String: Any] = [
"ok": true,
"engine": "SpeechAnalyzer+SpeechTranscriber/macOS26.5",
"locale": resolvedLocale.identifier,
"requestedLocale": localeId,
"transcript": full,
"segments": allSegments,
"elapsedSeconds": elapsed,
"audioPath": audioPath,
"durationSeconds": durationSec,
"realtimeFactor": durationSec > 0 ? elapsed / durationSec : 0,
"rtfx": durationSec > 0 ? durationSec / elapsed : 0,
"frames": Int(avFile.length),
"sampleRate": avFile.processingFormat.sampleRate,
"macOS": ProcessInfo.processInfo.operatingSystemVersionString,
"isAvailable": isAvail,
"installedLocales": installed
]
let dataOut = try JSONSerialization.data(withJSONObject: payload, options: [.prettyPrinted, .sortedKeys])
if !jsonOut.isEmpty {
try dataOut.write(to: URL(fileURLWithPath: jsonOut))
}
FileHandle.standardOutput.write(dataOut)
} catch {
fputs("Analysis failed: \\(error)\\n", stderr)
// Dump chain
var cur: Error? = error
while let e = cur {
fputs(" -> \\(e)\\n", stderr)
cur = (e as NSError).userInfo[NSUnderlyingErrorKey] as? Error
}
exit(6)
}
}
}
`;
}
async function ensureOutputDir() {
await mkdir(OUTPUT_BASE, { recursive: true });
}
async function cleanup(dir) {
try { await rm(dir, { recursive: true, force: true }); } catch {}
}
async function buildAndRun({ audioPath, locale = "en-US" }) {
const tmpDir = await (await import("node:fs/promises")).mkdtemp.call(null, path.join(os.tmpdir(), "speech-t-"));
// compatible mkdtemp
const { mkdtemp } = await import("node:fs/promises");
const dir = await mkdtemp(path.join(os.tmpdir(), "speech-t-"));
const swiftFile = path.join(dir, "Main.swift");
const binFile = path.join(dir, "transcriber");
const jsonOut = path.join(dir, "result.json");
await writeFile(swiftFile, swiftSourceFileTranscriber(), "utf8");
try {
await execFileAsync("/usr/bin/swiftc", ["-O", "-parse-as-library", swiftFile, "-o", binFile, "-framework", "AVFoundation", "-framework", "Speech"], { timeout: 60_000, maxBuffer: 20*1024*1024 });
} catch (e) {
await cleanup(dir);
throw new Error(`swiftc compile failed:\n${e.stderr || e.message}\n${e.stdout||""}`);
}
try { await stat(binFile); } catch { await cleanup(dir); throw new Error("Binary not built"); }
try {
const { stdout, stderr } = await execFileAsync(binFile, [audioPath, locale, jsonOut], { timeout: 120_000, maxBuffer: 20*1024*1024 });
if (stderr) { try { process.stderr.write(stderr.slice(0,4000)); } catch {} }
let result;
try { result = JSON.parse(await readFile(jsonOut, "utf8")); } catch { result = JSON.parse(stdout); }
await ensureOutputDir();
const persistPath = path.join(OUTPUT_BASE, `transcription-${Date.now()}.json`);
try { await writeFile(persistPath, JSON.stringify(result, null, 2), "utf8"); result.persistedTo = persistPath; } catch {}
await cleanup(dir);
return result;
} catch (e) {
const out = e.stdout || "";
const er = e.stderr || e.message || "";
try {
const partial = JSON.parse(out);
if (partial && partial.ok) { await cleanup(dir); return partial; }
} catch {}
await cleanup(dir);
throw new Error(`Transcribe failed\nSTDOUT:${out.slice(0,4000)}\nSTDERR:${er.slice(0,6000)}`);
}
}
export async function speechListLocales() {
const { mkdtemp } = await import("node:fs/promises");
const dir = await mkdtemp(path.join(os.tmpdir(), "speech-loc-"));
const swiftFile = path.join(dir, "List.swift");
const binFile = path.join(dir, "list");
const swiftSrc = `import Speech
import Foundation
@main
struct L {
static func main() async {
let isAvail = SpeechTranscriber.isAvailable
let supported = await SpeechTranscriber.supportedLocales.map { $0.identifier }.sorted()
let installed = await SpeechTranscriber.installedLocales.map { $0.identifier }.sorted()
let reserved = await AssetInventory.reservedLocales.map { $0.identifier }
let payload: [String: Any] = [
"isAvailable": isAvail,
"supported": supported,
"installed": installed,
"macOS": ProcessInfo.processInfo.operatingSystemVersionString,
"maxReserved": AssetInventory.maximumReservedLocales,
"reserved": reserved
]
let d = try! JSONSerialization.data(withJSONObject: payload, options: [.prettyPrinted, .sortedKeys])
FileHandle.standardOutput.write(d)
}
}
`;
await writeFile(swiftFile, swiftSrc, "utf8");
try {
await execFileAsync("/usr/bin/swiftc", ["-O", "-parse-as-library", swiftFile, "-o", binFile, "-framework", "Speech"], { timeout: 30_000 });
const { stdout } = await execFileAsync(binFile, [], { timeout: 15_000 });
await cleanup(dir);
return JSON.parse(stdout);
} catch (e) {
await cleanup(dir);
throw new Error(`List locales failed: ${e.stderr||e.message}\n${e.stdout||""}`);
}
}
export async function speechTranscribeFile({ filePath, locale }) {
if (!filePath) throw new Error("filePath required");
const resolved = path.resolve(filePath.replace(/^~(?=$|\/)/, os.homedir()));
try { await stat(resolved); } catch { throw new Error(`File not found: ${resolved}`); }
return await buildAndRun({ audioPath: resolved, locale: locale || "en-US" });
}
export async function speechQuickTest({ text, voice } = {}) {
const testText = text || "Hello world this is a test of Apple SpeechAnalyzer on the Mac mini M four";
const testVoice = voice || "Alex";
const { mkdtemp } = await import("node:fs/promises");
const tmp = await mkdtemp(path.join(os.tmpdir(), "speech-qtest-"));
const aiffPath = path.join(tmp, "test.aiff");
try {
await execFileAsync("/usr/bin/say", ["-v", testVoice, "-o", aiffPath, testText], { timeout: 15_000 });
} catch {
try { await execFileAsync("/usr/bin/say", ["-o", aiffPath, testText], { timeout: 15_000 }); }
catch (e2) { await cleanup(tmp); throw new Error(`say failed: ${e2.stderr||e2.message}`); }
}
try { await stat(aiffPath); } catch { await cleanup(tmp); throw new Error("Generated audio not found"); }
let result;
try { result = await buildAndRun({ audioPath: aiffPath, locale: "en-US" }); }
catch (e) { await cleanup(tmp); throw e; }
result.testInputText = testText;
result.testVoice = testVoice;
try {
await ensureOutputDir();
const dest = path.join(OUTPUT_BASE, `qtest-${Date.now()}.aiff`);
await execFileAsync("/bin/cp", [aiffPath, dest], { timeout: 5_000 });
result.persistedAudio = dest;
} catch {}
await cleanup(tmp);
return result;
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/speech-tts.js
+149
View File
@@ -0,0 +1,149 @@
import { execFile } from "node:child_process";
import { promisify } from "node:util";
import { mkdir, stat, readFile, writeFile } from "node:fs/promises";
import path from "node:path";
import os from "node:os";
const execFileAsync = promisify(execFile);
const OUTPUT_BASE = path.join(os.homedir(), "Projects", "MacMiniMCP", "generated-audio");
async function ensureOutputDir() {
await mkdir(OUTPUT_BASE, { recursive: true });
}
function sanitizeVoice(v) {
if (!v) return null;
return String(v).trim().slice(0, 100) || null;
}
function listVoicesParse(stdout) {
// format from `say -v ?` : "Alex en_US # Most people recognize me by my voice."
const lines = stdout.split("\n").map(l => l.trim()).filter(Boolean);
const voices = [];
for (const line of lines) {
const match = line.match(/^(\S+)\s+([a-z]{2}_[A-Z]{2}(?:_[A-Z]+)?)\s+#?\s*(.*)$/);
if (match) {
voices.push({ name: match[1], locale: match[2], description: match[3] || "" });
} else {
const parts = line.split(/\s+/);
if (parts.length >= 1 && parts[0]) {
voices.push({ name: parts[0], locale: parts[1] || "", description: parts.slice(2).join(" ") });
}
}
}
return voices;
}
export async function speechListVoices() {
try {
const { stdout } = await execFileAsync("/usr/bin/say", ["-v", "?"], { timeout: 10000, maxBuffer: 10 * 1024 * 1024 });
const voices = listVoicesParse(stdout);
return { ok: true, count: voices.length, voices: voices.slice(0, 150) };
} catch (e) {
throw new Error(`Failed to list voices: ${e.stderr || e.message}`);
}
}
export async function speechSynthesize({ text, voice, rate, outputFormat }) {
if (!text || !String(text).trim()) throw new Error("text required");
const cleanText = String(text).slice(0, 5000);
const v = sanitizeVoice(voice);
await ensureOutputDir();
const ts = Date.now();
const rand = Math.random().toString(16).slice(2, 8);
const aiffPath = path.join(OUTPUT_BASE, `tts-${ts}-${rand}.aiff`);
const wavPath = path.join(OUTPUT_BASE, `tts-${ts}-${rand}.wav`);
const finalWav16k = path.join(OUTPUT_BASE, `tts-${ts}-${rand}-16k.wav`);
const sayArgs = [];
if (v) sayArgs.push("-v", v);
if (rate) {
const r = parseInt(String(rate), 10);
if (!isNaN(r) && r >= 80 && r <= 500) {
sayArgs.push("-r", String(r));
}
}
sayArgs.push("-o", aiffPath, cleanText);
try {
await execFileAsync("/usr/bin/say", sayArgs, { timeout: 30000, maxBuffer: 20 * 1024 * 1024 });
} catch (e) {
throw new Error(`say failed: ${e.stderr || e.message}\nOUT:${e.stdout||""}`);
}
try { await stat(aiffPath); } catch { throw new Error("say output not created"); }
// Prefer afconvert to make 16k mono wav compatible with iPhone play_audio_base64 (expects 16k PCM s16le mono)
// afconvert -f WAVE -d LEI16@16000 -c 1 in.aiff out.wav
// Fallback to ffmpeg if afconvert not available is not ideal on Mac, but we try afconvert first.
try {
try {
await execFileAsync("/usr/bin/afconvert", ["-f", "WAVE", "-d", "LEI16@16000", "-c", "1", aiffPath, finalWav16k], { timeout: 15000 });
await stat(finalWav16k);
// Also create regular wav for compatibility
await execFileAsync("/usr/bin/afconvert", ["-f", "WAVE", "-d", "LEI16", aiffPath, wavPath], { timeout: 10000 }).catch(()=>{});
} catch {
// Fallback: try format without @ rate, then use afinfo, or just keep aiff path
await execFileAsync("/usr/bin/afconvert", ["-f", "WAVE", "-d", "LEI16", "-c", "1", aiffPath, finalWav16k], { timeout: 15000 });
}
} catch (e) {
// If afconvert fails, keep aiff and tell caller
// We'll still return aiff path
}
let chosenPath = finalWav16k;
try { await stat(chosenPath); } catch {
try { await stat(wavPath); chosenPath = wavPath; } catch { chosenPath = aiffPath; }
}
let wavBase64 = null;
let base64Len = 0;
// For fastest iPhone playback, provide base64 of 16k wav
try {
// try finalWav16k first
let b64Target = finalWav16k;
try { await stat(b64Target); } catch { b64Target = chosenPath; }
const buf = await readFile(b64Target);
// If file > 2MB, we still encode but warn - iPhone can handle ~500KB typical
if (buf.length < 4 * 1024 * 1024) {
wavBase64 = buf.toString("base64");
base64Len = wavBase64.length;
}
} catch {}
return {
ok: true,
text: cleanText,
voice: v || "default",
rate: rate || null,
aiffPath,
wavPath: finalWav16k,
filePath: chosenPath,
fallbackPath: aiffPath,
wavBase64: wavBase64 ? wavBase64.slice(0, 50) + "...(truncated for display)" : null,
wavBase64Full: wavBase64 ? "available" : null,
base64Length: base64Len,
fileSize: (await stat(chosenPath).then(s=>s.size).catch(()=>0)),
note: "Use filePath on Mac. For iPhone play_audio_base64, use the base64 wav. Call speech_synthesize_file variant or read endpoint needs full base64."
};
}
export async function speechSynthesizeBase64({ text, voice, rate }) {
if (!text) throw new Error("text required");
const res = await speechSynthesize({ text, voice, rate });
// read the 16k wav file full base64
const target = res.wavPath || res.filePath;
const buf = await readFile(target);
const b64 = buf.toString("base64");
return {
ok: true,
text: String(text).slice(0, 5000),
voice: res.voice,
filePath: target,
wavBase64: b64,
size: buf.length,
base64Length: b64.length,
format: "wav 16k mono s16le"
};
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/system.js
+135
View File
@@ -0,0 +1,135 @@
import { execFile, execFile as execFileCb } from "node:child_process";
import { promisify } from "node:util";
const execFileAsync = promisify(execFile);
export async function getSystemInfo() {
const results = {};
// sw_vers for macOS version
try {
const { stdout } = await execFileAsync("/usr/bin/sw_vers", { timeout: 5000 });
const info = {};
for (const line of stdout.split("\n")) {
const [k, ...rest] = line.split(":");
if (!k) continue;
const key = k.trim();
if (!key) continue;
info[key] = rest.join(":").trim();
}
results.sw_vers = info;
results.macos_version = info.ProductVersion || info.productVersion || "";
results.build = info.BuildVersion || info.buildVersion || "";
} catch (e) {
results.sw_vers_error = e.message;
}
// uname -a
try {
const { stdout } = await execFileAsync("/usr/bin/uname", ["-a"], { timeout: 3000 });
results.uname = stdout.trim();
} catch (e) {
results.uname_error = e.message;
}
// Check for SpeechAnalyzer / SpeechTranscriber availability (macOS 26+)
// These frameworks exist only on macOS 26+. We probe via swift/python check.
try {
const { stdout } = await execFileAsync("/usr/bin/python3", ["-c", `
import os, glob, sys
# Check if Speech framework contains new symbols (macOS 26)
frameworks = glob.glob('/System/Library/Frameworks/Speech.framework/*') + glob.glob('/System/Library/PrivateFrameworks/*Speech*')
# Simplest: check macOS version parse
import platform
print(platform.mac_ver()[0])
`], { timeout: 5000 });
results.python_mac_ver = stdout.trim();
} catch (e) {
results.python_mac_ver_error = e.message;
}
// Try to detect SpeechAnalyzer via file existence / Swift availability
try {
// On macOS 26, Speech.framework/Versions should have newer build
const { stdout } = await execFileAsync("/bin/ls", ["-la", "/System/Library/Frameworks/Speech.framework/"], { timeout: 3000 });
results.speech_framework_ls = stdout.trim().slice(0, 2000);
} catch (e) {
results.speech_framework_error = e.message;
}
// Check hardware model
try {
const { stdout } = await execFileAsync("/usr/sbin/sysctl", ["-n", "hw.model"], { timeout: 2000 });
results.hw_model = stdout.trim();
} catch {}
try {
const { stdout } = await execFileAsync("/usr/sbin/sysctl", ["-n", "machdep.cpu.brand_string"], { timeout: 2000 });
results.cpu_brand = stdout.trim();
} catch {}
// Is this macOS 26+ ?
const versionToCheck = results.macos_version || results.python_mac_ver || "";
if (versionToCheck) {
const major = parseInt(versionToCheck.split(".")[0], 10);
results.is_macos_26_plus = major >= 26;
results.speech_analyzer_expected = major >= 26 ? "likely available (macOS 26+)" : "not available - requires macOS 26+";
} else if (results.python_mac_ver) {
const major = parseInt(results.python_mac_ver.split(".")[0], 10);
results.macos_version = results.python_mac_ver;
results.is_macos_26_plus = major >= 26;
results.speech_analyzer_expected = major >= 26 ? "likely available (macOS 26+)" : "not available";
}
return results;
}
export async function getSpeechApiStatus() {
const sysInfo = await getSystemInfo();
// Try to run a tiny Swift snippet that imports Speech and checks for SpeechAnalyzer
// Fallback to reporting version info if swiftc not available
let swiftCheck = null;
try {
// Write temp swift file that checks API availability
const { stdout: swiftPath } = await execFileAsync("/usr/bin/which", ["swift"], { timeout: 2000 });
const swiftBin = swiftPath.trim();
if (swiftBin) {
// Create a small swift program to test SpeechAnalyzer availability
const swiftCode = `
import Speech
import Foundation
#if canImport(Speech)
if #available(macOS 26.0, *) {
print("SpeechAnalyzer: available")
// Try to reference the type
let _ = SpeechTranscriber.self
print("SpeechTranscriber: available")
} else {
print("SpeechAnalyzer: requires macOS 26")
}
#else
print("Speech framework not importable")
#endif
`;
const tmpFile = `/tmp/speech_check_${Date.now()}.swift`;
const { writeFile, unlink } = await import("node:fs/promises");
await writeFile(tmpFile, swiftCode, "utf8");
try {
const { stdout, stderr } = await execFileAsync(swiftBin, [tmpFile], { timeout: 15000, maxBuffer: 2 * 1024 * 1024 });
swiftCheck = { stdout: stdout.trim(), stderr: stderr.trim(), ok: true };
} catch (e) {
swiftCheck = { stdout: e.stdout?.toString().trim() || "", stderr: (e.stderr?.toString() || e.message).trim().slice(0, 2000), ok: false };
} finally {
try { await unlink(tmpFile); } catch {}
}
}
} catch (e) {
swiftCheck = { error: e.message };
}
return {
system: sysInfo,
swift_availability: swiftCheck,
conclusion: sysInfo.is_macos_26_plus
? "macOS 26+ detected — SpeechAnalyzer/SpeechTranscriber should be available per Apple docs."
: `macOS ${sysInfo.macos_version || "unknown"} detected — SpeechAnalyzer requires macOS 26+. ${sysInfo.macos_version ? `You are on ${sysInfo.macos_version}, need to upgrade to 26.` : ""}`,
};
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/integrations/voicebox.js
+168
View File
@@ -0,0 +1,168 @@
import { mkdir, stat, readFile } from "node:fs/promises";
import path from "node:path";
import os from "node:os";
const VOICEBOX_URL = process.env.VOICEBOX_URL || "http://127.0.0.1:17493";
const OUTPUT_BASE = path.join(os.homedir(), "Projects", "MacMiniMCP", "generated-audio");
const KNOWN_PROFILES = {
Aiden: "ff624ec6-5485-4173-a4f0-2ec2196efd39",
Adolfo: "0e042c6b-ae52-4f28-835b-528381ed60b4",
Nicole: "52330098-6fc3-4e9c-a30c-11164869636e",
Jessica: "579c7444-3905-4aab-8067-eb10a0b3e76f",
Dora: "1862f224-fd47-4791-9f37-76f76ca0450c",
Alex: "a0cf179a-c033-47e9-92b5-f61596f68adc",
};
async function fetchJSON(url, opts = {}) {
const res = await fetch(url, opts);
const txt = await res.text();
if (!res.ok) throw new Error(`HTTP ${res.status}: ${txt.slice(0,500)}`);
try { return JSON.parse(txt); } catch { return txt; }
}
export async function voiceboxListProfiles() {
try {
const profiles = await fetchJSON(`${VOICEBOX_URL}/profiles`);
const enriched = profiles.map(p => ({
id: p.id,
name: p.name,
engine: p.default_engine,
voice_type: p.voice_type,
preset_voice_id: p.preset_voice_id,
sample_count: p.sample_count,
generation_count: p.generation_count,
}));
return { ok: true, url: VOICEBOX_URL, count: enriched.length, profiles: enriched, defaultBoyVoice: "Aiden", defaultGirlVoice: "Jessica", mapping: KNOWN_PROFILES };
} catch (e) {
return { ok: false, error: e.message, url: VOICEBOX_URL };
}
}
export async function voiceboxHealth() {
try {
const health = await fetchJSON(`${VOICEBOX_URL}/health`);
return { ok: true, ...health, url: VOICEBOX_URL };
} catch (e) {
return { ok: false, error: e.message, url: VOICEBOX_URL };
}
}
async function pollGeneration(id, timeoutMs = 20000) {
const start = Date.now();
while (Date.now() - start < timeoutMs) {
try {
const gen = await fetchJSON(`${VOICEBOX_URL}/history/${id}`);
if (gen.status === "completed" && gen.audio_path) return gen;
if (gen.status === "failed") throw new Error(gen.error || "generation failed");
} catch (e) {
if (e.message && e.message.toLowerCase().includes("failed")) throw e;
}
await new Promise(r => setTimeout(r, 500));
}
throw new Error("poll timeout");
}
export async function voiceboxGenerate({ text, profile, engine, language, voice }) {
if (!text) throw new Error("text required");
let profileId = profile || voice || "Aiden";
if (KNOWN_PROFILES[profileId]) profileId = KNOWN_PROFILES[profileId];
if (!profileId.includes("-")) {
try {
const profiles = await fetchJSON(`${VOICEBOX_URL}/profiles`);
const match = profiles.find(p => p.name.toLowerCase() === profileId.toLowerCase());
if (match) profileId = match.id;
} catch {}
}
let autoEngine = engine;
if (!autoEngine && ["ff624ec6-5485-4173-a4f0-2ec2196efd39", "4d0ded93-3b12-465f-aeb4-aa4360f3dc5c", "d6c2e90f-ec01-4f5e-8efc-7822bd79ac56"].includes(profileId)) {
autoEngine = "qwen_custom_voice";
}
const body = {
profile_id: profileId,
text: String(text).slice(0, 1000),
language: language || "en",
engine: autoEngine || undefined,
};
Object.keys(body).forEach(k => body[k] === undefined && delete body[k]);
try {
const gen = await fetchJSON(`${VOICEBOX_URL}/generate`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body),
});
let finalGen = gen;
if (gen.status === "generating" || !gen.audio_path) {
try {
finalGen = await pollGeneration(gen.id, 20000);
} catch (pollErr) {
return { ok: false, id: gen.id, status: gen.status, error: pollErr.message, url: VOICEBOX_URL, polling: true, profile_id: profileId, text: body.text };
}
}
return {
ok: true,
id: finalGen.id,
profile_id: finalGen.profile_id,
text: finalGen.text,
audio_path: finalGen.audio_path,
duration: finalGen.duration,
engine: finalGen.engine,
status: finalGen.status,
url: VOICEBOX_URL,
};
} catch (e) {
throw new Error(`voicebox generate failed: ${e.message}`);
}
}
export async function voiceboxGenerateBase64({ text, profile, voice, engine, language }) {
const gen = await voiceboxGenerate({ text, profile, voice, engine, language });
if (!gen.ok || !gen.audio_path) return { ...gen, ok: false, error: gen.error || `no audio_path, status ${gen.status}`, fileExists: false };
// audio_path may be relative "generations/xxx.wav" or absolute
let filePath = gen.audio_path;
let candidates = [filePath];
if (!filePath.startsWith("/") && !filePath.startsWith("~")) {
candidates.push(path.join(os.homedir(), "Library", "Application Support", "sh.voicebox.app", filePath));
candidates.push(path.join(os.homedir(), "Library", "Application Support", "sh.voicebox.app", "generations", path.basename(filePath)));
}
let foundPath = null;
for (const cand of candidates) {
try { await stat(cand); foundPath = cand; break; } catch {}
}
if (!foundPath) {
try { await stat(filePath); foundPath = filePath; } catch {}
}
if (!foundPath) {
// try glob latest file matching id
return { ...gen, ok: false, error: `audio_path not found on disk: ${filePath}, tried ${candidates.join(",")}`, fileExists: false };
}
filePath = foundPath;
try {
const buf = await readFile(filePath);
const b64 = buf.toString("base64");
return {
ok: true,
id: gen.id,
profile_id: gen.profile_id,
text: gen.text,
filePath,
duration: gen.duration,
engine: gen.engine,
wavBase64: b64,
base64Length: b64.length,
size: buf.length,
format: filePath.endsWith(".wav") ? "wav" : "mp3",
url: VOICEBOX_URL,
profile: profile || voice || "Aiden",
};
} catch (e) {
return { ...gen, ok: false, error: `read failed: ${e.message}` };
}
}
export async function voiceboxQuickReply({ text, voice, profile }) {
const chosenProfile = profile || voice || "Aiden";
const result = await voiceboxGenerateBase64({ text, profile: chosenProfile, language: "en", engine: undefined });
return result;
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/server.js
+620
View File
@@ -0,0 +1,620 @@
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";
import {
FOCUS_CALENDAR,
createEvent,
listCalendars,
listEvents,
} from "./integrations/calendar.js";
import {
createContact,
readContact,
searchContacts,
} from "./integrations/contacts.js";
import {
generateCodexImage,
getCodexImageConfigStatus,
} from "./integrations/codex-image.js";
import { getDecoConfigStatus, getDecoStats } from "./integrations/deco.js";
import {
buildGeminiChromePrompt,
getGeminiChromePromptConfigStatus,
} from "./integrations/gemini-chrome-prompt.js";
import {
generateGeminiImage,
getGeminiImageConfigStatus,
} from "./integrations/gemini-image.js";
import { createNote, listNotes, readNote } from "./integrations/notes.js";
import {
listMailAccounts,
listMailboxes,
listMailMessages,
readMailMessage,
} from "./integrations/mail.js";
import {
createReminder,
listReminderLists,
listReminders,
} from "./integrations/reminders.js";
import { getSystemInfo, getSpeechApiStatus } from "./integrations/system.js";
import {
speechListVoices,
speechSynthesize,
speechSynthesizeBase64,
} from "./integrations/speech-tts.js";
import {
speechKokoroStatus,
speechKokoroSynthesize,
speechKokoroSynthesizeBase64,
} from "./integrations/kokoro-tts.js";
import {
voiceboxListProfiles,
voiceboxHealth,
voiceboxGenerate,
voiceboxGenerateBase64,
voiceboxQuickReply,
} from "./integrations/voicebox.js";
import {
speechTranscribeFile,
speechListLocales,
speechQuickTest,
} from "./integrations/speech-transcribe.js";
import {
speechLiveTranscribe,
speechLiveClose,
speechLiveStatus,
} from "./integrations/speech-live.js";
import {
appleLLMCheck,
appleLLMPolish,
appleLLMQuickReply,
appleLLMChat,
appleLLMClose,
appleLLMStatus,
} from "./integrations/apple-llm.js";
const jsonResult = (value) => ({
content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
});
const handled = (operation) => async (input) => {
try {
return jsonResult(await operation(input));
} catch (error) {
return {
isError: true,
content: [{ type: "text", text: error.message }],
};
}
};
function withFocusedCalendar(input) {
if (input.calendarIndex !== undefined) {
return { ...input, calendarIndex: input.calendarIndex };
}
if (input.calendar !== undefined) {
return { ...input, calendarIndex: null };
}
return { ...input, ...FOCUS_CALENDAR };
}
export function createMacMiniMcpServer() {
const server = new McpServer({
name: "macmini-mcp",
version: "0.1.0",
});
server.tool(
"notes_list",
"Find notes by optional text or folder filter. Titles and metadata are returned by default; request previews explicitly.",
{
query: z.string().optional().describe("Text to search in note title and plaintext body."),
folder: z.string().optional().describe("Exact Notes folder name."),
includePreview: z.boolean().default(false).describe("Include plaintext previews only when needed; note content can be sensitive."),
limit: z.number().int().positive().max(100).default(20),
},
handled(listNotes),
);
server.tool(
"notes_read",
"Read one Apple Note after locating its ID with notes_list.",
{ id: z.string().min(1).describe("Notes unique ID.") },
handled(({ id }) => readNote(id)),
);
server.tool(
"notes_create",
"Create a new Apple Note from plaintext content.",
{
title: z.string().min(1).max(300),
body: z.string().default(""),
folder: z.string().optional().describe("Exact destination folder; defaults to the first available folder."),
},
handled(createNote),
);
server.tool(
"mail_accounts",
"List configured Apple Mail accounts and their email addresses. Read-only.",
{},
handled(() => listMailAccounts()),
);
server.tool(
"mail_list_mailboxes",
"List mailboxes for one selected Apple Mail account. Call mail_accounts first. Read-only.",
{
accountId: z.string().min(1).describe("Account ID returned by mail_accounts."),
},
handled(listMailboxes),
);
server.tool(
"mail_list_messages",
"List message metadata in one selected Apple Mail account and mailbox. Read-only; does not fetch message bodies.",
{
accountId: z.string().min(1).describe("Account ID returned by mail_accounts."),
mailbox: z.string().min(1).describe("Exact mailbox name returned by mail_list_mailboxes."),
unreadOnly: z.boolean().default(false).describe("Return only unread messages."),
limit: z.number().int().positive().max(50).default(10),
},
handled(listMailMessages),
);
server.tool(
"mail_read_message",
"Read one Apple Mail message after selecting it with mail_list_messages. Read-only.",
{
accountId: z.string().min(1).describe("Account ID returned by mail_accounts."),
mailbox: z.string().min(1).describe("Exact mailbox name containing the selected message."),
id: z.string().min(1).describe("Message ID returned by mail_list_messages."),
},
handled(readMailMessage),
);
server.tool(
"calendar_list_calendars",
"List macOS Calendar calendars with indexes and indicate which accept new events. The server is focused on the event-rich Home calendar by default.",
{},
handled(listCalendars),
);
server.tool(
"calendar_list_events",
"List events in the focused Home calendar over a required ISO-8601 time range. Optional selectors override the focus calendar.",
{
start: z.string().describe("Range start as an ISO-8601 datetime."),
end: z.string().describe("Range end as an ISO-8601 datetime."),
calendar: z.string().optional().describe("Advanced override: exact calendar name."),
calendarIndex: z.number().int().nonnegative().optional().describe("Advanced override: index returned by calendar_list_calendars."),
limit: z.number().int().positive().max(250).default(50),
},
handled((input) => listEvents(withFocusedCalendar(input))),
);
server.tool(
"calendar_create_event",
"Create an event in the focused Home calendar. Optional selectors override the focus calendar.",
{
calendar: z.string().optional().describe("Advanced override: exact destination calendar name."),
calendarIndex: z.number().int().nonnegative().optional().describe("Advanced override: destination index."),
title: z.string().min(1).max(500),
start: z.string().describe("Event start as an ISO-8601 datetime."),
end: z.string().describe("Event end as an ISO-8601 datetime."),
allDay: z.boolean().default(false),
notes: z.string().optional(),
location: z.string().optional(),
},
handled((input) => createEvent(withFocusedCalendar(input))),
);
server.tool(
"reminders_list_lists",
"List Reminders lists, including account context and assignment metadata availability for shared lists.",
{},
handled(listReminderLists),
);
server.tool(
"reminders_list",
"List reminders with optional list and completion filters. Returns assignment details for shared-list reminders when available, plus title/notes-derived assignment hints.",
{
list: z.string().optional().describe("Exact Reminders list name."),
completed: z.boolean().nullable().default(false).describe("Use null to return both complete and incomplete items."),
limit: z.number().int().positive().max(100).default(25),
},
handled(listReminders),
);
server.tool(
"reminders_create",
"Create a reminder in an optional named Reminders list.",
{
title: z.string().min(1).max(500),
list: z.string().optional().describe("Exact destination list; defaults to the first available list."),
notes: z.string().optional(),
due: z.string().optional().describe("Optional due date as an ISO-8601 datetime."),
},
handled(createReminder),
);
server.tool(
"contacts_search",
"Search Contacts by name or organization. Returns metadata only; use contacts_read for contact methods.",
{
query: z.string().optional().describe("Text to search in display name or organization."),
limit: z.number().int().positive().max(100).default(20),
},
handled(searchContacts),
);
server.tool(
"contacts_read",
"Read contact details, including email addresses and phone numbers, after selecting an ID with contacts_search.",
{
id: z.string().min(1).describe("Persistent Contacts person ID."),
},
handled(({ id }) => readContact(id)),
);
server.tool(
"contacts_create",
"Create a new contact with optional email address and phone number.",
{
firstName: z.string().max(200).optional(),
lastName: z.string().max(200).optional(),
organization: z.string().max(300).optional(),
jobTitle: z.string().max(300).optional(),
note: z.string().max(2000).optional(),
email: z.object({
label: z.string().max(100).default("work"),
value: z.string().email(),
}).optional(),
phone: z.object({
label: z.string().max(100).default("mobile"),
value: z.string().min(1).max(100),
}).optional(),
},
handled((input) => {
if (!input.firstName && !input.lastName && !input.organization) {
throw new Error("firstName, lastName, or organization is required.");
}
return createContact(input);
}),
);
server.tool(
"deco_get_config_status",
"Show TP-Link Deco connection configuration without revealing the password.",
{},
handled(getDecoConfigStatus),
);
server.tool(
"deco_get_overview",
"Read TP-Link Deco overview stats: WAN/LAN addresses, CPU/memory usage, client counts, Wi-Fi enablement, and firmware.",
{},
handled(() => getDecoStats("overview")),
);
server.tool(
"deco_list_clients",
"List online TP-Link Deco clients with hostname, IP, MAC, connection type, current up/down speeds, and linked mesh node when available.",
{},
handled(() => getDecoStats("clients")),
);
server.tool(
"deco_get_ipv4_status",
"Read TP-Link Deco WAN/LAN IPv4 status including gateway, DNS, netmasks, and connection type.",
{},
handled(() => getDecoStats("ipv4")),
);
server.tool(
"deco_get_firmware",
"Read TP-Link Deco model, hardware version, and firmware version.",
{},
handled(() => getDecoStats("firmware")),
);
server.tool(
"system_get_info",
"Get Mac mini system info: macOS version (sw_vers), uname, hardware model, and whether macOS 26+ SpeechAnalyzer is available.",
{},
handled(() => getSystemInfo()),
);
server.tool(
"system_speech_api_status",
"Check if Apple's new SpeechAnalyzer / SpeechTranscriber (macOS 26+) is available — returns macOS version, build, and Swift availability probe.",
{},
handled(() => getSpeechApiStatus()),
);
server.tool(
"speech_list_locales",
"List SpeechTranscriber locales: isAvailable, supported, installed, reserved, maxReserved. Use to check if your language model is ready before transcribing.",
{},
handled(() => speechListLocales()),
);
server.tool(
"speech_transcribe_file",
"Transcribe an audio file using Apple's new SpeechAnalyzer + SpeechTranscriber (macOS 26+). Fastest and most accurate English engine on-device per Inscribe benchmark (2.12% WER). Supports m4a, wav, aiff, mp3, etc via AVFoundation. Returns transcript, segments, timing, realtime factor.",
{
filePath: z.string().min(1).describe("Absolute path to audio file on the Mac. Can be ~/path or /tmp/ etc."),
locale: z.string().optional().describe("Locale like en-US, es-ES, etc. Defaults to en-US. Use speech_list_locales to see options."),
},
handled(({ filePath, locale }) => speechTranscribeFile({ filePath, locale })),
);
server.tool(
"speech_quick_test",
"End-to-end loopback test: generates speech with macOS say command, then transcribes it with SpeechAnalyzer to verify the whole pipeline works. Returns both input text and transcript for comparison.",
{
text: z.string().optional().describe("Text to synthesize and transcribe. Default: hello world test."),
voice: z.string().optional().describe("macOS say voice, e.g. Alex, Samantha. Default: Alex."),
},
handled(({ text, voice }) => speechQuickTest({ text, voice })),
);
server.tool(
"speech_live_transcribe",
"LIVE draft transcription via persistent Apple pipe (ApplePipeTranscriber macOS 26+). Reuses your whisper-translation pipe protocol: 4-byte BE len + WAV payload -> draft/final JSON streaming. Input: base64-encoded 16kHz mono WAV. Output: {text, drafts[], finals[], isFinal}. Keep session alive for <200ms incremental feedback while streaming ESP32 PCM. Auto-closes after 60s idle.",
{
audioBase64: z.string().min(100).describe("Base64-encoded WAV file (16kHz mono s16le). Use 0.5-3s chunks for draft streaming."),
locale: z.string().optional().describe("Locale like en-US. Default en-US."),
},
handled(({ audioBase64, locale }) => speechLiveTranscribe({ audioBase64, locale })),
);
server.tool(
"speech_live_close",
"Close a persistent live transcription pipe session (frees Swift process).",
{
locale: z.string().optional().describe("Locale to close. Default en-US."),
},
handled(({ locale }) => speechLiveClose({ locale })),
);
server.tool(
"speech_live_status",
"Show active live pipe sessions: locale, pid, chunkIdx, lastActivity.",
{},
handled(() => speechLiveStatus()),
);
server.tool(
"codex_image_get_config_status",
"Show local Codex CLI image generation configuration.",
{},
handled(getCodexImageConfigStatus),
);
server.tool(
"codex_image_generate",
"Generate an image using this Mac's Codex CLI image generation and save it to the MacMiniMCP generated-images directory.",
{
prompt: z.string().min(1).max(8000).describe("Text prompt describing the image to generate."),
filename: z.string().min(1).max(200).optional().describe("Optional local filename. Directory components are ignored."),
size: z.string().max(100).optional().describe("Optional size or aspect request, such as 1024x1024, 16:9, or square."),
quality: z.string().max(100).optional().describe("Optional quality request, such as draft, standard, or high."),
style: z.string().max(500).optional().describe("Optional visual style guidance."),
referenceImage: z.string().optional().describe("Optional absolute path to a local reference image for Codex CLI --image."),
},
handled(generateCodexImage),
);
server.tool(
"gemini_image_get_config_status",
"Show Gemini image generation configuration without revealing the API key.",
{},
handled(getGeminiImageConfigStatus),
);
server.tool(
"gemini_image_generate",
"Generate one image with the Gemini API and save it to the local generated-images directory. This tool does not expose browser control.",
{
prompt: z.string().min(1).max(8000).describe("Text prompt describing the image to generate."),
filename: z.string().min(1).max(200).optional().describe("Optional local PNG filename. Directory components are ignored."),
model: z.string().min(1).max(100).default("gemini-3.1-flash-image"),
aspectRatio: z.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).optional(),
imageSize: z.enum(["1K", "2K", "4K"]).optional(),
useGoogleSearch: z.boolean().default(false).describe("Allow Gemini to use Google Search for prompts that need current real-world context."),
},
handled(generateGeminiImage),
);
server.tool(
"gemini_chrome_prompt_get_config_status",
"Show configuration for the Codex Chrome-skill Gemini image prompt builder.",
{},
handled(getGeminiChromePromptConfigStatus),
);
server.tool(
"gemini_chrome_prompt_build",
"Build a ready-to-run Codex prompt for generating one Gemini web-app image through the verified ReynaFamilyBot Chrome profile. This MCP tool does not control Chrome.",
{
prompt: z.string().min(1).max(8000).describe("Text prompt describing the image to generate in Gemini."),
filename: z.string().min(1).max(200).optional().describe("Optional local PNG filename. Directory components are ignored."),
},
handled(buildGeminiChromePrompt),
);
server.tool(
"apple_llm_check",
"Check if Apple on-device 3B LLM (FoundationModels SystemLanguageModel) is available. ANE-accelerated, offline, ~0.6s vs Ollama 2-3s. Required for polish/quick_reply/chat.",
{},
handled(() => appleLLMCheck()),
);
server.tool(
"apple_llm_polish",
"Polish a caption line/paragraph using Apple on-device 3B LLM ANE. From whisper-translation engine_apple_llm.py: same as AppleLLMPolish binary pipe. Fixes punctuation, casing, typos from live transcript. Mode: line (default) or paragraph. Reuses single warm session.",
{
text: z.string().min(1).describe("Text to polish (STT draft or final)."),
prev1: z.string().optional().describe("Previous line for context (line mode)."),
prev2: z.string().optional().describe("Second previous line."),
mode: z.enum(["line", "paragraph"]).optional().describe("line (default) or paragraph."),
},
handled(({ text, prev1, prev2, mode }) => appleLLMPolish({ text, prev1, prev2, mode })),
);
server.tool(
"apple_llm_quick_reply",
"INSTANT smart reply from live draft — for voice gateway. Feed the volatile draft transcript from speech_live_transcribe while user is speaking. Apple 3B ANE returns <20-word ACK preview in ~0.6s, before final transcription. Use this to provide almost immediate response when voice stops: send draft to quick_reply, get instant text to speak/display, then full Hermes turn in background. Reuses same ANE session as polish.",
{
draft: z.string().min(1).describe("Live draft transcript (partial, may have typos) from speech_live_transcribe. Used to infer intent for instant preview reply."),
context: z.string().optional().describe("Optional previous conversation context or last assistant reply."),
instructions: z.string().optional().describe("Optional system instructions for quick reply persona."),
},
handled(({ draft, context, instructions }) => appleLLMQuickReply({ draft, context, instructions })),
);
server.tool(
"apple_llm_chat",
"Fast voice-assistant chat via Apple 3B ANE (FoundationModels). Under 40 words, warm, kid-safe, for ESP32. Use when you want Mac mini to directly answer draft/final without calling Hermes gateway. Accepts history array and current text. ~0.6-1.2s.",
{
text: z.string().min(1).describe("User message (draft or final transcript)."),
history: z.array(z.object({ role: z.string(), text: z.string() })).optional().describe("Optional conversation history [{role, text}]."),
instructions: z.string().optional().describe("Optional custom instructions."),
},
handled(({ text, history, instructions }) => appleLLMChat({ text, history, instructions })),
);
server.tool(
"apple_llm_status",
"Show Apple LLM session status: active, ready, pid, lastActivity.",
{},
handled(() => appleLLMStatus()),
);
server.tool(
"apple_llm_close",
"Close Apple LLM ANE session (frees Swift process + KV cache). Auto-closes after 2min idle anyway.",
{},
handled(() => appleLLMClose()),
);
server.tool(
"speech_list_voices",
"List available macOS say voices with locale tags. Use for TTS voice selection.",
{},
handled(() => speechListVoices()),
);
server.tool(
"speech_synthesize",
"Synthesize text to speech using macOS say command (native Apple Neural voices). Generates AIFF and 16k wav for iPhone playback. Returns file paths.",
{
text: z.string().min(1).max(5000).describe("Text to speak (max 5000 chars)"),
voice: z.string().optional().describe("Voice name like Alex, Samantha, Ava, etc. Use speech_list_voices to see options"),
rate: z.number().int().min(80).max(500).optional().describe("Speech rate in wpm, 80-500, default system"),
},
handled(({ text, voice, rate }) => speechSynthesize({ text, voice, rate })),
);
server.tool(
"speech_synthesize_base64",
"Synthesize text to 16k mono WAV base64 using macOS say + afconvert. Ideal for sending to iPhone play_audio_base64. Returns full base64 payload.",
{
text: z.string().min(1).max(5000).describe("Text to speak"),
voice: z.string().optional().describe("Voice name"),
rate: z.number().int().min(80).max(500).optional(),
},
handled(({ text, voice, rate }) => speechSynthesizeBase64({ text, voice, rate })),
);
server.tool(
"speech_kokoro_status",
"Check the warm Kokoro ksay TTS daemon status: loaded model, default voice, default language, and load timing.",
{},
handled(() => speechKokoroStatus()),
);
server.tool(
"speech_kokoro_synthesize",
"Fast neural TTS using the warm mlx-audio Kokoro ksay daemon. Generates a 24kHz WAV and returns the local file path. Use this for low-latency local speech instead of macOS say.",
{
text: z.string().min(1).max(8000).describe("Text to speak."),
voice: z.string().optional().describe("Kokoro voice preset, e.g. af_heart, af_bella, af_nova, am_adam, bf_alice. Default af_heart."),
speed: z.number().min(0.5).max(2.0).optional().describe("Kokoro speed multiplier. Default 1.0."),
langCode: z.string().max(8).optional().describe("Kokoro language code: a American English, b British English, j Japanese, z Mandarin, etc. Default a."),
outputPath: z.string().optional().describe("Optional absolute output WAV path. Defaults to generated-audio/ksay-*.wav."),
},
handled(({ text, voice, speed, langCode, outputPath }) => speechKokoroSynthesize({ text, voice, speed, langCode, outputPath })),
);
server.tool(
"speech_kokoro_synthesize_base64",
"Fast neural TTS using the warm mlx-audio Kokoro ksay daemon. Returns full 24kHz WAV base64 for clients that need immediate audio bytes.",
{
text: z.string().min(1).max(3000).describe("Text to speak. Keep short for fast playback and smaller MCP payloads."),
voice: z.string().optional().describe("Kokoro voice preset. Default af_heart."),
speed: z.number().min(0.5).max(2.0).optional().describe("Kokoro speed multiplier. Default 1.0."),
langCode: z.string().max(8).optional().describe("Kokoro language code. Default a."),
},
handled(({ text, voice, speed, langCode }) => speechKokoroSynthesizeBase64({ text, voice, speed, langCode })),
);
server.tool(
"voicebox_list_profiles",
"List Voicebox voice profiles on Mac mini (Qwen3-TTS 1.7B MPS). Includes Aiden boy voice, Jessica/Nicole girl, Adolfo cloned. Use for TTS.",
{},
handled(() => voiceboxListProfiles()),
);
server.tool(
"voicebox_health",
"Check Voicebox TTS health: model_loaded, gpu_available (MPS), backend mlx, version. Port 17493 Qwen3 1.7B.",
{},
handled(() => voiceboxHealth()),
);
server.tool(
"voicebox_generate",
"Generate speech via Voicebox on Mac mini: text + profile (Aiden boy voice default, Jessica/Nicole girl, Adolfo cloned). Qwen3-TTS 1.7B MPS GPU. Returns audio_path, duration, engine. Use voicebox_generate_base64 for base64 audio to stream to iPhone/WiFi.",
{
text: z.string().min(1).max(1000).describe("Text to synthesize (max 1000 chars)."),
profile: z.string().optional().describe("Profile name or id: Aiden (boy voice default), Adolfo (cloned), Jessica/Nicole girl, Dora, Alex. Default Aiden."),
voice: z.string().optional().describe("Alias for profile — same as profile."),
engine: z.string().optional().describe("Optional engine override: qwen, qwen_custom_voice, kokoro, etc."),
language: z.string().optional().describe("Language code: en (default), es, ko, zh, etc."),
},
handled(({ text, profile, voice, engine, language }) => voiceboxGenerate({ text, profile, voice, engine, language })),
);
server.tool(
"voicebox_generate_base64",
"Generate speech via Voicebox and return base64 WAV audio for immediate playback on iPhone ESP32. Uses Mac mini Qwen3-TTS 1.7B boy voice Aiden by default. Ideal for instant fast reply audio: generate contextual reply with apple_llm_quick_reply, then speak it with this tool, then play_audio_base64 on ESP32 screen. Returns wavBase64 ready for play_audio_base64 MCP.",
{
text: z.string().min(1).max(500).describe("Text to speak (max 500 chars for fast instant reply, keep short)."),
profile: z.string().optional().describe("Profile: Aiden (boy default for instant), Jessica/Nicole girl, Adolfo cloned. Default Aiden."),
voice: z.string().optional().describe("Alias for profile"),
engine: z.string().optional().describe("Engine override"),
language: z.string().optional().describe("Language, default en"),
},
handled(({ text, profile, voice, engine, language }) => voiceboxGenerateBase64({ text, profile, voice, engine, language })),
);
server.tool(
"voicebox_quick_reply",
"ONE-CALL fast instant reply audio: text -> Voicebox boy voice Aiden base64 wav. Combines quick text already generated. For voice gateway: after apple_llm_quick_reply gives text like Got it! Switching to boy voice, immediately call this with that text to get audio base64 to play on iPhone while full Hermes answer generates. Boy voice Aiden default as requested.",
{
text: z.string().min(1).max(300).describe("Instant reply text from apple_llm_quick_reply (max 300 chars)."),
profile: z.string().optional().describe("Profile, default Aiden boy voice as requested for boys voice."),
voice: z.string().optional().describe("Alias for profile"),
},
handled(({ text, profile, voice }) => voiceboxQuickReply({ text, voice, profile })),
);
return server;
}
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/src/stdio.js
+7
View File
@@ -0,0 +1,7 @@
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { createMacMiniMcpServer } from "./server.js";
const server = createMacMiniMcpServer();
const transport = new StdioServerTransport();
await server.connect(transport);
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/test/apple-events.test.js
+15
View File
@@ -0,0 +1,15 @@
import assert from "node:assert/strict";
import test from "node:test";
import { dateFromInput, plainTextToNoteHtml } from "../src/apple-events.js";
test("plainTextToNoteHtml escapes input and preserves line breaks", () => {
assert.equal(
plainTextToNoteHtml("R&D <today>", 'First\n"second"'),
"<h1>R&amp;D &lt;today&gt;</h1><div>First<br>&quot;second&quot;</div>",
);
});
test("dateFromInput accepts valid datetimes and rejects invalid input", () => {
assert.equal(dateFromInput("2026-05-26T10:00:00-04:00", "start").toISOString(), "2026-05-26T14:00:00.000Z");
assert.throws(() => dateFromInput("not-a-date", "start"), /valid ISO-8601/);
});
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/test/mail.integration.test.js
+36
View File
@@ -0,0 +1,36 @@
import assert from "node:assert/strict";
import test from "node:test";
import {
listMailAccounts,
listMailboxes,
listMailMessages,
readMailMessage,
} from "../src/integrations/mail.js";
const enabled = process.env.RUN_APPLE_INTEGRATION_TESTS === "1";
test("Apple Mail read-only integration: enumerate accounts and read a selected inbox message", { skip: !enabled }, async () => {
const accounts = await listMailAccounts();
assert.ok(accounts.length > 0, "Apple Mail must have at least one configured account");
const mailboxes = await listMailboxes({ accountId: accounts[0].id });
const inbox = mailboxes.find((mailbox) => mailbox.role === "inbox");
assert.ok(inbox, "Apple Mail must expose a global inbox");
let accountWithMessage = null;
for (const account of accounts) {
const messages = await listMailMessages({ accountId: account.id, mailbox: inbox.name, limit: 1 });
if (messages.length) {
accountWithMessage = account;
break;
}
}
assert.ok(accountWithMessage, "At least one configured account must contain an inbox message");
const messages = await listMailMessages({ accountId: accountWithMessage.id, mailbox: inbox.name, limit: 1 });
assert.equal(messages.length, 1);
const message = await readMailMessage({ accountId: accountWithMessage.id, mailbox: inbox.name, id: messages[0].id });
assert.equal(message.id, messages[0].id);
assert.equal(message.accountId, accountWithMessage.id);
assert.equal(typeof message.body, "string");
});
backup/macmini-automation-baseline-2026-08-03/macmini-mcp/test/mail.test.js
+81
View File
@@ -0,0 +1,81 @@
import assert from "node:assert/strict";
import test from "node:test";
import { createMailClient } from "../src/integrations/mail.js";
function fakeRunJxa(result) {
const calls = [];
return {
calls,
client: createMailClient(async (script, input) => {
calls.push({ script, input });
return result;
}),
};
}
test("mail_accounts returns normalized account identities without message data", async () => {
const { client, calls } = fakeRunJxa([
{ id: "acct-personal", name: "Personal", emailAddresses: ["me@example.com"] },
{ id: "acct-emi", name: "EMI", emailAddresses: ["info@emmint.com"] },
]);
const result = await client.accounts();
assert.deepEqual(result, [
{ id: "acct-personal", name: "Personal", emailAddresses: ["me@example.com"] },
{ id: "acct-emi", name: "EMI", emailAddresses: ["info@emmint.com"] },
]);
assert.equal(calls.length, 1);
assert.deepEqual(calls[0].input, {});
});
test("mail_list_messages scopes the request to an account mailbox and bounded limit", async () => {
const { client, calls } = fakeRunJxa([
{
id: "message-1",
accountId: "acct-emi",
account: "EMI",
mailbox: "INBOX",
subject: "Board update",
sender: "Board <board@example.org>",
dateSent: "2026-08-03T12:00:00.000Z",
read: false,
},
]);
const result = await client.listMessages({ accountId: "acct-emi", mailbox: "INBOX", limit: 5, unreadOnly: true });
assert.equal(result.length, 1);
assert.equal(result[0].subject, "Board update");
assert.deepEqual(calls[0].input, { accountId: "acct-emi", mailbox: "INBOX", limit: 5, unreadOnly: true });
assert.match(calls[0].script, /input\.limit/);
});
test("mail_read_message requires the selected message ID and never returns data from another message", async () => {
const { client, calls } = fakeRunJxa({
id: "message-1",
accountId: "acct-personal",
mailbox: "INBOX",
subject: "Receipt",
sender: "Store <sales@example.org>",
dateSent: "2026-08-03T12:00:00.000Z",
read: true,
body: "Thanks for your order.",
});
const result = await client.readMessage({ accountId: "acct-personal", mailbox: "INBOX", id: "message-1" });
assert.equal(result.id, "message-1");
assert.equal(result.body, "Thanks for your order.");
assert.deepEqual(calls[0].input, { accountId: "acct-personal", mailbox: "INBOX", id: "message-1" });
});
test("mail_list_messages rejects out-of-range limits before asking Mail", async () => {
const { client, calls } = fakeRunJxa([]);
assert.throws(
() => client.listMessages({ accountId: "acct-emi", mailbox: "INBOX", limit: 51, unreadOnly: false }),
/limit must be between 1 and 50/,
);
assert.equal(calls.length, 0);
});
pyproject.toml
+2
View File
@@ -19,6 +19,8 @@ dependencies = [
"itsdangerous>=2.2.0",
"jinja2>=3.1.6",
"python-multipart>=0.0.32",
"pillow>=12.3.0",
"rmscene>=0.8.0",
]
readme = "README.md"
requires-python = ">=3.10"
src/reyna_cli/cli.py
+46
View File
@@ -19,6 +19,7 @@ from reyna_cli.email_local import ThunderbirdEmailClient, email_tool_specs
from reyna_cli.immich import ImmichClient
from reyna_cli.mcp import MCPClient
from reyna_cli.mongo_direct import MongoDirectClient
from reyna_cli.remarkable import LISTENER_LABEL, listen_forever, listener_service_action, listener_service_status, sync_once
from reyna_cli.tts import TTSError, synthesize_wav
from reyna_cli.utils import infer_capabilities, resolve_tool_name
from reyna_cli.zoom_direct import ZoomClient
@@ -39,6 +40,7 @@ zoom_app = typer.Typer(help="Zoom direct REST API commands.")
email_app = typer.Typer(help="Read-only local Thunderbird email commands.")
deco_app = typer.Typer(help="TP-Link Deco direct router commands.")
macmini_app = typer.Typer(help="Mac mini MCP tools (Calendar, Contacts, Notes, Reminders, Deco).")
remarkable_app = typer.Typer(help="Paper Pro discovery, local cache, and macOS listener service.")
macmini_calendar_app = typer.Typer(help="Mac mini Calendar tools.")
macmini_contacts_app = typer.Typer(help="Mac mini Contacts tools.")
macmini_notes_app = typer.Typer(help="Mac mini Notes tools.")
@@ -69,6 +71,7 @@ macmini_app.add_typer(macmini_notes_app, name="notes")
macmini_app.add_typer(macmini_reminders_app, name="reminders")
macmini_app.add_typer(macmini_deco_app, name="deco")
app.add_typer(macmini_app, name="macmini")
app.add_typer(remarkable_app, name="remarkable")
def scrub_sensitive(value: Any) -> Any:
@@ -692,6 +695,49 @@ def computer_service_logs(lines: int = typer.Option(80, "--lines")):
subprocess.run(["journalctl", "--user", "-u", SERVICE_NAME, "-n", str(lines), "--no-pager"], check=False)
@remarkable_app.command("listen")
def remarkable_listen():
"""Run the UDP receiver in the foreground (used by the LaunchAgent)."""
listen_forever()
@remarkable_app.command("sync")
def remarkable_sync(json_output: bool = typer.Option(False, "--json")):
"""Snapshot tracked notes and cache only fresh Paper Pro page versions."""
result = sync_once()
emit({"ok": bool(result.get("online")), "result": result}, json_output)
@remarkable_app.command("service-install")
def remarkable_service_install(json_output: bool = typer.Option(False, "--json")):
"""Install and start the macOS UDP-listener LaunchAgent."""
result = listener_service_action("install")
emit(result, json_output)
if not result.get("ok"):
raise typer.Exit(1)
@remarkable_app.command("service-status")
def remarkable_service_status(json_output: bool = typer.Option(False, "--json")):
emit({"ok": True, "service": LISTENER_LABEL, "status": listener_service_status()}, json_output)
@remarkable_app.command("service-start")
def remarkable_service_start(json_output: bool = typer.Option(False, "--json")):
result = listener_service_action("start")
emit(result, json_output)
if not result.get("ok"):
raise typer.Exit(1)
@remarkable_app.command("service-stop")
def remarkable_service_stop(json_output: bool = typer.Option(False, "--json")):
result = listener_service_action("stop")
emit(result, json_output)
if not result.get("ok"):
raise typer.Exit(1)
@iphone_app.command("tools")
def iphone_tools(json_output: bool = typer.Option(False, "--json"), live_only: bool = False, cache_only: bool = False, refresh: bool = False):
wrapper_tools("iphone_mcp", json_output, live_only, cache_only, refresh)
src/reyna_cli/remarkable.py
Executable
+515
View File
@@ -0,0 +1,515 @@
#!/usr/bin/env python3
import datetime as dt
import io
import json
import os
import plistlib
import shlex
import socket
import subprocess
import sys
import tarfile
import time
import uuid as uuidlib
from pathlib import Path
DEFAULT_TABLET = os.environ.get("REMARKABLE_HOST", "root@192.168.68.128")
BASE = "/home/root/.local/share/remarkable/xochitl"
LISTENER_LABEL = "com.reynafamily.reyna-cli.remarkable-listener"
SYNC_LABEL = "com.reynafamily.reyna-cli.remarkable-sync"
LISTENER_PORT = 49321
def data_root() -> Path:
"""Return the Mac-local Paper Pro cache, with a testable override."""
return Path(os.environ.get("REYNA_REMARKABLE_ROOT", Path.home() / "Library" / "Application Support" / "reyna-cli" / "remarkable"))
def parse_udp_message(message: str) -> dict[str, str]:
"""Parse the sidecar's key=value prefix while preserving its freeform details."""
fields: dict[str, str] = {}
prefix, marker, details = message.partition(" details=")
for part in prefix.split():
if "=" in part:
key, value = part.split("=", 1)
fields[key] = value
if marker:
fields["details"] = details
return fields
LOGDIR = data_root()
LOGDIR.mkdir(parents=True, exist_ok=True)
KNOWN_HOSTS = LOGDIR / "known_hosts"
STATE_PATH = LOGDIR / "state.json"
EVENTS_PATH = LOGDIR / "events.jsonl"
LATEST_PATH = LOGDIR / "latest.json"
CACHE_DIR = LOGDIR / "cache"
CACHE_DIR.mkdir(parents=True, exist_ok=True)
LATEST_CHANGED_PAGES = LOGDIR / "latest_changed_pages.json"
CACHE_STATE_PATH = LOGDIR / "cache_state.json"
TRACKED_CONFIG_PATH = LOGDIR / "tracked_documents.json"
RENDERER = LOGDIR / "tools" / "render_rm_fast.py"
RENDER_PYTHON = Path(sys.executable)
WATCH_TERMS = [t.strip().lower() for t in os.environ.get("REMARKABLE_WATCH_TERMS", "diary,dairy,journal").split(",") if t.strip()]
def resolve_tablet():
# If REMARKABLE_HOST is explicitly set, honor it. Otherwise use latest UDP discovery.
if os.environ.get("REMARKABLE_HOST"):
return DEFAULT_TABLET
latest = LOGDIR / "latest_device.json"
try:
data = json.loads(latest.read_text())
ip = (data.get("fields") or {}).get("ip") or data.get("source_ip")
if ip:
return f"root@{ip}"
except Exception:
pass
return DEFAULT_TABLET
def ssh_args():
return [
"ssh",
"-o", "BatchMode=yes",
"-o", "ConnectTimeout=8",
"-o", "StrictHostKeyChecking=no",
"-o", f"UserKnownHostsFile={KNOWN_HOSTS}",
resolve_tablet(),
]
def now_iso():
return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
def run_ssh(remote, timeout=20):
return subprocess.run(ssh_args() + [remote], text=True, capture_output=True, timeout=timeout)
def load_state():
try:
return json.loads(STATE_PATH.read_text())
except Exception:
return {}
def load_cache_state():
try:
data = json.loads(CACHE_STATE_PATH.read_text())
if isinstance(data, dict):
return data
except Exception:
pass
return {"seen_page_versions": []}
def save_cache_state(state):
# Keep the state small; it only prevents stale page batches from being
# re-announced after the tablet sleeps or reconnects.
seen = list(dict.fromkeys(state.get("seen_page_versions", [])))[-1000:]
tmp = CACHE_STATE_PATH.with_name(f"{CACHE_STATE_PATH.name}.{os.getpid()}.{uuidlib.uuid4().hex}.tmp")
tmp.write_text(json.dumps({"seen_page_versions": seen}, indent=2, sort_keys=True) + "\n")
tmp.replace(CACHE_STATE_PATH)
def save_state(state):
tmp = STATE_PATH.with_name(f"{STATE_PATH.name}.{os.getpid()}.{uuidlib.uuid4().hex}.tmp")
tmp.write_text(json.dumps(state, indent=2, sort_keys=True) + "\n")
tmp.replace(STATE_PATH)
def append_event(event):
with EVENTS_PATH.open("a") as f:
f.write(json.dumps(event, sort_keys=True, ensure_ascii=False) + "\n")
LATEST_PATH.write_text(json.dumps(event, indent=2, sort_keys=True, ensure_ascii=False) + "\n")
def load_tracked_uuids():
try:
data = json.loads(TRACKED_CONFIG_PATH.read_text())
except Exception:
return set()
return {d.get("uuid") for d in data.get("tracked_documents", []) if d.get("uuid")}
def is_watched_doc(doc, tracked_uuids=None):
tracked_uuids = tracked_uuids or set()
name = (doc.get("visibleName") or "").lower()
return doc.get("uuid") in tracked_uuids or any(term in name for term in WATCH_TERMS)
def ssh_read_file(remote_relpath, timeout=20):
remote_path = f"{BASE}/{remote_relpath.lstrip('/')}"
proc = subprocess.run(
ssh_args() + ["cat " + shlex.quote(remote_path)],
capture_output=True,
timeout=timeout,
)
if proc.returncode != 0:
return None
return proc.stdout
def cache_remote_file(remote_relpath, local_relpath=None, timeout=25):
data = ssh_read_file(remote_relpath, timeout=timeout)
if data is None:
return None
local = CACHE_DIR / (local_relpath or remote_relpath)
local.parent.mkdir(parents=True, exist_ok=True)
tmp = local.with_name(f"{local.name}.{os.getpid()}.{uuidlib.uuid4().hex}.tmp")
tmp.write_bytes(data)
tmp.replace(local)
return local
def recent_udp_document_changes(limit=500):
changes = []
udp_dir = LOGDIR / "udp"
files = sorted(udp_dir.glob("*.jsonl"), reverse=True)[:3]
for path in files:
try:
lines = path.read_text(errors="replace").splitlines()[-limit:]
except Exception:
continue
for line in reversed(lines):
try:
ev = json.loads(line)
except Exception:
continue
fields = ev.get("fields") or {}
if fields.get("event") == "document_change" and fields.get("file"):
changes.append(ev)
return changes
def render_cached_rm(rm_path):
if not rm_path or rm_path.suffix != ".rm" or not rm_path.exists():
return None
if not RENDERER.exists():
return None
py = RENDER_PYTHON if RENDER_PYTHON.exists() else Path("python3")
out = rm_path.with_suffix(".png")
try:
proc = subprocess.run([str(py), str(RENDERER), str(rm_path), str(out)], text=True, capture_output=True, timeout=45)
except Exception:
return None
return out if proc.returncode == 0 and out.exists() else None
def extract_page_ids(content):
"""Return only likely-current page IDs, not every page in the document.
Reprocessing every page whenever a document-level mtime changes caused the
reviewer to loop over old handwriting. Exact changed pages come from the UDP
sidecar below; this fallback should be narrow.
"""
ids = []
current = (
content.get("lastOpenedPage")
or content.get("currentPage")
or (content.get("cPages") or {}).get("lastOpened")
)
if isinstance(current, dict):
current = current.get("value")
if isinstance(current, str) and current:
ids.append(current)
seen = set()
return [p for p in ids if not (p in seen or seen.add(p))]
def cache_changed_pages(snapshot, prev):
"""Cache local copies of changed tracked pages so Hermes can read them later.
This intentionally limits itself to tracked/watched documents and recently
changed/current pages. It does not mirror the whole tablet.
"""
if not snapshot.get("online"):
return []
tracked_uuids = load_tracked_uuids()
prev_by_uuid = {d.get("uuid"): d for d in prev.get("watched", [])}
watched = [d for d in snapshot.get("watched", []) if is_watched_doc(d, tracked_uuids)]
changed_docs = []
for doc in watched:
old = prev_by_uuid.get(doc.get("uuid"))
if not old or old.get("lastModified") != doc.get("lastModified"):
changed_docs.append(doc)
if not changed_docs:
return []
udp_changes = recent_udp_document_changes()
cache_state = load_cache_state()
seen_versions = set(cache_state.get("seen_page_versions", []))
cached = []
for doc in changed_docs:
uuid = doc.get("uuid")
if not uuid:
continue
# Cache document metadata needed to map page IDs later.
for ext in ("metadata", "content", "pagedata"):
cache_remote_file(f"{uuid}.{ext}", f"{uuid}/{uuid}.{ext}", timeout=20)
content = {}
content_path = CACHE_DIR / uuid / f"{uuid}.content"
try:
content = json.loads(content_path.read_text())
except Exception:
content = {}
page_ids = set(extract_page_ids(content))
# UDP sidecar reports exact changed files; prefer those for changed pages.
for ev in udp_changes:
fields = ev.get("fields") or {}
rel = fields.get("file") or ""
if not rel.startswith(uuid + "/") and rel not in {f"{uuid}.content", f"{uuid}.metadata", f"{uuid}.pagedata"}:
continue
local = cache_remote_file(rel, rel, timeout=30)
if local and local.suffix == ".rm":
page_ids.add(local.stem)
# Also cache the last/current page from content because it is what the user most often just wrote on.
for page_id in sorted(page_ids):
version_key = f"{uuid}:{page_id}:{doc.get('lastModified') or 0}"
if version_key in seen_versions:
continue
rel = f"{uuid}/{page_id}.rm"
local = cache_remote_file(rel, rel, timeout=30)
if not local:
continue
png = render_cached_rm(local)
seen_versions.add(version_key)
cached.append({
"cached_at": now_iso(),
"document_uuid": uuid,
"document_name": doc.get("visibleName"),
"page_uuid": page_id,
"rm_path": str(local),
"png_path": str(png) if png else None,
"lastModified": doc.get("lastModified"),
"lastModifiedIso": doc.get("lastModifiedIso"),
"version_key": version_key,
})
if seen_versions != set(cache_state.get("seen_page_versions", [])):
save_cache_state({"seen_page_versions": sorted(seen_versions)})
if cached:
tmp = LATEST_CHANGED_PAGES.with_name(f"{LATEST_CHANGED_PAGES.name}.{os.getpid()}.{uuidlib.uuid4().hex}.tmp")
tmp.write_text(json.dumps({"ts": now_iso(), "pages": cached}, indent=2, sort_keys=True, ensure_ascii=False) + "\n")
tmp.replace(LATEST_CHANGED_PAGES)
else:
# No fresh page versions. Remove the manifest so the cron reviewer does
# not keep reprocessing an old batch.
try:
LATEST_CHANGED_PAGES.unlink()
except FileNotFoundError:
pass
return cached
def parse_json_member(tf, name):
try:
m = tf.extractfile(name)
if not m:
return None
return json.loads(m.read().decode("utf-8", "replace"))
except Exception:
return None
def collect_snapshot():
ping = run_ssh("echo online; date -u +%Y-%m-%dT%H:%M:%SZ; systemctl is-active xochitl 2>/dev/null || true", timeout=12)
if ping.returncode != 0:
return {
"ts": now_iso(),
"event": "tablet_unreachable",
"online": False,
"error": (ping.stderr or ping.stdout).strip()[-500:],
}
lines = [l.strip() for l in ping.stdout.splitlines() if l.strip()]
tablet_time = lines[1] if len(lines) > 1 else None
xochitl = lines[2] if len(lines) > 2 else "unknown"
tar_cmd = f"cd {BASE} && tar -cf - -- *.metadata *.content *.pagedata 2>/dev/null"
tar_proc = subprocess.run(ssh_args() + [tar_cmd], capture_output=True, timeout=45)
docs = []
if tar_proc.returncode == 0 and tar_proc.stdout:
tf = tarfile.open(fileobj=io.BytesIO(tar_proc.stdout), mode="r:")
infos = {i.name: i for i in tf.getmembers() if i.isfile()}
uuids = sorted({n[:-9] for n in infos if n.endswith(".metadata")})
for uuid in uuids:
meta_name = uuid + ".metadata"
content_name = uuid + ".content"
page_name = uuid + ".pagedata"
meta = parse_json_member(tf, meta_name) or {}
content = parse_json_member(tf, content_name) or {}
mt = max(
infos.get(meta_name).mtime if infos.get(meta_name) else 0,
infos.get(content_name).mtime if infos.get(content_name) else 0,
infos.get(page_name).mtime if infos.get(page_name) else 0,
)
visible = meta.get("visibleName") or meta.get("name") or ""
docs.append({
"uuid": uuid,
"visibleName": visible,
"type": meta.get("type"),
"parent": meta.get("parent"),
"lastModified": mt,
"lastModifiedIso": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(mt)) if mt else None,
"currentPage": content.get("lastOpenedPage") or content.get("cPages", {}).get("lastOpened") if isinstance(content.get("cPages"), dict) else content.get("lastOpenedPage"),
"pageCount": content.get("pageCount") or len(content.get("pages", [])) if isinstance(content.get("pages"), list) else content.get("pageCount"),
})
docs.sort(key=lambda d: d.get("lastModified") or 0, reverse=True)
tracked_uuids = load_tracked_uuids()
watched = [d for d in docs if is_watched_doc(d, tracked_uuids)]
return {
"ts": now_iso(),
"event": "snapshot",
"online": True,
"tablet_time": tablet_time,
"xochitl": xochitl,
"document_count": len(docs),
"most_recent": docs[:5],
"watched_terms": WATCH_TERMS,
"watched": watched[:10],
}
def summarize_changes(snapshot, prev):
events = [snapshot]
if not snapshot.get("online"):
if prev.get("online") is not False:
events.append({"ts": snapshot["ts"], "event": "tablet_offline_transition", "online": False})
return events
if prev.get("online") is False:
events.append({"ts": snapshot["ts"], "event": "tablet_online_transition", "online": True})
if prev.get("xochitl") and prev.get("xochitl") != snapshot.get("xochitl"):
events.append({"ts": snapshot["ts"], "event": "xochitl_state_changed", "from": prev.get("xochitl"), "to": snapshot.get("xochitl")})
cur = snapshot.get("most_recent", [{}])[0] if snapshot.get("most_recent") else {}
prev_cur = prev.get("current_guess") or {}
if cur and cur.get("uuid") != prev_cur.get("uuid"):
events.append({"ts": snapshot["ts"], "event": "current_document_guess_changed", "document": cur})
watched_prev = {d.get("uuid"): d for d in prev.get("watched", [])}
for d in snapshot.get("watched", []):
old = watched_prev.get(d.get("uuid"))
if old and old.get("lastModified") != d.get("lastModified"):
events.append({"ts": snapshot["ts"], "event": "watched_document_updated", "document": d})
elif not old:
events.append({"ts": snapshot["ts"], "event": "watched_document_seen", "document": d})
return events
def sync_once() -> dict:
"""Collect one tracked-note snapshot and cache only fresh changed pages."""
prev = load_state()
snap = collect_snapshot()
cached_pages = cache_changed_pages(snap, prev)
if cached_pages:
snap["cached_changed_pages"] = cached_pages
for ev in summarize_changes(snap, prev):
append_event(ev)
state = {
"online": snap.get("online"),
"xochitl": snap.get("xochitl"),
"current_guess": (snap.get("most_recent") or [{}])[0] if snap.get("online") else prev.get("current_guess", {}),
"watched": snap.get("watched", []) if snap.get("online") else prev.get("watched", []),
"last_snapshot_ts": snap.get("ts"),
}
save_state(state)
return snap
def listen_forever(port: int = LISTENER_PORT) -> None:
"""Persist Paper Pro UDP heartbeats and document_change events locally."""
udp_dir = LOGDIR / "udp"
udp_dir.mkdir(parents=True, exist_ok=True)
latest = LOGDIR / "latest_device.json"
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(("0.0.0.0", port))
print(f"listening on UDP 0.0.0.0:{port}", flush=True)
last_seen: dict[tuple[str, str], float] = {}
while True:
data, addr = sock.recvfrom(8192)
now = dt.datetime.now(dt.UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")
text = data.decode("utf-8", "replace").strip()
key = (addr[0], text)
now_epoch = time.time()
if now_epoch - last_seen.get(key, 0) < 2:
continue
last_seen[key] = now_epoch
if len(last_seen) > 200:
last_seen = {item: seen_at for item, seen_at in last_seen.items() if seen_at >= now_epoch - 30}
event = {
"received_ts": now,
"source_ip": addr[0],
"source_port": addr[1],
"message": text,
"fields": parse_udp_message(text),
}
day = dt.datetime.now(dt.UTC).strftime("%Y-%m-%d")
with (udp_dir / f"{day}.jsonl").open("a", encoding="utf-8") as handle:
handle.write(json.dumps(event, sort_keys=True, ensure_ascii=False) + "\n")
latest.write_text(json.dumps(event, indent=2, sort_keys=True, ensure_ascii=False) + "\n", encoding="utf-8")
print(json.dumps(event, sort_keys=True, ensure_ascii=False), flush=True)
def launch_agent_path() -> Path:
return Path.home() / "Library" / "LaunchAgents" / f"{LISTENER_LABEL}.plist"
def build_launch_agent(python_bin: Path, cli_module: str, root: Path) -> dict:
return {
"Label": LISTENER_LABEL,
"ProgramArguments": [str(python_bin), "-m", cli_module, "remarkable", "listen"],
"EnvironmentVariables": {"REYNA_REMARKABLE_ROOT": str(root)},
"RunAtLoad": True,
"KeepAlive": True,
"StandardOutPath": str(root / "listener.log"),
"StandardErrorPath": str(root / "listener.error.log"),
}
def build_sync_agent(python_bin: Path, cli_module: str, root: Path) -> dict:
return {
"Label": SYNC_LABEL,
"ProgramArguments": [str(python_bin), "-m", cli_module, "remarkable", "sync"],
"EnvironmentVariables": {"REYNA_REMARKABLE_ROOT": str(root)},
"RunAtLoad": True,
"StartInterval": 30,
"StandardOutPath": str(root / "sync.log"),
"StandardErrorPath": str(root / "sync.error.log"),
}
def sync_agent_path() -> Path:
return Path.home() / "Library" / "LaunchAgents" / f"{SYNC_LABEL}.plist"
def install_listener_service(python_bin: Path | None = None) -> Path:
root = data_root()
root.mkdir(parents=True, exist_ok=True)
path = launch_agent_path()
path.parent.mkdir(parents=True, exist_ok=True)
interpreter = python_bin or Path(sys.executable)
with path.open("wb") as handle:
plistlib.dump(build_launch_agent(interpreter, "reyna_cli.cli", root), handle)
with sync_agent_path().open("wb") as handle:
plistlib.dump(build_sync_agent(interpreter, "reyna_cli.cli", root), handle)
return path
def listener_service_status() -> dict:
uid = str(os.getuid())
services = {}
for label, path in ((LISTENER_LABEL, launch_agent_path()), (SYNC_LABEL, sync_agent_path())):
proc = subprocess.run(["launchctl", "print", f"gui/{uid}/{label}"], capture_output=True, text=True, check=False)
services[label] = {"installed": path.exists(), "path": str(path), "active": proc.returncode == 0, "detail": (proc.stdout or proc.stderr)[-1000:]}
return {"listener": services[LISTENER_LABEL], "sync": services[SYNC_LABEL]}
def listener_service_action(action: str) -> dict:
uid = str(os.getuid())
if action == "install":
install_listener_service()
action = "start"
commands: list[list[str]] = []
if action == "start":
for label, path in ((LISTENER_LABEL, launch_agent_path()), (SYNC_LABEL, sync_agent_path())):
subprocess.run(["launchctl", "bootout", f"gui/{uid}/{label}"], capture_output=True, text=True, check=False)
commands.append(["launchctl", "bootstrap", f"gui/{uid}", str(path)])
elif action == "stop":
commands = [["launchctl", "bootout", f"gui/{uid}/{label}"] for label in (LISTENER_LABEL, SYNC_LABEL)]
else:
raise ValueError(f"unsupported service action: {action}")
results = [subprocess.run(command, capture_output=True, text=True, check=False) for command in commands]
return {
"ok": all(proc.returncode == 0 for proc in results),
"action": action,
"results": [{"command": " ".join(command), "stdout": proc.stdout.strip(), "stderr": proc.stderr.strip()} for command, proc in zip(commands, results)],
"status": listener_service_status(),
}
if __name__ == "__main__":
print(json.dumps(sync_once(), indent=2, ensure_ascii=False, sort_keys=True))
tests/test_desktop_service.py
+1 -1
View File
@@ -27,5 +27,5 @@ def test_unit_content_matches_desktop_client_gui_session():
assert SERVICE_NAME == "reyna-desktop-client.service"
assert "Environment=WAYLAND_DISPLAY=wayland-0" in content
assert "Environment=XDG_RUNTIME_DIR=/run/user/1000" in content
assert "ExecStart=/usr/bin/python3 /home/adolforeyna/Projects/Screen/desktop_client/client.py" in content
assert "ExecStart=/usr/bin/python3 /Users/adolforeyna/Projects/Screen/desktop_client/client.py" in content
assert "Restart=always" in content
tests/test_remarkable.py
+77
View File
@@ -0,0 +1,77 @@
import json
from pathlib import Path
from typer.testing import CliRunner
from reyna_cli.cli import app
from reyna_cli.remarkable import build_launch_agent, build_sync_agent, data_root, extract_page_ids, parse_udp_message
runner = CliRunner()
def test_parse_udp_message_preserves_paperpro_identity_and_document_change():
message = (
"device=paperpro ts=2026-08-03T03:20:00Z ip=192.168.68.136 "
"event=document_change details=uuid=abc name=Quick_sheets file=abc/page.rm"
)
parsed = parse_udp_message(message)
assert parsed["device"] == "paperpro"
assert parsed["event"] == "document_change"
assert parsed["ip"] == "192.168.68.136"
assert parsed["details"] == "uuid=abc name=Quick_sheets file=abc/page.rm"
def test_extract_page_ids_handles_paperpro_cpages_last_opened_shape():
assert extract_page_ids({"cPages": {"lastOpened": {"value": "current-page"}}}) == ["current-page"]
def test_data_root_honors_environment_override(tmp_path, monkeypatch):
expected = tmp_path / "paperpro"
monkeypatch.setenv("REYNA_REMARKABLE_ROOT", str(expected))
assert data_root() == expected
def test_launch_agent_runs_reyna_cli_udp_listener_from_configured_root(tmp_path):
plist = build_launch_agent(
python_bin=Path("/usr/bin/python3"),
cli_module="reyna_cli.cli",
root=tmp_path / "paperpro",
)
serialized = json.dumps(plist)
assert plist["Label"] == "com.reynafamily.reyna-cli.remarkable-listener"
assert plist["ProgramArguments"] == [
"/usr/bin/python3",
"-m",
"reyna_cli.cli",
"remarkable",
"listen",
]
assert plist["KeepAlive"] is True
assert "REYNA_REMARKABLE_ROOT" in serialized
def test_sync_agent_runs_every_thirty_seconds_with_same_local_root(tmp_path):
plist = build_sync_agent(
python_bin=Path("/usr/bin/python3"),
cli_module="reyna_cli.cli",
root=tmp_path / "paperpro",
)
assert plist["Label"] == "com.reynafamily.reyna-cli.remarkable-sync"
assert plist["ProgramArguments"][-2:] == ["remarkable", "sync"]
assert plist["StartInterval"] == 30
assert plist["RunAtLoad"] is True
def test_remarkable_cli_exposes_service_management():
result = runner.invoke(app, ["remarkable", "--help"])
assert result.exit_code == 0
assert "listen" in result.stdout
assert "service-install" in result.stdout
assert "service-status" in result.stdout
uv.lock
Generated
+114 -4
View File
@@ -527,7 +527,7 @@ name = "exceptiongroup"
version = "1.3.1"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "typing-extensions", marker = "python_full_version < '3.13'" },
{ name = "typing-extensions" },
]
sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
wheels = [
@@ -1014,11 +1014,105 @@ wheels = [
[[package]]
name = "packaging"
version = "26.2"
version = "23.2"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
sdist = { url = "https://files.pythonhosted.org/packages/fb/2b/9b9c33ffed44ee921d0967086d653047286054117d584f1b1a7c22ceaf7b/packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5", size = 146714, upload-time = "2023-10-01T13:50:05.279Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
{ url = "https://files.pythonhosted.org/packages/ec/1a/610693ac4ee14fcdf2d9bf3c493370e4f2ef7ae2e19217d7a237ff42367d/packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7", size = 53011, upload-time = "2023-10-01T13:50:03.745Z" },
]
[[package]]
name = "pillow"
version = "12.3.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/25/c2/669d88644cddb1485bd9534e63e8cf476c8e51cb3c3a1297677023505c0e/pillow-12.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6c0016e7b354317c4e9e525b937ac8596c38d2d232b419529b9cd7a1cd46e39a", size = 5392418, upload-time = "2026-07-01T11:53:27.808Z" },
{ url = "https://files.pythonhosted.org/packages/6b/ba/3762f376a2948e3036488d773a146e0ae6ecc2ca03ac20e2615bd0b2ba02/pillow-12.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:bcc33feacfaefce60c12fd500a277533bdc02b10a19f7f6d348763d8140bbba7", size = 4785287, upload-time = "2026-07-01T11:53:29.761Z" },
{ url = "https://files.pythonhosted.org/packages/07/50/b5d688cc9c52d4482f3d5bcab6ce20bc2a74a85d2343841c907444a3be2c/pillow-12.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5594fc43d548a7ed94949d139aa1341b270f1863f11cfd37f5a6c8b778a6b67f", size = 6253754, upload-time = "2026-07-01T11:53:32.298Z" },
{ url = "https://files.pythonhosted.org/packages/4e/89/36f4cd76cf4baf05c50ababb976249153f18c959171c7f6ba09a6f217260/pillow-12.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0606c8bf2cdefea14a43530f7657cbbb7ecf1c4222512492ef4a4434a9501ec", size = 6925605, upload-time = "2026-07-01T11:53:34.487Z" },
{ url = "https://files.pythonhosted.org/packages/eb/c0/4de58cf6633b9e3a6061ef4be6fb91fc3c90b812ece886f531e3c523d777/pillow-12.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:85f998ea1848bc6757289e739cfbdda3a04adfd58b02fc018ce54d754a5ce468", size = 6327788, upload-time = "2026-07-01T11:53:36.433Z" },
{ url = "https://files.pythonhosted.org/packages/87/3c/14d53682a19550dbbaf3b598f807d5457646c510805a44c7d7891cd1cd1a/pillow-12.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:25b9b82bb22e6e2b3cd07b39c68b7b862001226cb3dff7130d1cb914121b39ed", size = 7036288, upload-time = "2026-07-01T11:53:38.712Z" },
{ url = "https://files.pythonhosted.org/packages/38/1d/36279e3c77efe034e4cc2b0393ee74ffdb5a62391dacbf9b916154f5f0b8/pillow-12.3.0-cp310-cp310-win32.whl", hash = "sha256:37dc8f7bbb66efe481bb60defacef820c950c24713fb44962ed6aa2a50966de1", size = 6472396, upload-time = "2026-07-01T11:53:40.781Z" },
{ url = "https://files.pythonhosted.org/packages/48/7c/8fa0039574c476d7c6fa57dd7c32a130436877c6ec1e5ce1cc8ec44878c1/pillow-12.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:300557495eb45ebb8aec96c2da9c4be642fbf7cd937278b4013ba894ea8eb0eb", size = 7226887, upload-time = "2026-07-01T11:53:42.764Z" },
{ url = "https://files.pythonhosted.org/packages/fa/17/e324be141d173c1c919428066c3259f21c1b8982e564e01a4a81e96dbdcf/pillow-12.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:514435a37670e3e5e08f3945b68718b6ed329bb84367777e16f9f4dfe1e61a0f", size = 2568039, upload-time = "2026-07-01T11:53:45.372Z" },
{ url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" },
{ url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" },
{ url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" },
{ url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" },
{ url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" },
{ url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" },
{ url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" },
{ url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" },
{ url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" },
{ url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" },
{ url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" },
{ url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" },
{ url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" },
{ url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" },
{ url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" },
{ url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" },
{ url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" },
{ url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" },
{ url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" },
{ url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" },
{ url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" },
{ url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" },
{ url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" },
{ url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" },
{ url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" },
{ url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" },
{ url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" },
{ url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" },
{ url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" },
{ url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" },
{ url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" },
{ url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" },
{ url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" },
{ url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" },
{ url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" },
{ url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" },
{ url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" },
{ url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" },
{ url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" },
{ url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" },
{ url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" },
{ url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" },
{ url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" },
{ url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" },
{ url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" },
{ url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" },
{ url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" },
{ url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" },
{ url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" },
{ url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" },
{ url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" },
{ url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" },
{ url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" },
{ url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" },
{ url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" },
{ url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" },
{ url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" },
{ url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" },
{ url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" },
{ url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" },
{ url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" },
{ url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" },
{ url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" },
{ url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" },
{ url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" },
{ url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" },
{ url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" },
{ url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" },
{ url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" },
{ url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" },
{ url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" },
{ url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" },
{ url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" },
{ url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" },
{ url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" },
{ url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" },
{ url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" },
]
[[package]]
@@ -1542,12 +1636,14 @@ dependencies = [
{ name = "httpx" },
{ name = "itsdangerous" },
{ name = "jinja2" },
{ name = "pillow" },
{ name = "pydantic" },
{ name = "pymongo" },
{ name = "pytest-mock" },
{ name = "python-multipart" },
{ name = "pyyaml" },
{ name = "rich" },
{ name = "rmscene" },
{ name = "tplinkrouterc6u" },
{ name = "typer" },
{ name = "uvicorn" },
@@ -1561,12 +1657,14 @@ requires-dist = [
{ name = "httpx" },
{ name = "itsdangerous", specifier = ">=2.2.0" },
{ name = "jinja2", specifier = ">=3.1.6" },
{ name = "pillow", specifier = ">=12.3.0" },
{ name = "pydantic" },
{ name = "pymongo" },
{ name = "pytest-mock" },
{ name = "python-multipart", specifier = ">=0.0.32" },
{ name = "pyyaml" },
{ name = "rich" },
{ name = "rmscene", specifier = ">=0.8.0" },
{ name = "tplinkrouterc6u", specifier = "==5.21.0" },
{ name = "typer" },
{ name = "uvicorn", specifier = ">=0.49.0" },
@@ -1585,6 +1683,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
]
[[package]]
name = "rmscene"
version = "0.8.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "packaging" },
]
sdist = { url = "https://files.pythonhosted.org/packages/de/dd/2ec964e1f5e007e3b6492e3aace7bfdb58422d6770a2cda08988068089bf/rmscene-0.8.0.tar.gz", hash = "sha256:db9417a6b8cc86e80c1be8cefa29cec24d4d49777433d49d1fc741773f10d5be", size = 23794, upload-time = "2026-04-05T14:56:59.883Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/1b/bb/c98189fa471986c13acb35dbce444345e05d8b58096b4457c1c4b3494443/rmscene-0.8.0-py3-none-any.whl", hash = "sha256:78f2bb8a746ceb6428005aa5fcb576eb7cf10ad537d043c49659c950633b01d1", size = 26765, upload-time = "2026-04-05T14:56:58.525Z" },
]
[[package]]
name = "shellingham"
version = "1.5.4"