diff --git a/.idea/back-end.iml b/.idea/back-end.iml
index ec63674..73f5b78 100644
--- a/.idea/back-end.iml
+++ b/.idea/back-end.iml
@@ -1,5 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<module version="4">
+<module external.system.id="java-source" type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="jdk" jdkName="uv (pymd3_vue_location_sim)" jdkType="Python SDK" />
+  </component>
   <component name="PyDocumentationSettings">
     <option name="format" value="PLAIN" />
     <option name="myDocStringFormat" value="Plain" />
diff --git a/.idea/modules.xml b/.idea/modules.xml
new file mode 100644
index 0000000..9dd3fb7
--- /dev/null
+++ b/.idea/modules.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/back-end.iml" filepath="$PROJECT_DIR$/.idea/back-end.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..6324d40
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.14
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/__pycache__/main.cpython-314.pyc b/__pycache__/main.cpython-314.pyc
index b59854b..d96cacc 100644
Binary files a/__pycache__/main.cpython-314.pyc and b/__pycache__/main.cpython-314.pyc differ
diff --git a/__pycache__/server.cpython-314.pyc b/__pycache__/server.cpython-314.pyc
index 5148778..9cb0fa5 100644
Binary files a/__pycache__/server.cpython-314.pyc and b/__pycache__/server.cpython-314.pyc differ
diff --git a/cookies/willbrunogmailcom.cookiejar b/cookies/willbrunogmailcom.cookiejar
new file mode 100644
index 0000000..87c210c
--- /dev/null
+++ b/cookies/willbrunogmailcom.cookiejar
@@ -0,0 +1,24 @@
+#LWP-Cookies-2.0
+Set-Cookie3: dslang=US-EN; path="/"; domain=.apple.com; path_spec; secure; discard; HttpOnly=None; version=0
+Set-Cookie3: site=USA; path="/"; domain=.apple.com; path_spec; secure; discard; HttpOnly=None; version=0
+Set-Cookie3: acn01="vWB+8XG/BRIWimhzMz5URIMyy8lepYRnuuCxqAANNsVFbcxf"; path="/"; domain=.apple.com; path_spec; secure; expires="2027-03-27 09:37:26Z"; HttpOnly=None; version=0
+Set-Cookie3: aasp=90537484E4B81989243BAABCFA1DE44F53876FB5F9C433FD2C4687BD0D409642748545163AD333F3CDBBDDC6128BF84382082E6C0A4E27921C8792F0883DABFBFE8534D699F84266A14F842D6502C6902F2F00DC126EBD3E7D5FF7C490D9FE6740C97EFA884B52031C2E5BB2469A785CBDD236AD7014E383; path="/"; domain=.idmsa.apple.com; path_spec; secure; discard; HttpOnly=None; version=0
+Set-Cookie3: DES580750186337023c50d1415a6e6ca44a2="HSARMTKNSRVXWFlajR2ecD1662phQjqU9vXxnL49ZjypuVYYXHDpA3wTiX6Mf2J4WDlIhZj52z81aDOuz+VC80bVhV41TSNN4ggoPjW8WnsQrjniTQYkgJycPQNnzhkK4hfe2AMrr/bhrJJm8sHHc+Oh1HUckN6T7T4c1bmf2Qg9tRwsdRDNyMMyFH/Ml/cQlWKj39/YHlY=SRVX"; path="/"; domain=.idmsa.apple.com; path_spec; secure; expires="2026-04-21 03:09:12Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-UNIQUE-CLIENT-ID="\"BA==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; discard; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-LOGIN="\"v=1:t=BA==BST_IAAAAAAABLwIAAAAAGnGXmMRDmdzLmljbG91ZC5hdXRovQCH_epzZatm6b76myo9LfRsbXIfkwxREvo7U3efqnjYgORbMDpBEJyshI1bhC-Ww30ipqYT87rp7mJxkcXRw4HYHvxJCs1rC9M6JWbFvrmUTu4RuVuaVYSNHRYAz8-DS6bagfD6XUHY-5Xmqf2fnmeGqZfNag~~\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; discard; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-VALIDATE="\"v=1:t=BA==BST_IAAAAAAABLwIAAAAAGnGXmMRDmdzLmljbG91ZC5hdXRovQCH_epzZatm6b76myo9LfRsbXIfkwxREvo7U3efqnjYgORbMDpBEJyshI1bhC-Ww30ipqYT87rp7mJxkcXRw4HYHvxJCs1rC9M6JWbFvrmUTllbuUPSPqBVc1raHL34Cl5lu7SfciATbqjQE4KgZchJLIo6PQ~~\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; discard; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-USER="\"v=1:s=1:d=157320350\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X_APPLE_WEB_KB-FHMLYL_TPMN_3A8D3KIPPI0C_EC="\"v=1:t=BA==BST_IAAAAAAABLwIAAAAAGm_OLQRDmdzLmljbG91ZC5hdXRovQD38nYoxQenHW9WggeFKkoDa8I8zeKoOshv6I4dsZQalR2itry1r6kUZe9d_BZan1W-oKlImTrYi_-Vt5Q4YEJWJITWeqN8QChxvbTXB0o8sQ-wAIzBL1J5sQIRBqMadrtP5U0wslkRg0u0AguK20CM4TGoGg~~\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-05-21 00:32:52Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-DS-WEB-SESSION-TOKEN="\"AQHO22bhY5UiUtuYBNJRupGy4tIGYR08ChFW77qgTTPDpPof4ZOPHhm2rGQ7OnoHchQlJLXG77T2BEoZxUO7ZknuRUUoK/j9/XTHYwv92CgFs/STC7oB1aMYmfddwNigbg9L5v40kX3Fmg6teX34bGYuOfqoHKTCuVxhllBNxZsKcPsKLGqRdZ4b3thHu+Y6+uVq5mAT9RnUbYAMD7hYP1Vr4aq+6CYi4+TdtO02SngpGcCRC5BR3PJh2udSG2YSGk5T+SBb4uBx94CzF2116QQWR0WjwSpqJ2K881lENtE3Kvf0pmM5mIw9fLdSgDi6kqP8iJHdni85QYpuTasMzd7ROWih6OqSV0U3O62X8ix+Xf3P1e/Fes7prNxjME+tcORKftTockp3c5U28DKcnZYYYuBRh+BNaAqVIAMg7AW9dNJUuTWdzVtUPhkLgvyTal625iiSh7Q6wsIISa03Cjtueli3NV++Z3R2jFvTQ/mC1lH9U//3ul+UPqblKCBy7SKGi/oph/PIroggTUwx/tvjQxCQf8RVkGg+8T0UE7rj6wDuaYu1i7twt7o1QsBlefEpVU9fYhCK3sq5aydhLRsb47wX42WhftBRTDenq7SwaHJZfxQ3T4NVULg8OsuCeuO1Gejnbylh9BI3Ws+I5k0ZNOaZtAWBlW8dsa5KrEdr+cRG0oV4EKPGTbt/mhvdFA/Kes/ksfI27DkKDmQ0MVj7nTTXQSkxeeQWEuP3T5LSNaYGDl+E6zqn5SsTt1RGxYMj3SHfSzxcLjNk7RoGcNle45L+V1wA5G8=\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-HSA-TRUST="\"28a33818a1dce9a0eecde38e7c8fcc6f080b70bc9feb505599fb2855903a4792_HSARMTKNSRVXWFlajR2ecD1662phQjqU9vXxnL49ZjypuVYYXHDpA3wTiX6Mf2J4WDlIhZj52z81aDOuz+VC80bVhV41TSNN4ggoPjW8WnsQrjniTQYkgJycPQNnzhkK4hfe2AMrr/bhrJJm8sHHc+Oh1HUckN6T7T4c1bmf2Qg9tRwsdRDNyMMyFH/Ml/cQlWKj39/YHlY=SRVX\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-06-25 10:39:31Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Events="\"S2V5QXBwbDoBAAAA8QQnAADHJQyTmjkr1lRgHCHPONwUkefefsNrEGp6R9lQhFZ2hQ==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Documents="\"S2V5QXBwbDoBAAAAAgQnAAATRltQsTNPTggWr2+h+Ck7taXy1Nfd/0gTtx4/mgZMuQ==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Photos="\"S2V5QXBwbDoBAAAAAwQnAAC2DQKpt8kGxmIXjouUofkM/o9x9ZcMbMi8+kob3iqjtg==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Cloudkit="\"S2V5QXBwbDoBAAAABAQnAAD32tR1O4Wfr112mDd798bvrPSnGJ9SGs1UAu8ZxpArag==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Safari="\"S2V5QXBwbDoBAAAAFgQnAAAPeaT9obfpF4JkzvnTqn9iKRIFWjCO4Ibdd3ETw14+Kw==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Mail="\"S2V5QXBwbDoBAAAABwQnAADn5vf2KKnwETMPFGonUQAJwl4zr2g3X+iUWawSMgWOEg==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Notes="\"S2V5QXBwbDoBAAAACQQnAAALAg7ubdhjkrtB/lFNTwHudI77mxFx9gsBauT9LBhB6g==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-News="\"S2V5QXBwbDoBAAAACwQnAAA5X6JspeIixJp6c7Uy+R2YynkGzH97NPfDPAkrO7uZ8g==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-PCS-Sharing="\"S2V5QXBwbDoBAAAADAQnAADz1ui+JqfV6Fy6AI0Z6DScPVidn3wzooDronhTKnsLmQ==\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-26 10:39:35Z"; HttpOnly=None; version=0
+Set-Cookie3: X-APPLE-WEBAUTH-TOKEN="\"v=2:t=BA==BST_IAAAAAAABLwIAAAAAGnGcucRDmdzLmljbG91ZC5hdXRovQBTsTtaO6tyhJbzfEVId4DPvNxvrOsTyKuhGBini_Ov9HBK9EgpLZCsfHxc0R0TWp-8AWGCWsLJSRkerU_Wt4CQG-vY_elLY1vevhKMmIi2CdVVyTBenEo_PyeAkNds0z9SjSi5a5z5rBqJpSysM1UyXNTTcg~~\""; path="/"; domain=.icloud.com; path_spec; domain_dot; secure; expires="2026-04-10 12:07:03Z"; HttpOnly=None; version=0
+Set-Cookie3: xr_3n2093n1a="BW/k2XvBcxLsX55iCOOGgMojIY0Q+/Ey61qJDHU0TQE="; path="/"; domain=p144-fmipweb.icloud.com; path_spec; secure; discard; HttpOnly=None; version=0
diff --git a/cookies/willbrunogmailcom.session b/cookies/willbrunogmailcom.session
new file mode 100644
index 0000000..f717bc6
--- /dev/null
+++ b/cookies/willbrunogmailcom.session
@@ -0,0 +1 @@
+{"client_id": "a803c3ce-2586-11f1-a724-8f6777a1d2b5", "session_id": "90537484E4B81989243BAABCFA1DE44F53876FB5F9C433FD2C4687BD0D409642748545163AD333F3CDBBDDC6128BF84382082E6C0A4E27921C8792F0883DABFBFE8534D699F84266A14F842D6502C6902F2F00DC126EBD3E7D5FF7C490D9FE6740C97EFA884B52031C2E5BB2469A785CBDD236AD7014E383", "auth_attributes": "CpWqHR6Y8JEnXubiHUHm2K5yCpOQORPPkclAkiMbW2nsEkSK2oVF24FHI3QNNw4cfBQfJOSEdRvVtGKtbi/Zxzbma2uaF9uD1kAlxlin4oPpxzNH5xKC472p08YUBkvusVaZ4wPqv6Zv+MZefISD/f/5A3vIn2fTZbXgImoKKaTLlwSn5wOcaJYoJYAhWgak+YPWeGLAdm1oGuXvTkCZe3gYtizo8lu6d4SBEjQ18GJ0BAN8D+BRxOb9B1AhxnzUd25aKq4CXzkRmLLCQWX0AA02xVKHQTE=", "scnt": "AAAA-jkwNTM3NDg0RTRCODE5ODkyNDNCQUFCQ0ZBMURFNDRGNTM4NzZGQjVGOUM0MzNGRDJDNDY4N0JEMEQ0MDk2NDI3NDg1NDUxNjNBRDMzM0YzQ0RCQkREQzYxMjhCRjg0MzgyMDgyRTZDMEE0RTI3OTIxQzg3OTJGMDg4M0RBQkZCRkU4NTM0RDY5OUY4NDI2NkExNEY4NDJENjUwMkM2OTAyRjJGMDBEQzEyNkVCRDNFN0Q1RkY3QzQ5MEQ5RkU2NzQwQzk3RUZBODg0QjUyMDMxQzJFNUJCMjQ2OUE3ODVDQkREMjM2QUQ3MDE0RTM4M3wyAAABnS61l867bZUy_24a4kaFbwGNgVJFgWQLrkDm8d_dAuxiqTUQBdnQ9m4C0ia8AA02xTey6hfMfAIuPPlov20tqtmvTh-N23rQ3Q4jQeaNx6uMrtovmQ", "account_country": "USA", "session_token": "idWfvF23GAFDtpDv51Mnga3iu7fJCAdyDaw22SorSHz5JTRc/SottqqYD2KGG/56FLnY9lHAZnJUz8APx24/Y5Udfi45jsW6FmUZ1btGt4ihu0lGg5zIWAxY6B9AHVe4ROZ0mI90mvT5jajGL56Ke3fhL6ncIYP/LTQz2EJfwZtd02MgeQ5j1W0IfF8zmhlDyb9eAn1dC6X61hh7d/DZdLDFfZxxyXkBhemi6dNQKDwAUnYl7YKlShZDLUFNFG0k3m2yiLQANI+InL7fDHPEdyiNaGh9Lu5VLcq7hgNFqIqN6JFjUBAr/cauSeTHHmGPtH9Ry4VWMpl3Ukd+nppFylMCazMj3hvjXpSIkMR7B41pxxRA1FtjgYryeUkexcQXx8vrMYwrkVdtOB4p2xRfX7xXzMGH5VpwpFO75/nO10A4n+YEXg/JaPW31R8zLBvnZd6oL5ElCGIlXQadsPM0mzDdbvM2dXhMQaJ4dLQC9p4XhIrEkGhV7op5YeLWfNiDg3tBDLYn+WVEw7xWmEp6/NRZqFmctEDgJak9AwUV5ostJ4O69UxiaqkL8VgYysHBVcN0Tl6XwVHvh+o5LBL3C9fAsQ1ZIMNb088Sl8iRHbwOxa/UfiQ9RWiTfUhlGzNhd6nxOLIN5SaBV4Z3Xu4asRpP00Ue0igWBzKmn6nTk5lEMABMA+fiDVYdpuN0dNWbscZwLLozBsToayEgfDD/KdYCdqEV8y1mL97z7nSjB1VAfs5x3Skhq6AhKIe9p1Y9AbsOJP8vs+p+G+xHi/sKKzz8r3g27yNpP7emIO6lioYeuHTg341QSGJtPofrq9d+04J08dgnvxJ6dsfyGrYYGjIV9OYidbhMlXkXPofkMVA+1SCjVi1pQOPtlZ8ygzJK4+OiLK8NJJR5tcaMNSZ0l16RIoZw+IdEi2invyN/SXQqjVyie10sEbRarN8cVOJ58AANNsVYFrWa", "trust_eligible": "true", "grant_code": "cca13786ef08a405f94e575e9e8501ab7.0.mrzwz.y2Ef8JBOyp06v2uZhFL20g", "trust_token": "HSARMTKNSRVXWFlajR2ecD1662phQjqU9vXxnL49ZjypuVYYXHDpA3wTiX6Mf2J4WDlIhZj52z81aDOuz+VC80bVhV41TSNN4ggoPjW8WnsQrjniTQYkgJycPQNnzhkK4hfe2AMrr/bhrJJm8sHHc+Oh1HUckN6T7T4c1bmf2Qg9tRwsdRDNyMMyFH/Ml/cQlWKj39/YHlY=SRVX"}
\ No newline at end of file
diff --git a/database.py b/database.py
deleted file mode 100644
index 9e6c968..0000000
--- a/database.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from sqlalchemy import create_engine
-from dqlalchemy.orm import sessionmaker, declaritive_base
-
-DATABASE_URL = "sqlite:///./locations.db"
-
-engine = create_engine(
-        DATABASE_URL, connect_engine("check_same_thread": false}
-)
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base = declarative_base()
-
-def get_db():
-    """Dependency for getting database session."""
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-def create_all_tables():
-    """Creates all tables defined with Base in the database."""
-    # Note: import models before calling create_all_tables()
-    Base.metadata_create_all(bind=engine)
-    print("Database and tables created.")
-
diff --git a/db_models.py b/db_models.py
deleted file mode 100644
index fa4af67..0000000
--- a/db_models.py
+++ /dev/null
@@ -1,58 +0,0 @@
-from sqlalchemy import Column, Integer, String, Float, ForeignKey
-from sqlalchemy.orm import relationship
-from .database import Base
-
-
-class Location(Base):
-    """
-    SQLAlchemy model for the 'locations' table.
-    """
-    __tablename__ = "locations"
-
-    id = Column(Integer, primary_key=True, index=True)
-    name = Column(String, unique=False, index=True)
-    address = Column(String, unique=False, index=True)
-    latitude = Column(Float, unique=False, index=True)
-    longitude = Column(Float, unique=False, index=True)
-    is_favorite = Column(Boolean, unique=False, index=True) 
-
-    def __repr__(self):
-        return f"<Location(name='{self.name}', address='{self.address}', latitude='{self.latitude}', longitude='{self.longitude}', is_favorite='{self.is_favorite}')>"
-
-class Route(Base):
-    """
-    SQLAlchemy model for the 'routes' table.
-    """
-    __tablename__ = "routes"
-
-    id = Column(Integer, primary_key=True, index=True)
-    name = Column(String, index=True)
-
-    # Start and Endpoints (One-to-Many relationship)
-    start_location_id = Column(Integer, ForeignKey('locations.id'))
-    end_location_id = Column(Integer, ForeignKey('locations.id'))
-    
-    start_location = relationship("Location", foreign_keys=[start_id])
-    end_location = relationship("Location", foreign_keys=[end_id])
-
-    # Relationship to get waypoints ordered
-    waypoints = relationship("Waypoint", order_by="Waypoint.order", back_populates="route")
-
-
-    def __repr__(self):
-        return f"<Route(name='{self.name}', start='{self.start_location.name}', end='{self.end_location.name}')>"
-
-# Association Table for Many-to-Many relationsjip (Routes <-> Waypoints)
-class Waypoint(Base): 
-    """
-    SQLAlchemy model for the 'waypoints' table.
-    """
-    __tablename__ = 'waypoints'
-
-    id = Column(Integer, primary_key=True)
-    route_id = Column(Integer, ForeignKey('routes.id'))
-    location_id = Column(Integer, ForeignKey('locations.id'))
-    order = Column(Integer, nullable=False) 
-    
-    route = relationship("Route", back_populates="waypoints")
-    location = relationship("Location")
diff --git a/icloud.py b/icloud.py
deleted file mode 100644
index 373292c..0000000
--- a/icloud.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import asyncio
-from dotenv import load_dotenv
-import os
-import json
-import logging
-
-from pyicloud import PyiCloudService
-from pyicloud.exceptions import PyiCloud2FARequiredException
-class JsonFormatter(logging.Formatter):
-    def format(self, record: logging.LogRecord) -> str:
-        payload = {
-            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S%z"),
-            "level": record.levelname,
-            "logger": record.name,
-            "message": record.getMessage(),
-        }
-        if record.exc_info:
-            payload["exc_info"] = self.formatException(record.exc_info)
-        return json.dumps(payload, ensure_ascii=True)
-
-
-handler = logging.StreamHandler()
-handler.setFormatter(JsonFormatter())
-root_logger = logging.getLogger()
-root_logger.handlers = [handler]
-root_logger.setLevel(logging.INFO)
-logger = logging.getLogger("ios-api")
-
-class FindMyMonitor:
-    def __init__(self, queue: asyncio.Queue, token_file="icloud_token.txt"):
-        self.username = os.getenv("APPLE_ID")
-        self.password = os.getenv("APPLE_PW")
-        self.token_file = token_file
-        self.queue = queue
-        self.api = None
-        self.device = None
-        self.running = True
-
-    async def authenticate(self):
-        """Authenticates with iCloud, handling 2FA and token storage."""
-        if os.path.exists(self.token_file):
-            print("Loading stored session...")
-            self.api = PyiCloudService(self.username, cookie_directory="./cookies")
-        else:
-            print("No stored session. Authenticating...")
-            self.api = PyiCloudService(self.username, self.password, cookie_directory="./cookies")
-
-        if self.api.requires_2fa:
-            print("Two-factor authentication required.")
-            code = input("Enter the code you received: ")
-            result = self.api.validate_2fa_code(code)
-            print(f"Code validation result: {result}")
-            if not result:
-                print("Failed to verify 2FA code")
-                return False
-            
-            # Trust the session
-            self.api.trust_session()
-            
-        print("Successfully authenticated.")
-        return True
-
-    async def get_location(self):
-        """Fetches the latest latitude and longitude."""
-        if not self.api:
-            await self.authenticate()
-        
-        # Refresh API data
-        self.api.refresh_client()
-        
-        # Find the device (modify name to match your iPhone name in iCloud)
-        if not self.device:
-            # Assuming you have devices, pick the first or match by name
-            self.device = self.api.devices[0] 
-            print(f"Monitoring device: {self.device.name()}")
-
-        location = self.device.location()
-        if location:
-            return location['latitude'], location['longitude'], location['timeStamp']
-        return None
-
-    def start(self):
-        self.running = True
-
-    def stop(self):
-        self.running = False
-
-    async def run_monitor(self, interval=60):
-        """Runs the monitor loop."""
-        if not await self.authenticate():
-            return
-
-        if not self.running:
-            self.start()
-
-        while self.running:
-            logger.info("Starting iCloud FMF loop")
-            try:
-                lat, lon, ts = await self.get_location()
-                print(f"[{ts}] Location: {lat}, {lon}")
-                # Add your logic to update database/API here
-                await self.queue.put(lat, lng, ts)
-                
-            except Exception as e:
-                print(f"Error: {e}")
-                # Re-authenticate if session expired
-                await self.authenticate()
-            
-            await asyncio.sleep(interval)
-
-
diff --git a/main.bk b/main.bk
deleted file mode 100644
index cb20409..0000000
--- a/main.bk
+++ /dev/null
@@ -1,50 +0,0 @@
-from flask import Flask, request, jsonify
-from flask_cors import CORS
-
-app = Flask(__name__, static_folder="../front-end/dist/assets", template_folder="../front-end/dist")
-CORS(app)
-
-@app.route('/')
-def index():
-    return app.send_static_file('index.html')
-
-# Essential for handling client-side routing (e.g., Vue Router history mode)
-@app.route('/<path:path>')
-def static_files(path):
-    return app.send_static_file(path)
-
-@app.route('/api/set', methods=['POST'])
-def handle_json_data():
-    data = request.get_json()
-
-    if not data:
-        return jsonify({'error': 'Missing JSON data'}), 400
-
-    if 'lat' not in data:
-        return jsonify({'error': 'Missing lat in JSON data'}), 400
-
-    if 'lng' not in data:
-        return jsonify({'error': 'Missing lng in JSON data'}), 400
-
-    # Process the data (e.g., save to a database)
-    lat = data['lat']
-    lng = data['lng']
-
-    # Return a JSON response
-    return jsonify({
-        'message': f'lat: {lat}, lng: {lng} received successfully!',
-        'data': data
-    }), 200
-
-@app.route('/api/status', methods=['GET'])
-def get_data():
-    return jsonify(message="Hello from Flask API!")
-
-@app.errorhandler(404)
-def not_found(error):
-    return jsonify({'error': 'Not found'}), 404
-
-
-
-if __name__ == '__main__':
-    app.run(debug=True, host='0.0.0.0', port=5000)
diff --git a/main.py b/main.py
index a8684dc..ca59beb 100644
--- a/main.py
+++ b/main.py
@@ -1,48 +1,16 @@
-import asyncio
-import dataclasses
-import json
-import logging
-import random
-import sys
-import socketio
 import tempfile
-from contextlib import nullcontext
 from functools import partial
-from pathlib import Path
-from typing import Annotated, Optional, TextIO
-
+from typing import Annotated
 import typer
-from typer_injector import InjectingTyper
 
-from pymobiledevice3.bonjour import DEFAULT_BONJOUR_TIMEOUT, browse_remotepairing_manual_pairing
-from pymobiledevice3.cli.cli_common import (
-    RSDServiceProviderDep,
-    async_command,
-    print_json,
-    prompt_device_list,
-    sudo_required,
-    user_requested_colored_output,
-)
-from pymobiledevice3.common import get_home_folder
-from pymobiledevice3.exceptions import NoDeviceConnectedError
-from pymobiledevice3.pair_records import PAIRING_RECORD_EXT, get_remote_pairing_record_filename
-from pymobiledevice3.remote.common import ConnectionType, TunnelProtocol
-from pymobiledevice3.remote.module_imports import MAX_IDLE_TIMEOUT, start_tunnel, verify_tunnel_imports
-from pymobiledevice3.remote.remote_service_discovery import RSD_PORT
-from pymobiledevice3.remote.tunnel_service import (
-    RemotePairingManualPairingService,
-    get_core_device_tunnel_services,
-    get_remote_pairing_tunnel_services,
-)
-from pymobiledevice3.remote.utils import get_rsds
+from pymobiledevice3.remote.common import TunnelProtocol
+from pymobiledevice3.remote.module_imports import verify_tunnel_imports
 from pymobiledevice3.tunneld.api import TUNNELD_DEFAULT_ADDRESS
-from pymobiledevice3.utils import run_in_loop
-from server import TunneldRunnerSio, LocationSimulationState, logger
-
+from src.pymd3_vue_location_sim.server import TunneldRunnerSio, LocationSimulationState
+from src.pymd3_vue_location_sim.json_formatter import logger
 
 def main():
