#!/usr/bin/env python3 """Tool Gateway — типизированные инструменты Buryans Hub. Один вход для агентов: /call {tool, args, actor}. Внутри — политика, подтверждения, идемпотентность, лимиты и аудит. Запуск: systemd tool-gateway (порт 9140). """ import base64 import json import os import re import sqlite3 import time import urllib.error import urllib.parse import urllib.request import uuid from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer CFG = "/etc/tool-gateway/config.json" DB = "/var/lib/tool-gateway/audit.db" HUB = "http://127.0.0.1:9120" HA = "http://192.168.1.106:8123" NC = "http://192.168.1.109:8080" IMMICH = "http://192.168.1.104:2283" RADARR = "http://192.168.1.118:7878" SONARR = "http://192.168.1.117:8989" JELLYFIN = "http://192.168.1.103:8096" def read(path): try: return open(path, encoding="utf-8").read().strip() except Exception: return "" CFG_D = json.load(open(CFG)) if os.path.exists(CFG) else {} TOKENS = {v: k for k, v in (CFG_D.get("tokens") or {}).items()} RATE = {} import threading RATE_LOCK = threading.Lock() HA_TOKEN = read("/root/.ha-token") RADARR_KEY = read("/root/.radarr-key") SONARR_KEY = read("/root/.sonarr-key") JELLYFIN_KEY = read("/root/.jellyfin-key") IMMICH_KEY = read("/root/.immich-key-new") NC_USER = "family" NC_PASS = read("/root/.family-nextcloud-pass") def http(method, url, headers=None, data=None, timeout=20): req = urllib.request.Request(url, method=method, data=json.dumps(data).encode() if data is not None else None, headers=dict({"Content-Type": "application/json"}, **(headers or {}))) with urllib.request.urlopen(req, timeout=timeout) as r: body = r.read() return r.status, body def basic(user, pw): return "Basic " + base64.b64encode(("%s:%s" % (user, pw)).encode()).decode() # ---------- инструменты ---------- def t_hub_status(args): last = None for _ in range(3): try: st, body = http("GET", HUB + "/status.json", timeout=30) break except Exception as e: last = e time.sleep(2) else: raise last or RuntimeError("hub status unavailable") d = json.loads(body) svc = d.get("services", []) down = [s["name"] for s in svc if not s.get("up")] return {"total": len(svc), "down": down} def t_hub_notify(args): msg = {"title": args.get("title", "Tool Gateway"), "message": args.get("message", ""), "priority": args.get("priority", "normal")} st, body = http("POST", HUB + "/notify", data=msg) return {"status": st, "body": body.decode("utf-8", "replace")[:200]} def t_ha_states(args): domain = args.get("domain") st, body = http("GET", HA + "/api/states", {"Authorization": "Bearer " + HA_TOKEN}) states = json.loads(body) if domain: states = [s for s in states if s["entity_id"].startswith(domain + ".")] out = [{"entity_id": s["entity_id"], "state": s["state"], "name": (s.get("attributes") or {}).get("friendly_name")} for s in states] return {"count": len(out), "states": out[:200]} def t_ha_call(args): domain = args["domain"] service = args["service"] data = args.get("data") or {} st, body = http("POST", "%s/api/services/%s/%s" % (HA, domain, service), {"Authorization": "Bearer " + HA_TOKEN}, data) return {"status": st, "body": body.decode("utf-8", "replace")[:200]} def t_media_queue(args): out = {} for name, url, key in (("radarr", RADARR, RADARR_KEY), ("sonarr", SONARR, SONARR_KEY)): try: st, body = http("GET", "%s/api/v3/queue?page=1&pageSize=50" % url, {"X-Api-Key": key}) d = json.loads(body) out[name] = {"total": d.get("totalRecords", 0), "items": [r.get("title") for r in (d.get("records") or [])][:20]} except Exception as e: out[name] = {"error": str(e)[:120]} return out def t_media_recent(args): st, body = http("GET", JELLYFIN + "/Items?IncludeItemTypes=Movie&Recursive=true" "&SortBy=DateCreated&SortOrder=Descending&Limit=10" "&Fields=DateCreated", {"Authorization": 'MediaBrowser Token="%s"' % JELLYFIN_KEY}) d = json.loads(body) return {"count": len(d.get("Items") or []), "items": [i.get("Name") for i in (d.get("Items") or [])]} def post_json(url, headers, payload): try: return http("POST", url, headers, payload) except urllib.error.HTTPError as e: return e.code, e.read() def _caldav(method, path, body=None, headers=None): url = NC + "/remote.php/dav/calendars/%s/%s/" % (NC_USER, urllib.parse.quote(path, safe="/")) h = {"Authorization": basic(NC_USER, NC_PASS)} if headers: h.update(headers) req = urllib.request.Request(url, method=method, data=body, headers=h) with urllib.request.urlopen(req, timeout=25) as r: return r.status, r.read() def t_calendar_list(args): days = int(args.get("days", 7)) now = time.time() start = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime(now)) end = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime(now + days * 86400)) cal = args.get("calendar", "Семья") body = ('' '' '' '' % (start, end)).encode() st, raw = _caldav("REPORT", cal, body, {"Content-Type": "application/xml; charset=utf-8", "Depth": "1"}) txt = raw.decode("utf-8", "replace") events = [] for block in re.findall(r"BEGIN:VEVENT(.*?)END:VEVENT", txt, re.S): s = re.search(r"SUMMARY:(.+)", block) t = re.search(r"DTSTART[^:]*:(\S+)", block) events.append({"summary": (s.group(1).strip() if s else ""), "start": (t.group(1).strip() if t else "")}) return {"calendar": cal, "count": len(events), "events": events[:30]} def t_calendar_create(args): title = args["title"] start = args["start"] # 20261120T150000 end = args.get("end") or start cal = args.get("calendar", "Семья") uid = uuid.uuid4().hex ics = ("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Buryans//ToolGateway//RU\r\n" "BEGIN:VEVENT\r\nUID:%s\r\nDTSTAMP:%s\r\nDTSTART:%s\r\nDTEND:%s\r\n" "SUMMARY:%s\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n" % (uid, time.strftime("%Y%m%dT%H%M%SZ", time.gmtime()), start, end, title)) st, raw = _caldav("PUT", cal + "/" + uid + ".ics", ics.encode(), {"Content-Type": "text/calendar; charset=utf-8"}) return {"status": st, "uid": uid, "calendar": cal, "title": title, "start": start} def t_photos_people(args): st, body = http("GET", IMMICH + "/api/people", {"x-api-key": IMMICH_KEY}) d = json.loads(body) return {"total": d.get("total", 0), "people": [p.get("name") for p in (d.get("people") or [])][:50]} def t_photos_albums(args): st, body = http("GET", IMMICH + "/api/albums", {"x-api-key": IMMICH_KEY}) d = json.loads(body) return {"count": len(d or []), "albums": [a.get("albumName") for a in (d or [])][:50]} def t_ha_search(args): q = (args.get("query") or "").lower() domain = args.get("domain") st, body = http("GET", HA + "/api/states", {"Authorization": "Bearer " + HA_TOKEN}) states = json.loads(body) out = [] for s in states: if domain and not s["entity_id"].startswith(domain + "."): continue name = ((s.get("attributes") or {}).get("friendly_name") or "").lower() if q and q not in name and q not in s["entity_id"].lower(): continue a = s.get("attributes") or {} out.append({"entity_id": s["entity_id"], "name": a.get("friendly_name"), "state": s.get("state"), "last_changed": s.get("last_changed"), "domain": s["entity_id"].split(".")[0], "device_class": a.get("device_class"), "supported_features": a.get("supported_features")}) return {"query": q, "count": len(out), "entities": out[:50]} def _lookup(kind, query): if kind == "series": st, body = http("GET", SONARR + "/api/v3/series/lookup?term=" + urllib.parse.quote(query), {"X-Api-Key": SONARR_KEY}) else: st, body = http("GET", RADARR + "/api/v3/movie/lookup?term=" + urllib.parse.quote(query), {"X-Api-Key": RADARR_KEY}) return json.loads(body) def t_media_search(args): kind = args.get("kind", "series") q = args.get("query") or "" items = _lookup(kind, q) out = [] for it in (items or [])[:8]: out.append({"title": it.get("title"), "year": it.get("year"), "tvdbId": it.get("tvdbId"), "tmdbId": it.get("tmdbId"), "overview": (it.get("overview") or "")[:200]}) return {"kind": kind, "query": q, "count": len(out), "items": out} def t_media_request(args): kind = args.get("kind", "series") q = args.get("query") or "" season = args.get("season") items = _lookup(kind, q) if not items: return {"error": "not_found", "query": q} it = items[0] if kind == "series": st, body = http("GET", SONARR + "/api/v3/rootfolder", {"X-Api-Key": SONARR_KEY}) roots = json.loads(body) st, body = http("GET", SONARR + "/api/v3/qualityprofile", {"X-Api-Key": SONARR_KEY}) profiles = json.loads(body) root = roots[0]["path"] if roots else "/data/series" qp = profiles[0]["id"] if profiles else 1 seasons = it.get("seasons") or [] for s in seasons: s["monitored"] = (str(s.get("seasonNumber")) == str(season)) if season else True payload = {"title": it.get("title"), "tvdbId": it.get("tvdbId"), "qualityProfileId": qp, "rootFolderPath": root, "monitored": True, "seasonFolder": True, "seasons": seasons, "addOptions": {"searchForMissingEpisodes": True, "monitor": "none" if season else "all"}} st, body = post_json(SONARR + "/api/v3/series", {"X-Api-Key": SONARR_KEY}, payload) else: st, body = http("GET", RADARR + "/api/v3/rootfolder", {"X-Api-Key": RADARR_KEY}) roots = json.loads(body) st, body = http("GET", RADARR + "/api/v3/qualityprofile", {"X-Api-Key": RADARR_KEY}) profiles = json.loads(body) root = roots[0]["path"] if roots else "/data/movies" qp = profiles[0]["id"] if profiles else 1 payload = {"title": it.get("title"), "tmdbId": it.get("tmdbId"), "qualityProfileId": qp, "rootFolderPath": root, "monitored": True, "addOptions": {"searchForMovie": True}} st, body = post_json(RADARR + "/api/v3/movie", {"X-Api-Key": RADARR_KEY}, payload) try: res = json.loads(body) except Exception: res = {"raw": body.decode("utf-8", "replace")[:200]} if st >= 400 and kind == "series": try: st2, body2 = http("GET", SONARR + "/api/v3/series", {"X-Api-Key": SONARR_KEY}) for ser in json.loads(body2): if ser.get("tvdbId") == it.get("tvdbId"): out = {"kind": kind, "query": q, "season": season, "already_exists": True, "title": ser.get("title"), "id": ser.get("id")} if season: try: cmd = {"name": "SeasonSearch", "seriesId": ser.get("id"), "seasonNumber": int(season)} st3, body3 = http("POST", SONARR + "/api/v3/command", {"X-Api-Key": SONARR_KEY}, cmd) out["search"] = {"status": st3, "body": body3.decode("utf-8", "replace")[:120]} except Exception as e: out["search"] = {"error": str(e)[:120]} return out except Exception: pass return {"kind": kind, "query": q, "season": season, "status": st, "title": res.get("title"), "id": res.get("id"), "error": res if st >= 400 else None} def t_hub_service_detail(args): name = (args.get("name") or "").lower() st, body = http("GET", HUB + "/status.json", timeout=30) d = json.loads(body) for svc in d.get("services", []): if svc.get("name", "").lower() == name: return svc matches = [x for x in d.get("services", []) if name and name in x.get("name", "").lower()] return {"found": False, "query": name, "matches": matches[:10]} def t_alerts_active(args): st, body = http("GET", "http://192.168.1.134:9093/api/v2/alerts", timeout=15) alerts = json.loads(body) out = [] for a in alerts: lb = a.get("labels") or {} out.append({"name": lb.get("alertname"), "severity": lb.get("severity"), "instance": lb.get("instance"), "status": (a.get("status") or {}).get("state"), "startsAt": a.get("startsAt")}) return {"count": len(out), "alerts": out[:50]} def t_backup_status(args): import subprocess as sp env = dict(os.environ, PGPASSWORD=read("/root/.pg-superuser-pass")) q = ("SELECT name, to_char(to_timestamp(last_run),'MM-DD HH24:MI'), " "last_status, fails FROM jobs WHERE name ILIKE '%backup%' OR name ILIKE '%verify%' " "ORDER BY name;") r = sp.run(["psql", "-w", "-h", "192.168.1.151", "-U", "postgres", "-d", "hermes", "-t", "-A", "-F", "|", "-c", q], capture_output=True, text=True, timeout=30, env=env) rows = [ln.split("|") for ln in (r.stdout or "").strip().splitlines() if ln] return {"jobs": [{"name": x[0], "last": x[1], "status": x[2], "fails": x[3]} for x in rows]} def vds_curl(url, timeout=25): """Запрос из VDS (у него есть интернет), т.к. с хоста DPI режет внешние TLS.""" import subprocess as sp r = sp.run(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=8", "root@10.88.0.1", "curl -s -m %d '%s'" % (timeout, url)], capture_output=True, text=True, timeout=timeout + 10) return (r.stdout or "").strip() def t_books_search(args): q = args.get("query") or "" items = [] url = "https://openlibrary.org/search.json?q=" + urllib.parse.quote(q) + "&limit=5" raw = "" try: st, body = http("GET", url, timeout=15) raw = body.decode("utf-8", "replace") except Exception: raw = vds_curl(url) try: d = json.loads(raw) for doc in (d.get("docs") or [])[:5]: items.append({"title": doc.get("title"), "authors": (doc.get("author_name") or [])[:3], "year": doc.get("first_publish_year"), "link": "https://openlibrary.org" + (doc.get("key") or "")}) except Exception as e: items.append({"error": str(e)[:120]}) return {"query": q, "count": len(items), "items": items} def t_books_link(args): q = args.get("query") or "" return {"query": q, "biglibrary": "https://biglibrary.org/search?q=" + urllib.parse.quote(q), "openlibrary": "https://openlibrary.org/search?q=" + urllib.parse.quote(q), "note": "автоматическое скачивание не выполняется"} def t_books_status(args): url = "http://127.0.0.1/" try: st, body = http("GET", url, {"Host": "books.buryans.ru"}, timeout=10) return {"calibre_web": "https://books.buryans.ru", "http": st, "reachable": st in (200, 302, 303, 401)} except Exception as e: return {"calibre_web": "https://books.buryans.ru", "error": str(e)[:120]} def t_audit_recent(args): n = int(args.get("limit", 20)) actor = args.get("actor") where = "" if actor: where = " WHERE actor='%s'" % actor.replace("'", "''") r = _pg("SELECT to_char(ts,'MM-DD HH24:MI:SS'), actor, tool, ok, ms " "FROM tool_audit%s ORDER BY id DESC LIMIT %d;" % (where, n)) rows = [] for ln in (r.stdout or "").strip().splitlines(): parts = ln.split("|") if len(parts) >= 5: rows.append({"ts": parts[0], "actor": parts[1], "tool": parts[2], "ok": parts[3] == "t", "ms": parts[4]}) return {"count": len(rows), "rows": rows} def t_docs_search(args): q = (args.get("query") or "").strip() if not q or len(q) > 120: return {"error": "query must be 1..120 chars"} import subprocess as sp cmd = ["grep", "-R", "-i", "-n", "-m", "3", "--include=*.md", "--include=*.py", "--include=*.yaml", "--include=*.yml", q, "/root/buryan-infra/ops", "/root/buryan-infra/docs"] r = sp.run(cmd, capture_output=True, text=True, timeout=20) rows = [] for ln in (r.stdout or "").splitlines()[:60]: parts = ln.split(":", 2) if len(parts) == 3: rows.append({"file": parts[0], "line": parts[1], "text": parts[2][:240]}) return {"query": q, "count": len(rows), "results": rows} LOCAL_ONLY = {"photos.people", "photos.albums"} TOOL_LIMIT = {"ha.call": (5, 60), "hub.notify": (10, 60), "media.request": (5, 60), "calendar.create": (10, 60)} TOOL_RATE = {} TOOL_RATE_LOCK = threading.Lock() MATRIX_ROOM = "!puEdcZCc87kKoCm3mX5bbjrTS-Skv2XCZg7JJBKOMw0" MATRIX_HS = "http://192.168.1.155:8008" def matrix_send(text): import urllib.request tok = read("/root/.matrix-admin-token").strip() txn = "approval-%d" % int(time.time() * 1000) body = json.dumps({"msgtype": "m.text", "body": text}).encode() url = "%s/_matrix/client/v3/rooms/%s/send/m.room.message/%s?access_token=%s" % ( MATRIX_HS, MATRIX_ROOM, txn, tok) req = urllib.request.Request(url, data=body, headers={"Content-Type": "application/json"}, method="PUT") with urllib.request.urlopen(req, timeout=20) as r: return r.status def create_approval(actor, tool, args): try: _pg("""CREATE TABLE IF NOT EXISTS tool_approvals( id bigserial PRIMARY KEY, ts timestamptz DEFAULT now(), actor text, tool text, args jsonb, decision text, result jsonb); ALTER TABLE tool_approvals ADD COLUMN IF NOT EXISTS result jsonb;""") a = json.dumps(args, ensure_ascii=False).replace("'", "''")[:3000] r = _pg("INSERT INTO tool_approvals(actor,tool,args,decision) VALUES " "('%s','%s','%s'::jsonb,'pending') RETURNING id;" % (actor.replace("'", "''"), tool.replace("'", "''"), a)) out = (r.stdout or "0").strip().splitlines() aid = int(out[0] if out else 0) except Exception: return 0 try: matrix_send("🔐 **Подтверждение #%d**\nИнструмент: `%s`\nАргументы: `%s`\n\nОтветьте: `approve %d` или `reject %d`" % (aid, tool, json.dumps(args, ensure_ascii=False)[:600], aid, aid)) except Exception: pass return aid def approval_state(aid): try: r = _pg("SELECT decision, tool FROM tool_approvals WHERE id=%d;" % int(aid)) line = (r.stdout or "").strip().split("|") if len(line) >= 2: return {"decision": line[0], "tool": line[1]} except Exception: pass return None def finish_approval(aid, result): try: res = json.dumps(result, ensure_ascii=False).replace("'", "''")[:4000] _pg("UPDATE tool_approvals SET decision='done', result='%s'::jsonb WHERE id=%d;" % (res, int(aid))) except Exception: pass def pg_approval(actor, tool, args): try: _pg("""CREATE TABLE IF NOT EXISTS tool_approvals( id bigserial PRIMARY KEY, ts timestamptz DEFAULT now(), actor text, tool text, args jsonb, decision text);""") a = json.dumps(args, ensure_ascii=False).replace("'", "''")[:2000] _pg("INSERT INTO tool_approvals(actor,tool,args,decision) VALUES " "('%s','%s','%s'::jsonb,'confirmed');" % (actor.replace("'", "''"), tool.replace("'", "''"), a)) except Exception: pass def t_approvals_recent(args): n = int(args.get("limit", 20)) r = _pg("SELECT to_char(ts,'MM-DD HH24:MI:SS'), actor, tool, decision " "FROM tool_approvals ORDER BY id DESC LIMIT %d;" % n) rows = [] for ln in (r.stdout or "").strip().splitlines(): p = ln.split("|") if len(p) >= 4: rows.append({"ts": p[0], "actor": p[1], "tool": p[2], "decision": p[3]}) return {"count": len(rows), "rows": rows} TOOLS = { "hub.status": {"fn": t_hub_status, "scope": "read", "confirm": False}, "hub.notify": {"fn": t_hub_notify, "scope": "write", "confirm": True, "actors": ["owner", "family", "agent"]}, "ha.states": {"fn": t_ha_states, "scope": "read", "confirm": False}, "ha.call": {"fn": t_ha_call, "scope": "write", "confirm": True, "actors": ["owner", "family"]}, "media.queue": {"fn": t_media_queue, "scope": "read", "confirm": False}, "media.recent": {"fn": t_media_recent, "scope": "read", "confirm": False}, "calendar.list": {"fn": t_calendar_list, "scope": "read", "confirm": False}, "calendar.create": {"fn": t_calendar_create, "scope": "write", "confirm": True, "actors": ["owner", "family"]}, "photos.people": {"fn": t_photos_people, "scope": "read", "confirm": False, "local_only": True}, "photos.albums": {"fn": t_photos_albums, "scope": "read", "confirm": False, "local_only": True}, "ha.search": {"fn": t_ha_search, "scope": "read", "confirm": False}, "media.search": {"fn": t_media_search, "scope": "read", "confirm": False}, "media.request": {"fn": t_media_request, "scope": "write", "confirm": True, "actors": ["owner", "family"]}, "hub.service_detail": {"fn": t_hub_service_detail, "scope": "read", "confirm": False}, "alerts.active": {"fn": t_alerts_active, "scope": "read", "confirm": False}, "backup.status": {"fn": t_backup_status, "scope": "read", "confirm": False}, "books.search": {"fn": t_books_search, "scope": "read", "confirm": False}, "books.link": {"fn": t_books_link, "scope": "read", "confirm": False}, "books.status": {"fn": t_books_status, "scope": "read", "confirm": False}, "audit.recent": {"fn": t_audit_recent, "scope": "read", "confirm": False}, "docs.search": {"fn": t_docs_search, "scope": "read", "confirm": False}, "approvals.recent": {"fn": t_approvals_recent, "scope": "read", "confirm": False}, } def _pg(sql, timeout=15): import subprocess as sp env = dict(os.environ, PGPASSWORD=read("/root/.pg-superuser-pass")) return sp.run(["psql", "-w", "-h", "192.168.1.151", "-U", "postgres", "-d", "hermes", "-t", "-A", "-F", "|", "-c", sql], capture_output=True, text=True, timeout=timeout, env=env) def pg_audit(actor, tool, args, result, ok, started): try: _pg("""CREATE TABLE IF NOT EXISTS tool_audit( id bigserial PRIMARY KEY, ts timestamptz DEFAULT now(), actor text, tool text, args jsonb, result jsonb, ok boolean, ms int);""") a = json.dumps(args, ensure_ascii=False).replace("'", "''")[:2000] r = json.dumps(result, ensure_ascii=False).replace("'", "''")[:4000] _pg("INSERT INTO tool_audit(actor,tool,args,result,ok,ms) VALUES " "('%s','%s','%s'::jsonb,'%s'::jsonb,%s,%d);" % (actor.replace("'", "''"), tool.replace("'", "''"), a, r, "true" if ok else "false", int((time.time() - started) * 1000))) except Exception: pass def audit(actor, tool, args, result, ok, started): try: os.makedirs(os.path.dirname(DB), exist_ok=True) c = sqlite3.connect(DB) c.execute("""CREATE TABLE IF NOT EXISTS audit( ts TEXT, actor TEXT, tool TEXT, args TEXT, result TEXT, ok INTEGER, ms INTEGER)""") c.execute("INSERT INTO audit VALUES(?,?,?,?,?,?,?)", (time.strftime("%Y-%m-%dT%H:%M:%S"), actor, tool, json.dumps(args, ensure_ascii=False)[:1000], json.dumps(result, ensure_ascii=False)[:2000], 1 if ok else 0, int((time.time() - started) * 1000))) c.commit() c.close() except Exception: pass pg_audit(actor, tool, args, result, ok, started) class Handler(BaseHTTPRequestHandler): server_version = "ToolGateway/1.0" def _send(self, code, obj): raw = json.dumps(obj, ensure_ascii=False).encode() self.send_response(code) self.send_header("Content-Type", "application/json; charset=utf-8") self.send_header("Content-Length", str(len(raw))) self.end_headers() self.wfile.write(raw) def _actor(self): tok = self.headers.get("X-Gateway-Token", "") return TOKENS.get(tok) def log_message(self, *a): pass def do_GET(self): if self.path == "/health": return self._send(200, {"ok": True, "tools": len(TOOLS)}) if self.path == "/tools": return self._send(200, {"tools": [{"name": k, "scope": v["scope"], "confirm": v["confirm"]} for k, v in TOOLS.items()]}) return self._send(404, {"error": "not found"}) def do_POST(self): if self.path != "/call": return self._send(404, {"error": "not found"}) actor = self._actor() if not actor: return self._send(401, {"error": "bad token"}) try: n = int(self.headers.get("Content-Length", 0)) req = json.loads(self.rfile.read(n).decode() or "{}") except Exception: return self._send(400, {"error": "bad json"}) tool = req.get("tool") args = req.get("args") or {} now = time.time() with RATE_LOCK: q = RATE.setdefault(actor, []) RATE[actor] = [t for t in q if now - t < 60] if len(RATE[actor]) >= 60: return self._send(429, {"error": "rate_limit", "actor": actor, "limit": "60/min"}) RATE[actor].append(now) spec = TOOLS.get(tool) if not spec: return self._send(404, {"error": "unknown tool"}) allowed = spec.get("actors", ["owner", "family", "agent"]) if actor not in allowed: return self._send(403, {"error": "forbidden for actor", "actor": actor, "allowed": allowed}) if spec.get("local_only") or tool in LOCAL_ONLY: return self._send(403, {"error": "privacy_gate", "tool": tool, "reason": "local-only: персональные/биометрические данные нельзя отдавать облачной модели"}) lim = TOOL_LIMIT.get(tool) if lim: n, window = lim now = time.time() with TOOL_RATE_LOCK: q = TOOL_RATE.setdefault(tool, []) TOOL_RATE[tool] = [t for t in q if now - t < window] if len(TOOL_RATE[tool]) >= n: return self._send(429, {"error": "tool_rate_limit", "tool": tool, "limit": "%d/%dsec" % (n, window)}) TOOL_RATE[tool].append(now) required = { "ha.call": ["domain", "service"], "calendar.create": ["title", "start"], "hub.notify": ["message"], "ha.search": ["query"], "media.search": ["query"], "media.request": ["query"], "hub.service_detail": ["name"], "books.search": ["query"], "books.link": ["query"], "docs.search": ["query"], }.get(tool, []) missing = [k for k in required if not args.get(k)] if missing: return self._send(400, {"error": "missing_args", "missing": missing, "tool": tool, "required": required}) if spec["confirm"] and not req.get("confirm"): return self._send(409, {"error": "confirmation_required", "tool": tool, "hint": "повторите с confirm=true"}) approval_id = req.get("approval_id") if spec.get("confirm") and not approval_id: aid = create_approval(actor, tool, args) return self._send(202, {"ok": False, "error": "approval_pending", "approval_id": aid, "tool": tool, "hint": "подтвердите в Matrix: approve %d" % aid}) if spec.get("confirm") and approval_id: st = approval_state(approval_id) if not st or st.get("decision") != "approved" or st.get("tool") != tool: return self._send(409, {"error": "approval_not_ready", "approval_id": approval_id}) started = time.time() try: result = spec["fn"](args) if req.get("approval_id"): finish_approval(req["approval_id"], result) audit(actor, tool, args, result, True, started) return self._send(200, {"ok": True, "result": result}) except Exception as e: err = str(e)[:200] audit(actor, tool, args, {"error": err}, False, started) return self._send(500, {"ok": False, "error": err}) def main(): port = int(CFG_D.get("port", 9140)) srv = ThreadingHTTPServer(("0.0.0.0", port), Handler) print("tool-gateway on :%d, tools=%d" % (port, len(TOOLS)), flush=True) srv.serve_forever() if __name__ == "__main__": main()