Spaces:
Sleeping
Sleeping
| """ | |
| telegram_bot.py — JARVIS Telegram bot (Hugging Face Spaces primary, no Render needed). | |
| Polls @AyomideJarvis_bot via getUpdates (default) or serves a Telegram webhook, | |
| and replies via the Muse Spark brain (OpenCode Zen) with Firebase memory. | |
| ALL Telegram network I/O goes through telegram_transport.py: | |
| TELEGRAM_TRANSPORT=auto|direct|proxy, TELEGRAM_PROXY_URL, TELEGRAM_PROXY_AUTH | |
| See telegram_transport.py for the full variable list and log markers. | |
| Secrets (Space Secrets / .env — NEVER hardcoded): | |
| TELEGRAM_BOT_TOKEN (required), OPENCODE_API_KEY, OPENCODE_MODEL, | |
| FIREBASE_CREDENTIALS_JSON, JARVIS_TG_UID, N8N_REMINDER_WEBHOOK, | |
| TELEGRAM_MODE=polling|webhook, SPACE_PUBLIC_URL, TELEGRAM_WEBHOOK_SECRET | |
| Endpoints on :7860 (HF Docker requirement): | |
| / health (model, polls, offset, last error, transport) | |
| /diag HF-environment network test matrix (JSON, no secrets) | |
| /webhook/<secret> Telegram webhook receiver (webhook mode only) | |
| JARVIS brain/skills below are unchanged behavior: Firebase memory/notes/ | |
| reminders, PC-status heartbeat, Firebase pc-command queue (executed on the PC | |
| by pc_heartbeat.py with full MCP), typo-tolerant commands, model-first 1.3 | |
| answers with hardcoded fallback only when the model fails. | |
| """ | |
| import os | |
| import re | |
| import json | |
| import time | |
| import signal | |
| import threading | |
| import requests # brain (Zen) + Firebase-adjacent posts; Telegram uses transport | |
| import telegram_transport as tg | |
| # ── .env (local dev only; HF uses Space Secrets) ──────────────────── | |
| def _load_dotenv(path=".env"): | |
| try: | |
| if not os.path.exists(path): | |
| return | |
| with open(path, "r", encoding="utf-8") as f: | |
| for line in f: | |
| line = line.strip() | |
| if not line or line.startswith("#") or "=" not in line: | |
| continue | |
| k, v = line.split("=", 1) | |
| k = k.strip(); v = v.strip().strip('"').strip("'") | |
| if k and v and k not in os.environ: | |
| os.environ[k] = v | |
| except Exception: | |
| pass | |
| _load_dotenv(".env") | |
| # ── Required secrets (fail fast, no hardcoded fallbacks) ──────────── | |
| BOT = (os.environ.get("TELEGRAM_BOT_TOKEN") or "").strip().strip('"').strip("'") | |
| if not BOT: | |
| print("TELEGRAM_NO_TOKEN TELEGRAM_BOT_TOKEN is not set. " | |
| "Add it to Hugging Face Space Secrets (or local .env).", flush=True) | |
| raise SystemExit(1) | |
| ZEN_URL = "https://opencode.ai/zen/v1/responses" | |
| MODEL = (os.environ.get("OPENCODE_MODEL") or "muse-spark-1.3-contributor-free").strip() | |
| KEY = (os.environ.get("OPENCODE_API_KEY") or "").strip() | |
| MODE = (os.environ.get("TELEGRAM_MODE") or "polling").strip().lower() | |
| SPACE_PUBLIC_URL = (os.environ.get("SPACE_PUBLIC_URL") or "").strip().rstrip("/") | |
| WEBHOOK_SECRET = (os.environ.get("TELEGRAM_WEBHOOK_SECRET") or "").strip() | |
| PC_BRIDGE_URL = (os.environ.get("PC_BRIDGE_URL") or "").strip() | |
| _poll_status = {"last_poll": "never", "last_err": "", "offset": 0, "polls": 0, | |
| "transport": tg.TRANSPORT, "replies": 0} | |
| _last_chat_id = None | |
| _shutdown = False | |
| def _on_signal(signum, frame): | |
| global _shutdown | |
| print(f"shutdown signal {signum} — finishing current poll, sir.", flush=True) | |
| _shutdown = True | |
| for _sig in ("SIGTERM", "SIGINT"): | |
| try: | |
| signal.signal(getattr(signal, _sig), _on_signal) | |
| except Exception: | |
| pass | |
| # ── Reminders support (Firebase or local fallback) ────────────────── | |
| try: | |
| import reminders as _rem | |
| except Exception: | |
| _rem = None | |
| def _init_firestore(): | |
| try: | |
| import firebase_admin | |
| from firebase_admin import credentials, firestore | |
| if not firebase_admin._apps: | |
| js = (os.environ.get("FIREBASE_CREDENTIALS_JSON") or "").strip() | |
| if js: | |
| firebase_admin.initialize_app(credentials.Certificate(json.loads(js))) | |
| else: | |
| p = os.path.join(os.path.dirname(__file__), "firebase_service_account.json") | |
| if os.path.exists(p): | |
| firebase_admin.initialize_app(credentials.Certificate(p)) | |
| return firestore.client() | |
| except Exception: | |
| return None | |
| def _pc_status(): | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return None, {"error": "no firebase"}, 9999 | |
| doc = db.collection("jarvis_status").document("pc").get() | |
| if doc.exists: | |
| d = doc.to_dict() | |
| age = time.time() - d.get("last_seen", 0) | |
| return age < 90, d, age | |
| except Exception as e: | |
| return None, {"error": str(e)}, 9999 | |
| return False, {}, 9999 | |
| def _chat_history_get(chat_id, limit=6): | |
| """Shared BAT<->bot conversation via memory_cloud (single doc, no index).""" | |
| try: | |
| import memory_cloud | |
| return [{"r": m.get("r"), "t": m.get("t", "")} for m in memory_cloud.chat_load(limit)] | |
| except Exception: | |
| pass | |
| return [] | |
| def _chat_history_put(chat_id, user_text, reply_text): | |
| try: | |
| import memory_cloud | |
| memory_cloud.chat_save("u", user_text or "", src=f"tg:{chat_id}") | |
| memory_cloud.chat_save("a", reply_text or "", src=f"tg:{chat_id}") | |
| except Exception: | |
| pass | |
| def _cloud_reminder_loop(): | |
| """Fire due Firebase reminders to Telegram even when the PC is off.""" | |
| db = _init_firestore() | |
| n8n_url = (os.environ.get("N8N_REMINDER_WEBHOOK") or "").strip() | |
| while not _shutdown: | |
| try: | |
| if db: | |
| now = time.time() | |
| for snap in db.collection("jarvis_reminders").where("due", "<=", now).stream(): | |
| task = (snap.to_dict() or {}).get("task") | |
| try: | |
| snap.reference.delete() | |
| except Exception: | |
| pass | |
| if task and _last_chat_id: | |
| try: | |
| tg.send_message(_last_chat_id, f"\u23f0 Reminder, sir: {task}") | |
| except Exception as e: | |
| print("reminder send err", tg._redact(str(e)), flush=True) | |
| print("cloud reminder fired:", task, flush=True) | |
| if task and n8n_url: | |
| try: | |
| requests.post(n8n_url, json={"text": f"Reminder: {task}"}, timeout=10) | |
| except Exception: | |
| pass | |
| except Exception: | |
| pass | |
| time.sleep(15) | |
| import datetime as _dt | |
| def _norm_triggers(text): | |
| """Fix jammed/misspelled action triggers before matching (speech-to-text garble).""" | |
| t = text.lower() | |
| t = re.sub(r"\bremind\s*me\b", "remind me", t) | |
| t = re.sub(r"\bremid\s*me\b", "remind me", t) # "remidmei want..." -> "remind me..." | |
| t = re.sub(r"\bremider\b", "reminder", t) | |
| t = re.sub(r"\bchage\b", "change", t) | |
| t = re.sub(r"\bchageto\b", "change to", t) # "chageto1121" | |
| t = re.sub(r"\bcnacel\b", "cancel", t) | |
| t = re.sub(r"\bdelet\b", "delete", t) | |
| return t | |
| def _latest_reminder(): | |
| """Newest pending reminder doc (or None). Streams all — count is tiny.""" | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return None, None | |
| docs = list(db.collection("jarvis_reminders").stream()) | |
| if not docs: | |
| return db, None | |
| docs.sort(key=lambda s: (s.to_dict() or {}).get("due", 0)) | |
| return db, docs[-1] | |
| except Exception: | |
| return None, None | |
| def _manage_reminder(text): | |
| """Edit/list/cancel the pending reminder. Returns reply or None if not applicable.""" | |
| low = _norm_triggers(text) | |
| if ("reminder" not in low and "remind" not in low | |
| and not any(k in low for k in ["change", "switch", "move", "update", | |
| "cancel", "delete", "remove", "forget"])): | |
| return None | |
| db, doc = _latest_reminder() | |
| if db is None: | |
| return "Couldn't reach the reminders database, sir." | |
| d = (doc.to_dict() or {}) if doc else {} | |
| if any(k in low for k in ["cancel", "delete", "remove", "forget"]): | |
| if not doc: | |
| return "No reminder to cancel, sir — none scheduled." | |
| doc.reference.delete() | |
| return f"Cancelled, sir — no more reminder to {d.get('task', '...')}." | |
| if "change" in low or "switch" in low or "move" in low or "update" in low: | |
| if not doc: | |
| return "No reminder to change, sir — tell me a new one instead." | |
| m = re.search(r"(\d{1,2})\s*[:.]?\s*(\d{2})\s*(am|pm|a\.m\.|p\.m\.)?\b", low) | |
| if not m: | |
| return "Change it to what time, sir?" | |
| hh, mm, ap = int(m.group(1)), int(m.group(2)), (m.group(3) or "") | |
| if "p" in ap and hh < 12: | |
| hh += 12 | |
| if "a" in ap and hh == 12: | |
| hh = 0 | |
| wat = _dt.datetime.now(_dt.timezone.utc) + _dt.timedelta(hours=1) | |
| target = wat.replace(hour=hh, minute=mm, second=0, microsecond=0) | |
| now = time.time() | |
| if target.timestamp() <= now + 3600: | |
| target = target + _dt.timedelta(days=1) | |
| doc.reference.update({"due": target.timestamp() - 3600}) | |
| when = (target).strftime("%I:%M %p").lstrip("0") | |
| return f"Done, sir — reminder moved to {when} WAT to {d.get('task', '...')}." | |
| if any(k in low for k in ["the reminder", "my reminder", "show reminder", "list reminder", | |
| "what.*remind", "pending reminder"]): | |
| if not doc: | |
| return "No reminders scheduled, sir." | |
| when = (_dt.datetime.fromtimestamp(d.get("due", 0), _dt.timezone.utc) | |
| + _dt.timedelta(hours=1)).strftime("%I:%M %p").lstrip("0") | |
| return f"Your reminder, sir: {d.get('task', '...')} at {when} WAT." | |
| return None | |
| def _parse_cloud_reminder(text): | |
| low = _norm_triggers(text) | |
| task, due_ts = "", None | |
| body = re.split(r"remind me (?:to )?", low, maxsplit=1)[-1] | |
| if "wake me up" in low: | |
| body = low.split("wake me up", 1)[-1] | |
| now = time.time() | |
| m = re.search(r"in (\d+)\s*(minute|min|hour|hr|second|sec)s?", body) | |
| if m: | |
| n = int(m.group(1)); unit = m.group(2) | |
| if unit.startswith("hour") or unit.startswith("hr"): | |
| delta = n * 3600 | |
| elif unit.startswith("minute") or unit.startswith("min"): | |
| delta = n * 60 | |
| else: | |
| delta = n | |
| due_ts = now + delta | |
| task = re.sub(r"in \d+\s*[\w]+s?", "", body).strip(" .") | |
| else: | |
| # Absolute time: "at" optional, colon optional ("at 10:48", "10 48pm", "10:48pm"). | |
| m = re.search(r"(?:\bat\s+)?(\d{1,2})\s*[:.]?\s*(\d{2})\s*(am|pm|a\.m\.|p\.m\.)?\b", body) | |
| if m: | |
| # "at HH:MM" means the user's wall clock (WAT = UTC+1); server runs UTC. | |
| hh, mm, ap = int(m.group(1)), int(m.group(2)), (m.group(3) or "") | |
| if 0 <= hh <= 23 and 0 <= mm <= 59: | |
| if "p" in ap and hh < 12: | |
| hh += 12 | |
| if "a" in ap and hh == 12: | |
| hh = 0 | |
| wat = _dt.datetime.now(_dt.timezone.utc) + _dt.timedelta(hours=1) | |
| target = wat.replace(hour=hh, minute=mm, second=0, microsecond=0) | |
| if now - 300 <= target.timestamp() - 3600 <= now: | |
| due_ts = now + 30 # just passed (<5 min) → nudge right now | |
| else: | |
| if target.timestamp() <= now + 3600: | |
| target = target + _dt.timedelta(days=1) | |
| due_ts = target.timestamp() - 3600 | |
| task = re.sub(r"(?:\bat\s+)?\d{1,2}\s*[:.]?\s*\d{2}\s*(?:am|pm|a\.m\.|p\.m\.)?\b", | |
| "", body).strip(" .") | |
| # Strip leftover fragments like "I." from speech-to-text garble. | |
| task = re.sub(r"\bif\s+something\b", "something", task).strip(" .") | |
| if due_ts is None and not task: | |
| return "What should I remind you about, and when, sir?" | |
| if due_ts is None: | |
| return f"Remind you {task} — when, sir? (e.g. in 30 minutes, or at 10:48 PM)" | |
| if not task: | |
| when_q = (_dt.datetime.fromtimestamp(due_ts, _dt.timezone.utc) | |
| + _dt.timedelta(hours=1)).strftime("%I:%M %p").lstrip("0") | |
| return f"At {when_q} WAT — remind you of what, sir?" | |
| if not task: | |
| task = "reminder" | |
| db = _init_firestore() | |
| if db is None: | |
| return "Couldn't save the reminder, sir — database unreachable." | |
| try: | |
| db.collection("jarvis_reminders").add({"task": task, "due": due_ts}) | |
| when = (_dt.datetime.fromtimestamp(due_ts, _dt.timezone.utc) | |
| + _dt.timedelta(hours=1)).strftime("%I:%M %p").lstrip("0") | |
| return f"Right away, sir. I'll remind you at {when} WAT to {task} — sent to Telegram even if my PC is off." | |
| except Exception as e: | |
| return f"Couldn't save reminder: {e}" | |
| def _enqueue_pc_command(text, chat_id): | |
| try: | |
| db = _init_firestore() | |
| if db is None: | |
| return False | |
| db.collection("jarvis_pc_commands").add({ | |
| "text": text, "chat_id": str(chat_id or ""), | |
| "created": time.time(), "status": "pending"}) | |
| return True | |
| except Exception: | |
| return False | |
| def _try_pc_bridge(text): | |
| low = text.lower() | |
| trigger = any(k in low for k in [" open ", "create a file", "screenshot", "play ", | |
| "pause", "youtube", "stop music", "close ", | |
| "search youtube", "open app", "control", "volume"]) | |
| if not trigger or not PC_BRIDGE_URL: | |
| return None | |
| try: | |
| r = requests.post(PC_BRIDGE_URL, json={"text": text}, timeout=25) | |
| if r.status_code == 200: | |
| return (r.json() or {}).get("reply") | |
| except Exception: | |
| pass | |
| return None | |
| def brain(text, _depth=0): | |
| # Approve/reject with auto-resume: approving a Telegram PC request | |
| # automatically continues the original command (no re-send needed). | |
| try: | |
| _m = re.search(r"\b(approve|reject)\s+(ap-[0-9a-f]{4,8})\b", (text or "").lower()) | |
| if _m and _depth < 2: | |
| from jarvis_core import approvals as _ap2, audit as _au2 | |
| _a2 = _ap2.decide(_m.group(2), _m.group(1) == "approve", by="boss") | |
| if _a2: | |
| try: | |
| _au2.record("boss", "telegram", f"{_m.group(1)} {_a2['id']}", | |
| tool="approvals", status="SUCCESS", | |
| result=(_a2.get("action") or "")[:150]) | |
| except Exception: | |
| pass | |
| _orig = ((_a2.get("meta") or {}).get("orig_text") or "").strip() | |
| if _m.group(1) == "approve" and _orig: | |
| _resume = brain(_orig, _depth + 1) | |
| return f"Approved, sir — continuing.\n{_resume}" | |
| except Exception: | |
| pass | |
| # Central router first: missions/jobs/approvals/health/routines/audit/memory. | |
| try: | |
| from jarvis_core.router import handle as core_handle | |
| routed = core_handle(text, channel="telegram") | |
| if routed: | |
| try: | |
| from jarvis_core import audit as _audit | |
| _audit.record("boss", "telegram", text[:120], tool="router", | |
| status="SUCCESS", result=routed[:150]) | |
| except Exception: | |
| pass | |
| return routed | |
| except Exception: | |
| pass | |
| # Full local brain first when running on the PC (MCP, Chrome, screenshots). | |
| try: | |
| import local_brain as lb | |
| ans = lb.handle(text) | |
| if ans: | |
| return ans | |
| except Exception: | |
| pass | |
| pcb = _try_pc_bridge(text) | |
| if pcb: | |
| return pcb | |
| low = _norm_triggers(text) | |
| nospace = low.replace(" ", "") | |
| # Reminder intents ALWAYS take the real handler — the model must never | |
| # roleplay setting one. ("remind", "remid", "reminder", "wake me up") | |
| _has_time = bool(re.search(r"(\d{1,2})\s*[:.]?\s*(\d{2})\s*(am|pm|a\.m\.|p\.m\.)?\b", low)) | |
| _edit_verb = any(k in low for k in ["change", "switch", "move", "update"]) | |
| _kill_verb = any(k in low for k in ["cancel", "delete", "remove", "forget"]) | |
| if ("wake me up" in low or "remind" in low or "remid" in low | |
| or (_edit_verb and (_has_time or " it" in low or " that" in low or "reminder" in low)) | |
| or (_kill_verb and (" it" in low or " that" in low or "reminder" in low))): | |
| managed = _manage_reminder(text) | |
| if managed: | |
| return managed | |
| return _parse_cloud_reminder(text) | |
| # Identity first — never dodge the model question. | |
| if any(k in low for k in ["which model", "what model", "what llm", "which llm", | |
| "brian", "brain llm", "what are you running on", | |
| "model are u", "model are you"]): | |
| return ("I run on Muse Spark, sir — model muse-spark-1.3-contributor-free, " | |
| "served via OpenCode Zen. Same brain on your BAT and here.") | |
| # Status questions get the detailed heartbeat reply — never the generic OFF text. | |
| if "is my pc on" in low or "is pc on" in low or "pc status" in low: | |
| on, d, age = _pc_status() | |
| if on is None: | |
| return f"I couldn't check PC status, sir: {d.get('error')}" | |
| if on: | |
| return (f"Yes, your PC is ON, sir — last heartbeat {int(age)}s ago " | |
| f"({d.get('last_seen_str')}). {d.get('details', '')}") | |
| return (f"Your PC is OFF, sir — no heartbeat for {int(age)}s " | |
| f"(last seen {d.get('last_seen_str', 'unknown')}). " | |
| "If the PC is actually on, open Jarvis_Local.bat so the heartbeat resumes.") | |
| has_access = any(k in low for k in ["access", "acess", "acces"]) or \ | |
| any(k in nospace for k in ["accessmypc", "acessmypc"]) | |
| has_pc = "pc" in low or "mypc" in nospace | |
| needs_pc = has_access and has_pc | |
| if not needs_pc: | |
| needs_pc = any(k in low for k in [ | |
| "downloads folder", "desktop folder", "documents folder", "what's in my", | |
| "what is in my", "list my files", "my files", "open my", "open the", | |
| "screenshot", "play video", "play music", "stop music", "volume", | |
| "search youtube", "open app", "open application", "create a file", | |
| "what is on my screen", "control my pc", "close the", "start the", | |
| "run program", "my pc's", "my pc ", "mypc", "navigate to"]) | |
| if needs_pc: | |
| try: | |
| from jarvis_core import approvals as _ap, audit as _au | |
| _risk = _ap.classify(text) | |
| except Exception: | |
| _ap, _au, _risk = None, None, "LOW_RISK" | |
| if _risk in ("MEDIUM_RISK", "HIGH_RISK") and _ap is not None: | |
| try: | |
| from jarvis_core import permissions as _pm | |
| _grant = _pm.recent_text_grant(text) | |
| except Exception: | |
| _grant = None | |
| if _grant is None: | |
| a = _ap.request(text, channel="telegram", actor="boss", | |
| meta={"orig_text": text}) | |
| try: | |
| _au.record("boss", "telegram", text[:120], tool="pc_queue", | |
| approval=_risk, approval_status=a["status"], | |
| status="SUCCESS", result=f"approval {a['id']}") | |
| except Exception: | |
| pass | |
| if a["status"] != "APPROVED": | |
| return ("That one needs your approval first, sir.\n" + _ap.format_request(a)) | |
| on, d, age = _pc_status() | |
| if on is True: | |
| if not PC_BRIDGE_URL: | |
| if _enqueue_pc_command(text, _last_chat_id): | |
| return ("Yes, sir — I have full access to your PC right now. " | |
| "I've queued your request; your PC will reply here in a few seconds.") | |
| return "Your PC is ON, sir, but I couldn't queue the task. Ask me directly on the PC." | |
| return "Your PC is ON, sir, but I couldn't reach it for that task right now." | |
| if on is False: | |
| return ("Your PC is OFF, sir, so I can't access your files or control apps. " | |
| "Turn it on (with Jarvis running) and ask again.") | |
| if _enqueue_pc_command(text, _last_chat_id): | |
| return "I've queued that for your PC, sir — it will run when your PC comes online." | |
| if "cold call" in low: | |
| return ("Cold calling is available on your PC BAT only, sir — open Jarvis_Local.bat " | |
| "and say 'cold call +234... say hello'.") | |
| if not KEY: | |
| return "Missing OPENCODE_API_KEY, sir." | |
| if "pending reminders" in low or "list reminders" in low or "what are my reminders" in low: | |
| db = _init_firestore() | |
| if db is None: | |
| return "Couldn't reach the reminders database, sir." | |
| try: | |
| items = [s.to_dict() for s in db.collection("jarvis_reminders").stream()] | |
| if not items: | |
| return "No reminders scheduled, sir." | |
| txt = " ".join( | |
| f"{i['task']} at {_dt.datetime.fromtimestamp(i['due']).strftime('%I:%M %p')}," | |
| for i in items) | |
| return f"Your reminders, sir: {txt}" | |
| except Exception as e: | |
| return f"Couldn't list reminders: {e}" | |
| if "save this to" in low and "database" in low: | |
| try: | |
| import memory_cloud | |
| ok = memory_cloud.remember(text) | |
| return ("Saved to your database, sir — Firebase \"jarvis_memory\" " | |
| "(project jarvisai-994bd).") if ok else "I couldn't save that, sir — database offline." | |
| except Exception as e: | |
| return f"Save failed: {e}" | |
| if "remember that" in low: | |
| try: | |
| import memory_cloud | |
| fact = text.lower().split("remember that", 1)[1].strip(" .") | |
| ok = memory_cloud.remember(fact) | |
| return "Right away, I'll remember that, sir — stored in Firebase \"jarvis_memory\"." \ | |
| if ok else "Couldn't save, sir." | |
| except Exception: | |
| pass | |
| if "is my pc on" in low or "is pc on" in low or "pc status" in low: | |
| on, d, age = _pc_status() | |
| if on is None: | |
| return f"I couldn't check PC status, sir: {d.get('error')}" | |
| if on: | |
| return (f"Yes, your PC is ON, sir — last heartbeat {int(age)}s ago " | |
| f"({d.get('last_seen_str')}). {d.get('details', '')}") | |
| return f"Your PC is OFF, sir — last seen {int(age)}s ago at {d.get('last_seen_str', 'unknown')}." | |
| # ── All remaining questions go to the 1.3 model (MCP-aware) ── | |
| _MCP_CAPS = ("You have full PC control via your local executor (71 MCP tools): open apps/files/sites, " | |
| "screenshots + screen vision, browser with 8 Chrome profiles (Default=haywhyeditz TikTok), " | |
| "YouTube/TikTok automation, volume, notes/memory, reminders. " | |
| "Data lives in Firebase project jarvisai-994bd (jarvis_memory, jarvis_notes, " | |
| "jarvis_reminders, jarvis_status/pc). " | |
| "Identity: you are Jarvis, model " + MODEL + " via " | |
| "OpenCode Zen — say so plainly when asked, never dodge. " | |
| "You CANNOT set, change, or cancel reminders yourself — if the user wants " | |
| "any of that, say you need the exact task and time, and never claim it is done.") | |
| try: | |
| _now_utc = _dt.datetime.now(_dt.timezone.utc) | |
| _now_wat = _now_utc + _dt.timedelta(hours=1) | |
| _clock = (f"Current time: {_now_wat.strftime('%I:%M:%S %p').lstrip('0')} WAT " | |
| f"({_now_utc.strftime('%H:%M:%S')} UTC) on {_now_wat.strftime('%A, %B %d, %Y')}. " | |
| "When asked for the time, always give the FULL time with seconds and timezone, sir.") | |
| except Exception: | |
| _clock = "" | |
| try: | |
| _msgs = [] | |
| for h in _chat_history_get(_last_chat_id): | |
| _msgs.append({"role": "user" if h.get("r") == "u" else "assistant", | |
| "content": h.get("t", "")}) | |
| _msgs.append({"role": "user", "content": text}) | |
| _mem = "" | |
| try: | |
| import memory_cloud | |
| _mem = (memory_cloud.recall(8) or "")[:800] | |
| except Exception: | |
| pass | |
| _ctx = ("Recent conversation: " + " | ".join( | |
| f"{'Boss' if m['role'] == 'user' else 'JARVIS'}: {m['content']}" for m in _msgs[:-1]) | |
| if len(_msgs) > 1 else "No prior conversation.") | |
| if _mem: | |
| _ctx += f" Remembered facts: {_mem}." | |
| payload = {"model": MODEL, "input": _msgs, | |
| "instructions": "You are J.A.R.V.I.S., witty loyal assistant. Under 2 sentences. " | |
| + _MCP_CAPS + " " + _clock + " " + _ctx} | |
| headers = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"} | |
| r = requests.post(ZEN_URL, json=payload, headers=headers, timeout=45) | |
| data = r.json() | |
| out = [] | |
| for item in data.get("output") or []: | |
| if item.get("type") == "message": | |
| for c in item.get("content") or []: | |
| if c.get("type") == "output_text": | |
| out.append(c.get("text", "")) | |
| ans = "".join(out).strip() | |
| if ans: | |
| return ans | |
| except Exception as e: | |
| print("model err", str(e)[:200], flush=True) | |
| # ── Offline fallback only (model failed) ── | |
| if any(k in low for k in ["where is your database", "where is your memory", "where do you store", | |
| "your database name", "what is your database", "where do you keep", | |
| "where is your data", "where do you save", "database name"]): | |
| return ("My data lives in Firebase, sir — project \"jarvisai-994bd\". " | |
| "Memory & conversation history: \"jarvis_memory\", notes: \"jarvis_notes\", " | |
| "reminders: \"jarvis_reminders\", and your PC status: \"jarvis_status/pc\". " | |
| "It's cloud-hosted, so I can recall it even when this PC is off.") | |
| if "where" in low and "conversation" in low and ("save" in low or "store" in low): | |
| return "Conversations are saved in Firebase jarvis_memory, sir." | |
| if "collect" in low and "details" in low and "pc" in low: | |
| on, d, age = _pc_status() | |
| if on: | |
| return f"Collected from your PC (ON): {d.get('details', '')} — heartbeat {int(age)}s ago, sir." | |
| return "Your PC is OFF, sir — I can't collect fresh details until it's on. Last details: " + \ | |
| d.get("details", "none") | |
| if "what time" in low or "time is it" in low or "whatisthetime" in nospace: | |
| _wat = _dt.datetime.now(_dt.timezone.utc) + _dt.timedelta(hours=1) | |
| return (f"It is {_wat.strftime('%I:%M:%S %p').lstrip('0')} WAT " | |
| f"({_wat.strftime('%A, %B %d, %Y')}), sir.") | |
| if "hello" in low and len(low) < 20: | |
| return "At your service, sir. What do you need?" | |
| return "(no reply)" | |
| def handle_update_text(text, chat_id): | |
| """Shared by polling loop and webhook handler. Returns reply string.""" | |
| global _last_chat_id | |
| _last_chat_id = chat_id | |
| print(f"\U0001f4e9 {text} from {chat_id}", flush=True) | |
| reply = brain(text) | |
| _chat_history_put(chat_id, text, reply) | |
| tg.send_message(chat_id, reply) | |
| _poll_status["replies"] += 1 | |
| print(f"\U0001f4e4 {reply[:80]}", flush=True) | |
| return reply | |
| # ── HTTP server: / health, /diag network matrix, /webhook receiver ── | |
| def _serve_http(): | |
| from http.server import BaseHTTPRequestHandler, HTTPServer | |
| class H(BaseHTTPRequestHandler): | |
| def do_GET(self): | |
| try: | |
| if self.path == "/dashboard" or self.path.startswith("/dashboard?"): | |
| from urllib.parse import urlparse, parse_qs | |
| try: | |
| from jarvis_core import missions, jobs, health as _h, audit as _a, events as _e | |
| from jarvis_core import approvals as _ap | |
| qs = parse_qs(urlparse(self.path).query) | |
| _key_ok = bool(WEBHOOK_SECRET) and (qs.get("key", [""])[0] == WEBHOOK_SECRET) | |
| _acted = "" | |
| _act, _aid = (qs.get("action", [""])[0] or "").lower(), qs.get("id", [""])[0] or "" | |
| if _act in ("approve", "reject") and _aid: | |
| if not _key_ok: | |
| _acted = "Missing or wrong ?key — approval NOT changed. Append ?key=YOUR_TELEGRAM_WEBHOOK_SECRET." | |
| else: | |
| _d = _ap.decide(_aid, _act == "approve", by="dashboard") | |
| if _d: | |
| _acted = f"{_aid} {_d.get('status')}." | |
| try: | |
| _a.record("boss", "dashboard", f"{_act} {_aid}", | |
| tool="approvals", status="SUCCESS", | |
| result=(_d.get("action") or "")[:150]) | |
| except Exception: | |
| pass | |
| else: | |
| _acted = f"{_aid} not found or already decided." | |
| st = _h.all_status() | |
| mrun = len([m for m in missions.list_all(active_only=True)]) | |
| jrun = len(jobs.list_all("RUNNING")) + len(jobs.list_all("QUEUED")) | |
| jfail = len(jobs.list_all("FAILED")) | |
| evts = _e.recent(5) | |
| acts = _a.recent(5) | |
| errs = _a.failures(3) | |
| L = ["JARVIS CONTROL DASHBOARD", "", "SYSTEM STATUS"] | |
| L += [f"{k}: {v['status']} ({v['detail']})" for k, v in st.items()] | |
| L += ["", f"MISSIONS active: {mrun}", | |
| f"JOBS running/queued: {jrun} failed: {jfail}", "", | |
| "PENDING APPROVALS"] | |
| _pend = _ap.pending()[:5] | |
| if _pend: | |
| for _p in _pend: | |
| _pid = _p.get("id") | |
| L.append(f"- {_pid} [{_p.get('risk')}] {_p.get('action')}") | |
| if _key_ok: | |
| L.append(f" approve: /dashboard?action=approve&id={_pid}&key={WEBHOOK_SECRET}") | |
| L.append(f" reject: /dashboard?action=reject&id={_pid}&key={WEBHOOK_SECRET}") | |
| else: | |
| L.append(" (add ?key=YOUR_TELEGRAM_WEBHOOK_SECRET to get one-tap links)") | |
| else: | |
| L.append("- none") | |
| if _acted: | |
| L += ["", f"ACTION: {_acted}"] | |
| L += ["", "RECENT EVENTS"] | |
| L += [f"- {e.get('type')} [{e.get('decision')}]" for e in evts] or ["- none"] | |
| L += ["", "RECENT ACTIONS"] | |
| L += [f"- {_a.format_row(a)}" for a in acts] or ["- none"] | |
| L += ["", "ERRORS"] | |
| L += [f"- {_a.format_row(a)}" for a in errs] or ["- none"] | |
| body = "\n".join(L).encode() | |
| except Exception as e: | |
| body = f"dashboard unavailable: {e}".encode() | |
| self.send_response(200) | |
| self.send_header("Content-type", "text/plain") | |
| self.end_headers() | |
| self.wfile.write(body) | |
| return | |
| if self.path == "/diag": | |
| body = json.dumps(tg.diag(), indent=1).encode() | |
| self.send_response(200) | |
| self.send_header("Content-type", "application/json") | |
| self.end_headers() | |
| self.wfile.write(body) | |
| return | |
| global _tg_ok_cache, _tg_ok_at | |
| try: | |
| now = time.time() | |
| except Exception: | |
| now = 0 | |
| if now - globals().get("_tg_ok_at", 0) > 60: | |
| try: | |
| me = tg.get_me() | |
| _tg_ok_cache = f"tg getMe ok bot={(me.get('result') or {}).get('username', '?')}" | |
| except tg.TelegramTransportError as e: | |
| _tg_ok_cache = f"{e.marker}: {tg._redact(str(e))[:100]}" | |
| except Exception as e: | |
| _tg_ok_cache = f"tg err {str(e)[:100]}" | |
| globals()["_tg_ok_at"] = now | |
| tg_ok = globals().get("_tg_ok_cache", "tg n/a") | |
| body = (f"JARVIS Telegram bot running\nModel {MODEL}\nMode {MODE}\n" | |
| f"Transport {tg.TRANSPORT}\nKey {'yes' if KEY else 'no'}\n" | |
| f"Polls {_poll_status['polls']} last:{_poll_status['last_poll']} " | |
| f"err:{_poll_status['last_err']}\nTG:{tg_ok}\n" | |
| f"Offset {_poll_status['offset']} Replies {_poll_status['replies']}").encode() | |
| self.send_response(200) | |
| self.send_header("Content-type", "text/plain") | |
| self.end_headers() | |
| self.wfile.write(body) | |
| except Exception as e: | |
| try: | |
| self.send_response(500) | |
| self.end_headers() | |
| except Exception: | |
| pass | |
| print("http err", str(e)[:150], flush=True) | |
| def do_POST(self): | |
| # Telegram webhook receiver: POST /webhook/<secret> | |
| try: | |
| if MODE != "webhook" or not WEBHOOK_SECRET or \ | |
| self.path != f"/webhook/{WEBHOOK_SECRET}": | |
| self.send_response(404) | |
| self.end_headers() | |
| return | |
| length = int(self.headers.get("Content-Length") or 0) | |
| raw = self.rfile.read(length) if length else b"" | |
| self.send_response(200) | |
| self.end_headers() | |
| try: | |
| upd = json.loads(raw.decode("utf-8") or "{}") | |
| msg = upd.get("message") or {} | |
| text = msg.get("text") or "" | |
| cid = (msg.get("chat") or {}).get("id") | |
| if text and cid: | |
| threading.Thread(target=handle_update_text, | |
| args=(text, cid), daemon=True).start() | |
| except Exception as e: | |
| print("webhook update err", str(e)[:150], flush=True) | |
| except Exception as e: | |
| print("webhook err", str(e)[:150], flush=True) | |
| def log_message(self, *a): | |
| pass | |
| s = HTTPServer(("0.0.0.0", 7860), H) | |
| threading.Thread(target=s.serve_forever, daemon=True).start() | |
| print("HTTP server on :7860 (/ /diag /webhook)", flush=True) | |
| def _poll_loop(): | |
| global _last_chat_id | |
| offset = 0 | |
| try: | |
| tg.delete_webhook(drop_pending=True) | |
| print("deleteWebhook called (sole poller)", flush=True) | |
| except tg.TelegramTransportError as e: | |
| print(f"deleteWebhook {e.marker}: {tg._redact(str(e))[:150]}", flush=True) | |
| print(f"JARVIS Telegram poller live (model {MODEL}, transport {tg.TRANSPORT})", flush=True) | |
| while not _shutdown: | |
| try: | |
| _poll_status["polls"] += 1 | |
| _poll_status["last_poll"] = time.strftime("%H:%M:%S") | |
| data = tg.get_updates(offset) | |
| _poll_status["last_err"] = "" | |
| for upd in data.get("result") or []: | |
| offset = upd["update_id"] + 1 | |
| _poll_status["offset"] = offset | |
| msg = upd.get("message") or {} | |
| chat = msg.get("chat") or {} | |
| text = msg.get("text") or "" | |
| cid = chat.get("id") | |
| if not text or not cid: | |
| continue | |
| try: | |
| tg.send_chat_action(cid) | |
| except Exception: | |
| pass | |
| handle_update_text(text, cid) | |
| if not _shutdown: | |
| time.sleep(2) # never tight-loop the relay, even on empty results | |
| except tg.TelegramTransportError as e: | |
| _poll_status["last_err"] = f"{e.marker}: {tg._redact(str(e))[:100]}" | |
| print(f"poll {e.marker} {tg._redact(str(e))[:150]}", flush=True) | |
| # A rate-limited relay must be given a full minute to drain; | |
| # anything shorter re-trips the limiter and self-perpetuates. | |
| time.sleep(60 if "rate_limited" in str(e) else 5) | |
| except Exception as e: | |
| _poll_status["last_err"] = str(e)[:120] | |
| print("poll err", str(e)[:200], flush=True) | |
| time.sleep(3) | |
| def main(): | |
| _serve_http() | |
| threading.Thread(target=_cloud_reminder_loop, daemon=True).start() | |
| if MODE == "webhook": | |
| if not SPACE_PUBLIC_URL or not WEBHOOK_SECRET: | |
| print("TELEGRAM_WEBHOOK_INCOMPLETE set SPACE_PUBLIC_URL + TELEGRAM_WEBHOOK_SECRET, " | |
| "falling back to polling.", flush=True) | |
| _poll_loop() | |
| return | |
| url = f"{SPACE_PUBLIC_URL}/webhook/{WEBHOOK_SECRET}" | |
| try: | |
| tg.set_webhook(url) | |
| print(f"TELEGRAM_WEBHOOK_ACTIVE {SPACE_PUBLIC_URL}/webhook/<secret>", flush=True) | |
| except tg.TelegramTransportError as e: | |
| print(f"webhook setup {e.marker} — falling back to polling.", flush=True) | |
| _poll_loop() | |
| return | |
| while not _shutdown: | |
| time.sleep(10) | |
| return | |
| _poll_loop() | |
| if __name__ == "__main__": | |
| main() | |