-    cli_tunneld(host="0.0.0.0", port=8000)
-
+    cli_tunneld(host="0.0.0.0", port=49151)
 
 def cli_tunneld(
         host: Annotated[str, typer.Option(help="Address to bind the tunneld server to.")] = TUNNELD_DEFAULT_ADDRESS[0],
@@ -93,4 +61,4 @@ def cli_tunneld(
 
 # 4. Entry point (always last)
 if __name__ == "__main__":
-    main()
\ No newline at end of file
+    main()
diff --git a/pyproject.toml b/pyproject.toml
index b5f9d44..56b95da 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,12 +3,18 @@ name = "back-end"
 version = "0.1.0"
 requires-python = ">=3.14"
 dependencies = [
+    "click>=8.3.1",
+    "daemonize>=2.5.0",
     "fastapi==0.135.1",
+    "geopy==2.4.1",
     "pydantic==2.12.5",
     "pyicloud>=2.4.1",
     "pymobiledevice3==9.0.0",
     "python-dotenv>=1.2.2",
     "python-socketio==5.16.1",
+    "sqlalchemy>=2.0.48",
+    "sqlalchemy-orm>=1.2.10",
+    "typer>=0.24.1",
     "typing==3.10.0.0",
     "uvicorn==0.41.0",
 ]
diff --git a/server.py b/server.py
deleted file mode 100644
index 9d92e69..0000000
--- a/server.py
+++ /dev/null
@@ -1,1102 +0,0 @@
-import asyncio
-
-from icloud import FindMyMonitor
-from datetime import datetime, timezone, timedelta
-import json
-import uuid
-import logging
-import os
-import signal
-import traceback
-import warnings
-import random
-from operator import truediv
-
-from pydantic import BaseModel, RootModel
-import socketio
-from contextlib import asynccontextmanager, suppress
-
-from typing import Optional, Dict
-
-from pymobiledevice3.services.dvt.instruments.location_simulation_base import LocationSimulationBase
-
-with warnings.catch_warnings():
-    # Ignore: "Core Pydantic V1 functionality isn't compatible with Python 3.14 or greater."
-    warnings.simplefilter("ignore", category=UserWarning)
-    import fastapi
-
-import uvicorn
-from fastapi import FastAPI
-
-from pymobiledevice3.exceptions import (
-    ConnectionFailedError,
-    InvalidServiceError,
-    MuxException,
-    TunneldConnectionError,
-)
-from pymobiledevice3.lockdown import create_using_usbmux, get_mobdev2_lockdowns
-from pymobiledevice3.osu.os_utils import get_os_utils
-from pymobiledevice3.remote.common import TunnelProtocol
-from pymobiledevice3.remote.remote_service_discovery import (
-    RemoteServiceDiscoveryService
-)
-from pymobiledevice3.remote.tunnel_service import (
-    CoreDeviceTunnelProxy,
-    TunnelResult,
-    create_core_device_tunnel_service_using_rsd,
-    get_remote_pairing_tunnel_services,
-)
-from pymobiledevice3.remote.utils import get_rsds
-from pymobiledevice3.services.dvt.instruments.location_simulation import LocationSimulation
-from pymobiledevice3.services.dvt.instruments.dvt_provider import DvtProvider
-from pymobiledevice3.tunneld.server import TunneldCore, TunnelTask
-
-class JsonFormatter(logging.Formatter):
-    def format(self, record: logging.LogRecord) -> str:
-        payload = {
-            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S%z"),
-            "level": record.levelname,
-            "logger": record.name,
-            "message": record.getMessage(),
-        }
-        if record.exc_info:
-            payload["exc_info"] = self.formatException(record.exc_info)
-        return json.dumps(payload, ensure_ascii=True)
-
-
-handler = logging.StreamHandler()
-handler.setFormatter(JsonFormatter())
-root_logger = logging.getLogger()
-root_logger.handlers = [handler]
-root_logger.setLevel(logging.INFO)
-logger = logging.getLogger("ios-api")
-
-# bugfix: after the device reboots, it might take some time for remoted to start answering the bonjour queries
-REATTEMPT_INTERVAL = 5
-REATTEMPT_COUNT = 5
-
-REMOTEPAIRING_INTERVAL = 5
-MOBDEV2_INTERVAL = 5
-
-# USB monitor will periodically forget what interfaces it has seen
-# and force a full rescan.  The value is the number of iterations of the
-# inner loop (which sleeps one second each) before blowing away the
-# `previous_ips` cache.
-USB_MONITOR_RESCAN_INTERVAL = 30
-
-USBMUX_INTERVAL = 2
-OSUTILS = get_os_utils()
-TUNNEL_ACQUIRE_TIMEOUT_SECONDS = 15
-DVT_CONNECT_TIMEOUT_SECONDS = 20
-
-
-class SimulationStatusData(BaseModel):
-    latitude: float
-    longitude: float
-    start: float
-    end: Optional[float]
-    next_move: Optional[float]
-
-
-class SimulationStatus(BaseModel):
-    status: bool
-    data: Optional[SimulationStatusData]
-
-
-class SimulationRequestData(BaseModel):
-    latitude: float
-    longitude: float
-    delay: int = 0
-    start: Optional[str] = None
-    end: Optional[str] = None
-
-
-class SimulationRequest(BaseModel):
-    status: bool
-    data: Optional[SimulationRequestData]
-
-
-class SimulationRequestResponseData(BaseModel):
-    loc_id: str
-    latitude: float
-    longitude: float
-    delay: int = 0
-    start: Optional[str] = None
-    end: Optional[str] = None
-
-class SimulationQueueList(BaseModel):
-    data: Optional[SimulationRequestResponseData]
-
-
-class SimulationRequestResponse(BaseModel):
-    status: bool
-    data: Optional[SimulationRequestResponseData]
-
-class SimulationQueueDict(BaseModel):
-    location_id: Dict[str, SimulationRequestResponseData]
-
-class iCloudLocationData(BaseModel):
-    latitude: number
-    longitude: number
-    timestamp: string
-
-
-class LocationSimulationState:
-    def __init__(self):
-        self.current_location: Optional[Dict[str, SimulationRequestResponseData]] = None
-        self.next_location: Optional[Dict[str, SimulationRequestResponseData]] = None
-        self.loc_id: Optional[str] = None
-        self.latitude: Optional[float] = None
-        self.longitude: Optional[float] = None
-        self.next_move: Optional[float] = None
-        self.udid: Optional[str] = None
-        self.simulation_active: bool = False
-        self.set_location_enabled: bool = True
-        self.queue: asyncio.Queue = asyncio.Queue()
-        self.queue_order: list[str] = []
-        self.queue_data: Dict = {} 
-        self.queue_status: Optional[asyncio.Event] = asyncio.Event()
-        self.queue_state: str = "STOPPED"
-        self.test_mode: bool = True
-        self.simulation_task: Optional[asyncio.Task] = None
-        self.sio: socketio.AsyncServer = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
-        self.tunnel: Optional[RemoteServiceDiscoveryService] = None
-        self.fmf_queue: asyncio.Queue = asyncio.Queue
-        self.fmf_location: Optional[iCloudLocationData] = None
-        self.icloud_monitor = FindMyMonitor(self.fmf_queue)
-        self.icloud_monitor_task = None
-
-
-class TunneldRunnerSio:
-    """TunneldRunner orchestrate between the webserver and TunneldCore"""
-
-    @classmethod
-    def create(
-            cls,
-            host: str,
-            port: int,
-            context: LocationSimulationState = LocationSimulationState(),
-            protocol: TunnelProtocol = TunnelProtocol.QUIC,
-            usb_monitor: bool = True,
-            wifi_monitor: bool = True,
-            usbmux_monitor: bool = True,
-            mobdev2_monitor: bool = True,
-    ) -> None:
-        cls(
-            host,
-            port,
-            protocol=protocol,
-            usb_monitor=usb_monitor,
-            wifi_monitor=wifi_monitor,
-            usbmux_monitor=usbmux_monitor,
-            mobdev2_monitor=mobdev2_monitor,
-            context=context,
-        )._run_app()
-
-    def __init__(
-            self,
-            host: str,
-            port: int,
-            context: LocationSimulationState = LocationSimulationState(),
-            protocol: TunnelProtocol = TunnelProtocol.QUIC,
-            usb_monitor: bool = True,
-            wifi_monitor: bool = True,
-            usbmux_monitor: bool = True,
-            mobdev2_monitor: bool = True,
-    ):
-        @asynccontextmanager
-        async def lifespan(app: FastAPI):
-            self._tunneld_core.start()
-            await start_icloud_monitor()
-            yield
-            logger.info("Closing tunneld tasks...")
-            await empty_simulation_queue()
-            await self._tunneld_core.close()
-            await self.context.sio.shutdown()
-
-        self.host = host
-        self.port = port
-        self.protocol = protocol
-        self.context = context
-        self._tunneld_api_address = ("127.0.0.1" if host in ("0.0.0.0", "::") else host, port)
-        self._app = FastAPI(title="iOS Device Management API", lifespan=lifespan, cors_allowed_origins="*")
-        self._asgi_app = socketio.ASGIApp(self.context.sio, self._app)
-        self._tunneld_core = TunneldCore(
-            protocol=protocol,
-            wifi_monitor=wifi_monitor,
-            usb_monitor=usb_monitor,
-            usbmux_monitor=usbmux_monitor,
-            mobdev2_monitor=mobdev2_monitor,
-        )
-
-        async def get_tun(
-                udid: Optional[str] = None, max_retries: int = 10, retry_delay: float = 0.5
-        ) -> RemoteServiceDiscoveryService:
-            """Resolve an active local tunnel and connect directly to its RSD endpoint."""
-            if self.context.tunnel is not None:
-                return self.context.tunnel
-
-            for attempt in range(max_retries):
-                candidates = []
-                for active_tunnel in self._tunneld_core.tunnel_tasks.values():
-                    if active_tunnel.tunnel is None or active_tunnel.udid is None:
-                        continue
-                    if udid is None or active_tunnel.udid == udid:
-                        candidates.append(active_tunnel.tunnel)
-
-                if not candidates:
-                    if attempt < max_retries - 1:
-                        logger.info("Waiting for local tunnel to be ready... (attempt %s/%s)", attempt + 1, max_retries)
-                        await asyncio.sleep(retry_delay)
-                        continue
-                    logger.error("Failed to find an active local tunnel after max retries")
-                    raise TunneldConnectionError()
-
-                tunnel = candidates[0]
-                if udid and len(candidates) > 1:
-                    logger.warning("Multiple local tunnels found for udid %s; using first available", udid)
-
-                try:
-                    rsd = RemoteServiceDiscoveryService((tunnel.address, tunnel.port))
-                    await rsd.connect()
-                    logger.info(
-                        "Connected to local tunnel at %s:%s after %s retries",
-                        tunnel.address,
-                        tunnel.port,
-                        attempt,
-                    )
-                    self.context.tunnel = rsd
-                    return rsd
-                except Exception:
-                    if attempt < max_retries - 1:
-                        logger.info("Tunnel endpoint not ready yet... (attempt %s/%s)", attempt + 1, max_retries)
-                        await asyncio.sleep(retry_delay)
-                    else:
-                        logger.error("Failed to connect to local tunnel endpoint after max retries")
-                        raise TunneldConnectionError()
-
-            raise TunneldConnectionError()
-
-        def cleanup_device_data(d):
-            mydict = {}
-            for key, value in d.items():
-                if isinstance(value, dict):
-                    cleanup_device_data(value)
-                elif isinstance(value, bytes):
-                    mydict[key] = 'BYTE DATA'
-                else:
-                    mydict[key] = value
-            return mydict
-
-        async def device_reboot(delay):
-            """ Reboot the device"""
-            logger.info("Reboot iniated with delay %s")
-            await asyncio.sleep(delay)
-            os.system("shutdown -r now")
-
-        async def device_shutdown(delay):
-            """ Shutdown the device"""
-            logger.info("Shutdown iniated with delay %s")
-            await asyncio.sleep(delay)
-            os.system("shutdown -h now")
-
-        """ Queue Functions"""
-        async def start_simulation_queue():
-            """ Start Simulation Queue Worker"""
-            logger.info("Starting location simulation worker...")
-            self.context.simulation_active = True
-            self.context.queue_state = "RUNNING"
-            self.context.queue_status.set()
-            try:
-                if self.context.test_mode:
-                    logger.info("Simulation worker: test mode enabled")
-                    with LocationSimulationTestQueue(self.context) as locate_simulation:
-                        await locate_simulation.play_queue()
-
-                if self.context.udid is None and not self.context.test_mode:
-                    active_udids = sorted(
-                        {t.udid for t in self._tunneld_core.tunnel_tasks.values() if
-                         t.udid is not None and t.tunnel is not None}
-                    )
-                    if len(active_udids) == 1:
-                        self.context.udid = active_udids[0]
-                        logger.info("Simulation worker: auto-selected udid=%s from active tunnel", self.context.udid)
-                    elif len(active_udids) == 0:
-                        logger.error("Simulation worker: no active tunnel with udid available")
-                        await self.context.sio.emit(
-                            "appError",
-                            {"type": "simulation_no_tunnel", "message": "No active tunnel found. Start tunnel first."},
-                            namespace="/",
-                        )
-                        return
-                    else:
-                        logger.error("Simulation worker: multiple active tunnels; explicit udid required: %s",
-                                     active_udids)
-                        await self.context.sio.emit(
-                            "appError",
-                            {
-                                "type": "simulation_udid_required",
-                                "message": "Multiple active tunnels found; provide udid in start_simulate_location.",
-                                "udids": active_udids,
-                            },
-                            namespace="/",
-                        )
-                        return
-
-                logger.info("Simulation worker: acquiring tunnel (udid=%s)", self.context.udid)
-
-                tun = await get_tun(self.context.udid)
-                logger.info("Simulation worker: tunnel acquired, connecting DVT provider")
-                dvt_provider = DvtProvider(tun)
-                dvt = await asyncio.wait_for(dvt_provider.__aenter__(), timeout=DVT_CONNECT_TIMEOUT_SECONDS)
-                logger.info("Simulation worker: DVT provider connected, starting queue playback")
-                try:
-                    async with LocationSimulationQueue(dvt, self.context) as locate_simulation:
-                        await locate_simulation.play_queue()
-                finally:
-                    logger.info("Simulation worker: closing DVT provider")
-                    await dvt_provider.__aexit__(None, None, None)
-                    logger.info("Simulation worker: DVT provider closed")
-            except TimeoutError:
-                logger.error(
-                    "Simulation worker timeout. tunnel_timeout=%ss dvt_timeout=%ss udid=%s",
-                    TUNNEL_ACQUIRE_TIMEOUT_SECONDS,
-                    DVT_CONNECT_TIMEOUT_SECONDS,
-                    self.context.udid,
-                )
-                await self.context.sio.emit(
-                    "appError",
-                    {
-                        "type": "simulation_timeout",
-                        "udid": self.context.udid,
-                        "tunnel_timeout_seconds": TUNNEL_ACQUIRE_TIMEOUT_SECONDS,
-                        "dvt_timeout_seconds": DVT_CONNECT_TIMEOUT_SECONDS,
-                    },
-                    namespace="/",
-                )
-            except Exception:
-                logger.exception("Simulation worker crashed")
-                await self.context.sio.emit(
-                    "appError",
-                    {"type": "simulation_crash", "udid": self.context.udid},
-                    namespace="/",
-                )
-            finally:
-                self.context.simulation_active = False
-                self.context.simulation_task = None
-
-
-
-        async def start_icloud_monitor():
-            """Start Apple iCloud Find My Monitor to retreive actual reported device location"""
-            self.context.icloud_monitor_task = asyncio.create_task(self.context.icloud_monitor.run_monitor(interval=30))
-            while True:
-                updated_location = await self.context.fmf_queue.get()
-                if self.context.fmf_location != updated_location:
-                    self.context.fmf_location = update_location
-                    self.context.sio.emit("fmf_update", updated_location, namespace="/",)
-
-        async def end_icloud_monitor():
-            self.context.icloud_monitor.end()
-
-        async def pause_simulation_queue():
-            """Pauses asyncio.Queue playback"""
-            self.context.queue_state = "PAUSED"
-
-        async def resume_simulation_queue():
-            """Resumes asyncio.Queue playback"""
-            self.context.queue_state = "RUNNING"
-
-        async def empty_simulation_queue():
-            """Empties all items from an asyncio.Queue."""
-            logger.info("Clearing location simulation queue...")
-            q = self.context.queue
-            self.context.set_location_enabled = False
-            while not q.empty():
-                try:
-                    item = q.get_nowait()
-                    q.task_done()
-                    logger.info("Discarding item from queue: %s", item)
-                except asyncio.QueueEmpty:
-                    break
-
-        def add_item(item_id, payload):
-            self.context.queue_data[item_id] = payload
-            self.context.queue_order.append(item_id)
-
-        def remove_item(item_id):
-            if item_id in self.context.queue_order:
-                self.context.queue_order.remove(item_id)
-
-        def get_item(item_id):
-            return self.context.queue_data[item_id]
-
-        def update_item(item_id, **updates):
-            if item_id in self.context.queue_data:
-                self.context.queue_data[item_id].update(updates)
-
-        def get_item_index(item_id):
-            return self.context.queue_order.index(item_id)
-
-        def get_item_id_by_index(index):
-            return self.context.queue_order[index]
-
-        def get_items_in_order():
-            return [self.context.queue_data[i] for i in self.context.queue_order]
-
-
-
-        async def end_simulation_queue() -> bool:
-            """Ends asyncio.Queue playback and closes tunnel"""
-            logger.info("End location simulation request")
-            try:
-                if self.context.test_mode:
-                    q = self.context.queue
-                    if q.qsize() > 0:
-                        self.context.set_location_enabled = False
-                        while not q.empty():
-                            try:
-                                item = q.get_nowait()
-                                q.task_done()
-                                logger.info("Discarding item from queue: %s", item)
-                            except asyncio.QueueEmpty:
-                                break
-
-                    await q.join()
-#                    with suppress(asyncio.CancelledError):
-#                        await self.context.simulation_task
-                    self.context.simulation_active = False
-                    self.context.queue_state = "SHUTDOWN"
-                    return True
-                if not self.context.test_mode:
-                    if self.context.simulation_task is not None and not self.context.simulation_task.done():
-                        q = self.context.queue
-                        if q.qsize() > 0:
-                            await empty_simulation_queue()
-                        while q.empty() and q.qsize() == 0:
-                            await q.join()
-                        with suppress(asyncio.CancelledError):
-                            await self.context.simulation_task
-                        if self.context.tunnel is not None:
-                            async with DvtProvider(self.context.tunnel) as dvt, LocationSimulation(dvt) as locate_simulation:
-                                await locate_simulation.clear()
-                        self.context.simulation_active = False
-                        self.context.queue_state = "SHUTDOWN"
-                        return True
-            except Exception as e:
-                logger.error(f"Error ending simulation queue: {e}")
-                return False
-
-
-        def get_status():
-            data = {
-                "current_location": self.context.current_location,
-                "next_location": self.context.next_location,
-                "latitude": self.context.latitude,
-                "longitude": self.context.longitude,
-                "next_move": self.context.next_move,
-                "udid": self.context.udid,
-                "simulation_active": self.context.simulation_active,
-                "loc_id": self.context.loc_id,
-                "set_location_enable": self.context.set_location_enabled,
-                "queue_length": self.context.queue.qsize() if self.context.queue else 0,
-                "queue_state": self.context.queue_state,
-                "queue_order": self.context.queue_order,
-                "queue_data": self.context.queue_data,
-                "queue_status": self.context.queue_status.is_set() if self.context.queue_status else False,
-                "test_mode": self.context.test_mode,
-                "simulation_task": self.context.simulation_task.get_name() if self.context.simulation_task else None,
-                "tunnel": self.context.tunnel.service.address[0] if self.context.tunnel else None,
-                "fmf_location": self.context.fmf_location,
-            }
-            return data
-
-        """ FastAPI HTTP Functions"""
-        def generate_http_response(
-                data: dict, status_code: int = 200, media_type: str = "application/json"
-        ) -> fastapi.Response:
-            return fastapi.Response(status_code=status_code, media_type=media_type, content=json.dumps(data))
-
-        """ Tunnel Functions"""
-        @self._app.get("/start-tunnel")
-        async def start_tunnel(
-                udid: Optional[str] = self.context.udid, ip: Optional[str] = None, connection_type: Optional[str] = None
-        ) -> fastapi.Response:
-            udid_tunnels = [
-                t.tunnel for t in self._tunneld_core.tunnel_tasks.values() if t.udid == udid and t.tunnel is not None
-            ]
-            if len(udid_tunnels) > 0:
-                self.context.udid = udid
-                data = {
-                    "interface": udid_tunnels[0].interface,
-                    "port": udid_tunnels[0].port,
-                    "address": udid_tunnels[0].address,
-                }
-                return generate_http_response(data)
-            queue = asyncio.Queue()
-            created_task = False
-            try:
-                if not created_task and connection_type in ("usbmux", None):
-                    task_identifier = f"usbmux-{udid}"
-                    try:
-                        async with await create_using_usbmux(udid) as lockdown:
-                            service = await CoreDeviceTunnelProxy.create(lockdown)
-                        task = asyncio.create_task(
-                            self._tunneld_core.start_tunnel_task(
-                                task_identifier, service, protocol=TunnelProtocol.TCP, queue=queue
-                            ),
-                            name=f"start-tunnel-task-{task_identifier}",
-                        )
-                        self._tunneld_core.tunnel_tasks[task_identifier] = TunnelTask(task=task, udid=udid)
-                        created_task = True
-                    except (ConnectionFailedError, InvalidServiceError, MuxException):
-                        pass
-                if connection_type in ("usb", None):
-                    for rsd in await get_rsds(udid=udid):
-                        rsd_ip = rsd.service.address[0]
-                        if ip is not None and rsd_ip != ip:
-                            await rsd.close()
-                            continue
-                        task = asyncio.create_task(
-                            self._tunneld_core.start_tunnel_task(
-                                rsd_ip, await create_core_device_tunnel_service_using_rsd(rsd), queue=queue
-                            ),
-                            name=f"start-tunnel-usb-{rsd_ip}",
-                        )
-                        self._tunneld_core.tunnel_tasks[rsd_ip] = TunnelTask(task=task, udid=rsd.udid)
-                        created_task = True
-                if not created_task and connection_type in ("wifi", None):
-                    for remotepairing in await get_remote_pairing_tunnel_services(udid=udid):
-                        remotepairing_ip = remotepairing.hostname
-                        if ip is not None and remotepairing_ip != ip:
-                            await remotepairing.close()
-                            continue
-                        task = asyncio.create_task(
-                            self._tunneld_core.start_tunnel_task(remotepairing_ip, remotepairing, queue=queue),
-                            name=f"start-tunnel-wifi-{remotepairing_ip}",
-                        )
-                        self._tunneld_core.tunnel_tasks[remotepairing_ip] = TunnelTask(
-                            task=task, udid=remotepairing.remote_identifier
-                        )
-                        created_task = True
-            except Exception as e:
-                return fastapi.Response(
-                    status_code=501,
-                    content=json.dumps({
-                        "error": {
-                            "exception": e.__class__.__name__,
-                            "traceback": traceback.format_exc(),
-                        }
-                    }),
-                )
-            if not created_task:
-                return fastapi.Response(status_code=501, content=json.dumps({"error": "task not created"}))
-            tunnel: Optional[TunnelResult] = await queue.get()
-            if tunnel is not None:
-                self.context.udid = udid
-                data = {"interface": tunnel.interface, "port": tunnel.port, "address": tunnel.address}
-                return generate_http_response(data)
-            else:
-                return fastapi.Response(
-                    status_code=404, content=json.dumps({"error": "something went wrong during tunnel creation"})
-                )
-
-        @self._app.get("/shutdown")
-        async def shutdown() -> fastapi.Response:
-            """Shutdown Tunneld"""
-            os.kill(os.getpid(), signal.SIGINT)
-            data = {"operation": "shutdown", "data": True, "message": "Server shutting down..."}
-            return generate_http_response(data)
-
-        @self._app.get("/clear-tunnels")
-        async def clear_tunnels() -> fastapi.Response:
-            """Clear all tunnels"""
-            self._tunneld_core.clear()
-            data = {"operation": "clear_tunnels", "data": True, "message": "Cleared tunnels..."}
-            return generate_http_response(data)
-
-        @self._app.get("/cancel")
-        async def cancel_tunnel(udid: str) -> fastapi.Response:
-            """Cancel a tunnel"""
-            self._tunneld_core.cancel(udid=udid)
-            data = {"operation": "cancel", "udid": udid, "data": True, "message": f"tunnel {udid} Canceled ..."}
-            return generate_http_response(data)
-
-        """Simulation Functions"""
-        @self._app.get("/start-simulation")
-        async def app_start_simulation() -> fastapi.Response:
-            logger.info("Simulation Start Requested ")
-            if self.context.simulation_task is None or self.context.simulation_task.done():
-                self.context.simulation_active = True
-                self.context.simulation_task = asyncio.create_task(
-                    start_simulation_queue(),
-                    name="location-simulation-worker",
-                )
-                data = {"status": "started", "message": "Simulation started"}
-            else:
-                data = {"status": "error", "message": "Simulation already running"}
-            return generate_http_response(data)
-
-        @self._app.post("/add-location")
-        async def app_add_location(data: SimulationRequestData) -> fastapi.Response:
-            """ Add a location to the simulation queue"""
-            logger.info("Request to add new location to queue")
-
-            loc_id = str(uuid.uuid4())
-            latitude = data.get("latitude") if isinstance(data, dict) else getattr(data, "latitude", None)
-            longitude = data.get("longitude") if isinstance(data, dict) else getattr(data, "longitude", None)
-            delay = data.get("delay", 0) if isinstance(data, dict) else getattr(data, "delay", 0)
-            delay = 0 if delay is None else delay
-            if latitude is not None and longitude is not None:
-                logger.info("Adding location %s (%s, %s) with %s delay to the queue", loc_id, latitude, longitude,
-                            delay)
-                accrued_delay = 0
-                if self.context.queue_data:
-                    accrued_delay = sum(item.get('delay', 0) for item in self.context.queue_data.values())
-                now_time = datetime.now(timezone.utc)
-                new_time = now_time + timedelta(seconds=accrued_delay) + timedelta(seconds=delay)
-                start_time = new_time.isoformat()
-                location_item = {
-                    "loc_id": loc_id,
-                    "latitude": latitude,
-                    "longitude": longitude,
-                    "delay": delay,
-                    "start": start_time
-                }
-                resp = {
-                    "status": "added",
-                    "message": f"Location {loc_id} added to the queue",
-                    "item": location_item
-                }
-                await self.context.queue.put(loc_id)
-                add_item(loc_id, location_item)
-                logger.info("Location %s added to the queue", loc_id)
-            else:
-                resp = {"status": "error", "message": "Invalid location data"}
-            return generate_http_response(resp)
-
-        @self._app.get("/clear-queue")
-        async def app_clear_queue() -> fastapi.Response:
-            """ Clear the simulation queue"""
-            logger.info("Simulation Start Requested ")
-            await empty_simulation_queue()
-            data = {"status": "cleared", "message": "Simulation cleared"}
-            return generate_http_response(data)
-
-        @self._app.get("/pause-queue")
-        async def app_pause_queue() -> fastapi.Response:
-            """ Pause the simulation queue"""
-            await pause_simulation_queue()
-            data = {"status": "paused", "message": "Simulation paused"}
-            return generate_http_response(data)
-
-        @self._app.get("/resume-queue")
-        async def app_resume_queue() -> fastapi.Response:
-            """ Resume the simulation queue"""
-            await resume_simulation_queue()
-            data = {"status": "resumed", "message": "Simulation resumed"}
-            return generate_http_response(data)
-
-        @self._app.get("/end-simulation")
-        async def app_end_simulation() -> fastapi.Response:
-            """ End the simulation queue"""
-            logger.info("End location simulation request")
-            end_task = asyncio.create_task(end_simulation_queue(), name="end-simulation-worker")
-            result = await end_task
-            data = {"status": result, "message": "Simulation ended"}
-            return generate_http_response(data)
-
-        """Status Functions"""
-        @self._app.get("/")
-        async def list_tunnels() -> dict[str, list[dict]]:
-            """Retrieve the available tunnels and format them as {UUID: TUNNEL_ADDRESS}"""
-            tunnels = {}
-            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
-                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
-                    continue
-                if active_tunnel.udid not in tunnels:
-                    tunnels[active_tunnel.udid] = []
-                tunnels[active_tunnel.udid].append(
-                    {
-                        "tunnel-address": active_tunnel.tunnel.address,
-                        "tunnel-port": active_tunnel.tunnel.port,
-                        "interface": ip,
-                    }
-                )
-            return tunnels
-
-        @self._app.get("/device-info")
-        async def device_info():
-            """Get device information"""
-            tunnels = {}
-            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
-                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
-                    continue
-                if active_tunnel.udid not in tunnels:
-                    tunnels[active_tunnel.udid] = {}
-                try:
-                    lockdown = await create_using_usbmux(serial=active_tunnel.udid, autopair=False)
-                    tunnels[active_tunnel.udid] = iterate_multidim(lockdown.all_values)
-                except Exception as e:
-                    logger.error(f"Failed to create lockdown session for device {active_tunnel.udid}: {e}")
-                    continue
-            return tunnels
-
-        @self._app.get("/hello")
-        async def hello() -> fastapi.Response:
-            data = {"message": "Hello, I'm alive"}
-            return generate_http_response(data)
-
-        @self._app.get("/context-status")
-        async def app_context_status() -> fastapi.Response:
-            data = get_status()
-            return generate_http_response(data)
-
-        """ Socket.IO Functions"""
-
-        async def sio_send_status(sid):
-            """ Send Current Status"""
-            await self.context.sio.emit("status", get_status(), namespace="/", to=sid)
-
-        """Socket.IO Connection Events"""
-        @self.context.sio.event
-        async def connect(sid, environ):
-            """Client connection event handler."""
-            logger.info("Client connected: %s", sid)
-            await sio_send_status(sid)
-            return '%s connected' % sid
-
-        @self.context.sio.event
-        async def disconnect(sid):
-            """Client disconnection event handler."""
-            logger.info("Client disconnected: %s", sid)
-
-        """ Socket.IO Request Events """
-        @self.context.sio.event
-        async def request_update(sid, data):
-            logger.info("Update request from %s", sid)
-
-        @self.context.sio.event
-        async def message(sid, data):
-            logger.info("Received message from %s: %s", sid, data)
-            return True, "Message received"
-#            await self.context.sio.emit("message", f"Received message from {sid}: {data}", namespace="/")
-
-        """ Device Control"""
-        @self.context.sio.event
-        async def device_control(sid, data):
-            """ Device Control """
-            command = data.get("command") if isinstance(data, dict) else getattr(data, "command", None)
-            delay = data.get("delay") if isinstance(data, dict) else getattr(data, "delay", None)
-            if delay is None:
-                delay = 5
-            match command:
-                case "shutdown":
-                    """ Shutdown the device"""
-                    logger.info("Shutdown command received from %s with delay %s", sid, delay)
-                    await device_shutdown(delay)
-                    return { "command": "shutdown", "status": "success", "message": f"Device shutdown initiated with {delay} seconds delay" }
-
-                case "reboot":
-                    """ Reboot the device"""
-                    logger.info("Reboot command received from %s with delay %s", sid, delay)
-                    await device_reboot(delay)
-                    return { "command": "reboot", "status": "success", "message": f"Device reboot initiated with {delay} seconds delay" }
-
-                case _:
-                    return { "command": command, "status": "error", "message": f"Invalid command: {command}" }
-
-        @self.context.sio.event
-        async def simulation_control(sid, data):
-            """ Simulation Control """
-            command = data.get("command") if isinstance(data, dict) else getattr(data, "command", None)
-            logger.info("Simulation Control command: %s requested from %s", command, sid)
-            try:
-                match command:
-                    case "add":
-                        """ Add a location to the simulation queue"""
-                        loc_id = str(uuid.uuid4())
-                        latitude = data.get("latitude") if isinstance(data, dict) else getattr(data, "latitude", None)
-                        longitude = data.get("longitude") if isinstance(data, dict) else getattr(data, "longitude", None)
-                        delay = data.get("delay", 0) if isinstance(data, dict) else getattr(data, "delay", 0)
-                        delay = 0 if delay is None else delay
-                        if latitude is not None and longitude is not None:
-                            logger.info("Adding location %s (%s, %s) with %s delay to the queue", loc_id, latitude, longitude,
-                                        delay)
-                            accrued_delay = 0
-                            if self.context.queue_data:
-                                accrued_delay = sum(item.get('delay', 0) for item in self.context.queue_data.values())
-                            now_time = datetime.now(timezone.utc)
-                            new_time = now_time + timedelta(seconds=accrued_delay) + timedelta(seconds=delay)
-                            start_time = new_time.isoformat()
-                            location_item = {
-                                "loc_id": loc_id,
-                                "latitude": latitude,
-                                "longitude": longitude,
-                                "delay": delay,
-                                "start": start_time
-                            }
-                            ack = {
-                                "command": command,
-                                "status": "added",
-                                "message": f"Location {loc_id} added to the queue",
-                                "item": location_item
-                            }
-                            await self.context.queue.put(loc_id)
-                            add_item(loc_id, location_item)
-                            logger.info("Location %s added to the queue", loc_id)
-                            return ack
-                        else:
-                            logger.warning("Invalid location data received from %s: %s", sid, data)
-                            return {"command": command, "status": "error", "message": "Invalid location data", "data": location_item}
-                    case "clear":
-                        """ Clear the simulation queue"""
-                        await empty_simulation_queue()
-                        return {"command": command, "status": "cleared", "message": "Simulation cleared"}
-                    case "pause":
-                        """ Pause the simulation queue"""
-                        await pause_simulation_queue()
-                        return {"command": command, "status": "paused", "message": "Simulation paused"}
-                    case "resume":
-                        """ Resume the simulation queue"""
-                        await resume_simulation_queue()
-                        return {"command": command, "status": "resumed", "message": "Simulation resumed"}
-                    case "end":
-                        """ End the simulation queue"""
-                        logger.info("End location simulation request from %s", sid)
-                        end_task = asyncio.create_task(end_simulation_queue(), name="end-simulation-worker")
-                        result = await end_task
-                        simstatus = not result
-                        return {"command": command, "status": simstatus, "message": "Simulation ended"}
-                    case "start":
-                        """ Start the simulation queue"""
-                        logger.info("Start location simulation request from %s", sid)
-                        if self.context.simulation_task is None or self.context.simulation_task.done():
-                            self.context.simulation_active = True
-                            self.context.queue_state = "RUNNING"
-                            self.context.simulation_task = asyncio.create_task(
-                                start_simulation_queue(),
-                                name="location-simulation-worker",
-                            )
-                            return {"command": command, "status": self.context.queue_state, "message": "Simulation started"}
-                        else:
-                            return {"command": command, "status": "error", "message": "Simulation already running"}
-                    case _:
-                        logger.warning("Invalid command received from %s: %s", sid, command)
-                        return {"status": "error", "message": "Invalid command"}
-            finally:
-                await sio_send_status(sid)
-
-
-        """ Tunnel Control """
-        @self.context.sio.event
-        async def tunneld_control(sid, data):
-            command = data.get("command") if isinstance(data, dict) else getattr(data, "command", None)
-            logger.info("Tunneld Control command: %s requested from %s", command, sid)
-            match command:
-                case "start":
-                    """Start Tunneld"""
-                    logger.info("Start tunneld request from %s: %s", sid, data)
-                    try:
-                        self._tunneld_core.start()
-                        logger.info("Tunneld started successfully")
-                        return {"status": "running", "message": "Tunneld started successfully"}
-                    except Exception as e:
-                        logger.error("Error starting tunneld: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error starting tunneld: {e}"}
-
-                case "shutdown":
-                    """Shutdown Tunneld"""
-                    logger.info("Shutdown tunneld request from %s: %s", sid, data)
-                    try:
-                        os.kill(os.getpid(), signal.SIGINT)
-                        return {"command": command, "status": "Success", "message": "Server shutting down..."}
-                    except Exception as e:
-                        logger.error("Error shutting down tunneld: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error shutting down tunneld: {e}"}
-
-                case "clear":
-                    """Clear all tunnels"""
-                    logger.info("Clearing tunnels...")
-                    try:
-                        self._tunneld_core.clear()
-                        return {"command": command, "status": "Success", "message": "Cleared tunnels..."}
-                    except Exception as e:
-                        logger.error("Error clearing tunnels: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error clearing tunnels: {e}"}
-
-                case "cancel":
-                    """Cancel a tunnel"""
-                    logger.info("Canceling tunnel request from %s: %s", sid, data)
-                    try:
-                        udid = data.get("udid") if isinstance(data, dict) else getattr(data, "udid", self.context.udid)
-                        if udid is None:
-                            udid = self.context.udid
-                        self._tunneld_core.cancel(udid=udid)
-                        return {"command": command, "status": "Success", "udid": udid, "message": f"tunnel {udid} Canceled ..."}
-                    except Exception as e:
-                        logger.error("Error canceling tunnel: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error canceling tunnel: {e}"}
-            
-                case _:
-                    return {"command": command, "status": "error", "message": f"Unknown operation: {command}"}
-                    
-
-    def _run_app(self) -> None:
-        uvicorn.run(self._asgi_app, host=self.host, port=self.port, loop="asyncio", workers=1)
-
-class LocationSimulationQueue(LocationSimulation):
-    def __init__(self, dvt, context: LocationSimulationState):
-        super().__init__(dvt)
-        self.context = context
-
-    async def play_queue(self, disable_sleep: bool = False, timing_randomness_range: int = 0) -> None:
-        while True:
-            if self.context.queue_state == "PAUSED":
-                await asyncio.sleep(0.1)
-                continue
-            if self.context.queue_state == "SHUTDOWN":
-                break
-            loc_id = await self.context.queue.get()
-            if loc_id == None:
-                break
-            location_item = self.context.queue_data.get(loc_id)
-            latitude = location_item.get("latitude")
-            longitude = location_item.get("longitude")
-            delay = location_item.get("delay")
-            delay = 0 if delay is None else delay
-            start_time = location_item.get("start_time")
-            if self.context.set_location_enabled:
-                if delay > 0 and not disable_sleep:
-                    if timing_randomness_range > 0:
-                        delay = delay + random.uniform(
-                            -timing_randomness_range, timing_randomness_range
-                        )
-                    for i in range(delay, 0, -1):
-                        self.context.next_move = i
-                        await self.context.sio.emit(
-                            "simulation_status",
-                            {
-                                "status": self.context.simulation_active,
-                                "loc_id": self.context.loc_id,
-                                "latitude": self.context.latitude,
-                                "longitude": self.context.longitude,
-                                "next_move": i
-                            },
-                            namespace="/",
-                        )
-                        await asyncio.sleep(1)
-                await self.set(latitude, longitude)
-                self.context.latitude = latitude
-                self.context.longitude = longitude
-                await self.context.sio.emit(
-                    "simulation_status",
-                    {
-                        "status": self.context.simulation_active,
-                        "loc_id": self.context.loc_id,
-                        "latitude": self.context.latitude,
-                        "longitude": self.context.longitude,
-                        "next_move": None,
-                    },
-                    namespace="/",
-                )
-                logger.info(
-                    "Set simulated location to %s, %s after %ss delay",
-                    latitude,
-                    longitude,
-                    delay,
-                )
-            self.context.queue.task_done()
-
-
-class LocationSimulationTestQueue(LocationSimulationBase):
-    def __init__(self, context: LocationSimulationState):
-        super().__init__()
-        self.context = context
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self):
-        return self
-
-    async def set(self, latitude: float, longitude: float) -> None:
-        await asyncio.sleep(0.1)
-        logger.info("Simulated location set to %s, %s", latitude, longitude)
-
-    async def clear(self) -> None:
-        q = self.context.queue
-        if self.context.simulation_task is not None and not self.context.simulation_task.done():
-            if q.qsize() > 0:
-                self.context.set_location_enabled = False
-                while not q.empty():
-                    try:
-                        item = q.get_nowait()
-                        q.task_done()
-                        logger.info("Discarding item from queue: %s", item)
-                    except asyncio.QueueEmpty:
-                        break
-        while q.empty() and q.qsize() == 0:
-            await q.join()
-            with suppress(asyncio.CancelledError):
-                await self.context.simulation_task
-            self.context.simulation_active = False
-            self.context.queue_state = "SHUTDOWN"
-
-    async def play_queue(self, disable_sleep: bool = False, timing_randomness_range: int = 0) -> None:
-        while True:
-            if self.context.queue_state == "PAUSED":
-                await asyncio.sleep(0.1)
-                continue
-            if self.context.queue_state == "SHUTDOWN":
-                break
-            loc_id = await self.context.queue.get()
-            if loc_id == None:
-                break
-            location_item = self.context.queue_data.get(loc_id)
-            latitude = location_item.get("latitude")
-            longitude = location_item.get("longitude")
-            delay = location_item.get("delay")
-            delay = 0 if delay is None else delay
-            start_time = location_item.get("start_time")
-            if self.context.set_location_enabled:
-                if delay > 0 and not disable_sleep:
-                    if timing_randomness_range > 0:
-                        delay = delay + random.uniform(
-                            -timing_randomness_range, timing_randomness_range
-                        )
-                    for i in range(delay, 0, -1):
-                        self.context.next_move = i
-                        await self.context.sio.emit(
-                            "simulation_status",
-                            {
-                                "status": self.context.simulation_active,
-                                "loc_id": self.context.loc_id,
-                                "latitude": self.context.latitude,
-                                "longitude": self.context.longitude,
-                                "next_move": i
-                            },
-                            namespace="/",
-                        )
-                        await asyncio.sleep(1)
-                await self.set(latitude, longitude)
-                self.context.latitude = latitude
-                self.context.longitude = longitude
-                await self.context.sio.emit(
-                    "simulation_status",
-                    {
-                        "status": self.context.simulation_active,
-                        "loc_id": self.context.loc_id,
-                        "latitude": self.context.latitude,
-                        "longitude": self.context.longitude,
-                        "next_move": None,
-                    },
-                    namespace="/",
-                )
-                logger.info(
-                    "Set simulated location to %s, %s after %ss delay",
-                    latitude,
-                    longitude,
-                    delay,
-                )
-            self.context.queue.task_done()
diff --git a/server_recover.py b/server_recover.py
deleted file mode 100644
index 1e66801..0000000
--- a/server_recover.py
+++ /dev/null
@@ -1,1074 +0,0 @@
-import asyncio
-
-from datetime import datetime, timezone, timedelta
-import json
-import uuid
-import logging
-import os
-import signal
-import traceback
-import warnings
-import random
-from operator import truediv
-
-from pydantic import BaseModel, RootModel
-import socketio
-from contextlib import asynccontextmanager, suppress
-
-from typing import Optional, Dict
-
-from pymobiledevice3.services.dvt.instruments.location_simulation_base import LocationSimulationBase
-
-with warnings.catch_warnings():
-    # Ignore: "Core Pydantic V1 functionality isn't compatible with Python 3.14 or greater."
-    warnings.simplefilter("ignore", category=UserWarning)
-    import fastapi
-
-import uvicorn
-from fastapi import FastAPI
-
-from pymobiledevice3.exceptions import (
-    ConnectionFailedError,
-    InvalidServiceError,
-    MuxException,
-    TunneldConnectionError,
-)
-from pymobiledevice3.lockdown import create_using_usbmux, get_mobdev2_lockdowns
-from pymobiledevice3.osu.os_utils import get_os_utils
-from pymobiledevice3.remote.common import TunnelProtocol
-from pymobiledevice3.remote.remote_service_discovery import (
-    RemoteServiceDiscoveryService
-)
-from pymobiledevice3.remote.tunnel_service import (
-    CoreDeviceTunnelProxy,
-    TunnelResult,
-    create_core_device_tunnel_service_using_rsd,
-    get_remote_pairing_tunnel_services,
-)
-from pymobiledevice3.remote.utils import get_rsds
-from pymobiledevice3.services.dvt.instruments.location_simulation import LocationSimulation
-from pymobiledevice3.services.dvt.instruments.dvt_provider import DvtProvider
-from pymobiledevice3.tunneld.server import TunneldCore, TunnelTask
-
-class JsonFormatter(logging.Formatter):
-    def format(self, record: logging.LogRecord) -> str:
-        payload = {
-            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S%z"),
-            "level": record.levelname,
-            "logger": record.name,
-            "message": record.getMessage(),
-        }
-        if record.exc_info:
-            payload["exc_info"] = self.formatException(record.exc_info)
-        return json.dumps(payload, ensure_ascii=True)
-
-
-handler = logging.StreamHandler()
-handler.setFormatter(JsonFormatter())
-root_logger = logging.getLogger()
-root_logger.handlers = [handler]
-root_logger.setLevel(logging.INFO)
-logger = logging.getLogger("ios-api")
-
-# bugfix: after the device reboots, it might take some time for remoted to start answering the bonjour queries
-REATTEMPT_INTERVAL = 5
-REATTEMPT_COUNT = 5
-
-REMOTEPAIRING_INTERVAL = 5
-MOBDEV2_INTERVAL = 5
-
-# USB monitor will periodically forget what interfaces it has seen
-# and force a full rescan.  The value is the number of iterations of the
-# inner loop (which sleeps one second each) before blowing away the
-# `previous_ips` cache.
-USB_MONITOR_RESCAN_INTERVAL = 30
-
-USBMUX_INTERVAL = 2
-OSUTILS = get_os_utils()
-TUNNEL_ACQUIRE_TIMEOUT_SECONDS = 15
-DVT_CONNECT_TIMEOUT_SECONDS = 20
-
-
-class SimulationStatusData(BaseModel):
-    latitude: float
-    longitude: float
-    start: float
-    end: Optional[float]
-    next_move: Optional[float]
-
-
-class SimulationStatus(BaseModel):
-    status: bool
-    data: Optional[SimulationStatusData]
-
-
-class SimulationRequestData(BaseModel):
-    latitude: float
-    longitude: float
-    delay: int = 0
-    start: Optional[str] = None
-    end: Optional[str] = None
-
-
-class SimulationRequest(BaseModel):
-    status: bool
-    data: Optional[SimulationRequestData]
-
-
-class SimulationRequestResponseData(BaseModel):
-    loc_id: str
-    latitude: float
-    longitude: float
-    delay: int = 0
-    start: Optional[str] = None
-    end: Optional[str] = None
-
-class SimulationQueueList(BaseModel):
-    data: Optional[SimulationRequestResponseData]
-
-
-class SimulationRequestResponse(BaseModel):
-    status: bool
-    data: Optional[SimulationRequestResponseData]
-
-class SimulationQueueDict(BaseModel):
-    location_id: Dict[str, SimulationRequestResponseData]
-
-class LocationSimulationState:
-    def __init__(self):
-        self.current_location: Optional[Dict[str, SimulationRequestResponseData]] = None
-        self.next_location: Optional[Dict[str, SimulationRequestResponseData]] = None
-        self.loc_id: Optional[str] = None
-        self.latitude: Optional[float] = None
-        self.longitude: Optional[float] = None
-        self.next_move: Optional[float] = None
-        self.udid: Optional[str] = None
-        self.simulation_active: bool = False
-        self.set_location_enabled: bool = True
-        self.queue: asyncio.Queue = asyncio.Queue()
-        self.queue_order: list[str] = []
-        self.queue_data: Dict = {} 
-        self.queue_status: Optional[asyncio.Event] = asyncio.Event()
-        self.queue_state: str = "STOPPED"
-        self.test_mode: bool = False
-        self.simulation_task: Optional[asyncio.Task] = None
-        self.sio: socketio.AsyncServer = socketio.AsyncServer(async_mode="asgi", cors_allowed_origins="*")
-        self.tunnel: Optional[RemoteServiceDiscoveryService] = None
-
-
-class TunneldRunnerSio:
-    """TunneldRunner orchestrate between the webserver and TunneldCore"""
-
-    @classmethod
-    def create(
-            cls,
-            host: str,
-            port: int,
-            context: LocationSimulationState = LocationSimulationState(),
-            protocol: TunnelProtocol = TunnelProtocol.QUIC,
-            usb_monitor: bool = True,
-            wifi_monitor: bool = True,
-            usbmux_monitor: bool = True,
-            mobdev2_monitor: bool = True,
-    ) -> None:
-        cls(
-            host,
-            port,
-            protocol=protocol,
-            usb_monitor=usb_monitor,
-            wifi_monitor=wifi_monitor,
-            usbmux_monitor=usbmux_monitor,
-            mobdev2_monitor=mobdev2_monitor,
-            context=context,
-        )._run_app()
-
-    def __init__(
-            self,
-            host: str,
-            port: int,
-            context: LocationSimulationState = LocationSimulationState(),
-            protocol: TunnelProtocol = TunnelProtocol.QUIC,
-            usb_monitor: bool = True,
-            wifi_monitor: bool = True,
-            usbmux_monitor: bool = True,
-            mobdev2_monitor: bool = True,
-    ):
-        @asynccontextmanager
-        async def lifespan(app: FastAPI):
-            self._tunneld_core.start()
-            yield
-            logger.info("Closing tunneld tasks...")
-            await empty_simulation_queue()
-            await self._tunneld_core.close()
-            await self.context.sio.shutdown()
-
-        self.host = host
-        self.port = port
-        self.protocol = protocol
-        self.context = context
-        self._tunneld_api_address = ("127.0.0.1" if host in ("0.0.0.0", "::") else host, port)
-        self._app = FastAPI(title="iOS Device Management API", lifespan=lifespan, cors_allowed_origins="*")
-        self._asgi_app = socketio.ASGIApp(self.context.sio, self._app)
-        self._tunneld_core = TunneldCore(
-            protocol=protocol,
-            wifi_monitor=wifi_monitor,
-            usb_monitor=usb_monitor,
-            usbmux_monitor=usbmux_monitor,
-            mobdev2_monitor=mobdev2_monitor,
-        )
-
-        async def get_tun(
-                udid: Optional[str] = None, max_retries: int = 10, retry_delay: float = 0.5
-        ) -> RemoteServiceDiscoveryService:
-            """Resolve an active local tunnel and connect directly to its RSD endpoint."""
-            if self.context.tunnel is not None:
-                return self.context.tunnel
-
-            for attempt in range(max_retries):
-                candidates = []
-                for active_tunnel in self._tunneld_core.tunnel_tasks.values():
-                    if active_tunnel.tunnel is None or active_tunnel.udid is None:
-                        continue
-                    if udid is None or active_tunnel.udid == udid:
-                        candidates.append(active_tunnel.tunnel)
-
-                if not candidates:
-                    if attempt < max_retries - 1:
-                        logger.info("Waiting for local tunnel to be ready... (attempt %s/%s)", attempt + 1, max_retries)
-                        await asyncio.sleep(retry_delay)
-                        continue
-                    logger.error("Failed to find an active local tunnel after max retries")
-                    raise TunneldConnectionError()
-
-                tunnel = candidates[0]
-                if udid and len(candidates) > 1:
-                    logger.warning("Multiple local tunnels found for udid %s; using first available", udid)
-
-                try:
-                    rsd = RemoteServiceDiscoveryService((tunnel.address, tunnel.port))
-                    await rsd.connect()
-                    logger.info(
-                        "Connected to local tunnel at %s:%s after %s retries",
-                        tunnel.address,
-                        tunnel.port,
-                        attempt,
-                    )
-                    self.context.tunnel = rsd
-                    return rsd
-                except Exception:
-                    if attempt < max_retries - 1:
-                        logger.info("Tunnel endpoint not ready yet... (attempt %s/%s)", attempt + 1, max_retries)
-                        await asyncio.sleep(retry_delay)
-                    else:
-                        logger.error("Failed to connect to local tunnel endpoint after max retries")
-                        raise TunneldConnectionError()
-
-            raise TunneldConnectionError()
-
-        def cleanup_device_data(d):
-            mydict = {}
-            for key, value in d.items():
-                if isinstance(value, dict):
-                    cleanup_device_data(value)
-                elif isinstance(value, bytes):
-                    mydict[key] = 'BYTE DATA'
-                else:
-                    mydict[key] = value
-            return mydict
-
-        async def device_reboot(delay):
-            """ Reboot the device"""
-            logger.info("Reboot iniated with delay %s")
-            await asyncio.sleep(delay)
-            os.system("shutdown -r now")
-
-        async def device_shutdown(delay):
-            """ Shutdown the device"""
-            logger.info("Shutdown iniated with delay %s")
-            await asyncio.sleep(delay)
-            os.system("shutdown -h now")
-
-        """ Queue Functions"""
-        async def start_simulation_queue():
-            """ Start Simulation Queue Worker"""
-            logger.info("Starting location simulation worker...")
-            self.context.simulation_active = True
-            self.context.queue_state = "RUNNING"
-            self.context.queue_status.set()
-            try:
-                if self.context.test_mode:
-                    logger.info("Simulation worker: test mode enabled")
-                    with LocationSimulationTestQueue(self.context) as locate_simulation:
-                        await locate_simulation.play_queue()
-
-                if self.context.udid is None and not self.context.test_mode:
-                    active_udids = sorted(
-                        {t.udid for t in self._tunneld_core.tunnel_tasks.values() if
-                         t.udid is not None and t.tunnel is not None}
-                    )
-                    if len(active_udids) == 1:
-                        self.context.udid = active_udids[0]
-                        logger.info("Simulation worker: auto-selected udid=%s from active tunnel", self.context.udid)
-                    elif len(active_udids) == 0:
-                        logger.error("Simulation worker: no active tunnel with udid available")
-                        await self.context.sio.emit(
-                            "appError",
-                            {"type": "simulation_no_tunnel", "message": "No active tunnel found. Start tunnel first."},
-                            namespace="/",
-                        )
-                        return
-                    else:
-                        logger.error("Simulation worker: multiple active tunnels; explicit udid required: %s",
-                                     active_udids)
-                        await self.context.sio.emit(
-                            "appError",
-                            {
-                                "type": "simulation_udid_required",
-                                "message": "Multiple active tunnels found; provide udid in start_simulate_location.",
-                                "udids": active_udids,
-                            },
-                            namespace="/",
-                        )
-                        return
-
-                logger.info("Simulation worker: acquiring tunnel (udid=%s)", self.context.udid)
-
-                tun = await get_tun(self.context.udid)
-                logger.info("Simulation worker: tunnel acquired, connecting DVT provider")
-                dvt_provider = DvtProvider(tun)
-                dvt = await asyncio.wait_for(dvt_provider.__aenter__(), timeout=DVT_CONNECT_TIMEOUT_SECONDS)
-                logger.info("Simulation worker: DVT provider connected, starting queue playback")
-                try:
-                    async with LocationSimulationQueue(dvt, self.context) as locate_simulation:
-                        await locate_simulation.play_queue()
-                finally:
-                    logger.info("Simulation worker: closing DVT provider")
-                    await dvt_provider.__aexit__(None, None, None)
-                    logger.info("Simulation worker: DVT provider closed")
-            except TimeoutError:
-                logger.error(
-                    "Simulation worker timeout. tunnel_timeout=%ss dvt_timeout=%ss udid=%s",
-                    TUNNEL_ACQUIRE_TIMEOUT_SECONDS,
-                    DVT_CONNECT_TIMEOUT_SECONDS,
-                    self.context.udid,
-                )
-                await self.context.sio.emit(
-                    "appError",
-                    {
-                        "type": "simulation_timeout",
-                        "udid": self.context.udid,
-                        "tunnel_timeout_seconds": TUNNEL_ACQUIRE_TIMEOUT_SECONDS,
-                        "dvt_timeout_seconds": DVT_CONNECT_TIMEOUT_SECONDS,
-                    },
-                    namespace="/",
-                )
-            except Exception:
-                logger.exception("Simulation worker crashed")
-                await self.context.sio.emit(
-                    "appError",
-                    {"type": "simulation_crash", "udid": self.context.udid},
-                    namespace="/",
-                )
-            finally:
-                self.context.simulation_active = False
-                self.context.simulation_task = None
-
-        async def pause_simulation_queue():
-            """Pauses asyncio.Queue playback"""
-            self.context.queue_state = "PAUSED"
-
-        async def resume_simulation_queue():
-            """Resumes asyncio.Queue playback"""
-            self.context.queue_state = "RUNNING"
-
-        async def empty_simulation_queue():
-            """Empties all items from an asyncio.Queue."""
-            logger.info("Clearing location simulation queue...")
-            q = self.context.queue
-            self.context.set_location_enabled = False
-            while not q.empty():
-                try:
-                    item = q.get_nowait()
-                    q.task_done()
-                    logger.info("Discarding item from queue: %s", item)
-                except asyncio.QueueEmpty:
-                    break
-
-        def add_item(item_id, payload):
-            self.context.queue_data[item_id] = payload
-            self.context.queue_order.append(item_id)
-
-        def remove_item(item_id):
-            if item_id in self.context.queue_order:
-                self.context.queue_order.remove(item_id)
-
-        def get_item(item_id):
-            return self.context.queue_data[item_id]
-
-        def update_item(item_id, **updates):
-            if item_id in self.context.queue_data:
-                self.context.queue_data[item_id].update(updates)
-
-        def get_item_index(item_id):
-            return self.context.queue_order.index(item_id)
-
-        def get_item_id_by_index(index):
-            return self.context.queue_order[index]
-
-        def get_items_in_order():
-            return [self.context.queue_data[i] for i in self.context.queue_order]
-
-
-
-        async def end_simulation_queue() -> bool:
-            """Ends asyncio.Queue playback and closes tunnel"""
-            logger.info("End location simulation request from %s", sid)
-            try:
-                if self.context.test_mode:
-                    q = self.context.queue
-                    if q.qsize() > 0:
-                        self.context.set_location_enabled = False
-                        while not q.empty():
-                            try:
-                                item = q.get_nowait()
-                                q.task_done()
-                                logger.info("Discarding item from queue: %s", item)
-                            except asyncio.QueueEmpty:
-                                break
-
-                    await q.join()
-#                    with suppress(asyncio.CancelledError):
-#                        await self.context.simulation_task
-                    self.context.simulation_active = False
-                    self.context.queue_state = "SHUTDOWN"
-                    return True
-                if not self.context.test_mode:
-                    if self.context.simulation_task is not None and not self.context.simulation_task.done():
-                        q = self.context.queue
-                        if q.qsize() > 0:
-                            await empty_simulation_queue()
-                        while q.empty() and q.qsize() == 0:
-                            await q.join()
-                        with suppress(asyncio.CancelledError):
-                            await self.context.simulation_task
-                        if self.context.tunnel is not None:
-                            async with DvtProvider(self.context.tunnel) as dvt, LocationSimulation(dvt) as locate_simulation:
-                                await locate_simulation.clear()
-                        self.context.simulation_active = False
-                logger.error(f"Error ending simulation queue: {e}")
-                return False
-
-
-        def get_status():
-            data = {
-                "current_location": self.context.current_location,
-                "next_location": self.context.next_location,
-                "latitude": self.context.latitude,
-                "longitude": self.context.longitude,
-                "next_move": self.context.next_move,
-                "udid": self.context.udid,
-                "simulation_active": self.context.simulation_active,
-                "loc_id": self.context.loc_id,
-                "set_location_enable": self.context.set_location_enabled,
-                "queue": self.context.queue.qsize() if self.context.queue else 0,
-                "queue_state": self.context.queue_state,
-                "queue_order": self.context.queue_order,
-                "queue_data": self.context.queue_data,
-                "queue_status": self.context.queue_status.is_set() if self.context.queue_status else False,
-                "test_mode": self.context.test_mode,
-                "simulation_task": self.context.simulation_task.get_name() if self.context.simulation_task else None,
-                "tunnel": self.context.tunnel.service.address[0] if self.context.tunnel else None,
-            }
-            return data
-
-        """ FastAPI HTTP Functions"""
-        def generate_http_response(
-                data: dict, status_code: int = 200, media_type: str = "application/json"
-        ) -> fastapi.Response:
-            return fastapi.Response(status_code=status_code, media_type=media_type, content=json.dumps(data))
-
-        """ Tunnel Functions"""
-        @self._app.get("/start-tunnel")
-        async def start_tunnel(
-                udid: Optional[str] = self.context.udid, ip: Optional[str] = None, connection_type: Optional[str] = None
-        ) -> fastapi.Response:
-            udid_tunnels = [
-                t.tunnel for t in self._tunneld_core.tunnel_tasks.values() if t.udid == udid and t.tunnel is not None
-            ]
-            if len(udid_tunnels) > 0:
-                self.context.udid = udid
-                data = {
-                    "interface": udid_tunnels[0].interface,
-                    "port": udid_tunnels[0].port,
-                    "address": udid_tunnels[0].address,
-                }
-                return generate_http_response(data)
-            queue = asyncio.Queue()
-            created_task = False
-            try:
-                if not created_task and connection_type in ("usbmux", None):
-                    task_identifier = f"usbmux-{udid}"
-                    try:
-                        async with await create_using_usbmux(udid) as lockdown:
-                            service = await CoreDeviceTunnelProxy.create(lockdown)
-                        task = asyncio.create_task(
-                            self._tunneld_core.start_tunnel_task(
-                                task_identifier, service, protocol=TunnelProtocol.TCP, queue=queue
-                            ),
-                            name=f"start-tunnel-task-{task_identifier}",
-                        )
-                        self._tunneld_core.tunnel_tasks[task_identifier] = TunnelTask(task=task, udid=udid)
-                        created_task = True
-                    except (ConnectionFailedError, InvalidServiceError, MuxException):
-                        pass
-                if connection_type in ("usb", None):
-                    for rsd in await get_rsds(udid=udid):
-                        rsd_ip = rsd.service.address[0]
-                        if ip is not None and rsd_ip != ip:
-                            await rsd.close()
-                            continue
-                        task = asyncio.create_task(
-                            self._tunneld_core.start_tunnel_task(
-                                rsd_ip, await create_core_device_tunnel_service_using_rsd(rsd), queue=queue
-                            ),
-                            name=f"start-tunnel-usb-{rsd_ip}",
-                        )
-                        self._tunneld_core.tunnel_tasks[rsd_ip] = TunnelTask(task=task, udid=rsd.udid)
-                        created_task = True
-                if not created_task and connection_type in ("wifi", None):
-                    for remotepairing in await get_remote_pairing_tunnel_services(udid=udid):
-                        remotepairing_ip = remotepairing.hostname
-                        if ip is not None and remotepairing_ip != ip:
-                            await remotepairing.close()
-                            continue
-                        task = asyncio.create_task(
-                            self._tunneld_core.start_tunnel_task(remotepairing_ip, remotepairing, queue=queue),
-                            name=f"start-tunnel-wifi-{remotepairing_ip}",
-                        )
-                        self._tunneld_core.tunnel_tasks[remotepairing_ip] = TunnelTask(
-                            task=task, udid=remotepairing.remote_identifier
-                        )
-                        created_task = True
-            except Exception as e:
-                return fastapi.Response(
-                    status_code=501,
-                    content=json.dumps({
-                        "error": {
-                            "exception": e.__class__.__name__,
-                            "traceback": traceback.format_exc(),
-                        }
-                    }),
-                )
-            if not created_task:
-                return fastapi.Response(status_code=501, content=json.dumps({"error": "task not created"}))
-            tunnel: Optional[TunnelResult] = await queue.get()
-            if tunnel is not None:
-                self.context.udid = udid
-                data = {"interface": tunnel.interface, "port": tunnel.port, "address": tunnel.address}
-                return generate_http_response(data)
-            else:
-                return fastapi.Response(
-                    status_code=404, content=json.dumps({"error": "something went wrong during tunnel creation"})
-                )
-
-        @self._app.get("/shutdown")
-        async def shutdown() -> fastapi.Response:
-            """Shutdown Tunneld"""
-            os.kill(os.getpid(), signal.SIGINT)
-            data = {"operation": "shutdown", "data": True, "message": "Server shutting down..."}
-            return generate_http_response(data)
-
-        @self._app.get("/clear-tunnels")
-        async def clear_tunnels() -> fastapi.Response:
-            """Clear all tunnels"""
-            self._tunneld_core.clear()
-            data = {"operation": "clear_tunnels", "data": True, "message": "Cleared tunnels..."}
-            return generate_http_response(data)
-
-        @self._app.get("/cancel")
-        async def cancel_tunnel(udid: str) -> fastapi.Response:
-            """Cancel a tunnel"""
-            self._tunneld_core.cancel(udid=udid)
-            data = {"operation": "cancel", "udid": udid, "data": True, "message": f"tunnel {udid} Canceled ..."}
-            return generate_http_response(data)
-
-        """Simulation Functions"""
-        @self._app.get("/start-simulation")
-        async def app_start_simulation() -> fastapi.Response:
-            logger.info("Simulation Start Requested ")
-            if self.context.simulation_task is None or self.context.simulation_task.done():
-                self.context.simulation_active = True
-                self.context.simulation_task = asyncio.create_task(
-                    start_simulation_queue(),
-                    name="location-simulation-worker",
-                )
-                data = {"status": "started", "message": "Simulation started"}
-            else:
-                data = {"status": "error", "message": "Simulation already running"}
-            return generate_http_response(data)
-
-        @self._app.post("/add-location")
-        async def app_add_location(data: SimulationRequestData) -> fastapi.Response:
-            """ Add a location to the simulation queue"""
-            logger.info("Request to add new location to queue")
-            loc_id = str(uuid.uuid4())
-            latitude = data.get("latitude") if isinstance(data, dict) else getattr(data, "latitude", None)
-            longitude = data.get("longitude") if isinstance(data, dict) else getattr(data, "longitude", None)
-            delay = data.get("delay", 0) if isinstance(data, dict) else getattr(data, "delay", 0)
-            delay = 0 if delay is None else delay
-            if latitude is not None and longitude is not None:
-                logger.info("Adding location %s (%s, %s) with %s delay to the queue", loc_id, latitude, longitude,
-                            delay)
-                await self.context.queue.put((loc_id, latitude, longitude, delay))
-                if delay == 0:
-                    start_time = datetime.now(timezone.utc).isoformat()
-                else:
-                    now_time = datetime.now(timezone.utc)
-                    new_time = now_time + timedelta(seconds=delay)
-                    start_time = new_time.isoformat()
-                location_item = {
-                    loc_id: {
-                        "loc_id": loc_id,
-                        "latitude": latitude,
-                        "longitude": longitude,
-                        "delay": delay,
-                        "start": start_time
-                    }
-                }
-                self.context.queue_list.append(location_item)
-                resp = {
-                    "status": "added",
-                    "message": f"Location {loc_id} added to the queue",
-                    "item": location_item
-                }
-            else:
-                resp = {"status": "error", "message": "Invalid location data"}
-            return generate_http_response(resp)
-
-        @self._app.get("/clear-queue")
-        async def app_clear_queue() -> fastapi.Response:
-            """ Clear the simulation queue"""
-            logger.info("Simulation Start Requested ")
-            await empty_simulation_queue()
-            data = {"status": "cleared", "message": "Simulation cleared"}
-            return generate_http_response(data)
-
-        @self._app.get("/pause-queue")
-        async def app_pause_queue() -> fastapi.Response:
-            """ Pause the simulation queue"""
-            await pause_simulation_queue()
-            data = {"status": "paused", "message": "Simulation paused"}
-            return generate_http_response(data)
-
-        @self._app.get("/resume-queue")
-        async def app_resume_queue() -> fastapi.Response:
-            """ Resume the simulation queue"""
-            await resume_simulation_queue()
-            data = {"status": "resumed", "message": "Simulation resumed"}
-            return generate_http_response(data)
-
-        @self._app.get("/end-simulation")
-        async def app_end_simulation() -> fastapi.Response:
-            """ End the simulation queue"""
-            logger.info("End location simulation request")
-            end_task = asyncio.create_task(end_simulation_queue(), name="end-simulation-worker")
-            result = await end_task
-            data = {"status": result, "message": "Simulation ended"}
-            return generate_http_response(data)
-
-        """Status Functions"""
-        @self._app.get("/")
-        async def list_tunnels() -> dict[str, list[dict]]:
-            """Retrieve the available tunnels and format them as {UUID: TUNNEL_ADDRESS}"""
-            tunnels = {}
-            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
-                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
-                    continue
-                if active_tunnel.udid not in tunnels:
-                    tunnels[active_tunnel.udid] = []
-                tunnels[active_tunnel.udid].append(
-                    {
-                        "tunnel-address": active_tunnel.tunnel.address,
-                        "tunnel-port": active_tunnel.tunnel.port,
-                        "interface": ip,
-                    }
-                )
-            return tunnels
-
-        @self._app.get("/device-info")
-        async def device_info():
-            """Get device information"""
-            tunnels = {}
-            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
-                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
-                    continue
-                if active_tunnel.udid not in tunnels:
-                    tunnels[active_tunnel.udid] = {}
-                try:
-                    lockdown = await create_using_usbmux(serial=active_tunnel.udid, autopair=False)
-                    tunnels[active_tunnel.udid] = iterate_multidim(lockdown.all_values)
-                except Exception as e:
-                    logger.error(f"Failed to create lockdown session for device {active_tunnel.udid}: {e}")
-                    continue
-            return tunnels
-
-        @self._app.get("/hello")
-        async def hello() -> fastapi.Response:
-            data = {"message": "Hello, I'm alive"}
-            return generate_http_response(data)
-
-        @self._app.get("/context-status")
-        async def app_context_status() -> fastapi.Response:
-            data = get_status()
-            return generate_http_response(data)
-
-        """ Socket.IO Functions"""
-
-        async def sio_send_status(sid):
-            """ Send Current Status"""
-            await self.context.sio.emit("status", get_status(), namespace="/", to=sid)
-
-        """Socket.IO Connection Events"""
-        @self.context.sio.event
-        async def connect(sid, environ):
-            """Client connection event handler."""
-            logger.info("Client connected: %s", sid)
-            await sio_send_status(sid)
-            return '%s connected' % sid
-
-        @self.context.sio.event
-        async def disconnect(sid):
-            """Client disconnection event handler."""
-            logger.info("Client disconnected: %s", sid)
-
-        """ Socket.IO Request Events """
-        @self.context.sio.event
-        async def request_update(sid, data):
-            logger.info("Update request from %s", sid)
-
-        @self.context.sio.event
-        async def message(sid, data):
-            logger.info("Received message from %s: %s", sid, data)
-            return True, "Message received"
-#            await self.context.sio.emit("message", f"Received message from {sid}: {data}", namespace="/")
-
-        """ Device Control"""
-        @self.context.sio.event
-        async def device_control(sid, data):
-            """ Device Control """
-            command = data.get("command") if isinstance(data, dict) else getattr(data, "command", None)
-            delay = data.get("delay") if isinstance(data, dict) else getattr(data, "delay", None)
-            if delay is None:
-                delay = 5
-            match command:
-                case "shutdown":
-                    """ Shutdown the device"""
-                    logger.info("Shutdown command received from %s with delay %s", sid, delay)
-                    await device_shutdown(delay)
-                    return { "command": "shutdown", "status": "success", "message": f"Device shutdown initiated with {delay} seconds delay" }
-
-                case "reboot":
-                    """ Reboot the device"""
-                    logger.info("Reboot command received from %s with delay %s", sid, delay)
-                    await device_reboot(delay)
-                    return { "command": "reboot", "status": "success", "message": f"Device reboot initiated with {delay} seconds delay" }
-
-                case _:
-                    return { "command": command, "status": "error", "message": f"Invalid command: {command}" }
-
-        @self.context.sio.event
-        async def simulation_control(sid, data):
-            """ Simulation Control """
-            command = data.get("command") if isinstance(data, dict) else getattr(data, "command", None)
-            logger.info("Simulation Control command: %s requested from %s", command, sid)
-            try:
-                match command:
-                    case "add":
-                        """ Add a location to the simulation queue"""
-                        loc_id = str(uuid.uuid4())
-                        latitude = data.get("latitude") if isinstance(data, dict) else getattr(data, "latitude", None)
-                        longitude = data.get("longitude") if isinstance(data, dict) else getattr(data, "longitude", None)
-                        delay = data.get("delay", 0) if isinstance(data, dict) else getattr(data, "delay", 0)
-                        delay = 0 if delay is None else delay
-                        if latitude is not None and longitude is not None:
-                            logger.info("Adding location %s (%s, %s) with %s delay to the queue", loc_id, latitude, longitude,
-                                        delay)
-                            accrued_delay = 0
-                            if self.context.queue_data:
-                                accrued_delay = sum(item.get('delay', 0) for item in self.context.queue_data.values())
-                            now_time = datetime.now(timezone.utc)
-                            new_time = now_time + timedelta(seconds=accrued_delay) + timedelta(seconds=delay)
-                            start_time = new_time.isoformat()
-                            location_item = {
-                                "loc_id": loc_id,
-                                "latitude": latitude,
-                                "longitude": longitude,
-                                "delay": delay,
-                                "start": start_time
-                            }
-                            ack = {
-                                "command": command,
-                                "status": "added",
-                                "message": f"Location {loc_id} added to the queue",
-                                "item": location_item
-                            }
-                            await self.context.queue.put(loc_id)
-                            add_item(loc_id, location_item)
-                            logger.info("Location %s added to the queue", loc_id)
-                            return ack
-                        else:
-                            logger.warning("Invalid location data received from %s: %s", sid, data)
-                            return {"command": command, "status": "error", "message": "Invalid location data", "data": location_item}
-                    case "clear":
-                        """ Clear the simulation queue"""
-                        await empty_simulation_queue()
-                        return {"command": command, "status": "cleared", "message": "Simulation cleared"}
-                    case "pause":
-                        """ Pause the simulation queue"""
-                        await pause_simulation_queue()
-                        return {"command": command, "status": "paused", "message": "Simulation paused"}
-                    case "resume":
-                        """ Resume the simulation queue"""
-                        await resume_simulation_queue()
-                        return {"command": command, "status": "resumed", "message": "Simulation resumed"}
-                    case "end":
-                        """ End the simulation queue"""
-                        logger.info("End location simulation request from %s", sid)
-                        end_task = asyncio.create_task(end_simulation_queue(), name="end-simulation-worker")
-                        result = await end_task
-                        simstatus = not result
-                        return {"command": command, "status": simstatus, "message": "Simulation ended"}
-                    case "start":
-                        """ Start the simulation queue"""
-                        logger.info("Start location simulation request from %s", sid)
-                        if self.context.simulation_task is None or self.context.simulation_task.done():
-                            self.context.simulation_active = True
-                            self.context.queue_state = "RUNNING"
-                            self.context.simulation_task = asyncio.create_task(
-                                start_simulation_queue(),
-                                name="location-simulation-worker",
-                            )
-                            return {"command": command, "status": self.context.queue_state, "message": "Simulation started"}
-                        else:
-                            return {"command": command, "status": "error", "message": "Simulation already running"}
-                    case _:
-                        logger.warning("Invalid command received from %s: %s", sid, command)
-                        return {"status": "error", "message": "Invalid command"}
-            finally:
-                await sio_send_status(sid)
-
-
-        """ Tunnel Control """
-        @self.context.sio.event
-        async def tunneld_control(sid, data):
-            command = data.get("command") if isinstance(data, dict) else getattr(data, "command", None)
-            logger.info("Tunneld Control command: %s requested from %s", command, sid)
-            match command:
-                case "start":
-                    """Start Tunneld"""
-                    logger.info("Start tunneld request from %s: %s", sid, data)
-                    try:
-                        self._tunneld_core.start()
-                        logger.info("Tunneld started successfully")
-                        return {"status": "running", "message": "Tunneld started successfully"}
-                    except Exception as e:
-                        logger.error("Error starting tunneld: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error starting tunneld: {e}"}
-
-                case "shutdown":
-                    """Shutdown Tunneld"""
-                    logger.info("Shutdown tunneld request from %s: %s", sid, data)
-                    try:
-                        os.kill(os.getpid(), signal.SIGINT)
-                        return {"command": command, "status": "Success", "message": "Server shutting down..."}
-                    except Exception as e:
-                        logger.error("Error shutting down tunneld: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error shutting down tunneld: {e}"}
-
-                case "clear":
-                    """Clear all tunnels"""
-                    logger.info("Clearing tunnels...")
-                    try:
-                        self._tunneld_core.clear()
-                        return {"command": command, "status": "Success", "message": "Cleared tunnels..."}
-                    except Exception as e:
-                        logger.error("Error clearing tunnels: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error clearing tunnels: {e}"}
-
-                case "cancel":
-                    """Cancel a tunnel"""
-                    logger.info("Canceling tunnel request from %s: %s", sid, data)
-                    try:
-                        udid = data.get("udid") if isinstance(data, dict) else getattr(data, "udid", self.context.udid)
-                        if udid is None:
-                            udid = self.context.udid
-                        self._tunneld_core.cancel(udid=udid)
-                        return {"command": command, "status": "Success", "udid": udid, "message": f"tunnel {udid} Canceled ..."}
-                    except Exception as e:
-                        logger.error("Error canceling tunnel: %s", e)
-                        return {"command": command, "status": "error", "message": f"Error canceling tunnel: {e}"}
-            
-                case _:
-                    return {"command": command, "status": "error", "message": f"Unknown operation: {command}"}
-                    
-
-    def _run_app(self) -> None:
-        uvicorn.run(self._asgi_app, host=self.host, port=self.port, loop="asyncio", workers=1)
-
-class LocationSimulationQueue(LocationSimulation):
-    def __init__(self, dvt, context: LocationSimulationState):
-        super().__init__(dvt)
-        self.context = context
-
-    async def play_queue(self, disable_sleep: bool = False, timing_randomness_range: int = 0) -> None:
-        while True:
-            if self.context.queue_state == "PAUSED":
-                await asyncio.sleep(0.1)
-                continue
-            if self.context.queue_state == "SHUTDOWN":
-                break
-            loc_id = await self.context.queue.get()
-            if loc_id == None:
-                break
-            location_item = self.context.queue_data.get(loc_id)
-            latitude = location_item.get("latitude")
-            longitude = location_item.get("longitude")
-            delay = location_item.get("delay")
-            delay = 0 if delay is None else delay
-            start_time = location_item.get("start_time")
-            if self.context.set_location_enabled:
-                if delay > 0 and not disable_sleep:
-                    if timing_randomness_range > 0:
-                        delay = delay + random.uniform(
-                            -timing_randomness_range, timing_randomness_range
-                        )
-                    for i in range(delay, 0, -1):
-                        self.context.next_move = i
-                        await self.context.sio.emit(
-                            "simulation_status",
-                            {
-                                "status": self.context.simulation_active,
-                                "loc_id": self.context.loc_id,
-                                "latitude": self.context.latitude,
-                                "longitude": self.context.longitude,
-                                "next_move": i
-                            },
-                            namespace="/",
-                        )
-                        await asyncio.sleep(1)
-                await self.set(latitude, longitude)
-                self.context.latitude = latitude
-                self.context.longitude = longitude
-                await self.context.sio.emit(
-                    "simulation_status",
-                    {
-                        "status": self.context.simulation_active,
-                        "loc_id": self.context.loc_id,
-                        "latitude": self.context.latitude,
-                        "longitude": self.context.longitude,
-                        "next_move": None,
-                    },
-                    namespace="/",
-                )
-                logger.info(
-                    "Set simulated location to %s, %s after %ss delay",
-                    latitude,
-                    longitude,
-                    delay,
-                )
-            self.context.queue.task_done()
-
-
-class LocationSimulationTestQueue(LocationSimulationBase):
-    def __init__(self, context: LocationSimulationState):
-        super().__init__()
-        self.context = context
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self):
-        return self
-
-    async def set(self, latitude: float, longitude: float) -> None:
-        await asyncio.sleep(0.1)
-        logger.info("Simulated location set to %s, %s", latitude, longitude)
-
-    async def clear(self) -> None:
-        q = self.context.queue
-        if self.context.simulation_task is not None and not self.context.simulation_task.done():
-            if q.qsize() > 0:
-                self.context.set_location_enabled = False
-                while not q.empty():
-                    try:
-                        item = q.get_nowait()
-                        q.task_done()
-                        logger.info("Discarding item from queue: %s", item)
-                    except asyncio.QueueEmpty:
-                        break
-        while q.empty() and q.qsize() == 0:
-            await q.join()
-            with suppress(asyncio.CancelledError):
-                await self.context.simulation_task
-            self.context.simulation_active = False
-            self.context.queue_state = "SHUTDOWN"
-
-    async def play_queue(self, disable_sleep: bool = False, timing_randomness_range: int = 0) -> None:
-        while True:
-            while self.context.queue_state == "PAUSED":
-                await asyncio.sleep(0.1)
-            if self.context.queue_state == "SHUTDOWN":
-                break
-            loc_id = await self.context.queue.get()
-            if loc_id == None:
-                break
-            location_item = self.context.queue_data.get(loc_id)
-            latitude = location_item.get("latitude")
-            longitude = location_item.get("longitude")
-            delay = location_item.get("delay")
-            start_time = location_item.get("start_time")
-            if self.context.set_location_enabled:
-                if delay > 0 and not disable_sleep:
-                    if timing_randomness_range > 0:
-                        delay = delay + random.uniform(
-                            -timing_randomness_range, timing_randomness_range
-                        )
-                    for i in range(delay, 0, -1):
-                        self.context.next_move = i
-                        await self.context.sio.emit(
-                            "simulation_status",
-                            {
-                                "status": self.context.simulation_active,
-                                "loc_id": self.context.loc_id,
-                                "latitude": self.context.latitude,
-                                "longitude": self.context.longitude,
-                                "next_move": i
-                            },
-                            namespace="/",
-                        )
-                        await asyncio.sleep(1)
-                        )
-                        await asyncio.sleep(1)
-                await self.set(latitude, longitude)
-                self.context.latitude = latitude
-                self.context.longitude = longitude
-                self.context.loc_id = loc_id
-                await self.context.sio.emit(
-                    
-                    "simulation_status",
-                    {
-                        "status": self.context.simulation_active,
-                        "loc_id": self.context.loc_id,
-                        "latitude": self.context.latitude,
-                        "longitude": self.context.longitude,
-                        "next_move": None,
-                    },
-                    namespace="/",
-                )
-                logger.info(
-                    "Set simulated location to %s, %s after %ss delay",
-                    latitude,
-                    longitude,
-                    delay,
-                )
-            self.context.queue.task_done()
diff --git a/socktest.py b/socktest.py
deleted file mode 100644
index 5161306..0000000
--- a/socktest.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import uvicorn
-from fastapi import FastAPI
-import socketio
-
-app = FastAPI()
-sio = socketio.AsyncServer(cors_allowed_origins="*", async_mode="asgi")
-socket_app = socketio.ASGIApp(sio, app)
-
-
-@app.get("/")
-def main():
-    return {"message": "Hello World"}
-
-
-@sio.on("connect")
-async def connect(sid, env):
-    print("New Client Connected to This id :" + " " + str(sid))
-    await sio.emit("message", f"Hello Client, Welcome to Socket.IO Server {sid}")
-
-
-@sio.event
-async def message(sid, data):
-    print("Message from Client: " + str(data))
-    return True
-
-@sio.on("disconnect")
-async def disconnect(sid):
-    print("Client Disconnected: " + " " + str(sid))
-
-@sio.on('*')
-async def any_event(event, sid, data):
-  print("Unregisered event received, event: " + str(event) + " sid: " + str(sid) + " data: " + str(data)) 
-
-if __name__ == "__main__":
-    uvicorn.run(
-        "socktest:socket_app", host="0.0.0.0", port=8000, lifespan="on", reload=True
-    )
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/pymd3_vue_location_sim/__init__.py b/src/pymd3_vue_location_sim/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/pymd3_vue_location_sim/database.py b/src/pymd3_vue_location_sim/database.py
new file mode 100644
index 0000000..5d96996
--- /dev/null
+++ b/src/pymd3_vue_location_sim/database.py
@@ -0,0 +1,44 @@
+
+from typing import List
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
+from .db_models import Base, Location, Route, Waypoint
+
+
+DATABASE_URL = "sqlite+aiosqlite:///.locations.db"
+engine = create_async_engine(DATABASE_URL, echo=True)
+async_session_local = async_sessionmaker(engine, expire_on_commit=False)
+
+async def init_db() -> None:
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+async def create_location(name: str, address: str, latitude: float, longitude: float, is_favorite: bool = False):
+    async with async_session_local() as session:
+        new_location = Location(name=name, address=address, latitude=latitude, longitude=longitude, is_favorite=is_favorite)
+        session.add(new_location)
+        await session.commit()
+        return new_location
+
+async def get_locations():
+    async with async_session_local() as session:
+        result = await session.execute(select(Location))
+        return result.scalars().all()
+
+async def create_route(name: str, origin_id: int, destination_id: int, waypoints_data: List[dict]):
+    async with async_session_local() as session:
+        new_route = Route(name=name, origin_id=origin_id, destination_id=destination_id)
+        for wp in waypoints_data:
+            new_route.waypoints.append(Waypoint(order=wp['order'], description=wp['description']))
+        session.add(new_route)
+        await session.commit()
+        return new_route
+
+async def get_routes():
+    async with async_session() as session:
+        # Use joinedload for efficient loading of relationships
+        from sqlalchemy.orm import joinedload
+        result = await session.execute(
+            select(Route).options(joinedload(Route.waypoints))
+        )
+        return result.scalars().unique().all()
diff --git a/src/pymd3_vue_location_sim/db_models.py b/src/pymd3_vue_location_sim/db_models.py
new file mode 100644
index 0000000..7c1028f
--- /dev/null
+++ b/src/pymd3_vue_location_sim/db_models.py
@@ -0,0 +1,42 @@
+
+from sqlalchemy import ForeignKey, String
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from typing import List
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    pass
+
+class Location(Base):
+    __tablename__ = "locations"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(100))
+    address: Mapped[str] = mapped_column(String(255))
+    latitude: Mapped[float]
+    longitude: Mapped[float]
+    is_favorite: Mapped[bool] = mapped_column(default=False)
+
+    routes: Mapped[List["Route"]] = relationship(back_populates="destination", cascade="all, delete-orphan")
+
+
+class Route(Base):
+    __tablename__ = "routes"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(100))
+    origin_id: Mapped[int] = mapped_column(ForeignKey("locations.id"))
+    destination_id: Mapped[int] = mapped_column(ForeignKey("locations.id"))
+    destination: Mapped["Location"] = relationship(back_populates="routes")
+
+    waypoints: Mapped[List["Waypoint"]] = relationship(back_populates="route", cascade="all, delete-orphan")
+
+
+
+class Waypoint(Base):
+    __tablename__ = "waypoint"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    order: Mapped[int]
+    description: Mapped[str]
+    route_id: Mapped[int] = mapped_column(ForeignKey("route.id"))
+    route: Mapped["Route"] = relationship(back_populates="waypoints")
+
diff --git a/src/pymd3_vue_location_sim/icloud_monitor.py b/src/pymd3_vue_location_sim/icloud_monitor.py
new file mode 100644
index 0000000..fcc937e
--- /dev/null
+++ b/src/pymd3_vue_location_sim/icloud_monitor.py
@@ -0,0 +1,334 @@
+import asyncio
+import logging
+import os
+import sys
+from collections.abc import Callable
+
+import click
+from dotenv import load_dotenv
+from pyicloud import PyiCloudService
+from pyicloud.exceptions import (
+    PyiCloud2FARequiredException,
+    PyiCloud2SARequiredException,
+    PyiCloudAuthRequiredException,
+    PyiCloudFailedLoginException,
+    PyiCloudNoStoredPasswordAvailableException,
+    PyiCloudPasswordException,
+)
+
+from .models import iCloudReturnData
+
+load_dotenv()
+logger = logging.getLogger("ios-api")
+AUTH_EXCEPTIONS = (
+    PyiCloudAuthRequiredException,
+    PyiCloudFailedLoginException,
+    PyiCloudPasswordException,
+    PyiCloud2FARequiredException,
+    PyiCloud2SARequiredException,
+    PyiCloudNoStoredPasswordAvailableException,
+)
+
+class FindMyMonitor:
+    def __init__(
+        self,
+        queue: asyncio.Queue,
+        token_file: str = "icloud_token.txt",
+        sio=None,
+        get_client_sids: Callable[[], list[str]] | None = None,
+        code_timeout_seconds: int = 180,
+    ):
+        self.username = os.getenv("APPLE_ID")
+        self.password = os.getenv("APPLE_PW")
+        self.token_file = token_file
+        self.selected_device_id = os.getenv("SELECTED_DEVICE_ID")
+        self.selected_device_name = os.getenv("SELECTED_DEVICE_NAME")
+        self.selected_device = None
+        self.queue = queue
+        self.api = None
+        self.device = None
+        self.running = True
+        self.sio = sio
+        self.get_client_sids = get_client_sids
+        self.code_timeout_seconds = code_timeout_seconds
+        self.auth_init_timeout_seconds = int(
+            os.getenv("ICLOUD_AUTH_INIT_TIMEOUT_SECONDS", "0")
+        )
+        self._logged_candidates = False
+        self._no_location_streak = 0
+        self._auth_error_streak = 0
+
+    async def _request_code_from_vue(self, prompt: str) -> str | None:
+        if self.sio is None or self.get_client_sids is None:
+            logger.warning("2FA request skipped: Socket.IO context not configured")
+            return None
+        sids = self.get_client_sids()
+        if not sids:
+            logger.warning("2FA request skipped: no connected Socket.IO clients")
+            return None
+
+        payload = {"prompt": prompt, "digits": 6}
+        logger.info("Emitting icloud_2fa_request to %s connected client(s)", len(sids))
+        for sid in sids:
+            try:
+                # Ask one connected UI client for the code and wait for ACK response.
+                response = await self.sio.call(
+                    "icloud_2fa_request",
+                    payload,
+                    to=sid,
+                    namespace="/",
+                    timeout=self.code_timeout_seconds,
+                )
+            except Exception:
+                logger.exception("Failed to retrieve 2FA code from sid=%s", sid)
+                continue
+
+            code = response.get("code") if isinstance(response, dict) else response
+            code_str = str(code).strip() if code is not None else ""
+            if len(code_str) == 6 and code_str.isdigit():
+                return code_str
+            logger.warning("Invalid 2FA code payload from sid=%s", sid)
+        return None
+
+    async def authenticate(self):
+        """Authenticates with iCloud, handling 2FA and token storage."""
+        if not self.username:
+            logger.warning("APPLE_ID is not configured; skipping iCloud monitor authentication")
+            return False
+        has_token = os.path.exists(self.token_file)
+        if not has_token and not self.password:
+            logger.warning(
+                "No stored iCloud session and APPLE_PW is not configured; skipping iCloud monitor authentication"
+            )
+            return False
+
+        if os.path.exists(self.token_file):
+            print("Loading stored session...")
+            try:
+                init_task = asyncio.to_thread(
+                    PyiCloudService, self.username, cookie_directory="./cookies"
+                )
+                if self.auth_init_timeout_seconds > 0:
+                    self.api = await asyncio.wait_for(
+                        init_task, timeout=self.auth_init_timeout_seconds
+                    )
+                else:
+                    self.api = await init_task
+            except Exception as e:
+                logger.exception("Failed to initialize iCloud session from cookies: %s", e)
+                return False
+        else:
+            print("No stored session. Authenticating...")
+            try:
+                init_task = asyncio.to_thread(
+                    PyiCloudService,
+                    self.username,
+                    self.password,
+                    cookie_directory="./cookies",
+                )
+                if self.auth_init_timeout_seconds > 0:
+                    self.api = await asyncio.wait_for(
+                        init_task, timeout=self.auth_init_timeout_seconds
+                    )
+                else:
+                    self.api = await init_task
+            except Exception as e:
+                logger.exception("Failed to initialize iCloud session with credentials: %s", e)
+                return False
+
+        if self.api.requires_2fa:
+            print("Two-factor authentication required.")
+            code = await self._request_code_from_vue("Enter the 6-digit Apple verification code")
+            if code is None:
+                if sys.stdin and sys.stdin.isatty():
+                    code = str(
+                        await asyncio.to_thread(
+                            click.prompt,
+                            "Please enter the 6-digit code sent to your trusted device",
+                            type=int,
+                        )
+                    )
+                else:
+                    logger.warning(
+                        "2FA required but no interactive terminal or Vue responder is available; deferring authentication"
+                    )
+                    return False
+            # Verify the code
+            result = await asyncio.to_thread(self.api.validate_2fa_code, code)
+            print(f"2FA validation result: {result}")
+
+            if not result:
+                print("Failed to verify 2FA code")
+                return False
+
+            # Trust the session
+            await asyncio.to_thread(self.api.trust_session)
+
+        if self.api.requires_2sa:
+            import textwrap
+            print(textwrap.dedent("""
+                Two-step authentication required.
+                Please select a device to receive a SMS verification code:
+            """))
+            # List available devices for 2SA
+            for i, device in enumerate(self.api.trusted_devices):
+                print(
+                    f"  {i + 1}: {device.get('deviceName', 'Unknown device')} ({device.get('phoneNumber', 'Unknown number')})")
+
+            # Prompt the user for their choice
+            if not (sys.stdin and sys.stdin.isatty()):
+                logger.warning(
+                    "2SA required but no interactive terminal is available; deferring authentication"
+                )
+                return False
+            device_index = await asyncio.to_thread(click.prompt, "Please select a device number", type=int) - 1
+            device = self.api.trusted_devices[device_index]
+            if not await asyncio.to_thread(self.api.send_verification_code, device):
+                print("Failed to send verification code")
+                return False
+
+            # Prompt the user to enter the verification code they received
+            code = await asyncio.to_thread(click.prompt, "Please enter verification code", type=int)
+            if not await asyncio.to_thread(self.api.validate_verification_code, device, code):
+                print("Failed to verify verification code")
+                return False
+
+        print("Successfully authenticated.")
+        return True
+
+    async def get_location(self):
+        """Fetches the latest latitude and longitude."""
+        if not self.api:
+            await self.authenticate()
+
+        # pyicloud 2.4.1 refresh lives on the FindMy manager, not PyiCloudService.
+        devices_manager = await asyncio.to_thread(lambda: self.api.devices)
+        await asyncio.to_thread(devices_manager.refresh, True)
+
+        # One-time diagnostics to help verify exact device selection among duplicates.
+        if not self._logged_candidates:
+            for d in devices_manager:
+                status = d.status()
+                logger.debug(
+                    "iCloud candidate id=%s name=%s model=%s deviceStatus=%s has_location=%s features=%s",
+                    d.data.get("id"),
+                    d.name,
+                    d.model_name,
+                    status.get("deviceStatus"),
+                    d.data.get("location") is not None,
+                    d.data.get("features"),
+                )
+            self._logged_candidates = True
+
+        # Select by ID first (exact), then by name, then first device if no selectors set.
+        self.selected_device = None
+        for device in devices_manager:
+            if self.selected_device_id and device.data.get("id") == self.selected_device_id:
+                self.selected_device = device
+                break
+        if self.selected_device is None:
+            for device in devices_manager:
+                if self.selected_device_name and device.name == self.selected_device_name:
+                    self.selected_device = device
+                    break
+        if self.selected_device is None and not self.selected_device_id and not self.selected_device_name:
+            for device in devices_manager:
+                self.selected_device = device
+                break
+
+        if self.selected_device:
+            location = self.selected_device.location
+            status = self.selected_device.status()
+            logger.info(
+                "iCloud device=%s location_available=%s status=%s",
+                self.selected_device.name,
+                self.selected_device.location_available,
+                status,
+            )
+            if location:
+                data = {
+                    "latitude": location['latitude'],
+                    "longitude": location['longitude'],
+                    "timeStamp": location['timeStamp'],
+                    "altitude": location['altitude'],
+                    "horizontalAccuracy": location['horizontalAccuracy'],
+                    "verticalAccuracy": location['verticalAccuracy'],
+                    "batteryLevel": status['batteryLevel'],
+                    "deviceDisplayName": status['deviceDisplayName'],
+                    "deviceStatus": status['deviceStatus'],
+                    "name": status['name']
+                }
+                response = iCloudReturnData(**data)
+                return response
+            logger.info("Location payload is None for device=%s", self.selected_device.name)
+            return None
+
+        logger.warning(
+            "No iCloud device matched SELECTED_DEVICE_ID='%s' or SELECTED_DEVICE_NAME='%s'.",
+            self.selected_device_id,
+            self.selected_device_name,
+        )
+
+        return None
+
+    def start(self):
+        self.running = True
+
+    def stop(self):
+        self.running = False
+
+    def _no_location_backoff_seconds(self, base_interval: int) -> int:
+        schedule = [15, 30, 60, 120, 300]
+        idx = min(self._no_location_streak - 1, len(schedule) - 1)
+        return max(base_interval, schedule[idx])
+
+    def _auth_backoff_seconds(self, base_interval: int) -> int:
+        schedule = [15, 30, 60, 120, 300]
+        idx = min(self._auth_error_streak - 1, len(schedule) - 1)
+        return max(base_interval, schedule[idx])
+
+    async def run_monitor(self, interval=60):
+        """Runs the monitor loop."""
+        if not await self.authenticate():
+            return
+
+        if not self.running:
+            self.start()
+
+        while self.running:
+            sleep_seconds = interval
+            try:
+                device_data = await self.get_location()
+                if device_data is not None:
+                    self._no_location_streak = 0
+                    self._auth_error_streak = 0
+                    print(f"{device_data.timeStamp} -  Location: {device_data.latitude}, {device_data.longitude}")
+                    await self.queue.put(device_data)
+                else:
+                    self._no_location_streak += 1
+                    sleep_seconds = self._no_location_backoff_seconds(interval)
+                    logger.info(
+                        "No iCloud location found for device id='%s' name='%s' streak=%s next_retry=%ss",
+                        self.selected_device_id,
+                        self.selected_device_name,
+                        self._no_location_streak,
+                        sleep_seconds,
+                    )
+            except AUTH_EXCEPTIONS as e:
+                self._auth_error_streak += 1
+                sleep_seconds = self._auth_backoff_seconds(interval)
+                logger.warning(
+                    "iCloud auth error (%s). Re-authenticating; streak=%s next_retry=%ss",
+                    type(e).__name__,
+                    self._auth_error_streak,
+                    sleep_seconds,
+                )
+                try:
+                    await self.authenticate()
+                except Exception:
+                    logger.exception("iCloud re-authentication failed")
+            except Exception as e:
+                logger.exception("iCloud monitor loop error: %s", e)
+                sleep_seconds = max(interval, 30)
+            
+            await asyncio.sleep(sleep_seconds)
diff --git a/src/pymd3_vue_location_sim/json_formatter.py b/src/pymd3_vue_location_sim/json_formatter.py
new file mode 100644
index 0000000..e19ecd4
--- /dev/null
+++ b/src/pymd3_vue_location_sim/json_formatter.py
@@ -0,0 +1,18 @@
+import logging
+import json
+
+handler = logging.StreamHandler()
+root_logger = logging.getLogger()
+logger = logging.getLogger("ios-api")
+
+class JsonFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        payload = {
+            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S%z"),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+        }
+        if record.exc_info:
+            payload["exc_info"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=True)
diff --git a/src/pymd3_vue_location_sim/locationsimulation.py b/src/pymd3_vue_location_sim/locationsimulation.py
new file mode 100644
index 0000000..d551774
--- /dev/null
+++ b/src/pymd3_vue_location_sim/locationsimulation.py
@@ -0,0 +1,213 @@
+from pymobiledevice3.services.dvt.instruments.location_simulation_base import (
+    LocationSimulationBase,
+)
+from pymobiledevice3.services.dvt.instruments.location_simulation import (
+    LocationSimulation,
+)
+
+
+class LocationSimulationQueue(LocationSimulation):
+    def __init__(self, dvt, context: LocationSimulationState):
+        super().__init__(dvt)
+        self.context = context
+
+    async def play_queue(
+        self, disable_sleep: bool = False, timing_randomness_range: int = 0
+    ) -> None:
+        while True:
+            if self.context.queue_state == "PAUSED":
+                await asyncio.sleep(0.1)
+                continue
+            if self.context.queue_state == "SHUTDOWN":
+                break
+            loc_id = await self.context.queue.get()
+            if loc_id is None:
+                self.context.queue.task_done()
+                break
+            location_item = self.context.queue_data.get(loc_id)
+            if location_item is None:
+                logger.warning(
+                    "Simulation queue item missing for loc_id=%s; skipping stale entry",
+                    loc_id,
+                )
+                self.context.queue.task_done()
+                continue
+            new_latitude = location_item.get("latitude")
+            new_longitude = location_item.get("longitude")
+            new_delay = location_item.get("delay")
+            new_delay = 0 if new_delay is None else new_delay
+            new_start = location_item.get("start")
+
+            current_location_item = self.context.queue_data.get(self.context.loc_id)
+            current_latitude = (
+                current_location_item.get("latitude")
+                if isinstance(current_location_item, dict)
+                else self.context.latitude
+            )
+            current_longitude = (
+                current_location_item.get("longitude")
+                if isinstance(current_location_item, dict)
+                else self.context.longitude
+            )
+            current_start = (
+                current_location_item.get("start")
+                if isinstance(current_location_item, dict)
+                else None
+            )
+
+            if self.context.set_location_enabled:
+                if new_delay > 0 and not disable_sleep:
+                    countdown_delay = int(round(float(new_delay)))
+                    if timing_randomness_range > 0:
+                        new_delay = new_delay + random.uniform(
+                            -timing_randomness_range, timing_randomness_range
+                        )
+                        countdown_delay = int(round(float(new_delay)))
+                    for i in range(max(0, countdown_delay), 0, -1):
+                        self.context.next_move = i
+                        await self.context.sio.emit(
+                            "simulation_status",
+                            {
+                                "status": self.context.simulation_active,
+                                "loc_id": self.context.loc_id,
+                                "latitude": current_latitude,
+                                "longitude": current_longitude,
+                                "start": current_start,
+                                "next_move": i,
+                            },
+                            namespace="/",
+                        )
+                        await asyncio.sleep(1)
+                self.context.queue_data[loc_id]["start"] = self.context.queue_data[self.context.loc_id]["end"] = datetime.now(timezone.utc).isoformat()
+                await self.set(new_latitude, new_longitude)
+                self.context.loc_id = loc_id
+                self.context.latitude = new_latitude
+                self.context.longitude = new_longitude
+                await self.context.sio.emit(
+                    "simulation_status",
+                    {
+                        "status": self.context.simulation_active,
+                        "loc_id": self.context.loc_id,
+                        "latitude": self.context.latitude,
+                        "longitude": self.context.longitude,
+                        "start": new_start,
+                        "next_move": None,
+                    },
+                    namespace="/",
+                )
+                logger.info(
+                    "Set simulated location to %s, %s after %ss delay",
+                    new_latitude,
+                    new_longitude,
+                    new_delay,
+                )
+            self.context.queue.task_done()
+
+
+class LocationSimulationTestQueue(LocationSimulationBase):
+    def __init__(self, context: LocationSimulationState):
+        super().__init__()
+        self.context = context
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self):
+        return self
+
+    async def set(self, latitude: float, longitude: float) -> None:
+        await asyncio.sleep(0.1)
+        logger.info("Simulated location set to %s, %s", latitude, longitude)
+
+    async def clear(self) -> None:
+        q = self.context.queue
+        self.context.set_location_enabled = False
+        self.context.queue_state = "SHUTDOWN"
+        while not q.empty():
+            try:
+                item = q.get_nowait()
+                q.task_done()
+                logger.info("Discarding item from queue: %s", item)
+            except asyncio.QueueEmpty:
+                break
+        await q.put(None)
+
+        if self.context.simulation_task is not None and not self.context.simulation_task.done():
+            try:
+                await asyncio.wait_for(self.context.simulation_task, timeout=5)
+            except TimeoutError:
+                self.context.simulation_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self.context.simulation_task
+        self.context.simulation_active = False
+        self.context.queue_state = "SHUTDOWN"
+
+    async def play_queue(
+        self, disable_sleep: bool = False, timing_randomness_range: int = 0
+    ) -> None:
+        while True:
+            if self.context.queue_state == "PAUSED":
+                await asyncio.sleep(0.1)
+                continue
+            if self.context.queue_state == "SHUTDOWN":
+                break
+            loc_id = await self.context.queue.get()
+            if loc_id is None:
+                self.context.queue.task_done()
+                break
+            location_item = self.context.queue_data.get(loc_id)
+            if location_item is None:
+                logger.warning(
+                    "Test simulation queue item missing for loc_id=%s; skipping stale entry",
+                    loc_id,
+                )
+                self.context.queue.task_done()
+                continue
+            latitude = location_item.get("latitude")
+            longitude = location_item.get("longitude")
+            delay = location_item.get("delay")
+            delay = 0 if delay is None else delay
+            start_time = location_item.get("start")
+            if self.context.set_location_enabled:
+                if delay > 0 and not disable_sleep:
+                    countdown_delay = int(round(float(delay)))
+                    if timing_randomness_range > 0:
+                        delay = delay + random.uniform(
+                            -timing_randomness_range, timing_randomness_range
+                        )
+                        countdown_delay = int(round(float(delay)))
+                    for i in range(max(0, countdown_delay), 0, -1):
+                        self.context.next_move = i
+                        await self.context.sio.emit(
+                            "simulation_status",
+                            {
+                                "status": self.context.simulation_active,
+                                "loc_id": self.context.loc_id,
+                                "latitude": self.context.latitude,
+                                "longitude": self.context.longitude,
+                                "next_move": i,
+                            },
+                            namespace="/",
+                        )
+                        await asyncio.sleep(1)
+                await self.set(latitude, longitude)
+                self.context.latitude = latitude
+                self.context.longitude = longitude
+                await self.context.sio.emit(
+                    "simulation_status",
+                    {
+                        "status": self.context.simulation_active,
+                        "loc_id": self.context.loc_id,
+                        "latitude": self.context.latitude,
+                        "longitude": self.context.longitude,
+                        "next_move": None,
+                    },
+                    namespace="/",
+                )
+                logger.info(
+                    "Set simulated location to %s, %s after %ss delay",
+                    latitude,
+                    longitude,
+                    delay,
+                )
+            self.context.queue.task_done()
diff --git a/src/pymd3_vue_location_sim/models.py b/src/pymd3_vue_location_sim/models.py
new file mode 100644
index 0000000..6dba00c
--- /dev/null
+++ b/src/pymd3_vue_location_sim/models.py
@@ -0,0 +1,64 @@
+from typing import Optional, Dict
+from pydantic import BaseModel
+
+class SimulationStatusData(BaseModel):
+    latitude: float
+    longitude: float
+    start: float
+    end: Optional[float]
+    next_move: Optional[float]
+
+
+class SimulationStatus(BaseModel):
+    status: bool
+    data: Optional[SimulationStatusData]
+
+
+class SimulationRequestData(BaseModel):
+    latitude: float
+    longitude: float
+    delay: int = 0
+    start: Optional[str] = None
+    end: Optional[str] = None
+
+
+class SimulationRequest(BaseModel):
+    status: bool
+    data: Optional[SimulationRequestData]
+
+
+class SimulationRequestResponseData(BaseModel):
+    loc_id: str
+    latitude: float
+    longitude: float
+    delay: int = 0
+    start: Optional[str] = None
+    end: Optional[str] = None
+
+class SimulationQueueList(BaseModel):
+    data: Optional[SimulationRequestResponseData]
+
+
+class SimulationRequestResponse(BaseModel):
+    status: bool
+    data: Optional[SimulationRequestResponseData]
+
+class SimulationQueueDict(BaseModel):
+    location_id: Dict[str, SimulationRequestResponseData]
+
+class iCloudLocationData(BaseModel):
+    latitude: float
+    longitude: float
+    timestamp: str
+
+class iCloudReturnData(BaseModel):
+    latitude: float
+    longitude: float
+    timeStamp: int
+    altitude: float
+    horizontalAccuracy: float
+    verticalAccuracy: float
+    batteryLevel: float
+    deviceDisplayName: str
+    deviceStatus: int
+    name: str
\ No newline at end of file
diff --git a/src/pymd3_vue_location_sim/routes/api.py b/src/pymd3_vue_location_sim/routes/api.py
new file mode 100644
index 0000000..718aac5
--- /dev/null
+++ b/src/pymd3_vue_location_sim/routes/api.py
@@ -0,0 +1,379 @@
+""" Tunnel Functions"""
+
+        @self._app.get("/start-tunnel")
+        async def start_tunnel(
+            udid: Optional[str] = self.context.udid,
+            ip: Optional[str] = None,
+            connection_type: Optional[str] = None,
+        ) -> fastapi.Response:
+            udid_tunnels = [
+                t.tunnel
+                for t in self._tunneld_core.tunnel_tasks.values()
+                if t.udid == udid and t.tunnel is not None
+            ]
+            if len(udid_tunnels) > 0:
+                self.context.udid = udid
+                data = {
+                    "interface": udid_tunnels[0].interface,
+                    "port": udid_tunnels[0].port,
+                    "address": udid_tunnels[0].address,
+                }
+                return generate_http_response(data)
+            queue = asyncio.Queue()
+            created_task = False
+            try:
+                if not created_task and connection_type in ("usbmux", None):
+                    task_identifier = f"usbmux-{udid}"
+                    try:
+                        async with await create_using_usbmux(udid) as lockdown:
+                            service = await CoreDeviceTunnelProxy.create(lockdown)
+                        task = asyncio.create_task(
+                            self._tunneld_core.start_tunnel_task(
+                                task_identifier,
+                                service,
+                                protocol=TunnelProtocol.TCP,
+                                queue=queue,
+                            ),
+                            name=f"start-tunnel-task-{task_identifier}",
+                        )
+                        self._tunneld_core.tunnel_tasks[task_identifier] = TunnelTask(
+                            task=task, udid=udid
+                        )
+                        created_task = True
+                    except ConnectionFailedError, InvalidServiceError, MuxException:
+                        pass
+                if connection_type in ("usb", None):
+                    for rsd in await get_rsds(udid=udid):
+                        rsd_ip = rsd.service.address[0]
+                        if ip is not None and rsd_ip != ip:
+                            await rsd.close()
+                            continue
+                        task = asyncio.create_task(
+                            self._tunneld_core.start_tunnel_task(
+                                rsd_ip,
+                                await create_core_device_tunnel_service_using_rsd(rsd),
+                                queue=queue,
+                            ),
+                            name=f"start-tunnel-usb-{rsd_ip}",
+                        )
+                        self._tunneld_core.tunnel_tasks[rsd_ip] = TunnelTask(
+                            task=task, udid=rsd.udid
+                        )
+                        created_task = True
+                if not created_task and connection_type in ("wifi", None):
+                    for remotepairing in await get_remote_pairing_tunnel_services(
+                        udid=udid
+                    ):
+                        remotepairing_ip = remotepairing.hostname
+                        if ip is not None and remotepairing_ip != ip:
+                            await remotepairing.close()
+                            continue
+                        task = asyncio.create_task(
+                            self._tunneld_core.start_tunnel_task(
+                                remotepairing_ip, remotepairing, queue=queue
+                            ),
+                            name=f"start-tunnel-wifi-{remotepairing_ip}",
+                        )
+                        self._tunneld_core.tunnel_tasks[remotepairing_ip] = TunnelTask(
+                            task=task, udid=remotepairing.remote_identifier
+                        )
+                        created_task = True
+            except Exception as e:
+                return fastapi.Response(
+                    status_code=501,
+                    content=json.dumps(
+                        {
+                            "error": {
+                                "exception": e.__class__.__name__,
+                                "traceback": traceback.format_exc(),
+                            }
+                        }
+                    ),
+                )
+            if not created_task:
+                return fastapi.Response(
+                    status_code=501, content=json.dumps({"error": "task not created"})
+                )
+            tunnel: Optional[TunnelResult] = await queue.get()
+            if tunnel is not None:
+                self.context.udid = udid
+                data = {
+                    "interface": tunnel.interface,
+                    "port": tunnel.port,
+                    "address": tunnel.address,
+                }
+                return generate_http_response(data)
+            else:
+                return fastapi.Response(
+                    status_code=404,
+                    content=json.dumps(
+                        {"error": "something went wrong during tunnel creation"}
+                    ),
+                )
+
+        @self._app.get("/restart-tunneld")
+        async def restart() -> fastapi.Response:
+            """Restart Tunneld"""
+            self._tunneld_core.clear()
+            await asyncio.sleep(2)
+            self._tunneld_core.start()
+            data = {
+                "operation": "restart-tunneld",
+                "data": True,
+                "message": "Restarting tunneld...",
+            }
+            return generate_http_response(data)
+
+
+        @self._app.get("/shutdown")
+        async def shutdown() -> fastapi.Response:
+            """Shutdown Tunneld"""
+            os.kill(os.getpid(), signal.SIGINT)
+            data = {
+                "operation": "shutdown",
+                "data": True,
+                "message": "Server shutting down...",
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/clear-tunnels")
+        async def clear_tunnels() -> fastapi.Response:
+            """Clear all tunnels"""
+            self._tunneld_core.clear()
+            data = {
+                "operation": "clear_tunnels",
+                "data": True,
+                "message": "Cleared tunnels...",
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/cancel")
+        async def cancel_tunnel(udid: str) -> fastapi.Response:
+            """Cancel a tunnel"""
+            self._tunneld_core.cancel(udid=udid)
+            data = {
+                "operation": "cancel",
+                "udid": udid,
+                "data": True,
+                "message": f"tunnel {udid} Canceled ...",
+            }
+            return generate_http_response(data)
+
+        """Simulation Functions"""
+
+        @self._app.get("/start-simulation")
+        async def app_start_simulation() -> fastapi.Response:
+            logger.info("Simulation Start Requested ")
+            if (
+                self.context.simulation_task is None
+                or self.context.simulation_task.done()
+            ):
+                await start_icloud_monitor()
+                self.context.simulation_active = True
+                self.context.simulation_task = asyncio.create_task(
+                    start_simulation_queue(),
+                    name="location-simulation-worker",
+                )
+                data = {"status": "started", "message": "Simulation started"}
+            else:
+                data = {"status": "error", "message": "Simulation already running"}
+            return generate_http_response(data)
+
+        @self._app.get("/start-icloud-monitor")
+        async def app_start_icloud_monitor() -> fastapi.Response:
+            await start_icloud_monitor()
+            data = {
+                "status": "started",
+                "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                "icloud_monitor_running": is_icloud_monitor_running(),
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/stop-icloud-monitor")
+        async def app_stop_icloud_monitor() -> fastapi.Response:
+            await end_icloud_monitor()
+            data = {
+                "status": "stopped",
+                "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                "icloud_monitor_running": is_icloud_monitor_running(),
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/icloud-monitor-status")
+        async def app_icloud_monitor_status() -> fastapi.Response:
+            data = {
+                "status": "ok",
+                "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                "icloud_monitor_running": is_icloud_monitor_running(),
+            }
+            return generate_http_response(data)
+
+        @self._app.post("/add-location")
+        async def app_add_location(data: SimulationRequestData) -> fastapi.Response:
+            """Add a location to the simulation queue"""
+            logger.info("Request to add new location to queue")
+
+            loc_id = str(uuid.uuid4())
+            latitude = (
+                data.get("latitude")
+                if isinstance(data, dict)
+                else getattr(data, "latitude", None)
+            )
+            longitude = (
+                data.get("longitude")
+                if isinstance(data, dict)
+                else getattr(data, "longitude", None)
+            )
+            delay = (
+                data.get("delay", 0)
+                if isinstance(data, dict)
+                else getattr(data, "delay", 0)
+            )
+            try:
+                delay = parse_delay_seconds(delay)
+            except ValueError as e:
+                return generate_http_response(
+                    {"status": "error", "message": str(e)},
+                    status_code=400,
+                )
+            if latitude is not None and longitude is not None:
+                logger.info(
+                    "Adding location %s (%s, %s) with %s delay to the queue",
+                    loc_id,
+                    latitude,
+                    longitude,
+                    delay,
+                )
+                accrued_delay = 0
+                if self.context.queue_data:
+                    accrued_delay = sum(
+                        parse_delay_seconds(item.get("delay", 0))
+                        for item in self.context.queue_data.values()
+                    )
+                now_time = datetime.now(timezone.utc)
+                new_time = (
+                    now_time
+                    + timedelta(seconds=accrued_delay)
+                    + timedelta(seconds=delay)
+                )
+                start_time = new_time.isoformat()
+                location_item = {
+                    "loc_id": loc_id,
+                    "latitude": latitude,
+                    "longitude": longitude,
+                    "delay": delay,
+                    "start": start_time,
+                    "status": "queued",
+                }
+                resp = {
+                    "status": "added",
+                    "message": f"Location {loc_id} added to the queue",
+                    "item": location_item,
+                }
+                await self.context.queue.put(loc_id)
+                add_item(loc_id, location_item)
+                logger.info("Location %s added to the queue", loc_id)
+            else:
+                resp = {"status": "error", "message": "Invalid location data"}
+            return generate_http_response(resp)
+
+        @self._app.get("/clear-queue")
+        async def app_clear_queue() -> fastapi.Response:
+            """Clear the simulation queue"""
+            logger.info("Simulation Start Requested ")
+            await empty_simulation_queue()
+            data = {"status": "cleared", "message": "Simulation cleared"}
+            return generate_http_response(data)
+
+        @self._app.get("/pause-queue")
+        async def app_pause_queue() -> fastapi.Response:
+            """Pause the simulation queue"""
+            await pause_simulation_queue()
+            data = {"status": "paused", "message": "Simulation paused"}
+            return generate_http_response(data)
+
+        @self._app.get("/resume-queue")
+        async def app_resume_queue() -> fastapi.Response:
+            """Resume the simulation queue"""
+            await resume_simulation_queue()
+            data = {"status": "resumed", "message": "Simulation resumed"}
+            return generate_http_response(data)
+
+        @self._app.get("/end-simulation")
+        async def app_end_simulation() -> fastapi.Response:
+            """End the simulation queue"""
+            logger.info("End location simulation request")
+            end_task = asyncio.create_task(
+                end_simulation_queue(), name="end-simulation-worker"
+            )
+            result = await end_task
+            data = {"status": result, "message": "Simulation ended"}
+            return generate_http_response(data)
+
+        """Status Functions"""
+
+        @self._app.get("/")
+        async def list_tunnels() -> dict[str, list[dict]]:
+            """Retrieve the available tunnels and format them as {UUID: TUNNEL_ADDRESS}"""
+            tunnels = {}
+            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
+                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
+                    continue
+                if active_tunnel.udid not in tunnels:
+                    tunnels[active_tunnel.udid] = []
+                tunnels[active_tunnel.udid].append(
+                    {
+                        "tunnel-address": active_tunnel.tunnel.address,
+                        "tunnel-port": active_tunnel.tunnel.port,
+                        "interface": ip,
+                    }
+                )
+            return tunnels
+
+
+        @self._app.get("/device-info")
+        async def device_info():
+            """Get device information"""
+            tunnels = {}
+            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
+                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
+                    continue
+                if active_tunnel.udid not in tunnels:
+                    tunnels[active_tunnel.udid] = {}
+                try:
+                    lockdown = await create_using_usbmux(
+                        serial=active_tunnel.udid, autopair=False
+                    )
+                    tunnels[active_tunnel.udid] = iterate_multidim(lockdown.all_values)
+                except Exception as e:
+                    logger.error(
+                        f"Failed to create lockdown session for device {active_tunnel.udid}: {e}"
+                    )
+                    continue
+            return tunnels
+
+        @self._app.get("/device-name")
+        async def rsd_info():
+            """Get rsd information"""
+            device_name = await get_device_name()
+            return generate_http_response(device_name)
+
+        @self._app.get("/rsd-info")
+        async def rsd_info():
+            """Get rsd information"""
+            rsd_info = {}
+            if self.context.tunnel is None:
+                await get_tun()
+            if self.context.tunnel is not None:
+                rsd_info = self.context.tunnel.peer_info
+            return generate_http_response(rsd_info)
+
+        @self._app.get("/hello")
+        async def hello() -> fastapi.Response:
+            data = {"message": "Hello, I'm alive"}
+            return generate_http_response(data)
+
+        @self._app.get("/context-status")
+        async def app_context_status() -> fastapi.Response:
+            data = get_status()
+            return generate_http_response(data)
diff --git a/src/pymd3_vue_location_sim/routes/socketio.py b/src/pymd3_vue_location_sim/routes/socketio.py
new file mode 100644
index 0000000..203757b
--- /dev/null
+++ b/src/pymd3_vue_location_sim/routes/socketio.py
@@ -0,0 +1,425 @@
+""" Socket.IO Functions"""
+
+
+async def sio_send_status(sid):
+    """Send Current Status"""
+    await self.context.sio.emit(
+        "status", jsonable_encoder(get_status()), namespace="/", to=sid
+    )
+
+
+"""Socket.IO Connection Events"""
+
+
+@self.context.sio.event
+async def connect(sid, environ):
+    """Client connection event handler."""
+    self.context.connected_clients.add(sid)
+    logger.info("Client connected: %s", sid)
+    await sio_send_status(sid)
+    return "%s connected" % sid
+
+
+@self.context.sio.event
+async def disconnect(sid):
+    """Client disconnection event handler."""
+    self.context.connected_clients.discard(sid)
+    logger.info("Client disconnected: %s", sid)
+
+
+""" Socket.IO Request Events """
+
+
+@self.context.sio.event
+async def request_update(sid):
+    status_update = jsonable_encoder(get_status())
+    logger.info("Update request from %s sending %s", sid, status_update)
+    return status_update
+
+
+@self.context.sio.event
+async def message(sid, data):
+    logger.info("Received message from %s: %s", sid, data)
+    return True, "Message received"
+
+
+#            await self.context.sio.emit("message", f"Received message from {sid}: {data}", namespace="/")
+
+""" Device Control"""
+
+
+@self.context.sio.event
+async def device_control(sid, data):
+    """Device Control"""
+    command = (
+        data.get("command")
+        if isinstance(data, dict)
+        else getattr(data, "command", None)
+    )
+    delay = (
+        data.get("delay")
+        if isinstance(data, dict)
+        else getattr(data, "delay", None)
+    )
+    if delay is None:
+        delay = 5
+    match command:
+        case "shutdown":
+            """ Shutdown the device"""
+            logger.info(
+                "Shutdown command received from %s with delay %s", sid, delay
+            )
+            await device_shutdown(delay)
+            return {
+                "command": "shutdown",
+                "status": "success",
+                "message": f"Device shutdown initiated with {delay} seconds delay",
+            }
+
+        case "reboot":
+            """ Reboot the device"""
+            logger.info(
+                "Reboot command received from %s with delay %s", sid, delay
+            )
+            await device_reboot(delay)
+            return {
+                "command": "reboot",
+                "status": "success",
+                "message": f"Device reboot initiated with {delay} seconds delay",
+            }
+
+        case _:
+            return {
+                "command": command,
+                "status": "error",
+                "message": f"Invalid command: {command}",
+            }
+
+
+@self.context.sio.event
+async def simulation_control(sid, data):
+    """Simulation Control"""
+    command = (
+        data.get("command")
+        if isinstance(data, dict)
+        else getattr(data, "command", None)
+    )
+    logger.info(
+        "Simulation Control command: %s requested from %s", command, sid
+    )
+    try:
+        match command:
+            case "add":
+                """ Add a location to the simulation queue"""
+                loc_id = str(uuid.uuid4())
+                latitude = (
+                    data.get("latitude")
+                    if isinstance(data, dict)
+                    else getattr(data, "latitude", None)
+                )
+                longitude = (
+                    data.get("longitude")
+                    if isinstance(data, dict)
+                    else getattr(data, "longitude", None)
+                )
+                delay = (
+                    data.get("delay", 0)
+                    if isinstance(data, dict)
+                    else getattr(data, "delay", 0)
+                )
+                try:
+                    delay = parse_delay_seconds(delay)
+                except ValueError as e:
+                    return {
+                        "command": command,
+                        "status": "error",
+                        "message": str(e),
+                    }
+                if latitude is not None and longitude is not None:
+                    logger.info(
+                        "Adding location %s (%s, %s) with %s delay to the queue",
+                        loc_id,
+                        latitude,
+                        longitude,
+                        delay,
+                    )
+                    accrued_delay = 0
+                    if self.context.queue_data:
+                        accrued_delay = sum(
+                            parse_delay_seconds(item.get("delay", 0))
+                            for item in self.context.queue_data.values()
+                        )
+                    now_time = datetime.now(timezone.utc)
+                    new_time = (
+                            now_time
+                            + timedelta(seconds=accrued_delay)
+                            + timedelta(seconds=delay)
+                    )
+                    start_time = new_time.isoformat()
+                    coords = f"{latitude}, {longitude}"
+                    rev_geocode = self.context.reverse_geocode(coords)
+                    if rev_geocode:
+                        address = rev_geocode.address
+                    else:
+                        address = f"{latitude}, {longitude}"
+
+                    location_item = {
+                        "loc_id": loc_id,
+                        "latitude": latitude,
+                        "longitude": longitude,
+                        "delay": delay,
+                        "start": start_time,
+                        "address": address,
+                    }
+                    ack = {
+                        "command": command,
+                        "status": "added",
+                        "message": f"Location {loc_id} added to the queue",
+                        "item": location_item,
+                    }
+                    await self.context.queue.put(loc_id)
+                    add_item(loc_id, location_item)
+                    logger.info("Location %s added to the queue", loc_id)
+                    return ack
+                else:
+                    logger.warning(
+                        "Invalid location data received from %s: %s", sid, data
+                    )
+                    return {
+                        "command": command,
+                        "status": "error",
+                        "message": "Invalid location data",
+                        "data": location_item,
+                    }
+            case "clear":
+                """ Clear the simulation queue"""
+                await empty_simulation_queue()
+                return {
+                    "command": command,
+                    "status": "cleared",
+                    "message": "Simulation cleared",
+                }
+            case "pause":
+                """ Pause the simulation queue"""
+                await pause_simulation_queue()
+                return {
+                    "command": command,
+                    "status": "paused",
+                    "message": "Simulation paused",
+                }
+            case "resume":
+                """ Resume the simulation queue"""
+                await resume_simulation_queue()
+                return {
+                    "command": command,
+                    "status": "resumed",
+                    "message": "Simulation resumed",
+                }
+            case "end":
+                """ End the simulation queue"""
+                logger.info("End location simulation request from %s", sid)
+                end_task = asyncio.create_task(
+                    end_simulation_queue(), name="end-simulation-worker"
+                )
+                result = await end_task
+                simstatus = not result
+                return {
+                    "command": command,
+                    "status": simstatus,
+                    "message": "Simulation ended",
+                }
+            case "start":
+                """ Start the simulation queue"""
+                logger.info("Start location simulation request from %s", sid)
+                if (
+                        self.context.simulation_task is None
+                        or self.context.simulation_task.done()
+                ):
+                    await start_icloud_monitor()
+                    self.context.simulation_active = True
+                    self.context.queue_state = "RUNNING"
+                    self.context.simulation_task = asyncio.create_task(
+                        start_simulation_queue(),
+                        name="location-simulation-worker",
+                    )
+                    return {
+                        "command": command,
+                        "status": self.context.queue_state,
+                        "message": "Simulation started",
+                    }
+                else:
+                    return {
+                        "command": command,
+                        "status": "error",
+                        "message": "Simulation already running",
+                    }
+            case _:
+                logger.warning(
+                    "Invalid command received from %s: %s", sid, command
+                )
+                return {"status": "error", "message": "Invalid command"}
+    finally:
+        await sio_send_status(sid)
+
+
+@self.context.sio.event
+async def icloud_monitor_control(sid, data):
+    command = (
+        data.get("command")
+        if isinstance(data, dict)
+        else getattr(data, "command", None)
+    )
+    logger.info(
+        "iCloud Monitor control command: %s requested from %s", command, sid
+    )
+    try:
+        match command:
+            case "start":
+                await start_icloud_monitor()
+                return {
+                    "command": command,
+                    "status": "running",
+                    "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                    "icloud_monitor_running": is_icloud_monitor_running(),
+                }
+            case "stop":
+                await end_icloud_monitor()
+                return {
+                    "command": command,
+                    "status": "stopped",
+                    "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                    "icloud_monitor_running": is_icloud_monitor_running(),
+                }
+            case "status":
+                return {
+                    "command": command,
+                    "status": "ok",
+                    "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                    "icloud_monitor_running": is_icloud_monitor_running(),
+                }
+            case _:
+                return {
+                    "command": command,
+                    "status": "error",
+                    "message": "Invalid command",
+                }
+    finally:
+        await sio_send_status(sid)
+
+
+""" Tunnel Control """
+
+
+@self.context.sio.event
+async def tunneld_control(sid, data):
+    command = (
+        data.get("command")
+        if isinstance(data, dict)
+        else getattr(data, "command", None)
+    )
+    logger.info("Tunneld Control command: %s requested from %s", command, sid)
+    match command:
+        case "start":
+            """Start Tunneld"""
+            logger.info("Start tunneld request from %s: %s", sid, data)
+            try:
+                self._tunneld_core.start()
+                logger.info("Tunneld started successfully")
+                return {
+                    "status": "running",
+                    "message": "Tunneld started successfully",
+                }
+            except Exception as e:
+                logger.error("Error starting tunneld: %s", e)
+                return {
+                    "command": command,
+                    "status": "error",
+                    "message": f"Error starting tunneld: {e}",
+                }
+
+        case "start-watcher":
+            """ Start Tunneld Watcher """
+            logger.info("Start tunneld watcher request from %s: %s", sid, data)
+            await start_tunnel_watcher()
+            return {
+                "status": "running",
+                "message": "Tunneld watcher started successfully",
+            }
+
+        case "end-watcher":
+            """ End Tunneld Watcher """
+            logger.info("End tunneld watcher request from %s: %s", sid, data)
+            await end_tunnel_watcher()
+            return {
+                "status": "stopped",
+                "message": "Tunneld watcher stopped successfully",
+            }
+
+        case "shutdown":
+            """Shutdown Tunneld"""
+            logger.info("Shutdown tunneld request from %s: %s", sid, data)
+            try:
+                os.kill(os.getpid(), signal.SIGINT)
+                return {
+                    "command": command,
+                    "status": "Success",
+                    "message": "Server shutting down...",
+                }
+            except Exception as e:
+                logger.error("Error shutting down tunneld: %s", e)
+                return {
+                    "command": command,
+                    "status": "error",
+                    "message": f"Error shutting down tunneld: {e}",
+                }
+
+        case "clear":
+            """Clear all tunnels"""
+            logger.info("Clearing tunnels...")
+            try:
+                self._tunneld_core.clear()
+                return {
+                    "command": command,
+                    "status": "Success",
+                    "message": "Cleared tunnels...",
+                }
+            except Exception as e:
+                logger.error("Error clearing tunnels: %s", e)
+                return {
+                    "command": command,
+                    "status": "error",
+                    "message": f"Error clearing tunnels: {e}",
+                }
+
+        case "cancel":
+            """Cancel a tunnel"""
+            logger.info("Canceling tunnel request from %s: %s", sid, data)
+            try:
+                udid = (
+                    data.get("udid")
+                    if isinstance(data, dict)
+                    else getattr(data, "udid", self.context.udid)
+                )
+                if udid is None:
+                    udid = self.context.udid
+                self._tunneld_core.cancel(udid=udid)
+                return {
+                    "command": command,
+                    "status": "Success",
+                    "udid": udid,
+                    "message": f"tunnel {udid} Canceled ...",
+                }
+            except Exception as e:
+                logger.error("Error canceling tunnel: %s", e)
+                return {
+                    "command": command,
+                    "status": "error",
+                    "message": f"Error canceling tunnel: {e}",
+                }
+
+        case _:
+            return {
+                "command": command,
+                "status": "error",
+                "message": f"Unknown operation: {command}",
+            }
\ No newline at end of file
diff --git a/src/pymd3_vue_location_sim/server.py b/src/pymd3_vue_location_sim/server.py
new file mode 100644
index 0000000..58020a5
--- /dev/null
+++ b/src/pymd3_vue_location_sim/server.py
@@ -0,0 +1,1835 @@
+import asyncio
+from datetime import datetime, timezone, timedelta
+import json
+import uuid
+import logging
+import os
+import signal
+import traceback
+import warnings
+import random
+import math
+import socketio
+from contextlib import asynccontextmanager, suppress
+from geopy.geocoders import Nominatim
+from geopy.extra.rate_limiter import RateLimiter
+
+from dotenv import load_dotenv
+
+with warnings.catch_warnings():
+    # Ignore: "Core Pydantic V1 functionality isn't compatible with Python 3.14 or greater."
+    warnings.simplefilter("ignore", category=UserWarning)
+    import fastapi
+import uvicorn
+from fastapi import FastAPI
+from fastapi.encoders import jsonable_encoder
+
+from pymobiledevice3.services.dvt.instruments.location_simulation_base import (
+    LocationSimulationBase,
+)
+from pymobiledevice3.exceptions import (
+    ConnectionFailedError,
+    InvalidServiceError,
+    MuxException,
+    TunneldConnectionError,
+)
+from pymobiledevice3.lockdown import create_using_usbmux, get_mobdev2_lockdowns
+from pymobiledevice3.osu.os_utils import get_os_utils
+from pymobiledevice3.remote.common import TunnelProtocol
+from pymobiledevice3.remote.remote_service_discovery import (
+    RemoteServiceDiscoveryService,
+)
+from pymobiledevice3.remote.tunnel_service import (
+    CoreDeviceTunnelProxy,
+    TunnelResult,
+    create_core_device_tunnel_service_using_rsd,
+    get_remote_pairing_tunnel_services,
+)
+from pymobiledevice3.remote.utils import get_rsds
+from pymobiledevice3.services.dvt.instruments.location_simulation import (
+    LocationSimulation,
+)
+from pymobiledevice3.services.dvt.instruments.dvt_provider import DvtProvider
+from pymobiledevice3.tunneld.server import TunneldCore, TunnelTask
+
+from .icloud_monitor import FindMyMonitor
+from .models import *
+from .json_formatter import JsonFormatter, handler, root_logger, logger
+
+load_dotenv()
+
+handler.setFormatter(JsonFormatter())
+root_logger.handlers = [handler]
+root_logger.setLevel(logging.INFO)
+
+
+# bugfix: after the device reboots, it might take some time for remoted to start answering the bonjour queries
+REATTEMPT_INTERVAL = 5
+REATTEMPT_COUNT = 5
+
+REMOTEPAIRING_INTERVAL = 5
+MOBDEV2_INTERVAL = 5
+
+# USB monitor will periodically forget what interfaces it has seen
+# and force a full rescan.  The value is the number of iterations of the
+# inner loop (which sleeps one second each) before blowing away the
+# `previous_ips` cache.
+USB_MONITOR_RESCAN_INTERVAL = 30
+
+USBMUX_INTERVAL = 2
+OSUTILS = get_os_utils()
+TUNNEL_ACQUIRE_TIMEOUT_SECONDS = 15
+DVT_CONNECT_TIMEOUT_SECONDS = 20
+
+
+class LocationSimulationState:
+    def __init__(self):
+        self.connected_clients: set[str] = set()
+        self.current_location: Optional[Dict[str, SimulationRequestResponseData]] = None
+        self.device_name: Optional[str] = os.getenv("SELECTED_DEVICE_NAME")
+        self.fmf_location: Optional[iCloudLocationData] = None
+        self.fmf_queue: asyncio.Queue = asyncio.Queue()
+        self.icloud_consumer_task = None
+        self.icloud_monitor = FindMyMonitor(self.fmf_queue)
+        self.icloud_monitor_task = None
+        self.icloud_monitor_enabled: bool = False
+        self.tunnel_watcher_task = None
+        self.latitude: Optional[float] = None
+        self.loc_id: Optional[str] = None
+        self.longitude: Optional[float] = None
+        self.next_move: Optional[float] = None
+        self.queue: asyncio.Queue = asyncio.Queue()
+        self.queue_data: Dict = {}
+        self.queue_order: list[str] = []
+        self.queue_state: str = "STOPPED"
+        self.set_location_enabled: bool = True
+        self.simulation_active: bool = False
+        self.simulation_task: Optional[asyncio.Task] = None
+        self.sio: socketio.AsyncServer = socketio.AsyncServer(
+            async_mode="asgi", cors_allowed_origins="*"
+        )
+        self.test_mode: bool = os.getenv("TEST_MODE", "True").lower() == "true"
+        self.tunnel: Optional[RemoteServiceDiscoveryService] = None
+        self.udid: Optional[str] = None
+        self.geolocator = Nominatim(user_agent="pymd3_location_sim")
+        self.reverse_geocode = RateLimiter(self.geolocator.reverse, min_delay_seconds=1)
+
+
+class TunneldRunnerSio:
+    """TunneldRunner orchestrate between the webserver and TunneldCore"""
+
+    @classmethod
+    def create(
+        cls,
+        host: str,
+        port: int,
+        context: LocationSimulationState = LocationSimulationState(),
+        protocol: TunnelProtocol = TunnelProtocol.QUIC,
+        usb_monitor: bool = True,
+        wifi_monitor: bool = True,
+        usbmux_monitor: bool = True,
+        mobdev2_monitor: bool = True,
+    ) -> None:
+        cls(
+            host,
+            port,
+            protocol=protocol,
+            usb_monitor=usb_monitor,
+            wifi_monitor=wifi_monitor,
+            usbmux_monitor=usbmux_monitor,
+            mobdev2_monitor=mobdev2_monitor,
+            context=context,
+        )._run_app()
+
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        context: LocationSimulationState = LocationSimulationState(),
+        protocol: TunnelProtocol = TunnelProtocol.QUIC,
+        usb_monitor: bool = True,
+        wifi_monitor: bool = True,
+        usbmux_monitor: bool = True,
+        mobdev2_monitor: bool = True,
+    ):
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            self._tunneld_core.start()
+            await start_tunnel_watcher()
+            yield
+            logger.info("Closing tunneld tasks...")
+            await end_tunnel_watcher()
+            await end_icloud_monitor()
+            await empty_simulation_queue()
+            await self._tunneld_core.close()
+            await self.context.sio.shutdown()
+
+        self.host = host
+        self.port = port
+        self.protocol = protocol
+        self.context = context
+        self._tunneld_api_address = (
+            "127.0.0.1" if host in ("0.0.0.0", "::") else host,
+            port,
+        )
+        self._app = FastAPI(
+            title="iOS Device Management API",
+            lifespan=lifespan,
+            cors_allowed_origins="*",
+        )
+        self._asgi_app = socketio.ASGIApp(self.context.sio, self._app)
+        self.context.icloud_monitor.sio = self.context.sio
+        self.context.icloud_monitor.get_client_sids = lambda: list(
+            self.context.connected_clients
+        )
+        self._tunneld_core = TunneldCore(
+            protocol=protocol,
+            wifi_monitor=wifi_monitor,
+            usb_monitor=usb_monitor,
+            usbmux_monitor=usbmux_monitor,
+            mobdev2_monitor=mobdev2_monitor,
+        )
+
+        async def get_tun(
+            udid: Optional[str] = None, max_retries: int = 10, retry_delay: float = 0.5
+        ) -> RemoteServiceDiscoveryService:
+            """Resolve an active local tunnel and connect directly to its RSD endpoint."""
+            if self.context.tunnel is not None:
+                return self.context.tunnel
+
+            for attempt in range(max_retries):
+                candidates = []
+                for active_tunnel in self._tunneld_core.tunnel_tasks.values():
+                    if active_tunnel.tunnel is None or active_tunnel.udid is None:
+                        continue
+                    if udid is None or active_tunnel.udid == udid:
+                        candidates.append(active_tunnel.tunnel)
+
+                if not candidates:
+                    if attempt < max_retries - 1:
+                        logger.info(
+                            "Waiting for local tunnel to be ready... (attempt %s/%s)",
+                            attempt + 1,
+                            max_retries,
+                        )
+                        await asyncio.sleep(retry_delay)
+                        continue
+                    logger.error(
+                        "Failed to find an active local tunnel after max retries"
+                    )
+                    raise TunneldConnectionError()
+
+                tunnel = candidates[0]
+                if udid and len(candidates) > 1:
+                    logger.warning(
+                        "Multiple local tunnels found for udid %s; using first available",
+                        udid,
+                    )
+
+                try:
+                    rsd = RemoteServiceDiscoveryService((tunnel.address, tunnel.port))
+                    await rsd.connect()
+                    logger.info(
+                        "Connected to local tunnel at %s:%s after %s retries",
+                        tunnel.address,
+                        tunnel.port,
+                        attempt,
+                    )
+                    self.context.tunnel = rsd
+                    return rsd
+                except Exception:
+                    if attempt < max_retries - 1:
+                        logger.info(
+                            "Tunnel endpoint not ready yet... (attempt %s/%s)",
+                            attempt + 1,
+                            max_retries,
+                        )
+                        await asyncio.sleep(retry_delay)
+                    else:
+                        logger.error(
+                            "Failed to connect to local tunnel endpoint after max retries"
+                        )
+                        raise TunneldConnectionError()
+
+            raise TunneldConnectionError()
+
+
+
+        async def get_device_name():
+            if self.context.tunnel is None:
+                await get_tun()
+            device_name = await self.context.tunnel.get_value(key='DeviceName')
+            return device_name
+
+        def collect_active_tunnels() -> Dict[str, dict]:
+            active: Dict[str, dict] = {}
+            for interface, tunnel_task in self._tunneld_core.tunnel_tasks.items():
+                if tunnel_task is None or tunnel_task.tunnel is None or tunnel_task.udid is None:
+                    continue
+                tunnel = tunnel_task.tunnel
+                active[str(interface)] = {
+                    "interface": str(interface),
+                    "udid": tunnel_task.udid,
+                    "address": getattr(tunnel, "address", None),
+                    "port": getattr(tunnel, "port", None),
+                    "transport": getattr(tunnel, "protocol", None),
+                }
+            return active
+
+        async def handle_tunnel_drop(disconnected: list[dict]) -> None:
+            disconnected_udids = {d.get("udid") for d in disconnected if d.get("udid")}
+            if not disconnected_udids:
+                return
+
+            current_active = collect_active_tunnels()
+            active_udids = {d.get("udid") for d in current_active.values() if d.get("udid")}
+            primary_disconnected = self.context.udid in disconnected_udids if self.context.udid else False
+            no_tunnels_left = len(current_active) == 0
+            if not primary_disconnected and not no_tunnels_left:
+                return
+
+            logger.warning(
+                "Tunnel drop detected. primary_udid=%s disconnected_udids=%s active_udids=%s",
+                self.context.udid,
+                sorted(disconnected_udids),
+                sorted(active_udids),
+            )
+
+            if self.context.tunnel is not None:
+                with suppress(Exception):
+                    await self.context.tunnel.close()
+                self.context.tunnel = None
+            if no_tunnels_left:
+                self.context.udid = None
+
+            if self.context.simulation_active:
+                await pause_simulation_queue()
+                await self.context.sio.emit(
+                    "appError",
+                    {
+                        "type": "tunnel_disconnected",
+                        "message": "Tunnel dropped. Simulation paused until reconnection.",
+                        "disconnected_udids": sorted(disconnected_udids),
+                    },
+                    namespace="/",
+                )
+            await end_icloud_monitor()
+
+        async def safe_sio_emit(event: str, payload: dict, timeout_seconds: float = 2.0) -> None:
+            try:
+                await asyncio.wait_for(
+                    self.context.sio.emit(event, payload, namespace="/"),
+                    timeout=timeout_seconds,
+                )
+            except TimeoutError:
+                logger.warning("Socket.IO emit timed out for event=%s", event)
+            except Exception:
+                logger.exception("Socket.IO emit failed for event=%s", event)
+
+        async def tunnel_watcher_loop() -> None:
+            previous = collect_active_tunnels()
+            while True:
+                await asyncio.sleep(1)
+                current = collect_active_tunnels()
+                added_keys = set(current.keys()) - set(previous.keys())
+                removed_keys = set(previous.keys()) - set(current.keys())
+
+                added = [current[k] for k in sorted(added_keys)]
+                removed = [previous[k] for k in sorted(removed_keys)]
+
+                for item in added:
+                    logger.info(
+                        "Tunnel discovered interface=%s udid=%s address=%s port=%s transport=%s",
+                        item.get("interface"),
+                        item.get("udid"),
+                        item.get("address"),
+                        item.get("port"),
+                        item.get("transport"),
+                    )
+                    await safe_sio_emit("tunnel_device_connected", item)
+                    logger.info(f"Current udid: %s, new udid: %s", self.context.udid, item.get("udid"))
+                    if self.context.udid is None:
+                        self.context.udid = item.get("udid")
+                    device_name = await get_device_name()
+                    if device_name != self.context.device_name:
+                        self._tunneld_core.cancel(udid=item.get("udid"))
+                        logger.warning(
+                            "Tunnel established to wrong device. Dropping tunnel. wrong_udid=%s for device: %s",
+                            self.context.udid, self.context.device_name)
+                        self.context.udid = None
+                        await safe_sio_emit(
+                            "appError",
+                            {
+                                "type": "tunnel_wrong_device",
+                                "message": "Tunnel established to wrong device. Dropping tunnel.",
+                                "wrong_udid": self.context.udid,
+                                "device_name": device_name,
+                            },
+                        )
+                    await get_tun(item.get("udid"), max_retries=10, retry_delay=1.0)
+
+                if removed:
+                    for item in removed:
+                        logger.warning(
+                            "Tunnel disconnected interface=%s udid=%s address=%s port=%s",
+                            item.get("interface"),
+                            item.get("udid"),
+                            item.get("address"),
+                            item.get("port"),
+                        )
+                        await safe_sio_emit("tunnel_device_disconnected", item)
+                    await handle_tunnel_drop(removed)
+
+                previous = current
+
+        async def start_tunnel_watcher() -> None:
+            if self.context.tunnel_watcher_task is None or self.context.tunnel_watcher_task.done():
+                self.context.tunnel_watcher_task = asyncio.create_task(
+                    tunnel_watcher_loop(),
+                    name="tunnel-task-watcher",
+                )
+
+        async def end_tunnel_watcher() -> None:
+            if self.context.tunnel_watcher_task is not None:
+                self.context.tunnel_watcher_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self.context.tunnel_watcher_task
+                self.context.tunnel_watcher_task = None
+
+        def cleanup_device_data(d):
+            mydict = {}
+            for key, value in d.items():
+                if isinstance(value, dict):
+                    cleanup_device_data(value)
+                elif isinstance(value, bytes):
+                    mydict[key] = "BYTE DATA"
+                else:
+                    mydict[key] = value
+            return mydict
+
+        async def device_reboot(delay):
+            """Reboot the device"""
+            logger.info("Reboot iniated with delay %s")
+            await asyncio.sleep(delay)
+            os.system("shutdown -r now")
+
+        async def device_shutdown(delay):
+            """Shutdown the device"""
+            logger.info("Shutdown iniated with delay %s")
+            await asyncio.sleep(delay)
+            os.system("shutdown -h now")
+
+        """ Queue Functions"""
+
+        async def start_simulation_queue():
+            if (
+                self.context.simulation_task is None
+                or self.context.simulation_task.done()
+            ):
+                await start_icloud_monitor()
+                self.context.simulation_active = True
+                self.context.simulation_task = asyncio.create_task(
+                    start_queue_worker(),
+                    name="location-simulation-worker",
+                )
+                data = {"status": "started", "message": "Simulation started"}
+            else:
+                data = {"status": "error", "message": "Simulation already running"}
+            return data
+
+        async def start_queue_worker():
+            """Start Simulation Queue Worker"""
+            logger.info("Starting location simulation worker...")
+            self.context.simulation_active = True
+            self.context.queue_state = "RUNNING"
+            try:
+                if self.context.test_mode:
+                    logger.info("Simulation worker: test mode enabled")
+                    with LocationSimulationTestQueue(self.context) as locate_simulation:
+                        await locate_simulation.play_queue()
+
+                if self.context.udid is None and not self.context.test_mode:
+                    active_udids = sorted(
+                        {
+                            t.udid
+                            for t in self._tunneld_core.tunnel_tasks.values()
+                            if t.udid is not None and t.tunnel is not None
+                        }
+                    )
+                    if len(active_udids) == 1:
+                        self.context.udid = active_udids[0]
+                        logger.info(
+                            "Simulation worker: auto-selected udid=%s from active tunnel",
+                            self.context.udid,
+                        )
+                    elif len(active_udids) == 0:
+                        logger.error(
+                            "Simulation worker: no active tunnel with udid available"
+                        )
+                        await self.context.sio.emit(
+                            "appError",
+                            {
+                                "type": "simulation_no_tunnel",
+                                "message": "No active tunnel found. Start tunnel first.",
+                            },
+                            namespace="/",
+                        )
+                        return
+                    else:
+                        logger.error(
+                            "Simulation worker: multiple active tunnels; explicit udid required: %s",
+                            active_udids,
+                        )
+                        await self.context.sio.emit(
+                            "appError",
+                            {
+                                "type": "simulation_udid_required",
+                                "message": "Multiple active tunnels found; provide udid in start_simulate_location.",
+                                "udids": active_udids,
+                            },
+                            namespace="/",
+                        )
+                        return
+
+                logger.info(
+                    "Simulation worker: acquiring tunnel (udid=%s)", self.context.udid
+                )
+
+                tun = await get_tun(self.context.udid)
+                logger.info(
+                    "Simulation worker: tunnel acquired, connecting DVT provider"
+                )
+                dvt_provider = DvtProvider(tun)
+                dvt = await asyncio.wait_for(
+                    dvt_provider.__aenter__(), timeout=DVT_CONNECT_TIMEOUT_SECONDS
+                )
+                logger.info(
+                    "Simulation worker: DVT provider connected, starting queue playback"
+                )
+                try:
+                    async with LocationSimulationQueue(
+                        dvt, self.context
+                    ) as locate_simulation:
+                        await locate_simulation.play_queue()
+                finally:
+                    logger.info("Simulation worker: closing DVT provider")
+                    await dvt_provider.__aexit__(None, None, None)
+                    logger.info("Simulation worker: DVT provider closed")
+            except TimeoutError:
+                logger.error(
+                    "Simulation worker timeout. tunnel_timeout=%ss dvt_timeout=%ss udid=%s",
+                    TUNNEL_ACQUIRE_TIMEOUT_SECONDS,
+                    DVT_CONNECT_TIMEOUT_SECONDS,
+                    self.context.udid,
+                )
+                await self.context.sio.emit(
+                    "appError",
+                    {
+                        "type": "simulation_timeout",
+                        "udid": self.context.udid,
+                        "tunnel_timeout_seconds": TUNNEL_ACQUIRE_TIMEOUT_SECONDS,
+                        "dvt_timeout_seconds": DVT_CONNECT_TIMEOUT_SECONDS,
+                    },
+                    namespace="/",
+                )
+            except Exception:
+                logger.exception("Simulation worker crashed")
+                await self.context.sio.emit(
+                    "appError",
+                    {"type": "simulation_crash", "udid": self.context.udid},
+                    namespace="/",
+                )
+            finally:
+                self.context.simulation_active = False
+                self.context.simulation_task = None
+                await end_icloud_monitor()
+
+        async def start_icloud_monitor():
+            """Start Apple iCloud Find My Monitor to retreive actual reported device location"""
+            logger.info("iCloud monitor start requested")
+            self.context.icloud_monitor_enabled = True
+            if (
+                self.context.icloud_monitor_task is None
+                or self.context.icloud_monitor_task.done()
+            ):
+                self.context.icloud_monitor_task = asyncio.create_task(
+                    self.context.icloud_monitor.run_monitor(interval=30),
+                    name="icloud-monitor-producer",
+                )
+                logger.info("iCloud monitor producer task started")
+            if (
+                self.context.icloud_consumer_task is None
+                or self.context.icloud_consumer_task.done()
+            ):
+                self.context.icloud_consumer_task = asyncio.create_task(
+                    consume_icloud_updates(),
+                    name="icloud-monitor-consumer",
+                )
+                logger.info("iCloud monitor consumer task started")
+
+        async def consume_icloud_updates():
+            while True:
+                updated_location = await self.context.fmf_queue.get()
+                try:
+                    if self.context.fmf_location != updated_location:
+                        self.context.fmf_location = updated_location
+                        await self.context.sio.emit(
+                            "fmf_update", updated_location.model_dump(), namespace="/"
+                        )
+                finally:
+                    self.context.fmf_queue.task_done()
+
+        async def end_icloud_monitor():
+            logger.info("iCloud monitor stop requested")
+            self.context.icloud_monitor_enabled = False
+            self.context.icloud_monitor.stop()
+            if self.context.icloud_monitor_task is not None:
+                self.context.icloud_monitor_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self.context.icloud_monitor_task
+                self.context.icloud_monitor_task = None
+            if self.context.icloud_consumer_task is not None:
+                self.context.icloud_consumer_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self.context.icloud_consumer_task
+                self.context.icloud_consumer_task = None
+
+        def is_icloud_monitor_running() -> bool:
+            return (
+                self.context.icloud_monitor_task is not None
+                and not self.context.icloud_monitor_task.done()
+                and self.context.icloud_consumer_task is not None
+                and not self.context.icloud_consumer_task.done()
+            )
+
+        async def pause_simulation_queue():
+            """Pauses asyncio.Queue playback"""
+            self.context.queue_state = "PAUSED"
+
+        async def resume_simulation_queue():
+            """Resumes asyncio.Queue playback"""
+            self.context.queue_state = "RUNNING"
+            update_queue_times()
+
+        def update_queue_times():
+            current_index = get_item_index(self.context.loc_id)
+            remaining_items = self.context.queue_order[current_index + 1:]
+            new_delay = self.context.next_move or 0
+            now_time = datetime.now(timezone.utc)
+            for item in remaining_items:
+                item_delay = parse_delay_seconds(self.context.queue_data[item].get("delay")) or 0
+                new_delay += item_delay
+                new_time = (now_time + timedelta(seconds=new_delay)).isoformat()
+                self.context.queue_data[item].start = new_time
+
+
+        async def empty_simulation_queue():
+            """Empties all items from an asyncio.Queue."""
+            logger.info("Clearing location simulation queue...")
+            q = self.context.queue
+            self.context.set_location_enabled = False
+            while not q.empty():
+                try:
+                    item = q.get_nowait()
+                    q.task_done()
+                    logger.info("Discarding item from queue: %s", item)
+                except asyncio.QueueEmpty:
+                    break
+            clear_items()
+
+
+        def add_item(item_id, payload):
+            self.context.queue_data[item_id] = payload
+            self.context.queue_order.append(item_id)
+
+        def remove_item(item_id):
+            if item_id in self.context.queue_order:
+#                self.context.queue_order.remove(item_id)
+                self.context.queue_data[item_id]["status"] = "deleted"
+
+        def clear_item(item_id):
+            if item_id in self.context.queue_order:
+                self.context.queue_order.remove(item_id)
+                del self.context.queue_data[item_id]
+
+        def clear_items():
+            self.context.queue_data = {}
+            self.context.queue_order = []
+
+        def get_item(item_id):
+            return self.context.queue_data[item_id]
+
+        def update_item(item_id, **updates):
+            if item_id in self.context.queue_data:
+                self.context.queue_data[item_id].update(updates)
+
+        def get_item_index(item_id):
+            return self.context.queue_order.index(item_id)
+
+        def get_item_id_by_index(index):
+            return self.context.queue_order[index]
+
+        def get_items_in_order():
+            return [self.context.queue_data[i] for i in self.context.queue_order if self.context.queue_data[i].get("status") != "deleted"]
+
+        def parse_delay_seconds(raw_delay) -> int:
+            if raw_delay is None:
+                return 0
+            if isinstance(raw_delay, bool):
+                raise ValueError("delay must be a non-negative number")
+            parsed = float(raw_delay)
+            if math.isnan(parsed) or math.isinf(parsed) or parsed < 0:
+                raise ValueError("delay must be a non-negative finite number")
+            return int(parsed)
+
+        async def end_simulation_queue():
+            logger.info("End location simulation request")
+            end_task = asyncio.create_task(
+                end_simulation_worker(), name="end-simulation-worker"
+            )
+            result = await end_task
+            data = {"status": result, "message": "Simulation ended"}
+            return data
+
+        async def end_simulation_worker() -> bool:
+            """Ends asyncio.Queue playback and closes tunnel"""
+            logger.info("End location simulation request")
+            try:
+                q = self.context.queue
+                self.context.set_location_enabled = False
+                self.context.queue_state = "SHUTDOWN"
+
+                # Drain pending queue entries.
+                while not q.empty():
+                    try:
+                        item = q.get_nowait()
+                        q.task_done()
+                        logger.info("Discarding item from queue: %s", item)
+                    except asyncio.QueueEmpty:
+                        break
+
+                # Wake queue consumers blocked on queue.get().
+                await q.put(None)
+
+                clear_items()
+
+                if self.context.simulation_task is not None and not self.context.simulation_task.done():
+                    try:
+                        await asyncio.wait_for(self.context.simulation_task, timeout=5)
+                    except TimeoutError:
+                        logger.warning("Simulation worker did not stop in time; canceling task")
+                        self.context.simulation_task.cancel()
+                        with suppress(asyncio.CancelledError):
+                            await self.context.simulation_task
+
+                if not self.context.test_mode and self.context.tunnel is not None:
+                    async with (
+                        DvtProvider(self.context.tunnel) as dvt,
+                        LocationSimulationQueue(dvt) as locate_simulation,
+                    ):
+                        await locate_simulation.clear()
+
+                self.context.simulation_active = False
+                self.context.simulation_task = None
+                self.context.simulation_state = "ENDED"
+                self.context.set_location_enabled = True
+                self.context.next_move = None
+                self.context.loc_id = None
+                self.context.latitude = None
+                self.context.longitude = None
+                self.context.queue_state = "STOPPED"
+                # Recreate queue to discard sentinel wakeup items and unblock clean restarts.
+                self.context.queue = asyncio.Queue()
+                await end_icloud_monitor()
+                return True
+            except Exception as e:
+                logger.error(f"Error ending simulation queue: {e}")
+                return False
+
+        def get_status() -> dict:
+            current_item = self.context.queue_data.get(self.context.loc_id) if self.context.loc_id else None
+            current_start = (
+                current_item.get("start")
+                if isinstance(current_item, dict)
+                else getattr(current_item, "start", None)
+            )
+            data = {
+                "connected_clients": list(self.context.connected_clients),
+                "current_location": {
+                    "loc_id": self.context.loc_id,
+                    "longitude": self.context.longitude,
+                    "latitude": self.context.latitude,
+                    "start": current_start,
+                },
+                "device_name": self.context.device_name,
+                "fmf_location": self.context.fmf_location,
+                "icloud": {
+                        "consumer_queue": self.context.fmf_queue.qsize() if self.context.fmf_queue else 0,
+                        "consumer_task": self.context.icloud_consumer_task.done() if self.context.icloud_consumer_task else False,
+                        "monitor_task": self.context.icloud_monitor_task.done() if self.context.icloud_monitor_task else False,
+                        "monitor_enabled": self.context.icloud_monitor_enabled,
+                        "monitor_running": is_icloud_monitor_running(),
+                },
+                "tunnel_watcher_running": True if self.context.tunnel_watcher_task and not self.context.tunnel_watcher_task.done() else False,
+                "next_move": self.context.next_move,
+                "simulation_queue": {
+                    "active": self.context.simulation_active,
+                    "data": self.context.queue_data,
+                    "order": self.context.queue_order,
+                    "state": self.context.queue_state,
+                    "worker_task": self.context.simulation_task.get_name() if self.context.simulation_task else None,
+                },
+                "set_location_enable": self.context.set_location_enabled,
+                "test_mode": self.context.test_mode,
+                "tunnel": self.context.tunnel.service.address[0] if self.context.tunnel else None,
+                "udid": self.context.udid,
+            }
+            return data
+
+        """ FastAPI HTTP Functions"""
+
+        def generate_http_response(
+            data: dict, status_code: int = 200, media_type: str = "application/json"
+        ) -> fastapi.Response:
+            return fastapi.Response(
+                status_code=status_code,
+                media_type=media_type,
+                content=json.dumps(jsonable_encoder(data)),
+            )
+
+
+        """ Device Functions """
+
+        @self._app.get("/device/name")
+        async def rsd_info():
+            """Get rsd information"""
+            device_name = await get_device_name()
+            return generate_http_response(device_name)
+
+
+        @self._app.get("/device/info")
+        async def device_info():
+            """Get device information"""
+            tunnels = {}
+            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
+                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
+                    continue
+                if active_tunnel.udid not in tunnels:
+                    tunnels[active_tunnel.udid] = {}
+                try:
+                    lockdown = await create_using_usbmux(
+                        serial=active_tunnel.udid, autopair=False
+                    )
+                    tunnels[active_tunnel.udid] = iterate_multidim(lockdown.all_values)
+                except Exception as e:
+                    logger.error(
+                        f"Failed to create lockdown session for device {active_tunnel.udid}: {e}"
+                    )
+                    continue
+            return tunnels
+
+        """ Tunnel Functions"""
+        @self._app.get("/")
+        async def list_tunnels() -> dict[str, list[dict]]:
+            """Retrieve the available tunnels and format them as {UUID: TUNNEL_ADDRESS}"""
+            tunnels = {}
+            for ip, active_tunnel in self._tunneld_core.tunnel_tasks.items():
+                if (active_tunnel.udid is None) or (active_tunnel.tunnel is None):
+                    continue
+                if active_tunnel.udid not in tunnels:
+                    tunnels[active_tunnel.udid] = []
+                tunnels[active_tunnel.udid].append(
+                    {
+                        "tunnel-address": active_tunnel.tunnel.address,
+                        "tunnel-port": active_tunnel.tunnel.port,
+                        "interface": ip,
+                    }
+                )
+            return tunnels
+
+        @self._app.get("/shutdown")
+        async def shutdown() -> fastapi.Response:
+            """Shutdown Tunneld"""
+            os.kill(os.getpid(), signal.SIGINT)
+            data = {"operation": "shutdown", "data": True, "message": "Server shutting down..."}
+            return generate_http_response(data)
+
+        @self._app.get("/clear-tunnels")
+        async def clear_tunnels() -> fastapi.Response:
+            """Clear all tunnels"""
+            self._tunneld_core.clear()
+            data = {
+                "operation": "clear_tunnels",
+                "data": True,
+                "message": "Cleared tunnels...",
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/cancel")
+        async def cancel_tunnel(udid: str) -> fastapi.Response:
+            """Cancel a tunnel"""
+            self._tunneld_core.cancel(udid=udid)
+            data = {
+                "operation": "cancel",
+                "udid": udid,
+                "data": True,
+                "message": f"tunnel {udid} Canceled ...",
+            }
+            return generate_http_response(data)
+
+
+        @self._app.get("/hello")
+        async def hello() -> fastapi.Response:
+            data = {"message": "Hello, I'm alive"}
+            return generate_http_response(data)
+
+        @self._app.get("/start-tunnel")
+        async def start_tunnel(
+            udid: Optional[str] = self.context.udid,
+            ip: Optional[str] = None,
+            connection_type: Optional[str] = None,
+        ) -> fastapi.Response:
+            udid_tunnels = [
+                t.tunnel
+                for t in self._tunneld_core.tunnel_tasks.values()
+                if t.udid == udid and t.tunnel is not None
+            ]
+            if len(udid_tunnels) > 0:
+                self.context.udid = udid
+                data = {
+                    "interface": udid_tunnels[0].interface,
+                    "port": udid_tunnels[0].port,
+                    "address": udid_tunnels[0].address,
+                }
+                return generate_http_response(data)
+            queue = asyncio.Queue()
+            created_task = False
+            try:
+                if not created_task and connection_type in ("usbmux", None):
+                    task_identifier = f"usbmux-{udid}"
+                    try:
+                        async with await create_using_usbmux(udid) as lockdown:
+                            service = await CoreDeviceTunnelProxy.create(lockdown)
+                        task = asyncio.create_task(
+                            self._tunneld_core.start_tunnel_task(
+                                task_identifier,
+                                service,
+                                protocol=TunnelProtocol.TCP,
+                                queue=queue,
+                            ),
+                            name=f"start-tunnel-task-{task_identifier}",
+                        )
+                        self._tunneld_core.tunnel_tasks[task_identifier] = TunnelTask(
+                            task=task, udid=udid
+                        )
+                        created_task = True
+                    except ConnectionFailedError, InvalidServiceError, MuxException:
+                        pass
+                if connection_type in ("usb", None):
+                    for rsd in await get_rsds(udid=udid):
+                        rsd_ip = rsd.service.address[0]
+                        if ip is not None and rsd_ip != ip:
+                            await rsd.close()
+                            continue
+                        task = asyncio.create_task(
+                            self._tunneld_core.start_tunnel_task(
+                                rsd_ip,
+                                await create_core_device_tunnel_service_using_rsd(rsd),
+                                queue=queue,
+                            ),
+                            name=f"start-tunnel-usb-{rsd_ip}",
+                        )
+                        self._tunneld_core.tunnel_tasks[rsd_ip] = TunnelTask(
+                            task=task, udid=rsd.udid
+                        )
+                        created_task = True
+                if not created_task and connection_type in ("wifi", None):
+                    for remotepairing in await get_remote_pairing_tunnel_services(
+                        udid=udid
+                    ):
+                        remotepairing_ip = remotepairing.hostname
+                        if ip is not None and remotepairing_ip != ip:
+                            await remotepairing.close()
+                            continue
+                        task = asyncio.create_task(
+                            self._tunneld_core.start_tunnel_task(
+                                remotepairing_ip, remotepairing, queue=queue
+                            ),
+                            name=f"start-tunnel-wifi-{remotepairing_ip}",
+                        )
+                        self._tunneld_core.tunnel_tasks[remotepairing_ip] = TunnelTask(
+                            task=task, udid=remotepairing.remote_identifier
+                        )
+                        created_task = True
+            except Exception as e:
+                return fastapi.Response(
+                    status_code=501,
+                    content=json.dumps(
+                        {
+                            "error": {
+                                "exception": e.__class__.__name__,
+                                "traceback": traceback.format_exc(),
+                            }
+                        }
+                    ),
+                )
+            if not created_task:
+                return fastapi.Response(
+                    status_code=501, content=json.dumps({"error": "task not created"})
+                )
+            tunnel: Optional[TunnelResult] = await queue.get()
+            if tunnel is not None:
+                self.context.udid = udid
+                data = {
+                    "interface": tunnel.interface,
+                    "port": tunnel.port,
+                    "address": tunnel.address,
+                }
+                return generate_http_response(data)
+            else:
+                return fastapi.Response(
+                    status_code=404,
+                    content=json.dumps(
+                        {"error": "something went wrong during tunnel creation"}
+                    ),
+                )
+
+        @self._app.get("/restart")
+        async def restart() -> fastapi.Response:
+            """Restart Tunneld"""
+            self._tunneld_core.clear()
+            await asyncio.sleep(2)
+            self._tunneld_core.start()
+            data = {
+                "operation": "restart-tunneld",
+                "data": True,
+                "message": "Restarting tunneld...",
+            }
+            return generate_http_response(data)
+
+
+
+        """ iCloud Monitor"""
+
+
+        @self._app.get("/icloud-monitor/start")
+        async def app_start_icloud_monitor() -> fastapi.Response:
+            await start_icloud_monitor()
+            data = {
+                "status": "started",
+                "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                "icloud_monitor_running": is_icloud_monitor_running(),
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/icloud-monitor/stop")
+        async def app_stop_icloud_monitor() -> fastapi.Response:
+            await end_icloud_monitor()
+            data = {
+                "status": "stopped",
+                "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                "icloud_monitor_running": is_icloud_monitor_running(),
+            }
+            return generate_http_response(data)
+
+        @self._app.get("/icloud-monitor/status")
+        async def app_icloud_monitor_status() -> fastapi.Response:
+            data = {
+                "status": "ok",
+                "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                "icloud_monitor_running": is_icloud_monitor_running(),
+            }
+            return generate_http_response(data)
+
+
+        """Simulation Functions"""
+        """ start, add, clear, pause, resume, end, status """
+
+        @self._app.get("/simulation/start")
+        async def app_start_simulation() -> fastapi.Response:
+            data = await start_simulation_queue()
+            return generate_http_response(data)
+
+
+        @self._app.post("/simulation/add")
+        async def app_add_location(data: SimulationRequestData) -> fastapi.Response:
+            """Add a location to the simulation queue"""
+            logger.info("Request to add new location to queue")
+
+            loc_id = str(uuid.uuid4())
+            latitude = (
+                data.get("latitude")
+                if isinstance(data, dict)
+                else getattr(data, "latitude", None)
+            )
+            longitude = (
+                data.get("longitude")
+                if isinstance(data, dict)
+                else getattr(data, "longitude", None)
+            )
+            delay = (
+                data.get("delay", 0)
+                if isinstance(data, dict)
+                else getattr(data, "delay", 0)
+            )
+            try:
+                delay = parse_delay_seconds(delay)
+            except ValueError as e:
+                return generate_http_response(
+                    {"status": "error", "message": str(e)},
+                    status_code=400,
+                )
+            if latitude is not None and longitude is not None:
+                logger.info(
+                    "Adding location %s (%s, %s) with %s delay to the queue",
+                    loc_id,
+                    latitude,
+                    longitude,
+                    delay,
+                )
+                accrued_delay = 0
+                if self.context.queue_data:
+                    current_index = get_item_index(self.context.loc_id)
+                    remaining_items = self.context.queue_order[current_index + 1:]
+                    accrued_delay = sum(parse_delay_seconds(self.context.queue_data[loc_id]['delay']) for loc_id in remaining_items if loc_id in self.context.queue_data)
+                    accrued_delay = accrued_delay + parse_delay_seconds(self.context.next_move)
+
+                now_time = datetime.now(timezone.utc)
+                new_time = (
+                        now_time
+                        + timedelta(seconds=accrued_delay)
+                        + timedelta(seconds=delay)
+                )
+                start_time = new_time.isoformat()
+                coords = f"{latitude}, {longitude}"
+                rev_geocode = self.context.reverse_geocode(coords)
+                if rev_geocode:
+                    address = rev_geocode.address
+                else:
+                    address = f"{latitude}, {longitude}"
+                location_item = {
+                    "loc_id": loc_id,
+                    "latitude": latitude,
+                    "longitude": longitude,
+                    "delay": delay,
+                    "start": start_time,
+                    "address": address,
+                }
+                resp = {
+                    "status": "added",
+                    "message": f"Location {loc_id} added to the queue",
+                    "item": location_item,
+                }
+                await self.context.queue.put(loc_id)
+                add_item(loc_id, location_item)
+                logger.info("Location %s added to the queue", loc_id)
+            else:
+                logger.error("Invalid location data: %s", data)
+                resp = {"status": "error", "message": "Invalid location data", "data": data}
+            return generate_http_response(resp)
+
+        @self._app.get("/simulation/clear")
+        async def app_clear_queue() -> fastapi.Response:
+            """Clear the simulation queue"""
+            logger.info("Simulation Start Requested ")
+            await empty_simulation_queue()
+            data = {"status": "cleared", "message": "Simulation cleared"}
+            return generate_http_response(data)
+
+        @self._app.get("/simulation/pause")
+        async def app_pause_queue() -> fastapi.Response:
+            """Pause the simulation queue"""
+            await pause_simulation_queue()
+            data = {"status": "paused", "message": "Simulation paused"}
+            return generate_http_response(data)
+
+        @self._app.get("/simulation/resume")
+        async def app_resume_queue() -> fastapi.Response:
+            """Resume the simulation queue"""
+            await resume_simulation_queue()
+            data = {"status": "resumed", "message": "Simulation resumed"}
+            return generate_http_response(data)
+
+        @self._app.get("/simulation/end")
+        async def app_end_simulation() -> fastapi.Response:
+            """End the simulation queue"""
+            data = end_simulation_queue()
+            return generate_http_response(data)
+
+        @self._app.get("/simulation/test")
+        async def app_simulation_test_mode() -> fastapi.Response:
+            """Enable test mode for the simulation queue"""
+            before_toggle = self.context.test_mode
+            self.context.test_mode = not self.context.test_mode
+            data = {"status": "Ok", "message": f"Test mode toggled from {before_toggle} to {self.context.test_mode}"}
+            return generate_http_response(data)
+
+
+
+        """Status Functions"""
+
+        @self._app.get("/status/rsd")
+        async def rsd_info():
+            """Get rsd information"""
+            rsd_info = {}
+            if self.context.tunnel is None:
+                await get_tun()
+            if self.context.tunnel is not None:
+                rsd_info = self.context.tunnel.peer_info
+            return generate_http_response(rsd_info)
+
+
+        @self._app.get("/status/context")
+        async def app_context_status() -> fastapi.Response:
+            data = get_status()
+            return generate_http_response(data)
+
+
+
+
+
+        """ Socket.IO Functions"""
+
+        async def sio_send_status(sid):
+            """Send Current Status"""
+            await self.context.sio.emit(
+                "status", jsonable_encoder(get_status()), namespace="/", to=sid
+            )
+
+        """Socket.IO Connection Events"""
+
+        @self.context.sio.event
+        async def connect(sid, environ):
+            """Client connection event handler."""
+            self.context.connected_clients.add(sid)
+            logger.info("Client connected: %s", sid)
+            await sio_send_status(sid)
+            return "%s connected" % sid
+
+        @self.context.sio.event
+        async def disconnect(sid):
+            """Client disconnection event handler."""
+            self.context.connected_clients.discard(sid)
+            logger.info("Client disconnected: %s", sid)
+
+        """ Socket.IO Request Events """
+
+        @self.context.sio.event
+        async def request_update(sid):
+            status_update = jsonable_encoder(get_status())
+            logger.info("Update request from %s sending %s", sid, status_update)
+            return status_update
+
+        @self.context.sio.event
+        async def message(sid, data):
+            logger.info("Received message from %s: %s", sid, data)
+            return True, "Message received"
+
+        #            await self.context.sio.emit("message", f"Received message from {sid}: {data}", namespace="/")
+
+        """ Device Control"""
+
+        @self.context.sio.event
+        async def device_control(sid, data):
+            """Device Control"""
+            command = (
+                data.get("command")
+                if isinstance(data, dict)
+                else getattr(data, "command", None)
+            )
+            delay = (
+                data.get("delay")
+                if isinstance(data, dict)
+                else getattr(data, "delay", None)
+            )
+            if delay is None:
+                delay = 5
+            match command:
+                case "shutdown":
+                    """ Shutdown the device"""
+                    logger.info(
+                        "Shutdown command received from %s with delay %s", sid, delay
+                    )
+                    await device_shutdown(delay)
+                    return {
+                        "command": "shutdown",
+                        "status": "success",
+                        "message": f"Device shutdown initiated with {delay} seconds delay",
+                    }
+
+                case "reboot":
+                    """ Reboot the device"""
+                    logger.info(
+                        "Reboot command received from %s with delay %s", sid, delay
+                    )
+                    await device_reboot(delay)
+                    return {
+                        "command": "reboot",
+                        "status": "success",
+                        "message": f"Device reboot initiated with {delay} seconds delay",
+                    }
+
+                case _:
+                    return {
+                        "command": command,
+                        "status": "error",
+                        "message": f"Invalid command: {command}",
+                    }
+
+        @self.context.sio.event
+        async def simulation_control(sid, data):
+            """Simulation Control"""
+            command = (
+                data.get("command")
+                if isinstance(data, dict)
+                else getattr(data, "command", None)
+            )
+            logger.info(
+                "Simulation Control command: %s requested from %s", command, sid
+            )
+            try:
+                match command:
+                    case "add":
+                        """ Add a location to the simulation queue"""
+                        loc_id = str(uuid.uuid4())
+                        latitude = (
+                            data.get("latitude")
+                            if isinstance(data, dict)
+                            else getattr(data, "latitude", None)
+                        )
+                        longitude = (
+                            data.get("longitude")
+                            if isinstance(data, dict)
+                            else getattr(data, "longitude", None)
+                        )
+                        delay = (
+                            data.get("delay", 0)
+                            if isinstance(data, dict)
+                            else getattr(data, "delay", 0)
+                        )
+                        try:
+                            delay = parse_delay_seconds(delay)
+                        except ValueError as e:
+                            return {
+                                "command": command,
+                                "status": "error",
+                                "message": str(e),
+                            }
+                        if latitude is not None and longitude is not None:
+                            logger.info(
+                                "Adding location %s (%s, %s) with %s delay to the queue",
+                                loc_id,
+                                latitude,
+                                longitude,
+                                delay,
+                            )
+                            accrued_delay = 0
+                            if self.context.queue_data:
+                                current_index = get_item_index(self.context.loc_id)
+                                remaining_items = self.context.queue_order[current_index + 1:]
+                                accrued_delay = sum(parse_delay_seconds(self.context.queue_data[loc_id]['delay']) for loc_id in remaining_items if loc_id in self.context.queue_data)
+                                accrued_delay = accrued_delay + parse_delay_seconds(self.context.next_move)
+
+                            now_time = datetime.now(timezone.utc)
+                            new_time = (
+                                    now_time
+                                    + timedelta(seconds=accrued_delay)
+                                    + timedelta(seconds=delay)
+                            )
+                            start_time = new_time.isoformat()
+                            coords = f"{latitude}, {longitude}"
+                            rev_geocode = self.context.reverse_geocode(coords)
+                            if rev_geocode:
+                                address = rev_geocode.address
+                            else:
+                                address = f"{latitude}, {longitude}"
+                            location_item = {
+                                "loc_id": loc_id,
+                                "latitude": latitude,
+                                "longitude": longitude,
+                                "delay": delay,
+                                "start": start_time,
+                                "address": address,
+                            }
+                            ack = {
+                                "command": command,
+                                "status": "added",
+                                "message": f"Location {loc_id} added to the queue",
+                                "item": location_item,
+                            }
+                            await self.context.queue.put(loc_id)
+                            add_item(loc_id, location_item)
+                            logger.info("Location %s added to the queue", loc_id)
+                            return ack
+                        else:
+                            logger.warning(
+                                "Invalid location data received from %s: %s", sid, data
+                            )
+                            return {
+                                "command": command,
+                                "status": "error",
+                                "message": "Invalid location data",
+                                "data": data,
+                            }
+                    case "clear":
+                        """ Clear the simulation queue"""
+                        await empty_simulation_queue()
+                        return {
+                            "command": command,
+                            "status": "cleared",
+                            "message": "Simulation cleared",
+                        }
+                    case "pause":
+                        """ Pause the simulation queue"""
+                        await pause_simulation_queue()
+                        return {
+                            "command": command,
+                            "status": "paused",
+                            "message": "Simulation paused",
+                        }
+                    case "resume":
+                        """ Resume the simulation queue"""
+                        await resume_simulation_queue()
+                        return {
+                            "command": command,
+                            "status": "resumed",
+                            "message": "Simulation resumed",
+                        }
+                    case "end":
+                        """ End the simulation queue"""
+                        logger.info("End location simulation request from %s", sid)
+                        data = await end_simulation_queue()
+                        return data
+                    case "start":
+                        """ Start the simulation queue"""
+                        logger.info("Start location simulation request from %s", sid)
+                        data = await start_simulation_queue()
+                        return data
+                    case _:
+                        logger.warning(
+                            "Invalid command received from %s: %s", sid, command
+                        )
+                        return {"status": "error", "message": "Invalid command"}
+            finally:
+                await sio_send_status(sid)
+
+        @self.context.sio.event
+        async def icloud_monitor_control(sid, data):
+            command = (
+                data.get("command")
+                if isinstance(data, dict)
+                else getattr(data, "command", None)
+            )
+            logger.info(
+                "iCloud Monitor control command: %s requested from %s", command, sid
+            )
+            try:
+                match command:
+                    case "start":
+                        await start_icloud_monitor()
+                        return {
+                            "command": command,
+                            "status": "running",
+                            "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                            "icloud_monitor_running": is_icloud_monitor_running(),
+                        }
+                    case "stop":
+                        await end_icloud_monitor()
+                        return {
+                            "command": command,
+                            "status": "stopped",
+                            "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                            "icloud_monitor_running": is_icloud_monitor_running(),
+                        }
+                    case "status":
+                        return {
+                            "command": command,
+                            "status": "ok",
+                            "icloud_monitor_enabled": self.context.icloud_monitor_enabled,
+                            "icloud_monitor_running": is_icloud_monitor_running(),
+                        }
+                    case _:
+                        return {
+                            "command": command,
+                            "status": "error",
+                            "message": "Invalid command",
+                        }
+            finally:
+                await sio_send_status(sid)
+
+        """ Tunnel Control """
+
+        @self.context.sio.event
+        async def tunneld_control(sid, data):
+            command = (
+                data.get("command")
+                if isinstance(data, dict)
+                else getattr(data, "command", None)
+            )
+            logger.info("Tunneld Control command: %s requested from %s", command, sid)
+            match command:
+                case "start":
+                    """Start Tunneld"""
+                    logger.info("Start tunneld request from %s: %s", sid, data)
+                    try:
+                        self._tunneld_core.start()
+                        logger.info("Tunneld started successfully")
+                        return {
+                            "status": "running",
+                            "message": "Tunneld started successfully",
+                        }
+                    except Exception as e:
+                        logger.error("Error starting tunneld: %s", e)
+                        return {
+                            "command": command,
+                            "status": "error",
+                            "message": f"Error starting tunneld: {e}",
+                        }
+
+                case "start-watcher":
+                    """ Start Tunneld Watcher """
+                    logger.info("Start tunneld watcher request from %s: %s", sid, data)
+                    await start_tunnel_watcher()
+                    return {
+                        "status": "running",
+                        "message": "Tunneld watcher started successfully",
+                    }
+
+                case "end-watcher":
+                    """ End Tunneld Watcher """
+                    logger.info("End tunneld watcher request from %s: %s", sid, data)
+                    await end_tunnel_watcher()
+                    return {
+                        "status": "stopped",
+                        "message": "Tunneld watcher stopped successfully",
+                    }
+
+                case "shutdown":
+                    """Shutdown Tunneld"""
+                    logger.info("Shutdown tunneld request from %s: %s", sid, data)
+                    try:
+                        os.kill(os.getpid(), signal.SIGINT)
+                        return {
+                            "command": command,
+                            "status": "Success",
+                            "message": "Server shutting down...",
+                        }
+                    except Exception as e:
+                        logger.error("Error shutting down tunneld: %s", e)
+                        return {
+                            "command": command,
+                            "status": "error",
+                            "message": f"Error shutting down tunneld: {e}",
+                        }
+
+                case "clear":
+                    """Clear all tunnels"""
+                    logger.info("Clearing tunnels...")
+                    try:
+                        self._tunneld_core.clear()
+                        return {
+                            "command": command,
+                            "status": "Success",
+                            "message": "Cleared tunnels...",
+                        }
+                    except Exception as e:
+                        logger.error("Error clearing tunnels: %s", e)
+                        return {
+                            "command": command,
+                            "status": "error",
+                            "message": f"Error clearing tunnels: {e}",
+                        }
+
+                case "cancel":
+                    """Cancel a tunnel"""
+                    logger.info("Canceling tunnel request from %s: %s", sid, data)
+                    try:
+                        udid = (
+                            data.get("udid")
+                            if isinstance(data, dict)
+                            else getattr(data, "udid", self.context.udid)
+                        )
+                        if udid is None:
+                            udid = self.context.udid
+                        self._tunneld_core.cancel(udid=udid)
+                        return {
+                            "command": command,
+                            "status": "Success",
+                            "udid": udid,
+                            "message": f"tunnel {udid} Canceled ...",
+                        }
+                    except Exception as e:
+                        logger.error("Error canceling tunnel: %s", e)
+                        return {
+                            "command": command,
+                            "status": "error",
+                            "message": f"Error canceling tunnel: {e}",
+                        }
+
+                case _:
+                    return {
+                        "command": command,
+                        "status": "error",
+                        "message": f"Unknown operation: {command}",
+                    }
+
+    def _run_app(self) -> None:
+        uvicorn.run(
+            self._asgi_app, host=self.host, port=self.port, loop="asyncio", workers=1
+        )
+
+
+class LocationSimulationQueue(LocationSimulation):
+    def __init__(self, dvt, context: LocationSimulationState):
+        super().__init__(dvt)
+        self.context = context
+
+    async def play_queue(
+        self, disable_sleep: bool = False, timing_randomness_range: int = 0
+    ) -> None:
+        while True:
+            if self.context.queue_state == "PAUSED":
+                await asyncio.sleep(0.1)
+                continue
+            if self.context.queue_state == "SHUTDOWN":
+                break
+            loc_id = await self.context.queue.get()
+            if loc_id is None:
+                self.context.queue.task_done()
+                break
+            location_item = self.context.queue_data.get(loc_id)
+            if location_item is None:
+                logger.warning(
+                    "Simulation queue item missing for loc_id=%s; skipping stale entry",
+                    loc_id,
+                )
+                self.context.queue.task_done()
+                continue
+            new_latitude = location_item.get("latitude")
+            new_longitude = location_item.get("longitude")
+            new_delay = location_item.get("delay")
+            new_delay = 0 if new_delay is None else new_delay
+            new_start = location_item.get("start")
+
+            current_location_item = self.context.queue_data.get(self.context.loc_id)
+            current_latitude = (
+                current_location_item.get("latitude")
+                if isinstance(current_location_item, dict)
+                else self.context.latitude
+            )
+            current_longitude = (
+                current_location_item.get("longitude")
+                if isinstance(current_location_item, dict)
+                else self.context.longitude
+            )
+            current_start = (
+                current_location_item.get("start")
+                if isinstance(current_location_item, dict)
+                else None
+            )
+
+            if self.context.set_location_enabled:
+                if new_delay > 0 and not disable_sleep:
+                    countdown_delay = int(round(float(new_delay)))
+                    if timing_randomness_range > 0:
+                        new_delay = new_delay + random.uniform(
+                            -timing_randomness_range, timing_randomness_range
+                        )
+                        countdown_delay = int(round(float(new_delay)))
+                    for i in range(max(0, countdown_delay), 0, -1):
+                        if self.context.queue_state == "SHUTDOWN":
+                            break
+                        while self.context.queue_state == "PAUSED":
+                            await asyncio.sleep(0.1)
+                            if self.context.queue_state == "SHUTDOWN":
+                                break
+                        if self.context.queue_state == "SHUTDOWN":
+                            break
+                        self.context.next_move = i
+                        await self.context.sio.emit(
+                            "simulation_status",
+                            {
+                                "status": self.context.simulation_active,
+                                "loc_id": self.context.loc_id,
+                                "latitude": current_latitude,
+                                "longitude": current_longitude,
+                                "start": current_start,
+                                "next_move": i,
+                            },
+                            namespace="/",
+                        )
+                        await asyncio.sleep(1)
+                    if self.context.queue_state == "SHUTDOWN":
+                        self.context.queue.task_done()
+                        break
+                self.context.queue_data[loc_id]["start"] = datetime.now(timezone.utc).isoformat()
+                if self.context.loc_id is not None:
+                    self.context.queue_data[self.context.loc_id]["end"] = datetime.now(timezone.utc).isoformat()
+                await self.set(new_latitude, new_longitude)
+                self.context.loc_id = loc_id
+                self.context.latitude = new_latitude
+                self.context.longitude = new_longitude
+                await self.context.sio.emit(
+                    "simulation_status",
+                    {
+                        "status": self.context.simulation_active,
+                        "loc_id": self.context.loc_id,
+                        "latitude": self.context.latitude,
+                        "longitude": self.context.longitude,
+                        "start": new_start,
+                        "next_move": None,
+                    },
+                    namespace="/",
+                )
+                logger.info(
+                    "Set simulated location to %s, %s after %ss delay",
+                    new_latitude,
+                    new_longitude,
+                    new_delay,
+                )
+            self.context.queue.task_done()
+
+
+class LocationSimulationTestQueue(LocationSimulationBase):
+    def __init__(self, context: LocationSimulationState):
+        super().__init__()
+        self.context = context
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self):
+        return self
+
+    async def set(self, latitude: float, longitude: float) -> None:
+        await asyncio.sleep(0.1)
+        logger.info("Simulated location set to %s, %s", latitude, longitude)
+
+    async def clear(self) -> None:
+        q = self.context.queue
+        self.context.set_location_enabled = False
+        self.context.queue_state = "SHUTDOWN"
+        while not q.empty():
+            try:
+                item = q.get_nowait()
+                q.task_done()
+                logger.info("Discarding item from queue: %s", item)
+            except asyncio.QueueEmpty:
+                break
+        await q.put(None)
+
+        if self.context.simulation_task is not None and not self.context.simulation_task.done():
+            try:
+                await asyncio.wait_for(self.context.simulation_task, timeout=5)
+            except TimeoutError:
+                self.context.simulation_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await self.context.simulation_task
+        self.context.simulation_active = False
+        self.context.queue_state = "SHUTDOWN"
+
+    async def play_queue(
+        self, disable_sleep: bool = False, timing_randomness_range: int = 0
+    ) -> None:
+        while True:
+            if self.context.queue_state == "PAUSED":
+                await asyncio.sleep(0.1)
+                continue
+            if self.context.queue_state == "SHUTDOWN":
+                break
+            loc_id = await self.context.queue.get()
+            if loc_id is None:
+                self.context.queue.task_done()
+                break
+            location_item = self.context.queue_data.get(loc_id)
+            if location_item is None:
+                logger.warning(
+                    "Test simulation queue item missing for loc_id=%s; skipping stale entry",
+                    loc_id,
+                )
+                self.context.queue.task_done()
+                continue
+            new_latitude = location_item.get("latitude")
+            new_longitude = location_item.get("longitude")
+            new_delay = location_item.get("delay")
+            new_delay = 0 if delay is None else delay
+            new_start = location_item.get("start")
+
+            current_location_item = self.context.queue_data.get(self.context.loc_id)
+            current_latitude = (
+                current_location_item.get("latitude")
+                if isinstance(current_location_item, dict)
+                else self.context.latitude
+            )
+            current_longitude = (
+                current_location_item.get("longitude")
+                if isinstance(current_location_item, dict)
+                else self.context.longitude
+            )
+            current_start = (
+                current_location_item.get("start")
+                if isinstance(current_location_item, dict)
+                else None
+            )
+
+            if self.context.set_location_enabled:
+                if new_delay > 0 and not disable_sleep:
+                    countdown_delay = int(round(float(new_delay)))
+                    if timing_randomness_range > 0:
+                        delay = new_delay + random.uniform(
+                            -timing_randomness_range, timing_randomness_range
+                        )
+                        countdown_delay = int(round(float(new_delay)))
+                    for i in range(max(0, countdown_delay), 0, -1):
+                        if self.context.queue_state == "SHUTDOWN":
+                            break
+                        while self.context.queue_state == "PAUSED":
+                            await asyncio.sleep(0.1)
+                            if self.context.queue_state == "SHUTDOWN":
+                                break
+                        if self.context.queue_state == "SHUTDOWN":
+                            break
+                        self.context.next_move = i
+                        await self.context.sio.emit(
+                            "simulation_status",
+                            {
+                                "status": self.context.simulation_active,
+                                "loc_id": self.context.loc_id,
+                                "latitude": current_latitude,
+                                "longitude": current_longitude,
+                                "start": current_start,
+                                "next_move": i,
+                            },
+                            namespace="/",
+                        )
+                        await asyncio.sleep(1)
+                    if self.context.queue_state == "SHUTDOWN":
+                        self.context.queue.task_done()
+                        break
+                self.context.queue_data[loc_id]["start"] = datetime.now(timezone.utc).isoformat()
+                if self.context.loc_id is not None:
+                    self.context.queue_data[self.context.loc_id]["end"] = datetime.now(timezone.utc).isoformat()
+                await self.set(new_latitude, new_longitude)
+                self.context.loc_id = loc_id
+                self.context.latitude = new_latitude
+                self.context.longitude = new_longitude
+                await self.context.sio.emit(
+                    "simulation_status",
+                    {
+                        "status": self.context.simulation_active,
+                        "loc_id": self.context.loc_id,
+                        "latitude": self.context.latitude,
+                        "longitude": self.context.longitude,
+                        "start": new_start,
+                        "next_move": None,
+                        "next_move": None,
+                    },
+                    namespace="/",
+                )
+                logger.info(
+                    "Set simulated location to %s, %s after %ss delay",
+                    latitude,
+                    longitude,
+                    delay,
+                )
+            self.context.queue.task_done()
diff --git a/uv.lock b/uv.lock
index 4064283..84b8439 100644
--- a/uv.lock
+++ b/uv.lock
@@ -93,24 +93,36 @@ name = "back-end"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "click" },
+    { name = "daemonize" },
     { name = "fastapi" },
+    { name = "geopy" },
     { name = "pydantic" },
     { name = "pyicloud" },
     { name = "pymobiledevice3" },
     { name = "python-dotenv" },
     { name = "python-socketio" },
+    { name = "sqlalchemy" },
+    { name = "sqlalchemy-orm" },
+    { name = "typer" },
     { name = "typing" },
     { name = "uvicorn" },
 ]
 
 [package.metadata]
 requires-dist = [
+    { name = "click", specifier = ">=8.3.1" },
+    { name = "daemonize", specifier = ">=2.5.0" },
     { name = "fastapi", specifier = "==0.135.1" },
+    { name = "geopy", specifier = "==2.4.1" },
     { name = "pydantic", specifier = "==2.12.5" },
     { name = "pyicloud", specifier = ">=2.4.1" },
     { name = "pymobiledevice3", specifier = "==9.0.0" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
     { name = "python-socketio", specifier = "==5.16.1" },
+    { name = "sqlalchemy", specifier = ">=2.0.48" },
+    { name = "sqlalchemy-orm", specifier = ">=1.2.10" },
+    { name = "typer", specifier = ">=0.24.1" },
     { name = "typing", specifier = "==3.10.0.0" },
     { name = "uvicorn", specifier = "==0.41.0" },
 ]
@@ -428,6 +440,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e2/ab/d0fa89cc4b982800dd88daa799612f11642bf9393851715d9eaeba3cfcac/fido2-2.1.1-py3-none-any.whl", hash = "sha256:f85c16c8084abf6530b6c6ec3a0cf8575943321842e06916686943a8b784182c", size = 226945, upload-time = "2026-01-19T11:08:29.675Z" },
 ]
 
+[[package]]
+name = "geographiclib"
+version = "2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/78/4892343230a9d29faa1364564e525307a37e54ad776ea62c12129dbba704/geographiclib-2.1.tar.gz", hash = "sha256:6a6545e6262d0ed3522e13c515713718797e37ed8c672c31ad7b249f372ef108", size = 37004, upload-time = "2025-08-21T21:34:26Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/b3/802576f2ea5dcb48501bb162e4c7b7b3ca5654a42b2c968ef98a797a4c79/geographiclib-2.1-py3-none-any.whl", hash = "sha256:e2a873b9b9e7fc38721ad73d5f4e6c9ed140d428a339970f505c07056997d40b", size = 40740, upload-time = "2025-08-21T21:34:24.955Z" },
+]
+
+[[package]]
+name = "geopy"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "geographiclib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/fd/ef6d53875ceab72c1fad22dbed5ec1ad04eb378c2251a6a8024bad890c3b/geopy-2.4.1.tar.gz", hash = "sha256:50283d8e7ad07d89be5cb027338c6365a32044df3ae2556ad3f52f4840b3d0d1", size = 117625, upload-time = "2023-11-23T21:49:32.734Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/15/cf2a69ade4b194aa524ac75112d5caac37414b20a3a03e6865dfe0bd1539/geopy-2.4.1-py3-none-any.whl", hash = "sha256:ae8b4bc5c1131820f4d75fce9d4aaaca0c85189b3aa5d64c3dcaf5e3b7b882a7", size = 125437, upload-time = "2023-11-23T21:49:30.421Z" },
+]
+
 [[package]]
 name = "gpxpy"
 version = "1.6.2"
