From 1eef99e3b4362c6030d354ad58dfa42df7854533 Mon Sep 17 00:00:00 2001
From: William Bruno <wbruno@intrepidnet.org>
Date: Fri, 27 Mar 2026 17:12:20 -0400
Subject: [PATCH] extensive changes

---
 .idea/back-end.iml                            |   10 +-
 .idea/modules.xml                             |    8 +
 .python-version                               |    1 +
 README.md                                     |    0
 __pycache__/main.cpython-314.pyc              |  Bin 5343 -> 4012 bytes
 __pycache__/server.cpython-314.pyc            |  Bin 74436 -> 68944 bytes
 cookies/willbrunogmailcom.cookiejar           |   24 +
 cookies/willbrunogmailcom.session             |    1 +
 database.py                                   |   27 -
 db_models.py                                  |   58 -
 icloud.py                                     |  111 -
 main.bk                                       |   50 -
 main.py                                       |   46 +-
 pyproject.toml                                |    6 +
 server.py                                     | 1102 ----------
 server_recover.py                             | 1074 ----------
 socktest.py                                   |   37 -
 src/__init__.py                               |    0
 src/pymd3_vue_location_sim/__init__.py        |    0
 src/pymd3_vue_location_sim/database.py        |   44 +
 src/pymd3_vue_location_sim/db_models.py       |   42 +
 src/pymd3_vue_location_sim/icloud_monitor.py  |  334 +++
 src/pymd3_vue_location_sim/json_formatter.py  |   18 +
 .../locationsimulation.py                     |  213 ++
 src/pymd3_vue_location_sim/models.py          |   64 +
 src/pymd3_vue_location_sim/routes/api.py      |  379 ++++
 src/pymd3_vue_location_sim/routes/socketio.py |  425 ++++
 src/pymd3_vue_location_sim/server.py          | 1835 +++++++++++++++++
 uv.lock                                       |  125 ++
 29 files changed, 3535 insertions(+), 2499 deletions(-)
 create mode 100644 .idea/modules.xml
 create mode 100644 .python-version
 create mode 100644 README.md
 create mode 100644 cookies/willbrunogmailcom.cookiejar
 create mode 100644 cookies/willbrunogmailcom.session
 delete mode 100644 database.py
 delete mode 100644 db_models.py
 delete mode 100644 icloud.py
 delete mode 100644 main.bk
 delete mode 100644 server.py
 delete mode 100644 server_recover.py
 delete mode 100644 socktest.py
 create mode 100644 src/__init__.py
 create mode 100644 src/pymd3_vue_location_sim/__init__.py
 create mode 100644 src/pymd3_vue_location_sim/database.py
 create mode 100644 src/pymd3_vue_location_sim/db_models.py
 create mode 100644 src/pymd3_vue_location_sim/icloud_monitor.py
 create mode 100644 src/pymd3_vue_location_sim/json_formatter.py
 create mode 100644 src/pymd3_vue_location_sim/locationsimulation.py
 create mode 100644 src/pymd3_vue_location_sim/models.py
 create mode 100644 src/pymd3_vue_location_sim/routes/api.py
 create mode 100644 src/pymd3_vue_location_sim/routes/socketio.py
 create mode 100644 src/pymd3_vue_location_sim/server.py

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 b59854b97924baaa0cc3732b64b7c4eb09a95ebd..d96cacc25bbb3ec583c25ec964fba4a0f8b32008 100644
GIT binary patch
delta 876
zcmZuv&rcIU6rO4Kcek^(fE8?03n5w|kO+w!j7rktt|3U4lIWpqHtk|I+3wcaDUoP`
zHxu<j=H{K7H}3im7>U;<4JO8eH{xI5%mTrKv)OOH_vX#K_r95v`ll+IL3s_Z@#@wW
ze^lE?<9p0_1Gaz-EkO93v7nhDnJVX5D{BfwNIA4bA~K&~Nv2HX)F)bssS-8ilBJnB
zl1sU4>1LkfO+=7s5Tgogr36T!o!bJl6FmLdU^d+Q*I}z|d42L?`Es_kv#*V6VDa3&
zpxU_-u=NrM3IQa=_K2NddI~_7^;ZV%!et~&52w<<j(+pqYjv2&eHRno4Qh<5%V8K1
zmv~)fpw=J^y<i<jB<e&#9nx>viEE|S=Gt0wwc#|HE6ba!EoZsWu$vnjbYD1tO?p?n
zdAq;c>n=Du1J4Pfj!XO~bYj0Z-*f$NuD_cIoZuo$pQA6tF<3Z!D^{{lrw7U+%+o~q
z3CHMX^(z$Udu{5D$O5s-fR!X|N4V#b7&3DbUtyT&j^mye?KpUvxzOPc&4ldOx;~$Q
zCHf3KgcbS`y{<@X6=yjpe5=&K9_tlf<(?V3U_7?@lSl+V+>R14CQO(*!a85hb4UYA
zoQ-qf7l^NOD08SVNDxUy>pGavm>qj$%o@B>j4l8jYJ~|nJ&O4aChGPe?2sr5;<U6x
zBD;M*e2xVkeuKU%PC=1YN6Pf5Xh4a+9I5Ted|xfb9VX}hq@IgCyu*_7E>r0+?<<u&
zk<affEhkYNCv<xrQ_kQK1rDjK%DrCH9R%Keyuy53?|8uAGz%e|JO;)PRED5@4D?@M
cX$T$-!Gjavd<V`S0m7M6g?<=)BJk7x0<$y3`~Uy|

delta 2188
zcmZuzO-vhC5PoZnfAK>2GY|{`l7N9gfP|#^X+mR?w^0JfA!-gG+r?hUChL9f+c6DQ
zB=^!okChMYz3Q!(D%YNSYOCf@saoWsDu=4Kv{IC7XP!;d(i;4|nR)Z`X5P$$uZH)t
z`jnnZF#I@QeC=G<Kh^uI8e<=^2Q04{3>vEjn&LwcQfmves5J~>wYEa5S|boqYZRim
zhKv}GLwuNgv=|AVgruUwMjKB-O3|%`&fB4#cR&X}0!K(z#lW4=iAE8li+4k}Qj8is
zycc?T8q$i78GXDT`uPA1@S|{)55geNK!y*&klK$M!~7T=Q*^=@;iE9B=%g{mkHc|(
z0!}Et%{a-&VVqCEgyK_1HOnVql25@DpN45A)QwYo24)o9Zp`x2aGKA-9G{1ICF?L2
z_!&5(=p)8iz6gto?ljKv^Kf3#UB+Ad0$ku1;Ud2TmxfusJI&zo#^M7uJwO-G_-rgz
zA87v+<a;(I)}9`0zghFWjh~H+BkW95yb#Z)(=6YYW^RY8!Ih1x`Tq0w7%Sop53-HR
zZ!|HyHm1JWf#1n`C94HVuj0Ces_?*m0?0?pmITLgkqoa{@G#pF#FsozfCY9jh^>~v
z5uW7+k#*EJR#8niyhnBc9B+Glw`|L7C`jj)uP@!bwQjz%x^i>%Zr)rsZZEIiT@S`K
zrTD<NO=*_|*k#L+Xl0fxuUfHOv&m;8K~Mfp?v5>YoPxb3#g0?7WzH@KDa+sW3T8o+
z(4-h7%4iPeBVTwyXIY9;8O)+hMyBid5TyJ{QDCh1D~`moXDYre6>IyL3%YRy%1u#$
za<xLaw{P2EJ`^R}+!8LvL{aaG$SIfCgy&(Fc5zusK}mM5Eg5-Z<%XGGzP6grnalUq
zgHdwONbVpTWD7zT%`L~ZJ*#A+rQY;~g`|oF`g)~`&Rt9u1fB{@-f?^Bo@wN6E&pA*
zHXra}OsJ4%(6eJpXKS~~nog-KB=~sV7*@_)Tg|VdlaahC^ID_Kw=EBg++>=?4TkB!
zc)lC<LFF0&Oe_@@(*NI-4(U)>mAGH5-PbZYHkGV+rsJ8e5arqv?MrQ@HWV7~Dp`&<
zQ{D~2M969Ez^R%D^=OmNJ`QDCQYTUH;mM_9QQE#=`?Ynr_Csr28?XJ``a+wneG~ak
zi_|`ej?Jf0PmUpA;K-JcB@29fzu2gpLJZnW(`q)XY04`ontk?5lxrAfJU$!J=4$UI
zuWILNpC_MYXb5GPV3bTF1!-fS%hM!TuFbXG%pWIt*zvYR(5kK=t4lhl94AnUb3`o=
z&`ip+1d9ac5CXkXt)huF@ob51zi*pvr<2Nw1DJglOATn%r68(0+z~;tXn|F5E#JpG
z2&)#4x?+19=Ou_p?0!)STKru<i20)M*v6rhD-<nJXiT!}Y|0iA#J4J50fcaUl_$+N
zJfz)L+Ks?&8C}W<ounEij1gR*O&vFJVjMNzLdrM^)8*Zg*u-XTOxnWCrtlt#ij?#R
zMJ7pQ=&(w`b!PCZ23L5pjWkmPIzc-@2SQ06K@58TV~+EVW}UP-aCp;xQn1yV<jXEn
z7(A>%uS#<Wec6pFvWN6CwX&X0(Nlu1dr6$GJ=Ui>`iSf&pxy{(No}Ax(#@eTi;iCq
zIDxzJDB27T|9c+fAX#S!hRDSrxrkQ4!7CW9eWs68kCC|N@If0IBeWNxNZ2dXl&aGu
zwV|4rAliIfRrdrj)1+4g8$C-JlLTrCVwXyySaI#QrH?Wi5C2<)mo1uB)%KXa$2#{|
zQW2>=me^zM_*-YAb(X2KzI`_HoXxyoZFQFYjlK6e6xBkn8N#a$rY+Rj<$Y%EGrrHZ
zpR?^c%e@YTwa_07;Z=fZ^L2Km&Q9&K+;f)uGooozFB5D7|DpI1DnH%dsTJFEVLItw
DwNrVq

diff --git a/__pycache__/server.cpython-314.pyc b/__pycache__/server.cpython-314.pyc
index 5148778c35278e0d9832a4337dbf66a43ac715c0..9cb0fa5a2c7c9cf8fb11b751ba84f349eb2db749 100644
GIT binary patch
delta 11122
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

delta 16194
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

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"