Update app.py

app.py

@@ -4,6 +4,9 @@ import datetime
 import threading
 import sys
 import math
+import json
+import random
+import logging
 from typing import Optional, Dict, Any
 
 try:
@@ -14,7 +17,14 @@ except ImportError:
 
 from flask import Flask, request, jsonify
 
-# ========== Configuration ==========
+# db_signals helpers you already have; we add read_user_json_file below.
+from db_signals import (
+    fetch_authenticity_token_and_commit_oid,
+    update_user_json_file,
+    # If you already have a reader, import it instead of defining here.
+)
+
+# ================ Configuration ================
 API_URL = "https://research.titanfx.com/api/live-rate?group=forex"
 API_HEADERS = {
     "referer": "https://research.titanfx.com/instruments/gbpusd",
@@ -25,16 +35,76 @@ API_HEADERS = {
 }
 
 SYMBOL_DEFAULT = "XAUUSD"
-PRINT_INTERVAL_SECONDS = 5
-REQUEST_TIMEOUT_SECONDS = 5
+
+# Polling and retry behavior
+REQUEST_TIMEOUT_SECONDS = 4
 MAX_RETRIES = 5
-RETRY_BACKOFF_SECONDS = 1.5
+RETRY_BACKOFF_SECONDS = 1.2
+
+# Tick cadence
+MIN_TICK_SLEEP_SEC = 0.35
+MAX_TICK_SLEEP_SEC = 0.6
+PRINT_EVERY_N_TICKS = 12
+
+# External systems
+ANALYSIS_BASE = "https://dooratre-xauusd-pro.hf.space"
+ANALYSIS_STOP_URL = f"{ANALYSIS_BASE}/stop_analysis"
+ANALYSIS_NOW_URL = f"{ANALYSIS_BASE}/analysis_now"
+OTHER_ALERT_CLEAR_URL = "https://dooratre-alert.hf.space/cancel"
 
-# Fixed webhook to send alert messages to (as requested)
-ALERT_WEBHOOK_URL = "https://dooratre-xauusd-pro.hf.space/analysis_now"
+# User message API
+MESSAGE_API_URL = "https://aoamrnuwara.pythonanywhere.com/api/send-message"
+MESSAGE_API_KEY = "Seakp0683asppoit"
 
+# Flask app
 app = Flask(__name__)
 
+# Logger
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("signal-alert-pro")
+
+# ================ Active State ================
+ACTIVE_MONITOR = {
+    "thread": None,
+    "cancel_token": None,
+    "id": None,
+    "symbol": SYMBOL_DEFAULT,
+    "side": None,
+    "entry": None,
+    "tp": None,
+    "sl": None,
+    "timestamps": None  # keep activation timestamps to preserve on /ts_points updates
+}
+ACTIVE_LOCK = threading.Lock()
+
+# ================ db_signals reader helper ================
+# If you already have an official reader, replace this function with it.
+def read_user_json_file(authenticity_token: str, commit_oid: str) -> Dict[str, Any]:
+    """
+    Reads the current JSON from the GitHub file the same way update_user_json_file writes it.
+    Your db_signals module can implement this properly. Here we show a pattern:
+    - It likely needs the file URL or the API route you already use in update_user_json_file.
+    """
+    # You should implement inside db_signals a function that fetches the raw file content.
+    # For demonstration, we assume you can call a function db_signals.get_user_json_file()
+    # that returns {"success": True, "content": "..."} (JSON string).
+    # If you don't have it, implement it there and call it here.
+    from db_signals import get_user_json_file  # implement this helper in your module
+    res = get_user_json_file(authenticity_token, commit_oid)
+    if not res.get("success"):
+        raise RuntimeError(f"Failed to read user json file: {res}")
+    content = res.get("content", "")
+    try:
+        return json.loads(content) if content else {}
+    except Exception:
+        # If file is a list [] or other structure, return parsed content or an empty dict
+        try:
+            parsed = json.loads(content)
+            return parsed
+        except Exception:
+            return {}
+
+# ================ Utilities ================
 def safe_float_join(whole, decimal):
     try:
         return float(f"{whole}.{decimal}")
@@ -44,267 +114,630 @@ def safe_float_join(whole, decimal):
         except Exception:
             return None
 
+def ts(dt=None):
+    return (dt or datetime.datetime.now()).strftime('%H:%M:%S')
+
+def random_sleep_tick():
+    time.sleep(random.uniform(MIN_TICK_SLEEP_SEC, MAX_TICK_SLEEP_SEC))
+
+def now_utc():
+    return datetime.datetime.now(datetime.timezone.utc)
+
+def format_zone_times(dt_utc: datetime.datetime) -> Dict[str, Any]:
+    def last_sunday(year, month):
+        d = datetime.datetime(year, month, 31, tzinfo=datetime.timezone.utc)
+        while d.weekday() != 6:
+            d -= datetime.timedelta(days=1)
+        return d
+
+    def nth_weekday_of_month(year, month, weekday, n):
+        d = datetime.datetime(year, month, 1, tzinfo=datetime.timezone.utc)
+        while d.weekday() != weekday:
+            d += datetime.timedelta(days=1)
+        d += datetime.timedelta(days=7*(n-1))
+        return d
+
+    y = dt_utc.year
+
+    last_sun_march = last_sunday(y, 3).replace(hour=1, minute=0, second=0, microsecond=0)
+    last_sun_oct = last_sunday(y, 10).replace(hour=1, minute=0, second=0, microsecond=0)
+    london_is_bst = last_sun_march <= dt_utc < last_sun_oct
+    london_offset = datetime.timedelta(hours=1 if london_is_bst else 0)
+    london_sfx = "BST" if london_is_bst else "GMT"
+    london_time = (dt_utc + london_offset).replace(tzinfo=None)
+
+    second_sun_march = nth_weekday_of_month(y, 3, 6, 2).replace(hour=7)
+    first_sun_nov = nth_weekday_of_month(y, 11, 6, 1).replace(hour=6)
+    ny_is_edt = second_sun_march <= dt_utc < first_sun_nov
+    ny_offset = datetime.timedelta(hours=-4 if ny_is_edt else -5)
+    ny_sfx = "EDT" if ny_is_edt else "EST"
+    ny_time = (dt_utc + ny_offset).replace(tzinfo=None)
+
+    tokyo_time = (dt_utc + datetime.timedelta(hours=9)).replace(tzinfo=None)
+
+    first_sun_oct = nth_weekday_of_month(y, 10, 6, 1).replace(hour=16)
+    first_sun_apr = nth_weekday_of_month(y, 4, 6, 1).replace(hour=16)
+    syd_is_aedt = (dt_utc >= first_sun_oct) or (dt_utc < first_sun_apr)
+    sydney_offset = datetime.timedelta(hours=11 if syd_is_aedt else 10)
+    sydney_sfx = "AEDT" if syd_is_aedt else "AEST"
+    sydney_time = (dt_utc + sydney_offset).replace(tzinfo=None)
+
+    return {
+        "zones": {
+            "Greenwich": f"{dt_utc.replace(tzinfo=None).strftime('%Y-%m-%d %H:%M:%S')} UTC",
+            "London": f"{london_time.strftime('%Y-%m-%d %H:%M:%S')} {london_sfx}",
+            "New York": f"{ny_time.strftime('%Y-%m-%d %H:%M:%S')} {ny_sfx}",
+            "Tokyo": f"{tokyo_time.strftime('%Y-%m-%d %H:%M:%S')} JST",
+            "Sydney": f"{sydney_time.strftime('%Y-%m-%d %H:%M:%S')} {sydney_sfx}",
+        },
+        "iso_utc": dt_utc.isoformat()
+    }
+
+def send_message_to_users(message: str, max_retries=5, retry_delay=10):
+    headers = {
+        "Content-Type": "application/json",
+        "X-API-Key": MESSAGE_API_KEY
+    }
+    payload = {"message": message}
+    for attempt in range(1, max_retries + 1):
+        try:
+            response = requests.post(MESSAGE_API_URL, headers=headers, data=json.dumps(payload), timeout=8)
+            if response.status_code == 200:
+                logger.info(f"Message sent to users successfully on attempt {attempt}")
+                return {"success": True, "response": response.json()}
+            else:
+                logger.warning(f"Attempt {attempt}: Users API status {response.status_code}, body: {response.text[:200]}")
+        except requests.exceptions.RequestException as e:
+            logger.warning(f"Attempt {attempt}: Users API request failed: {e}")
+        if attempt < max_retries:
+            time.sleep(retry_delay)
+        else:
+            logger.error("Max retries reached. Failed to send user message.")
+    return {"success": False, "error": "Failed after retries"}
+
+def play_alert_sound():
+    def _beep():
+        if HAS_WINSOUND:
+            try:
+                for _ in range(3):
+                    winsound.Beep(1000, 350)
+                    time.sleep(0.15)
+            except Exception:
+                for _ in range(3):
+                    sys.stdout.write('\a'); sys.stdout.flush()
+                    time.sleep(0.2)
+        else:
+            for _ in range(3):
+                sys.stdout.write('\a'); sys.stdout.flush()
+                time.sleep(0.2)
+    threading.Thread(target=_beep, daemon=True).start()
+
+# ================ Prices ================
 def get_current_price(symbol=SYMBOL_DEFAULT):
-    """
-    Fetch current bid/ask for the given symbol.
-    Returns: dict {bid: float, ask: float} or None on failure.
-    """
     try:
         r = requests.get(API_URL, headers=API_HEADERS, timeout=REQUEST_TIMEOUT_SECONDS)
         r.raise_for_status()
         data = r.json()
-
         if symbol not in data:
-            print(f"[DATA] Symbol {symbol} not found in feed.")
+            logger.warning(f"[DATA] Symbol {symbol} not found in feed.")
             return None
-
         row = data[symbol]
         if not isinstance(row, list) or len(row) < 4:
-            print(f"[DATA] Unexpected data format for {symbol}.")
+            logger.warning(f"[DATA] Unexpected data format for {symbol}.")
             return None
-
         bid = safe_float_join(row[0], row[1])
         ask = safe_float_join(row[2], row[3])
-
         if bid is None or ask is None or math.isnan(bid) or math.isnan(ask):
-            print(f"[DATA] Invalid price values for {symbol}.")
+            logger.warning(f"[DATA] Invalid price values for {symbol}.")
             return None
-
         return {"bid": bid, "ask": ask}
-
     except requests.RequestException as e:
-        print(f"[NETWORK] {e}")
+        logger.warning(f"[NETWORK] {e}")
         return None
     except Exception as e:
-        print(f"[ERROR] Unexpected: {e}")
+        logger.warning(f"[ERROR] Unexpected: {e}")
         return None
 
-def play_alert_sound():
-    def _beep():
-        if HAS_WINSOUND:
-            try:
-                for _ in range(3):
-                    winsound.Beep(1000, 450)
-                    time.sleep(0.2)
-            except Exception:
-                for _ in range(3):
-                    sys.stdout.write('\a'); sys.stdout.flush()
-                    time.sleep(0.3)
-        else:
-            for _ in range(3):
-                sys.stdout.write('\a'); sys.stdout.flush()
-                time.sleep(0.3)
-    threading.Thread(target=_beep, daemon=True).start()
+def mid_price(bid: float, ask: float) -> float:
+    return (bid + ask) / 2.0
 
-def ts(dt=None):
-    return (dt or datetime.datetime.now()).strftime('%H:%M:%S')
+# ================ External orchestration ================
+def call_stop_analysis_and_clear_others():
+    try:
+        requests.get(ANALYSIS_STOP_URL, timeout=5)
+    except Exception as e:
+        logger.warning(f"[ANALYSIS] stop_analysis failed: {e}")
+    try:
+        requests.get(OTHER_ALERT_CLEAR_URL, timeout=5)
+    except Exception as e:
+        logger.warning(f"[ALERT] clear failed: {e}")
 
-def send_alert_message(text: str):
+def call_analysis_now(text: str):
+    try:
+        headers = {"Content-Type": "application/json"}
+        payload = {"message": text}
+        requests.post(ANALYSIS_NOW_URL, headers=headers, json=payload, timeout=8)
+    except Exception as e:
+        logger.warning(f"[ANALYSIS] analysis_now failed: {e}")
+
+# ================ GitHub signal writers/readers ================
+def write_active_scenario_to_github(pair: str, side: str, entry: str, sl: str, tp: str, dt_utc: datetime.datetime, preserve_timestamps: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """
-    Send alert message to fixed webhook as JSON { "message": "..." }.
-    Fire-and-forget (non-blocking).
+    Writes a single-element array as the active trade. If preserve_timestamps provided, use it;
+    otherwise compute fresh timestamps from dt_utc.
     """
-    def _post():
-        try:
-            headers = {"Content-Type": "application/json"}
-            payload = {"message": text}
-            requests.post(ALERT_WEBHOOK_URL, headers=headers, json=payload, timeout=5)
-        except Exception as e:
-            print(f"[WEBHOOK] Failed to POST to {ALERT_WEBHOOK_URL}: {e}")
-    threading.Thread(target=_post, daemon=True).start()
-
-def build_upside_message(symbol, bid, ask, target_up, target_down, elapsed_min, hi_bid, lo_ask):
-    dist_to_down = max(0.0, ask - target_down)
-    return (
-        f"[EXECUTION] {symbol} Upside target hit. "
-        f"Bid {bid} ≥ {target_up}. "
-        f"SessionHighBid {hi_bid} | SessionLowAsk {lo_ask}. "
-        f"AskNow {ask} vs Downside {target_down} (distance {dist_to_down:.5f}). "
-        f"Elapsed {elapsed_min:.2f}m."
-    )
-
-def build_downside_message(symbol, bid, ask, target_up, target_down, elapsed_min, hi_bid, lo_ask):
-    dist_to_up = max(0.0, target_up - bid)
-    return (
-        f"[EXECUTION] {symbol} Downside target hit. "
-        f"Ask {ask} ≤ {target_down}. "
-        f"SessionHighBid {hi_bid} | SessionLowAsk {lo_ask}. "
-        f"BidNow {bid} vs Upside {target_up} (distance {dist_to_up:.5f}). "
-        f"Elapsed {elapsed_min:.2f}m."
-    )
+    timestamps = preserve_timestamps if preserve_timestamps else format_zone_times(dt_utc)
+    payload_obj = [{
+        "pair": pair,
+        "type": side,
+        "entry": str(entry),
+        "stop_loss": str(sl),
+        "take_profit": str(tp),
+        "timestamps": timestamps
+    }]
+    new_content = json.dumps(payload_obj, ensure_ascii=False)
+    try:
+        authenticity_token, commit_oid = fetch_authenticity_token_and_commit_oid()
+        if not authenticity_token or not commit_oid:
+            msg = "Failed to get authenticity_token/commit_oid."
+            logger.error(f"[GITHUB] {msg}")
+            return {"success": False, "message": msg}
+        result = update_user_json_file(authenticity_token, commit_oid, new_content)
+        if result.get("success"):
+            logger.info("[GITHUB] signals updated with active scenario.")
+            return {"success": True}
+        else:
+            logger.error(f"[GITHUB] Update failed: {result}")
+            return {"success": False, "message": result.get("message", "Unknown error")}
+    except Exception as e:
+        logger.error(f"[GITHUB] Exception: {e}")
+        return {"success": False, "message": str(e)}
 
-def build_expired_message(symbol, hi_bid, lo_ask, target_up, target_down, duration_min):
-    miss_up = max(0.0, target_up - hi_bid)
-    miss_down = max(0.0, lo_ask - target_down)
-    return (
-        f"[EXPIRED] {symbol} window ended without execution. "
-        f"SessionHighBid {hi_bid} | SessionLowAsk {lo_ask}. "
-        f"MissUpside {miss_up:.5f} | MissDownside {miss_down:.5f}. "
-        f"Duration {duration_min:.2f}m."
-    )
+def clear_github_signals_to_empty_list() -> Dict[str, Any]:
+    """
+    Clears the db_signals file to [] after SL/TP hit as requested.
+    """
+    try:
+        authenticity_token, commit_oid = fetch_authenticity_token_and_commit_oid()
+        if not authenticity_token or not commit_oid:
+            return {"success": False, "message": "Failed to get auth/commit"}
+        result = update_user_json_file(authenticity_token, commit_oid, "[]")
+        if result.get("success"):
+            logger.info("[GITHUB] signals cleared to []")
+            return {"success": True}
+        return {"success": False, "message": str(result)}
+    except Exception as e:
+        logger.error(f"[GITHUB] clear exception: {e}")
+        return {"success": False, "message": str(e)}
 
-def monitor_price_dual(target_up, target_down, duration_minutes, symbol=SYMBOL_DEFAULT):
+def read_current_scenario_from_github() -> Optional[Dict[str, Any]]:
     """
-    Monitor both upside and downside targets. Synchronous call.
-    On hit/expired, sends alert message to fixed webhook.
-    Returns a final dict, but in async usage we don't return it to client.
+    Reads the pre-activation scenario JSON structure:
+    {
+      "scenario": {
+        "Buy":  {"at": "...", "SL": "...", "TP": "..."},
+        "Sell": {"at": "...", "SL": "...", "TP": "..."},
+        "timestamps": {...}
+      }
+    }
     """
-    if duration_minutes <= 0:
-        return {"status": "error", "message": "Configuration error: duration must be > 0."}
-    if target_up <= target_down:
-        return {"status": "error", "message": "Configuration error: target_up must be greater than target_down."}
+    try:
+        authenticity_token, commit_oid = fetch_authenticity_token_and_commit_oid()
+        if not authenticity_token or not commit_oid:
+            logger.error("[GITHUB] Missing auth tokens to read scenario")
+            return None
+        content = read_user_json_file(authenticity_token, commit_oid)
+        # content might be dict (scenario object) or list (active array) or empty
+        if isinstance(content, dict) and "scenario" in content:
+            return content
+        else:
+            # Not in pre-activation mode
+            return None
+    except Exception as e:
+        logger.warning(f"[SCENARIO] fetch failed: {e}")
+        return None
 
-    # Initial fetch with retry
+# ================ Activation helpers ================
+class CancelToken:
+    def __init__(self):
+        self._cancel = False
+        self._lock = threading.Lock()
+    def cancel(self):
+        with self._lock:
+            self._cancel = True
+    def is_cancelled(self):
+        with self._lock:
+            return self._cancel
+
+def init_price_snapshot(symbol) -> Optional[Dict[str, float]]:
     retries, snap = 0, None
     while retries < MAX_RETRIES and snap is None:
         snap = get_current_price(symbol)
         if snap is None:
             retries += 1
             if retries < MAX_RETRIES:
-                delay = RETRY_BACKOFF_SECONDS * retries
-                time.sleep(delay)
+                time.sleep(RETRY_BACKOFF_SECONDS * retries)
             else:
-                msg = "Unable to retrieve initial price snapshot."
-                return {"status": "error", "message": msg}
-
-    t_start = datetime.datetime.now()
-    t_end = t_start + datetime.timedelta(minutes=duration_minutes)
-
-    bid0, ask0 = snap["bid"], snap["ask"]
-    hi_bid = bid0
-    lo_ask = ask0
-
-    # Instant checks at start
-    if bid0 >= target_up:
-        play_alert_sound()
-        elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
-        message = build_upside_message(symbol, bid0, ask0, target_up, target_down, elapsed_min, hi_bid, lo_ask)
-        send_alert_message(message)
-        return {"status": "hit", "side": "upside", "message": message}
-
-    if ask0 <= target_down:
-        play_alert_sound()
-        elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
-        message = build_downside_message(symbol, bid0, ask0, target_up, target_down, elapsed_min, hi_bid, lo_ask)
-        send_alert_message(message)
-        return {"status": "hit", "side": "downside", "message": message}
-
-    ticks = 0
-    try:
-        while datetime.datetime.now() < t_end:
-            q = get_current_price(symbol)
-            if q is None:
-                time.sleep(1)
-                continue
-
-            bid, ask = q["bid"], q["ask"]
-            hi_bid = max(hi_bid, bid)
-            lo_ask = min(lo_ask, ask)
-
-            # Target checks
-            if bid >= target_up:
-                play_alert_sound()
-                elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
-                message = build_upside_message(symbol, bid, ask, target_up, target_down, elapsed_min, hi_bid, lo_ask)
-                send_alert_message(message)
-                return {"status": "hit", "side": "upside", "message": message}
-
-            if ask <= target_down:
-                play_alert_sound()
-                elapsed_min = (datetime.datetime.now() - t_start).total_seconds() / 60
-                message = build_downside_message(symbol, bid, ask, target_up, target_down, elapsed_min, hi_bid, lo_ask)
-                send_alert_message(message)
-                return {"status": "hit", "side": "downside", "message": message}
-
-            # Optional: light logging cadence
-            ticks += 1
-            if ticks % PRINT_INTERVAL_SECONDS == 0:
-                mins_left = max(0.0, (t_end - datetime.datetime.now()).total_seconds() / 60)
-                print(f"[{ts()}] {symbol} Bid {bid} (hi {hi_bid}) | Ask {ask} (lo {lo_ask}) | ↑ {target_up} / ↓ {target_down} | {mins_left:.1f}m left")
-
-            time.sleep(1)
-
-        # Expiry
-        message = build_expired_message(symbol, hi_bid, lo_ask, target_up, target_down, duration_minutes)
-        send_alert_message(message)
-        return {"status": "expired", "message": message}
-
-    except Exception as e:
-        message = f"Unexpected error: {e}"
-        send_alert_message(f"[ERROR] {message}")
-        return {"status": "error", "message": message}
+                return None
+    return snap
+
+def detect_cross(prev_price: float, curr_price: float, level: float, direction: Optional[str]) -> bool:
+    if direction == "up":
+        return prev_price < level <= curr_price
+    elif direction == "down":
+        return prev_price > level >= curr_price
+    else:
+        return (prev_price < level <= curr_price) or (prev_price > level >= curr_price)
+
+def price_crossing_to_activate(side: str, entry: float, prev: float, curr: float) -> bool:
+    if side == "Buy":
+        return prev < entry <= curr
+    else:
+        return prev > entry >= curr
+
+def wait_until_activation_dual(buy_entry: Optional[float],
+                               sell_entry: Optional[float],
+                               symbol: str,
+                               cancel_token: "CancelToken",
+                               max_minutes: int = 240) -> Optional[Dict[str, float]]:
+    if buy_entry is None and sell_entry is None:
+        return None
+    snap = init_price_snapshot(symbol)
+    if snap is None:
+        logger.error("[ACTIVATOR] Initial price fetch failed.")
+        return None
+    prev = mid_price(snap["bid"], snap["ask"])
+    t_end = datetime.datetime.now() + datetime.timedelta(minutes=max_minutes)
+    tick = 0
+    if buy_entry is not None and abs(prev - buy_entry) < 1e-9:
+        return {"side": "Buy", "price": prev}
+    if sell_entry is not None and abs(prev - sell_entry) < 1e-9:
+        return {"side": "Sell", "price": prev}
+    while datetime.datetime.now() < t_end and not cancel_token.is_cancelled():
+        q = get_current_price(symbol)
+        if q is None:
+            time.sleep(0.5)
+            continue
+        curr = mid_price(q["bid"], q["ask"])
+        # Sell first then Buy (stable tie-break)
+        if sell_entry is not None and price_crossing_to_activate("Sell", sell_entry, prev, curr):
+            return {"side": "Sell", "price": curr}
+        if buy_entry is not None and price_crossing_to_activate("Buy", buy_entry, prev, curr):
+            return {"side": "Buy", "price": curr}
+        tick += 1
+        if tick % PRINT_EVERY_N_TICKS == 0:
+            logger.info(f"[{ts()}] Waiting activation Buy@{buy_entry} Sell@{sell_entry}, now {curr:.3f}")
+        prev = curr
+        random_sleep_tick()
+    return None
+
+# ================ SL/TP monitor ================
+def start_sl_tp_monitor(side: str, entry: float, sl: float, tp: float, symbol: str = SYMBOL_DEFAULT):
+    cancel_token = CancelToken()
+    monitor_id = f"{int(time.time()*1000)}-{random.randint(1000,9999)}"
 
-def start_monitor_async(symbol: str, target_up: float, target_down: float, duration_minutes: int):
-    """
-    Start monitor_price_dual in a daemon thread (non-blocking).
-    """
     def _runner():
         try:
-            result = monitor_price_dual(target_up, target_down, duration_minutes, symbol=symbol)
-            # Optional: log final result
-            print(f"[MONITOR-END] {symbol} result: {result}")
+            snap = init_price_snapshot(symbol)
+            if snap is None:
+                logger.error("[MONITOR] Unable to retrieve initial price snapshot.")
+                return
+            bid0, ask0 = snap["bid"], snap["ask"]
+            price0 = mid_price(bid0, ask0)
+            prev_price = price0
+            hi_bid = bid0
+            lo_ask = ask0
+
+            if side == "Buy":
+                tp_dir = "up" if tp >= entry else None
+                sl_dir = "down" if sl <= entry else None
+            else:
+                tp_dir = "down" if tp <= entry else None
+                sl_dir = "up" if sl >= entry else None
+
+            tick = 0
+            while not cancel_token.is_cancelled():
+                q = get_current_price(symbol)
+                if q is None:
+                    time.sleep(0.6)
+                    continue
+                bid, ask = q["bid"], q["ask"]
+                price_now = mid_price(bid, ask)
+                hi_bid = max(hi_bid, bid)
+                lo_ask = min(lo_ask, ask)
+
+                hit = None
+                if detect_cross(prev_price, price_now, sl, sl_dir):
+                    hit = ("SL", sl)
+                if hit is None and detect_cross(prev_price, price_now, tp, tp_dir):
+                    hit = ("TP", tp)
+
+                if hit:
+                    play_alert_sound()
+                    hit_type, hit_price = hit
+                    # 1) Notify user immediately
+                    msg = f"{side.upper()} SIGNAL {hit_type} hit at {hit_price}\nEntry: {entry}\nTP: {tp}\nSL: {sl}\nPair: {symbol}"
+                    send_message_to_users(msg)
+
+                    # 2) Clear db_signals to []
+                    try:
+                        clear_github_signals_to_empty_list()
+                    except Exception as e:
+                        logger.warning(f"[GITHUB] clearing after hit failed: {e}")
+
+                    # 3) Stop analysis and other alert system again
+                    call_stop_analysis_and_clear_others()
+
+                    # 4) Notify analysis of the result
+                    analysis_msg = f"{symbol} {side} trade {hit_type} reached at {hit_price} (entry {entry}, TP {tp}, SL {sl})."
+                    call_analysis_now(analysis_msg)
+
+                    logger.info(f"[MONITOR-END] {side} {hit_type} hit.")
+                    return
+
+                tick += 1
+                if tick % PRINT_EVERY_N_TICKS == 0:
+                    logger.info(f"[{ts()}] {symbol} {side} Mid {price_now:.3f} | Bid {bid:.3f}(hi {hi_bid:.3f}) | Ask {ask:.3f}(lo {lo_ask:.3f}) | TP {tp} / SL {sl}")
+                prev_price = price_now
+                random_sleep_tick()
         except Exception as e:
-            print(f"[MONITOR-THREAD] Error: {e}")
+            logger.error(f"[MONITOR-THREAD] Error: {e}")
+        finally:
+            with ACTIVE_LOCK:
+                if ACTIVE_MONITOR.get("id") == monitor_id:
+                    ACTIVE_MONITOR["thread"] = None
+                    ACTIVE_MONITOR["cancel_token"] = None
+
     t = threading.Thread(target=_runner, daemon=True)
+    with ACTIVE_LOCK:
+        if ACTIVE_MONITOR["cancel_token"]:
+            ACTIVE_MONITOR["cancel_token"].cancel()
+        ACTIVE_MONITOR["thread"] = t
+        ACTIVE_MONITOR["cancel_token"] = cancel_token
+        ACTIVE_MONITOR["id"] = monitor_id
+        ACTIVE_MONITOR["symbol"] = symbol
+        ACTIVE_MONITOR["side"] = side
+        ACTIVE_MONITOR["entry"] = entry
+        ACTIVE_MONITOR["tp"] = tp
+        ACTIVE_MONITOR["sl"] = sl
+        # timestamps preserved in ACTIVE_MONITOR["timestamps"] by activator
     t.start()
 
-# ========== API Endpoints ==========
+# ================ Scenario fetcher ================
+def fetch_current_scenario_struct() -> Optional[Dict[str, Any]]:
+    """
+    Reads the pre-activation scenario (Buy/Sell at/SL/TP) from db_signals storage.
+    Returns:
+      {
+        "scenario": {
+          "Buy": {"at": "...", "SL": "...", "TP": "..."},
+          "Sell": {"at": "...", "SL": "...", "TP": "..."},
+          "timestamps": {...}
+        }
+      }
+      or None if not available.
+    """
+    return read_current_scenario_from_github()
 
-@app.route("/monitor", methods=["POST"])
-def start_monitor():
+# ================ API Endpoints ================
+@app.route("/track", methods=["POST"])
+def track_signal():
     """
-    Start monitoring asynchronously and immediately return 200.
-    Payload:
-    {
-      "symbol": "XAUUSD",        // optional, default XAUUSD
-      "target_up": 2490.5,       // required
-      "target_down": 2475.0,     // required
-      "duration_minutes": 15     // required
-    }
-    Immediate Response:
-      { "status": "accepted", "message": "Okay your alert added succes" }
+    Accepts: {"Buy": number?, "Sell": number?}
+    Behavior:
+      - Stop analysis and clear other alert (immediately).
+      - Cancel any existing activation/monitor (newest wins).
+      - Start watcher for activation of Buy/Sell (gap-aware). On first hit:
+          * Play sound
+          * Read SL/TP from scenario in db_signals
+          * Write active array [ {...} ] with timestamps for the start moment
+          * Send user "BUY NOW/SELL NOW..." message
+          * Start SL/TP monitor
+          * Notify analysis via analysis_now
+      - Respond 200 immediately after accepting.
     """
     try:
         data = request.get_json(force=True)
     except Exception:
         return jsonify({"status": "error", "message": "Invalid JSON"}), 400
 
-    symbol = data.get("symbol", SYMBOL_DEFAULT)
-    target_up = data.get("target_up")
-    target_down = data.get("target_down")
-    duration_minutes = data.get("duration_minutes")
+    buy_at = data.get("Buy")
+    sell_at = data.get("Sell")
+
+    if buy_at is None and sell_at is None:
+        return jsonify({"status": "error", "message": "Provide Buy or Sell or both"}), 400
+
+    if buy_at is not None:
+        try:
+            buy_at = float(buy_at)
+        except Exception:
+            return jsonify({"status": "error", "message": "Buy must be numeric"}), 400
+
+    if sell_at is not None:
+        try:
+            sell_at = float(sell_at)
+        except Exception:
+            return jsonify({"status": "error", "message": "Sell must be numeric"}), 400
+
+    # 1) Stop external analysis and other alert now
+    call_stop_analysis_and_clear_others()
+
+    # 2) Cancel any current operation
+    with ACTIVE_LOCK:
+        if ACTIVE_MONITOR["cancel_token"]:
+            ACTIVE_MONITOR["cancel_token"].cancel()
+        # Reset active monitor state; activation not yet started
+        ACTIVE_MONITOR["thread"] = None
+        ACTIVE_MONITOR["cancel_token"] = None
+        ACTIVE_MONITOR["id"] = None
+        ACTIVE_MONITOR["symbol"] = SYMBOL_DEFAULT
+        ACTIVE_MONITOR["side"] = None
+        ACTIVE_MONITOR["entry"] = None
+        ACTIVE_MONITOR["tp"] = None
+        ACTIVE_MONITOR["sl"] = None
+        ACTIVE_MONITOR["timestamps"] = None
+
+    activator_cancel = CancelToken()
+
+    def _activator():
+        try:
+            act = wait_until_activation_dual(
+                buy_entry=buy_at,
+                sell_entry=sell_at,
+                symbol=SYMBOL_DEFAULT,
+                cancel_token=activator_cancel,
+                max_minutes=240
+            )
+            if act is None:
+                logger.info("[ACTIVATOR] Cancelled or timed out.")
+                return
+
+            chosen_side = act["side"]
+            entry_used = act["price"]
+
+            play_alert_sound()
+
+            # Read scenario SL/TP from db_signals
+            scenario_blob = fetch_current_scenario_struct()
+            if not scenario_blob or "scenario" not in scenario_blob:
+                logger.error("[ACTIVATOR] Missing scenario data to read SL/TP.")
+                send_message_to_users(f"ERROR: Missing scenario SL/TP for {chosen_side} at {entry_used}")
+                return
+
+            side_block = scenario_blob["scenario"].get(chosen_side, {})
+            try:
+                sl_f = float(side_block.get("SL"))
+                tp_f = float(side_block.get("TP"))
+            except Exception:
+                logger.error("[ACTIVATOR] Invalid SL/TP from scenario data.")
+                send_message_to_users(f"ERROR: Invalid SL/TP for {chosen_side} at {entry_used}")
+                return
+
+            # 3) Write active array with fresh timestamps for the start moment
+            dt_utc = now_utc()
+            ts_block = format_zone_times(dt_utc)
+            wr = write_active_scenario_to_github(
+                pair=SYMBOL_DEFAULT,
+                side=chosen_side,
+                entry=str(entry_used),
+                sl=str(sl_f),
+                tp=str(tp_f),
+                dt_utc=dt_utc
+            )
+            if not wr.get("success"):
+                logger.warning(f"[GITHUB] Write failed: {wr}")
+
+            # Save timestamps in memory to preserve on /ts_points updates
+            with ACTIVE_LOCK:
+                ACTIVE_MONITOR["timestamps"] = ts_block
+
+            # 4) Notify users
+            user_msg = f"{chosen_side.upper()} NOW at {entry_used}\nSL: {sl_f}\nTP: {tp_f}\nPair: {SYMBOL_DEFAULT}"
+            send_message_to_users(user_msg)
+
+            # 5) Inform analysis
+            call_analysis_now(f"Scenario {chosen_side} activated for {SYMBOL_DEFAULT} at {entry_used}. SL {sl_f}, TP {tp_f}.")
+
+            # 6) Start SL/TP monitor
+            start_sl_tp_monitor(side=chosen_side, entry=entry_used, sl=sl_f, tp=tp_f, symbol=SYMBOL_DEFAULT)
 
-    if target_up is None or target_down is None or duration_minutes is None:
-        return jsonify({"status": "error", "message": "target_up, target_down, duration_minutes are required"}), 400
+        except Exception as e:
+            logger.error(f"[ACTIVATOR] Error: {e}")
 
-    # Basic type validation before starting async work
+    t = threading.Thread(target=_activator, daemon=True)
+    t.start()
+
+    return jsonify({"status": "accepted", "message": f"Tracking activation for Buy at {buy_at} and/or Sell at {sell_at} started."}), 200
+
+@app.route("/ts_points", methods=["POST"])
+def ts_points():
+    """
+    Accepts: {"TP": "...", "SL": "..."} to update active trade points.
+    Behavior:
+      - Requires an active trade.
+      - Cancel current monitor and restart with the updated levels.
+      - DO NOT change the activation timestamps (trade start time).
+      - Rewrite GitHub active array with preserved timestamps.
+      - Notify users and analysis.
+    """
     try:
-        target_up = float(target_up)
-        target_down = float(target_down)
-        duration_minutes = int(duration_minutes)
+        data = request.get_json(force=True)
     except Exception:
-        return jsonify({"status": "error", "message": "Invalid types: target_up/target_down must be float, duration_minutes must be int"}), 400
+        return jsonify({"status": "error", "message": "Invalid JSON"}), 400
+
+    tp_new = data.get("TP")
+    sl_new = data.get("SL")
+    if tp_new is None and sl_new is None:
+        return jsonify({"status": "error", "message": "Provide TP or SL"}), 400
+
+    with ACTIVE_LOCK:
+        if ACTIVE_MONITOR["id"] is None or ACTIVE_MONITOR["side"] is None:
+            return jsonify({"status": "error", "message": "No active trade to update"}), 400
+
+        # Parse and stage updates
+        if tp_new is not None:
+            try:
+                ACTIVE_MONITOR["tp"] = float(tp_new)
+            except Exception:
+                return jsonify({"status": "error", "message": "Invalid TP"}), 400
+        if sl_new is not None:
+            try:
+                ACTIVE_MONITOR["sl"] = float(sl_new)
+            except Exception:
+                return jsonify({"status": "error", "message": "Invalid SL"}), 400
+
+        side = ACTIVE_MONITOR["side"]
+        entry = ACTIVE_MONITOR["entry"]
+        symbol = ACTIVE_MONITOR["symbol"]
+        tp = ACTIVE_MONITOR["tp"]
+        sl = ACTIVE_MONITOR["sl"]
+        preserved_ts = ACTIVE_MONITOR["timestamps"]
+
+        if ACTIVE_MONITOR["cancel_token"]:
+            ACTIVE_MONITOR["cancel_token"].cancel()
+
+    # Restart monitor with new TP/SL
+    start_sl_tp_monitor(side=side, entry=entry, sl=sl, tp=tp, symbol=symbol)
+
+    # Update GitHub record preserving timestamps (do NOT change time)
+    wr = write_active_scenario_to_github(
+        pair=symbol,
+        side=side,
+        entry=str(entry),
+        sl=str(sl),
+        tp=str(tp),
+        dt_utc=now_utc(),  # ignored when preserve_timestamps provided
+        preserve_timestamps=preserved_ts
+    )
+    if not wr.get("success"):
+        logger.warning(f"[GITHUB] Update after TS change failed: {wr}")
 
-    if duration_minutes <= 0:
-        return jsonify({"status": "error", "message": "duration_minutes must be > 0"}), 400
-    if target_up <= target_down:
-        return jsonify({"status": "error", "message": "target_up must be greater than target_down"}), 400
+    # Notify users
+    msg = f"{side.upper()} update: TP -> {tp if tp_new is not None else '(unchanged)'} | SL -> {sl if sl_new is not None else '(unchanged)'}"
+    send_message_to_users(msg)
 
-    # Start monitoring in background thread
-    start_monitor_async(symbol, target_up, target_down, duration_minutes)
+    # Notify analysis
+    call_analysis_now(f"{symbol} {side} updated: TP {tp if tp_new is not None else '(unchanged)'}, SL {sl if sl_new is not None else '(unchanged)'}.")
 
-    # Immediate success response
-    return jsonify({"status": "accepted", "message": "Okay your alert added succes"}), 200
+    return jsonify({"status": "ok", "message": "TP/SL updated and tracking restarted"}), 200
 
 @app.route("/", methods=["GET"])
 def root():
     return jsonify({
-        "service": "Forex Trade Alert API (async monitor)",
-        "fixed_alert_webhook": ALERT_WEBHOOK_URL,
-        "endpoint": "POST /monitor",
-        "behavior": "returns immediately; monitoring runs in background"
+        "service": "Signal Trade Activation & SL/TP Tracking (PRO)",
+        "symbol": SYMBOL_DEFAULT,
+        "routes": {
+            "POST /track": "Payload: { 'Buy': price?, 'Sell': price? }. Starts activation tracking. Newest wins.",
+            "POST /ts_points": "Payload: { 'TP': new_tp?, 'SL': new_sl? }. Updates active trade without changing start time."
+        },
+        "notes": [
+            "Only one operation active at a time; newest request cancels previous (across users).",
+            "On activation: stop analysis & clear other alert, write single-scenario array with fresh timestamps, notify user, start SL/TP monitor, notify analysis.",
+            "On SL/TP hit: notify user first, then clear db_signals to [], stop analysis & clear other alert, and inform analysis.",
+            "On /ts_points: do NOT change timestamps in GitHub; preserve trade start time; restart monitor with new TP/SL."
+        ]
     }), 200
 
+# ================ Main ================
 if __name__ == "__main__":
-    # threaded=True is fine; we also use daemon threads for monitors
     app.run(host="0.0.0.0", port=7860, debug=False, threaded=True)