@@ -437,6 +470,29 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/44/9f/62df6c1e52462bdd04275b36cec49efa9e8af7e7b834499eb288f73dcfbc/gpxpy-1.6.2-py3-none-any.whl", hash = "sha256:289bc2d80f116c988d0a1e763fda22838f83005573ece2bbc6521817b26fb40a", size = 42649, upload-time = "2023-11-29T17:25:35.76Z" },
 ]
 
+[[package]]
+name = "greenlet"
+version = "3.3.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/51/1664f6b78fc6ebbd98019a1fd730e83fa78f2db7058f72b1463d3612b8db/greenlet-3.3.2.tar.gz", hash = "sha256:2eaf067fc6d886931c7962e8c6bede15d2f01965560f3359b27c80bde2d151f2", size = 188267, upload-time = "2026-02-20T20:54:15.531Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/ae/8bffcbd373b57a5992cd077cbe8858fff39110480a9d50697091faea6f39/greenlet-3.3.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:8d1658d7291f9859beed69a776c10822a0a799bc4bfe1bd4272bb60e62507dab", size = 279650, upload-time = "2026-02-20T20:18:00.783Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c0/45f93f348fa49abf32ac8439938726c480bd96b2a3c6f4d949ec0124b69f/greenlet-3.3.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18cb1b7337bca281915b3c5d5ae19f4e76d35e1df80f4ad3c1a7be91fadf1082", size = 650295, upload-time = "2026-02-20T20:47:34.036Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/de/dd7589b3f2b8372069ab3e4763ea5329940fc7ad9dcd3e272a37516d7c9b/greenlet-3.3.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2e47408e8ce1c6f1ceea0dffcdf6ebb85cc09e55c7af407c99f1112016e45e9", size = 662163, upload-time = "2026-02-20T20:56:01.295Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d8/09bfa816572a4d83bccd6750df1926f79158b1c36c5f73786e26dbe4ee38/greenlet-3.3.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63d10328839d1973e5ba35e98cccbca71b232b14051fd957b6f8b6e8e80d0506", size = 664160, upload-time = "2026-02-20T20:21:04.015Z" },
+    { url = "https://files.pythonhosted.org/packages/48/cf/56832f0c8255d27f6c35d41b5ec91168d74ec721d85f01a12131eec6b93c/greenlet-3.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e4ab3cfb02993c8cc248ea73d7dae6cec0253e9afa311c9b37e603ca9fad2ce", size = 1619181, upload-time = "2026-02-20T20:49:36.052Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/23/b90b60a4aabb4cec0796e55f25ffbfb579a907c3898cd2905c8918acaa16/greenlet-3.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94ad81f0fd3c0c0681a018a976e5c2bd2ca2d9d94895f23e7bb1af4e8af4e2d5", size = 1687713, upload-time = "2026-02-20T20:21:11.684Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ca/2101ca3d9223a1dc125140dbc063644dca76df6ff356531eb27bc267b446/greenlet-3.3.2-cp314-cp314-win_amd64.whl", hash = "sha256:8c4dd0f3997cf2512f7601563cc90dfb8957c0cff1e3a1b23991d4ea1776c492", size = 232034, upload-time = "2026-02-20T20:20:08.186Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/4a/ecf894e962a59dea60f04877eea0fd5724618da89f1867b28ee8b91e811f/greenlet-3.3.2-cp314-cp314-win_arm64.whl", hash = "sha256:cd6f9e2bbd46321ba3bbb4c8a15794d32960e3b0ae2cc4d49a1a53d314805d71", size = 231437, upload-time = "2026-02-20T20:18:59.722Z" },
+    { url = "https://files.pythonhosted.org/packages/98/6d/8f2ef704e614bcf58ed43cfb8d87afa1c285e98194ab2cfad351bf04f81e/greenlet-3.3.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:e26e72bec7ab387ac80caa7496e0f908ff954f31065b0ffc1f8ecb1338b11b54", size = 286617, upload-time = "2026-02-20T20:19:29.856Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0d/93894161d307c6ea237a43988f27eba0947b360b99ac5239ad3fe09f0b47/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b466dff7a4ffda6ca975979bab80bdadde979e29fc947ac3be4451428d8b0e4", size = 655189, upload-time = "2026-02-20T20:47:35.742Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/2c/d2d506ebd8abcb57386ec4f7ba20f4030cbe56eae541bc6fd6ef399c0b41/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8bddc5b73c9720bea487b3bffdb1840fe4e3656fba3bd40aa1489e9f37877ff", size = 658225, upload-time = "2026-02-20T20:56:02.527Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/30/3a09155fbf728673a1dea713572d2d31159f824a37c22da82127056c44e4/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26b0f4428b871a751968285a1ac9648944cea09807177ac639b030bddebcea4", size = 657907, upload-time = "2026-02-20T20:21:05.259Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/fd/d05a4b7acd0154ed758797f0a43b4c0962a843bedfe980115e842c5b2d08/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1fb39a11ee2e4d94be9a76671482be9398560955c9e568550de0224e41104727", size = 1618857, upload-time = "2026-02-20T20:49:37.309Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/e1/50ee92a5db521de8f35075b5eff060dd43d39ebd46c2181a2042f7070385/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:20154044d9085151bc309e7689d6f7ba10027f8f5a8c0676ad398b951913d89e", size = 1680010, upload-time = "2026-02-20T20:21:13.427Z" },
+    { url = "https://files.pythonhosted.org/packages/29/4b/45d90626aef8e65336bed690106d1382f7a43665e2249017e9527df8823b/greenlet-3.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c04c5e06ec3e022cbfe2cd4a846e1d4e50087444f875ff6d2c2ad8445495cf1a", size = 237086, upload-time = "2026-02-20T20:20:45.786Z" },
+]
+
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -491,6 +547,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9c/1f/19ebc343cc71a7ffa78f17018535adc5cbdd87afb31d7c34874680148b32/ifaddr-0.2.0-py3-none-any.whl", hash = "sha256:085e0305cfe6f16ab12d72e2024030f5d52674afad6911bb1eee207177b8a748", size = 12314, upload-time = "2022-06-15T21:40:25.756Z" },
 ]
 
+[[package]]
+name = "inflection"
+version = "0.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/7e/691d061b7329bc8d54edbf0ec22fbfb2afe61facb681f9aaa9bff7a27d04/inflection-0.5.1.tar.gz", hash = "sha256:1a29730d366e996aaacffb2f1f1cb9593dc38e2ddd30c91250c6dde09ea9b417", size = 15091, upload-time = "2020-08-22T08:16:29.139Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/91/aa6bde563e0085a02a435aa99b49ef75b0a4b062635e606dab23ce18d720/inflection-0.5.1-py2.py3-none-any.whl", hash = "sha256:f38b2b640938a4f35ade69ac3d053042959b62a0f1076a5bbaa1b9526605a8a2", size = 9454, upload-time = "2020-08-22T08:16:27.816Z" },
+]
+
 [[package]]
 name = "inquirer3"
 version = "0.6.1"
@@ -728,6 +793,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/8e/469e5a4a2f5855992e425f3cb33804cc07bf18d48f2db061aec61ce50270/more_itertools-10.8.0-py3-none-any.whl", hash = "sha256:52d4362373dcf7c52546bc4af9a86ee7c4579df9a8dc268be0a2f949d376cc9b", size = 69667, upload-time = "2025-09-02T15:23:09.635Z" },
 ]
 
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
 [[package]]
 name = "opack2"
 version = "0.0.1"
@@ -1354,6 +1428,44 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
 ]
 
+[[package]]
+name = "sqlalchemy"
+version = "2.0.48"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/73/b4a9737255583b5fa858e0bb8e116eb94b88c910164ed2ed719147bde3de/sqlalchemy-2.0.48.tar.gz", hash = "sha256:5ca74f37f3369b45e1f6b7b06afb182af1fd5dde009e4ffd831830d98cbe5fe7", size = 9886075, upload-time = "2026-03-02T15:28:51.474Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/b3/f437eaa1cf028bb3c927172c7272366393e73ccd104dcf5b6963f4ab5318/sqlalchemy-2.0.48-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e2d0d88686e3d35a76f3e15a34e8c12d73fc94c1dea1cd55782e695cc14086dd", size = 2154401, upload-time = "2026-03-02T15:49:17.24Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/1c/b3abdf0f402aa3f60f0df6ea53d92a162b458fca2321d8f1f00278506402/sqlalchemy-2.0.48-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49b7bddc1eebf011ea5ab722fdbe67a401caa34a350d278cc7733c0e88fecb1f", size = 3274528, upload-time = "2026-03-02T15:50:41.489Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/5e/327428a034407651a048f5e624361adf3f9fbac9d0fa98e981e9c6ff2f5e/sqlalchemy-2.0.48-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:426c5ca86415d9b8945c7073597e10de9644802e2ff502b8e1f11a7a2642856b", size = 3279523, upload-time = "2026-03-02T15:53:32.962Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ca/ece73c81a918add0965b76b868b7b5359e068380b90ef1656ee995940c02/sqlalchemy-2.0.48-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:288937433bd44e3990e7da2402fabc44a3c6c25d3704da066b85b89a85474ae0", size = 3224312, upload-time = "2026-03-02T15:50:42.996Z" },
+    { url = "https://files.pythonhosted.org/packages/88/11/fbaf1ae91fa4ee43f4fe79661cead6358644824419c26adb004941bdce7c/sqlalchemy-2.0.48-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8183dc57ae7d9edc1346e007e840a9f3d6aa7b7f165203a99e16f447150140d2", size = 3246304, upload-time = "2026-03-02T15:53:34.937Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/a8/5fb0deb13930b4f2f698c5541ae076c18981173e27dd00376dbaea7a9c82/sqlalchemy-2.0.48-cp314-cp314-win32.whl", hash = "sha256:1182437cb2d97988cfea04cf6cdc0b0bb9c74f4d56ec3d08b81e23d621a28cc6", size = 2116565, upload-time = "2026-03-02T15:54:38.321Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7e/e83615cb63f80047f18e61e31e8e32257d39458426c23006deeaf48f463b/sqlalchemy-2.0.48-cp314-cp314-win_amd64.whl", hash = "sha256:144921da96c08feb9e2b052c5c5c1d0d151a292c6135623c6b2c041f2a45f9e0", size = 2142205, upload-time = "2026-03-02T15:54:39.831Z" },
+    { url = "https://files.pythonhosted.org/packages/83/e3/69d8711b3f2c5135e9cde5f063bc1605860f0b2c53086d40c04017eb1f77/sqlalchemy-2.0.48-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5aee45fd2c6c0f2b9cdddf48c48535e7471e42d6fb81adfde801da0bd5b93241", size = 3563519, upload-time = "2026-03-02T15:57:52.387Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4f/a7cce98facca73c149ea4578981594aaa5fd841e956834931de503359336/sqlalchemy-2.0.48-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7cddca31edf8b0653090cbb54562ca027c421c58ddde2c0685f49ff56a1690e0", size = 3528611, upload-time = "2026-03-02T16:04:42.097Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7d/5936c7a03a0b0cb0fa0cc425998821c6029756b0855a8f7ee70fba1de955/sqlalchemy-2.0.48-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7a936f1bb23d370b7c8cc079d5fce4c7d18da87a33c6744e51a93b0f9e97e9b3", size = 3472326, upload-time = "2026-03-02T15:57:54.423Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/33/cea7dfc31b52904efe3dcdc169eb4514078887dff1f5ae28a7f4c5d54b3c/sqlalchemy-2.0.48-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e004aa9248e8cb0a5f9b96d003ca7c1c0a5da8decd1066e7b53f59eb8ce7c62b", size = 3478453, upload-time = "2026-03-02T16:04:44.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/95/32107c4d13be077a9cae61e9ae49966a35dc4bf442a8852dd871db31f62e/sqlalchemy-2.0.48-cp314-cp314t-win32.whl", hash = "sha256:b8438ec5594980d405251451c5b7ea9aa58dda38eb7ac35fb7e4c696712ee24f", size = 2147209, upload-time = "2026-03-02T15:52:54.274Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d7/1e073da7a4bc645eb83c76067284a0374e643bc4be57f14cc6414656f92c/sqlalchemy-2.0.48-cp314-cp314t-win_amd64.whl", hash = "sha256:d854b3970067297f3a7fbd7a4683587134aa9b3877ee15aa29eea478dc68f933", size = 2182198, upload-time = "2026-03-02T15:52:55.606Z" },
+    { url = "https://files.pythonhosted.org/packages/46/2c/9664130905f03db57961b8980b05cab624afd114bf2be2576628a9f22da4/sqlalchemy-2.0.48-py3-none-any.whl", hash = "sha256:a66fe406437dd65cacd96a72689a3aaaecaebbcd62d81c5ac1c0fdbeac835096", size = 1940202, upload-time = "2026-03-02T15:52:43.285Z" },
+]
+
+[[package]]
+name = "sqlalchemy-orm"
+version = "1.2.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cached-property" },
+    { name = "inflection" },
+    { name = "sqlalchemy" },
+    { name = "typing-inspect" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c8/98/b0451ae949f8b16287965d4fc4a180fae50a78d9b186300e135ec22e1883/sqlalchemy-orm-1.2.10.tar.gz", hash = "sha256:7ab46d2a54a429d4fd384df9a37ad639dc87ff93be5205ed649c5ca4dad164bb", size = 21846, upload-time = "2023-05-20T09:18:19.064Z" }
+
 [[package]]
 name = "srp"
 version = "1.0.22"
@@ -1491,6 +1603,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
 ]
 
+[[package]]
+name = "typing-inspect"
+version = "0.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/dc/74/1789779d91f1961fa9438e9a8710cdae6bd138c80d7303996933d117264a/typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78", size = 13825, upload-time = "2023-05-24T20:25:47.612Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/65/f3/107a22063bf27bdccf2024833d3445f4eea42b2e598abfbd46f6a63b6cb0/typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f", size = 8827, upload-time = "2023-05-24T20:25:45.287Z" },
+]
+
 [[package]]
 name = "typing-inspection"
 version = "0.4.2"