@syncause/debug-daemon 0.1.0 → 0.1.2

package/dist/index.js

@@ -10740,7 +10740,7 @@ var require_winston = __commonJS({
 var require_object_hash = __commonJS({
   "node_modules/object-hash/index.js"(exports2, module2) {
     "use strict";
-    var crypto5 = require("crypto");
+    var crypto6 = require("crypto");
     exports2 = module2.exports = objectHash;
     function objectHash(object, options) {
       options = applyDefaults(object, options);
@@ -10758,7 +10758,7 @@ var require_object_hash = __commonJS({
     exports2.keysMD5 = function(object) {
       return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
     };
-    var hashes = crypto5.getHashes ? crypto5.getHashes().slice() : ["sha1", "md5"];
+    var hashes = crypto6.getHashes ? crypto6.getHashes().slice() : ["sha1", "md5"];
     hashes.push("passthrough");
     var encodings = ["buffer", "hex", "binary", "base64"];
     function applyDefaults(object, sourceOptions) {
@@ -10804,7 +10804,7 @@ var require_object_hash = __commonJS({
     function hash(object, options) {
       var hashingStream;
       if (options.algorithm !== "passthrough") {
-        hashingStream = crypto5.createHash(options.algorithm);
+        hashingStream = crypto6.createHash(options.algorithm);
       } else {
         hashingStream = new PassThrough();
       }
@@ -15121,7 +15121,7 @@ var require_FileStreamRotator = __commonJS({
     var fs5 = require("fs");
     var path6 = require("path");
     var moment = require_moment();
-    var crypto5 = require("crypto");
+    var crypto6 = require("crypto");
     var EventEmitter = require("events");
     var FileStreamRotator = {};
     module2.exports = FileStreamRotator;
@@ -15250,7 +15250,7 @@ var require_FileStreamRotator = __commonJS({
       }
     };
     function removeFile(file, verbose) {
-      if (file.hash === crypto5.createHash(file.hashType).update(file.name + "LOG_FILE" + file.date).digest("hex")) {
+      if (file.hash === crypto6.createHash(file.hashType).update(file.name + "LOG_FILE" + file.date).digest("hex")) {
         try {
           if (fs5.existsSync(file.name)) {
             fs5.unlinkSync(file.name);
@@ -15316,7 +15316,7 @@ var require_FileStreamRotator = __commonJS({
         audit.files.push({
           date: time,
           name: logfile,
-          hash: crypto5.createHash(audit.hashType).update(logfile + "LOG_FILE" + time).digest("hex")
+          hash: crypto6.createHash(audit.hashType).update(logfile + "LOG_FILE" + time).digest("hex")
         });
         if (audit.keep.days) {
           var oldestDate = moment().subtract(audit.keep.amount, "days").valueOf();
@@ -15993,6 +15993,733 @@ var require_p_limit = __commonJS({
   }
 });
 
+// node_modules/node-machine-id/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/node-machine-id/dist/index.js"(exports2, module2) {
+    !(function(t, n) {
+      "object" == typeof exports2 && "object" == typeof module2 ? module2.exports = n(require("child_process"), require("crypto")) : "function" == typeof define && define.amd ? define(["child_process", "crypto"], n) : "object" == typeof exports2 ? exports2["electron-machine-id"] = n(require("child_process"), require("crypto")) : t["electron-machine-id"] = n(t.child_process, t.crypto);
+    })(exports2, function(t, n) {
+      return (function(t2) {
+        function n2(e) {
+          if (r[e]) return r[e].exports;
+          var o = r[e] = { exports: {}, id: e, loaded: false };
+          return t2[e].call(o.exports, o, o.exports, n2), o.loaded = true, o.exports;
+        }
+        var r = {};
+        return n2.m = t2, n2.c = r, n2.p = "", n2(0);
+      })([function(t2, n2, r) {
+        t2.exports = r(34);
+      }, function(t2, n2, r) {
+        var e = r(29)("wks"), o = r(33), i = r(2).Symbol, c = "function" == typeof i, u = t2.exports = function(t3) {
+          return e[t3] || (e[t3] = c && i[t3] || (c ? i : o)("Symbol." + t3));
+        };
+        u.store = e;
+      }, function(t2, n2) {
+        var r = t2.exports = "undefined" != typeof window && window.Math == Math ? window : "undefined" != typeof self && self.Math == Math ? self : Function("return this")();
+        "number" == typeof __g && (__g = r);
+      }, function(t2, n2, r) {
+        var e = r(9);
+        t2.exports = function(t3) {
+          if (!e(t3)) throw TypeError(t3 + " is not an object!");
+          return t3;
+        };
+      }, function(t2, n2, r) {
+        t2.exports = !r(24)(function() {
+          return 7 != Object.defineProperty({}, "a", { get: function() {
+            return 7;
+          } }).a;
+        });
+      }, function(t2, n2, r) {
+        var e = r(12), o = r(17);
+        t2.exports = r(4) ? function(t3, n3, r2) {
+          return e.f(t3, n3, o(1, r2));
+        } : function(t3, n3, r2) {
+          return t3[n3] = r2, t3;
+        };
+      }, function(t2, n2) {
+        var r = t2.exports = { version: "2.4.0" };
+        "number" == typeof __e && (__e = r);
+      }, function(t2, n2, r) {
+        var e = r(14);
+        t2.exports = function(t3, n3, r2) {
+          if (e(t3), void 0 === n3) return t3;
+          switch (r2) {
+            case 1:
+              return function(r3) {
+                return t3.call(n3, r3);
+              };
+            case 2:
+              return function(r3, e2) {
+                return t3.call(n3, r3, e2);
+              };
+            case 3:
+              return function(r3, e2, o) {
+                return t3.call(n3, r3, e2, o);
+              };
+          }
+          return function() {
+            return t3.apply(n3, arguments);
+          };
+        };
+      }, function(t2, n2) {
+        var r = {}.hasOwnProperty;
+        t2.exports = function(t3, n3) {
+          return r.call(t3, n3);
+        };
+      }, function(t2, n2) {
+        t2.exports = function(t3) {
+          return "object" == typeof t3 ? null !== t3 : "function" == typeof t3;
+        };
+      }, function(t2, n2) {
+        t2.exports = {};
+      }, function(t2, n2) {
+        var r = {}.toString;
+        t2.exports = function(t3) {
+          return r.call(t3).slice(8, -1);
+        };
+      }, function(t2, n2, r) {
+        var e = r(3), o = r(26), i = r(32), c = Object.defineProperty;
+        n2.f = r(4) ? Object.defineProperty : function(t3, n3, r2) {
+          if (e(t3), n3 = i(n3, true), e(r2), o) try {
+            return c(t3, n3, r2);
+          } catch (t4) {
+          }
+          if ("get" in r2 || "set" in r2) throw TypeError("Accessors not supported!");
+          return "value" in r2 && (t3[n3] = r2.value), t3;
+        };
+      }, function(t2, n2, r) {
+        var e = r(42), o = r(15);
+        t2.exports = function(t3) {
+          return e(o(t3));
+        };
+      }, function(t2, n2) {
+        t2.exports = function(t3) {
+          if ("function" != typeof t3) throw TypeError(t3 + " is not a function!");
+          return t3;
+        };
+      }, function(t2, n2) {
+        t2.exports = function(t3) {
+          if (void 0 == t3) throw TypeError("Can't call method on  " + t3);
+          return t3;
+        };
+      }, function(t2, n2, r) {
+        var e = r(9), o = r(2).document, i = e(o) && e(o.createElement);
+        t2.exports = function(t3) {
+          return i ? o.createElement(t3) : {};
+        };
+      }, function(t2, n2) {
+        t2.exports = function(t3, n3) {
+          return { enumerable: !(1 & t3), configurable: !(2 & t3), writable: !(4 & t3), value: n3 };
+        };
+      }, function(t2, n2, r) {
+        var e = r(12).f, o = r(8), i = r(1)("toStringTag");
+        t2.exports = function(t3, n3, r2) {
+          t3 && !o(t3 = r2 ? t3 : t3.prototype, i) && e(t3, i, { configurable: true, value: n3 });
+        };
+      }, function(t2, n2, r) {
+        var e = r(29)("keys"), o = r(33);
+        t2.exports = function(t3) {
+          return e[t3] || (e[t3] = o(t3));
+        };
+      }, function(t2, n2) {
+        var r = Math.ceil, e = Math.floor;
+        t2.exports = function(t3) {
+          return isNaN(t3 = +t3) ? 0 : (t3 > 0 ? e : r)(t3);
+        };
+      }, function(t2, n2, r) {
+        var e = r(11), o = r(1)("toStringTag"), i = "Arguments" == e(/* @__PURE__ */ (function() {
+          return arguments;
+        })()), c = function(t3, n3) {
+          try {
+            return t3[n3];
+          } catch (t4) {
+          }
+        };
+        t2.exports = function(t3) {
+          var n3, r2, u;
+          return void 0 === t3 ? "Undefined" : null === t3 ? "Null" : "string" == typeof (r2 = c(n3 = Object(t3), o)) ? r2 : i ? e(n3) : "Object" == (u = e(n3)) && "function" == typeof n3.callee ? "Arguments" : u;
+        };
+      }, function(t2, n2) {
+        t2.exports = "constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",");
+      }, function(t2, n2, r) {
+        var e = r(2), o = r(6), i = r(7), c = r(5), u = "prototype", s = function(t3, n3, r2) {
+          var f, a, p, l = t3 & s.F, v = t3 & s.G, h = t3 & s.S, d = t3 & s.P, y = t3 & s.B, _ = t3 & s.W, x = v ? o : o[n3] || (o[n3] = {}), m = x[u], w = v ? e : h ? e[n3] : (e[n3] || {})[u];
+          v && (r2 = n3);
+          for (f in r2) a = !l && w && void 0 !== w[f], a && f in x || (p = a ? w[f] : r2[f], x[f] = v && "function" != typeof w[f] ? r2[f] : y && a ? i(p, e) : _ && w[f] == p ? (function(t4) {
+            var n4 = function(n5, r3, e2) {
+              if (this instanceof t4) {
+                switch (arguments.length) {
+                  case 0:
+                    return new t4();
+                  case 1:
+                    return new t4(n5);
+                  case 2:
+                    return new t4(n5, r3);
+                }
+                return new t4(n5, r3, e2);
+              }
+              return t4.apply(this, arguments);
+            };
+            return n4[u] = t4[u], n4;
+          })(p) : d && "function" == typeof p ? i(Function.call, p) : p, d && ((x.virtual || (x.virtual = {}))[f] = p, t3 & s.R && m && !m[f] && c(m, f, p)));
+        };
+        s.F = 1, s.G = 2, s.S = 4, s.P = 8, s.B = 16, s.W = 32, s.U = 64, s.R = 128, t2.exports = s;
+      }, function(t2, n2) {
+        t2.exports = function(t3) {
+          try {
+            return !!t3();
+          } catch (t4) {
+            return true;
+          }
+        };
+      }, function(t2, n2, r) {
+        t2.exports = r(2).document && document.documentElement;
+      }, function(t2, n2, r) {
+        t2.exports = !r(4) && !r(24)(function() {
+          return 7 != Object.defineProperty(r(16)("div"), "a", { get: function() {
+            return 7;
+          } }).a;
+        });
+      }, function(t2, n2, r) {
+        "use strict";
+        var e = r(28), o = r(23), i = r(57), c = r(5), u = r(8), s = r(10), f = r(45), a = r(18), p = r(52), l = r(1)("iterator"), v = !([].keys && "next" in [].keys()), h = "@@iterator", d = "keys", y = "values", _ = function() {
+          return this;
+        };
+        t2.exports = function(t3, n3, r2, x, m, w, g) {
+          f(r2, n3, x);
+          var b, O, j, S = function(t4) {
+            if (!v && t4 in T) return T[t4];
+            switch (t4) {
+              case d:
+                return function() {
+                  return new r2(this, t4);
+                };
+              case y:
+                return function() {
+                  return new r2(this, t4);
+                };
+            }
+            return function() {
+              return new r2(this, t4);
+            };
+          }, E = n3 + " Iterator", P = m == y, M = false, T = t3.prototype, A = T[l] || T[h] || m && T[m], k = A || S(m), C = m ? P ? S("entries") : k : void 0, I = "Array" == n3 ? T.entries || A : A;
+          if (I && (j = p(I.call(new t3())), j !== Object.prototype && (a(j, E, true), e || u(j, l) || c(j, l, _))), P && A && A.name !== y && (M = true, k = function() {
+            return A.call(this);
+          }), e && !g || !v && !M && T[l] || c(T, l, k), s[n3] = k, s[E] = _, m) if (b = { values: P ? k : S(y), keys: w ? k : S(d), entries: C }, g) for (O in b) O in T || i(T, O, b[O]);
+          else o(o.P + o.F * (v || M), n3, b);
+          return b;
+        };
+      }, function(t2, n2) {
+        t2.exports = true;
+      }, function(t2, n2, r) {
+        var e = r(2), o = "__core-js_shared__", i = e[o] || (e[o] = {});
+        t2.exports = function(t3) {
+          return i[t3] || (i[t3] = {});
+        };
+      }, function(t2, n2, r) {
+        var e, o, i, c = r(7), u = r(41), s = r(25), f = r(16), a = r(2), p = a.process, l = a.setImmediate, v = a.clearImmediate, h = a.MessageChannel, d = 0, y = {}, _ = "onreadystatechange", x = function() {
+          var t3 = +this;
+          if (y.hasOwnProperty(t3)) {
+            var n3 = y[t3];
+            delete y[t3], n3();
+          }
+        }, m = function(t3) {
+          x.call(t3.data);
+        };
+        l && v || (l = function(t3) {
+          for (var n3 = [], r2 = 1; arguments.length > r2; ) n3.push(arguments[r2++]);
+          return y[++d] = function() {
+            u("function" == typeof t3 ? t3 : Function(t3), n3);
+          }, e(d), d;
+        }, v = function(t3) {
+          delete y[t3];
+        }, "process" == r(11)(p) ? e = function(t3) {
+          p.nextTick(c(x, t3, 1));
+        } : h ? (o = new h(), i = o.port2, o.port1.onmessage = m, e = c(i.postMessage, i, 1)) : a.addEventListener && "function" == typeof postMessage && !a.importScripts ? (e = function(t3) {
+          a.postMessage(t3 + "", "*");
+        }, a.addEventListener("message", m, false)) : e = _ in f("script") ? function(t3) {
+          s.appendChild(f("script"))[_] = function() {
+            s.removeChild(this), x.call(t3);
+          };
+        } : function(t3) {
+          setTimeout(c(x, t3, 1), 0);
+        }), t2.exports = { set: l, clear: v };
+      }, function(t2, n2, r) {
+        var e = r(20), o = Math.min;
+        t2.exports = function(t3) {
+          return t3 > 0 ? o(e(t3), 9007199254740991) : 0;
+        };
+      }, function(t2, n2, r) {
+        var e = r(9);
+        t2.exports = function(t3, n3) {
+          if (!e(t3)) return t3;
+          var r2, o;
+          if (n3 && "function" == typeof (r2 = t3.toString) && !e(o = r2.call(t3))) return o;
+          if ("function" == typeof (r2 = t3.valueOf) && !e(o = r2.call(t3))) return o;
+          if (!n3 && "function" == typeof (r2 = t3.toString) && !e(o = r2.call(t3))) return o;
+          throw TypeError("Can't convert object to primitive value");
+        };
+      }, function(t2, n2) {
+        var r = 0, e = Math.random();
+        t2.exports = function(t3) {
+          return "Symbol(".concat(void 0 === t3 ? "" : t3, ")_", (++r + e).toString(36));
+        };
+      }, function(t2, n2, r) {
+        "use strict";
+        function e(t3) {
+          return t3 && t3.__esModule ? t3 : { default: t3 };
+        }
+        function o() {
+          return "win32" !== process.platform ? "" : "ia32" === process.arch && process.env.hasOwnProperty("PROCESSOR_ARCHITEW6432") ? "mixed" : "native";
+        }
+        function i(t3) {
+          return (0, l.createHash)("sha256").update(t3).digest("hex");
+        }
+        function c(t3) {
+          switch (h) {
+            case "darwin":
+              return t3.split("IOPlatformUUID")[1].split("\n")[0].replace(/\=|\s+|\"/gi, "").toLowerCase();
+            case "win32":
+              return t3.toString().split("REG_SZ")[1].replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+            case "linux":
+              return t3.toString().replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+            case "freebsd":
+              return t3.toString().replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+            default:
+              throw new Error("Unsupported platform: " + process.platform);
+          }
+        }
+        function u(t3) {
+          var n3 = c((0, p.execSync)(y[h]).toString());
+          return t3 ? n3 : i(n3);
+        }
+        function s(t3) {
+          return new a.default(function(n3, r2) {
+            return (0, p.exec)(y[h], {}, function(e2, o2, u2) {
+              if (e2) return r2(new Error("Error while obtaining machine id: " + e2.stack));
+              var s2 = c(o2.toString());
+              return n3(t3 ? s2 : i(s2));
+            });
+          });
+        }
+        Object.defineProperty(n2, "__esModule", { value: true });
+        var f = r(35), a = e(f);
+        n2.machineIdSync = u, n2.machineId = s;
+        var p = r(70), l = r(71), v = process, h = v.platform, d = { native: "%windir%\\System32", mixed: "%windir%\\sysnative\\cmd.exe /c %windir%\\System32" }, y = { darwin: "ioreg -rd1 -c IOPlatformExpertDevice", win32: d[o()] + "\\REG.exe QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid", linux: "( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :", freebsd: "kenv -q smbios.system.uuid || sysctl -n kern.hostuuid" };
+      }, function(t2, n2, r) {
+        t2.exports = { default: r(36), __esModule: true };
+      }, function(t2, n2, r) {
+        r(66), r(68), r(69), r(67), t2.exports = r(6).Promise;
+      }, function(t2, n2) {
+        t2.exports = function() {
+        };
+      }, function(t2, n2) {
+        t2.exports = function(t3, n3, r, e) {
+          if (!(t3 instanceof n3) || void 0 !== e && e in t3) throw TypeError(r + ": incorrect invocation!");
+          return t3;
+        };
+      }, function(t2, n2, r) {
+        var e = r(13), o = r(31), i = r(62);
+        t2.exports = function(t3) {
+          return function(n3, r2, c) {
+            var u, s = e(n3), f = o(s.length), a = i(c, f);
+            if (t3 && r2 != r2) {
+              for (; f > a; ) if (u = s[a++], u != u) return true;
+            } else for (; f > a; a++) if ((t3 || a in s) && s[a] === r2) return t3 || a || 0;
+            return !t3 && -1;
+          };
+        };
+      }, function(t2, n2, r) {
+        var e = r(7), o = r(44), i = r(43), c = r(3), u = r(31), s = r(64), f = {}, a = {}, n2 = t2.exports = function(t3, n3, r2, p, l) {
+          var v, h, d, y, _ = l ? function() {
+            return t3;
+          } : s(t3), x = e(r2, p, n3 ? 2 : 1), m = 0;
+          if ("function" != typeof _) throw TypeError(t3 + " is not iterable!");
+          if (i(_)) {
+            for (v = u(t3.length); v > m; m++) if (y = n3 ? x(c(h = t3[m])[0], h[1]) : x(t3[m]), y === f || y === a) return y;
+          } else for (d = _.call(t3); !(h = d.next()).done; ) if (y = o(d, x, h.value, n3), y === f || y === a) return y;
+        };
+        n2.BREAK = f, n2.RETURN = a;
+      }, function(t2, n2) {
+        t2.exports = function(t3, n3, r) {
+          var e = void 0 === r;
+          switch (n3.length) {
+            case 0:
+              return e ? t3() : t3.call(r);
+            case 1:
+              return e ? t3(n3[0]) : t3.call(r, n3[0]);
+            case 2:
+              return e ? t3(n3[0], n3[1]) : t3.call(r, n3[0], n3[1]);
+            case 3:
+              return e ? t3(n3[0], n3[1], n3[2]) : t3.call(r, n3[0], n3[1], n3[2]);
+            case 4:
+              return e ? t3(n3[0], n3[1], n3[2], n3[3]) : t3.call(r, n3[0], n3[1], n3[2], n3[3]);
+          }
+          return t3.apply(r, n3);
+        };
+      }, function(t2, n2, r) {
+        var e = r(11);
+        t2.exports = Object("z").propertyIsEnumerable(0) ? Object : function(t3) {
+          return "String" == e(t3) ? t3.split("") : Object(t3);
+        };
+      }, function(t2, n2, r) {
+        var e = r(10), o = r(1)("iterator"), i = Array.prototype;
+        t2.exports = function(t3) {
+          return void 0 !== t3 && (e.Array === t3 || i[o] === t3);
+        };
+      }, function(t2, n2, r) {
+        var e = r(3);
+        t2.exports = function(t3, n3, r2, o) {
+          try {
+            return o ? n3(e(r2)[0], r2[1]) : n3(r2);
+          } catch (n4) {
+            var i = t3.return;
+            throw void 0 !== i && e(i.call(t3)), n4;
+          }
+        };
+      }, function(t2, n2, r) {
+        "use strict";
+        var e = r(49), o = r(17), i = r(18), c = {};
+        r(5)(c, r(1)("iterator"), function() {
+          return this;
+        }), t2.exports = function(t3, n3, r2) {
+          t3.prototype = e(c, { next: o(1, r2) }), i(t3, n3 + " Iterator");
+        };
+      }, function(t2, n2, r) {
+        var e = r(1)("iterator"), o = false;
+        try {
+          var i = [7][e]();
+          i.return = function() {
+            o = true;
+          }, Array.from(i, function() {
+            throw 2;
+          });
+        } catch (t3) {
+        }
+        t2.exports = function(t3, n3) {
+          if (!n3 && !o) return false;
+          var r2 = false;
+          try {
+            var i2 = [7], c = i2[e]();
+            c.next = function() {
+              return { done: r2 = true };
+            }, i2[e] = function() {
+              return c;
+            }, t3(i2);
+          } catch (t4) {
+          }
+          return r2;
+        };
+      }, function(t2, n2) {
+        t2.exports = function(t3, n3) {
+          return { value: n3, done: !!t3 };
+        };
+      }, function(t2, n2, r) {
+        var e = r(2), o = r(30).set, i = e.MutationObserver || e.WebKitMutationObserver, c = e.process, u = e.Promise, s = "process" == r(11)(c);
+        t2.exports = function() {
+          var t3, n3, r2, f = function() {
+            var e2, o2;
+            for (s && (e2 = c.domain) && e2.exit(); t3; ) {
+              o2 = t3.fn, t3 = t3.next;
+              try {
+                o2();
+              } catch (e3) {
+                throw t3 ? r2() : n3 = void 0, e3;
+              }
+            }
+            n3 = void 0, e2 && e2.enter();
+          };
+          if (s) r2 = function() {
+            c.nextTick(f);
+          };
+          else if (i) {
+            var a = true, p = document.createTextNode("");
+            new i(f).observe(p, { characterData: true }), r2 = function() {
+              p.data = a = !a;
+            };
+          } else if (u && u.resolve) {
+            var l = u.resolve();
+            r2 = function() {
+              l.then(f);
+            };
+          } else r2 = function() {
+            o.call(e, f);
+          };
+          return function(e2) {
+            var o2 = { fn: e2, next: void 0 };
+            n3 && (n3.next = o2), t3 || (t3 = o2, r2()), n3 = o2;
+          };
+        };
+      }, function(t2, n2, r) {
+        var e = r(3), o = r(50), i = r(22), c = r(19)("IE_PROTO"), u = function() {
+        }, s = "prototype", f = function() {
+          var t3, n3 = r(16)("iframe"), e2 = i.length, o2 = ">";
+          for (n3.style.display = "none", r(25).appendChild(n3), n3.src = "javascript:", t3 = n3.contentWindow.document, t3.open(), t3.write("<script>document.F=Object</script" + o2), t3.close(), f = t3.F; e2--; ) delete f[s][i[e2]];
+          return f();
+        };
+        t2.exports = Object.create || function(t3, n3) {
+          var r2;
+          return null !== t3 ? (u[s] = e(t3), r2 = new u(), u[s] = null, r2[c] = t3) : r2 = f(), void 0 === n3 ? r2 : o(r2, n3);
+        };
+      }, function(t2, n2, r) {
+        var e = r(12), o = r(3), i = r(54);
+        t2.exports = r(4) ? Object.defineProperties : function(t3, n3) {
+          o(t3);
+          for (var r2, c = i(n3), u = c.length, s = 0; u > s; ) e.f(t3, r2 = c[s++], n3[r2]);
+          return t3;
+        };
+      }, function(t2, n2, r) {
+        var e = r(55), o = r(17), i = r(13), c = r(32), u = r(8), s = r(26), f = Object.getOwnPropertyDescriptor;
+        n2.f = r(4) ? f : function(t3, n3) {
+          if (t3 = i(t3), n3 = c(n3, true), s) try {
+            return f(t3, n3);
+          } catch (t4) {
+          }
+          if (u(t3, n3)) return o(!e.f.call(t3, n3), t3[n3]);
+        };
+      }, function(t2, n2, r) {
+        var e = r(8), o = r(63), i = r(19)("IE_PROTO"), c = Object.prototype;
+        t2.exports = Object.getPrototypeOf || function(t3) {
+          return t3 = o(t3), e(t3, i) ? t3[i] : "function" == typeof t3.constructor && t3 instanceof t3.constructor ? t3.constructor.prototype : t3 instanceof Object ? c : null;
+        };
+      }, function(t2, n2, r) {
+        var e = r(8), o = r(13), i = r(39)(false), c = r(19)("IE_PROTO");
+        t2.exports = function(t3, n3) {
+          var r2, u = o(t3), s = 0, f = [];
+          for (r2 in u) r2 != c && e(u, r2) && f.push(r2);
+          for (; n3.length > s; ) e(u, r2 = n3[s++]) && (~i(f, r2) || f.push(r2));
+          return f;
+        };
+      }, function(t2, n2, r) {
+        var e = r(53), o = r(22);
+        t2.exports = Object.keys || function(t3) {
+          return e(t3, o);
+        };
+      }, function(t2, n2) {
+        n2.f = {}.propertyIsEnumerable;
+      }, function(t2, n2, r) {
+        var e = r(5);
+        t2.exports = function(t3, n3, r2) {
+          for (var o in n3) r2 && t3[o] ? t3[o] = n3[o] : e(t3, o, n3[o]);
+          return t3;
+        };
+      }, function(t2, n2, r) {
+        t2.exports = r(5);
+      }, function(t2, n2, r) {
+        var e = r(9), o = r(3), i = function(t3, n3) {
+          if (o(t3), !e(n3) && null !== n3) throw TypeError(n3 + ": can't set as prototype!");
+        };
+        t2.exports = { set: Object.setPrototypeOf || ("__proto__" in {} ? (function(t3, n3, e2) {
+          try {
+            e2 = r(7)(Function.call, r(51).f(Object.prototype, "__proto__").set, 2), e2(t3, []), n3 = !(t3 instanceof Array);
+          } catch (t4) {
+            n3 = true;
+          }
+          return function(t4, r2) {
+            return i(t4, r2), n3 ? t4.__proto__ = r2 : e2(t4, r2), t4;
+          };
+        })({}, false) : void 0), check: i };
+      }, function(t2, n2, r) {
+        "use strict";
+        var e = r(2), o = r(6), i = r(12), c = r(4), u = r(1)("species");
+        t2.exports = function(t3) {
+          var n3 = "function" == typeof o[t3] ? o[t3] : e[t3];
+          c && n3 && !n3[u] && i.f(n3, u, { configurable: true, get: function() {
+            return this;
+          } });
+        };
+      }, function(t2, n2, r) {
+        var e = r(3), o = r(14), i = r(1)("species");
+        t2.exports = function(t3, n3) {
+          var r2, c = e(t3).constructor;
+          return void 0 === c || void 0 == (r2 = e(c)[i]) ? n3 : o(r2);
+        };
+      }, function(t2, n2, r) {
+        var e = r(20), o = r(15);
+        t2.exports = function(t3) {
+          return function(n3, r2) {
+            var i, c, u = String(o(n3)), s = e(r2), f = u.length;
+            return s < 0 || s >= f ? t3 ? "" : void 0 : (i = u.charCodeAt(s), i < 55296 || i > 56319 || s + 1 === f || (c = u.charCodeAt(s + 1)) < 56320 || c > 57343 ? t3 ? u.charAt(s) : i : t3 ? u.slice(s, s + 2) : (i - 55296 << 10) + (c - 56320) + 65536);
+          };
+        };
+      }, function(t2, n2, r) {
+        var e = r(20), o = Math.max, i = Math.min;
+        t2.exports = function(t3, n3) {
+          return t3 = e(t3), t3 < 0 ? o(t3 + n3, 0) : i(t3, n3);
+        };
+      }, function(t2, n2, r) {
+        var e = r(15);
+        t2.exports = function(t3) {
+          return Object(e(t3));
+        };
+      }, function(t2, n2, r) {
+        var e = r(21), o = r(1)("iterator"), i = r(10);
+        t2.exports = r(6).getIteratorMethod = function(t3) {
+          if (void 0 != t3) return t3[o] || t3["@@iterator"] || i[e(t3)];
+        };
+      }, function(t2, n2, r) {
+        "use strict";
+        var e = r(37), o = r(47), i = r(10), c = r(13);
+        t2.exports = r(27)(Array, "Array", function(t3, n3) {
+          this._t = c(t3), this._i = 0, this._k = n3;
+        }, function() {
+          var t3 = this._t, n3 = this._k, r2 = this._i++;
+          return !t3 || r2 >= t3.length ? (this._t = void 0, o(1)) : "keys" == n3 ? o(0, r2) : "values" == n3 ? o(0, t3[r2]) : o(0, [r2, t3[r2]]);
+        }, "values"), i.Arguments = i.Array, e("keys"), e("values"), e("entries");
+      }, function(t2, n2) {
+      }, function(t2, n2, r) {
+        "use strict";
+        var e, o, i, c = r(28), u = r(2), s = r(7), f = r(21), a = r(23), p = r(9), l = (r(3), r(14)), v = r(38), h = r(40), d = (r(58).set, r(60)), y = r(30).set, _ = r(48)(), x = "Promise", m = u.TypeError, w = u.process, g = u[x], w = u.process, b = "process" == f(w), O = function() {
+        }, j = !!(function() {
+          try {
+            var t3 = g.resolve(1), n3 = (t3.constructor = {})[r(1)("species")] = function(t4) {
+              t4(O, O);
+            };
+            return (b || "function" == typeof PromiseRejectionEvent) && t3.then(O) instanceof n3;
+          } catch (t4) {
+          }
+        })(), S = function(t3, n3) {
+          return t3 === n3 || t3 === g && n3 === i;
+        }, E = function(t3) {
+          var n3;
+          return !(!p(t3) || "function" != typeof (n3 = t3.then)) && n3;
+        }, P = function(t3) {
+          return S(g, t3) ? new M(t3) : new o(t3);
+        }, M = o = function(t3) {
+          var n3, r2;
+          this.promise = new t3(function(t4, e2) {
+            if (void 0 !== n3 || void 0 !== r2) throw m("Bad Promise constructor");
+            n3 = t4, r2 = e2;
+          }), this.resolve = l(n3), this.reject = l(r2);
+        }, T = function(t3) {
+          try {
+            t3();
+          } catch (t4) {
+            return { error: t4 };
+          }
+        }, A = function(t3, n3) {
+          if (!t3._n) {
+            t3._n = true;
+            var r2 = t3._c;
+            _(function() {
+              for (var e2 = t3._v, o2 = 1 == t3._s, i2 = 0, c2 = function(n4) {
+                var r3, i3, c3 = o2 ? n4.ok : n4.fail, u2 = n4.resolve, s2 = n4.reject, f2 = n4.domain;
+                try {
+                  c3 ? (o2 || (2 == t3._h && I(t3), t3._h = 1), c3 === true ? r3 = e2 : (f2 && f2.enter(), r3 = c3(e2), f2 && f2.exit()), r3 === n4.promise ? s2(m("Promise-chain cycle")) : (i3 = E(r3)) ? i3.call(r3, u2, s2) : u2(r3)) : s2(e2);
+                } catch (t4) {
+                  s2(t4);
+                }
+              }; r2.length > i2; ) c2(r2[i2++]);
+              t3._c = [], t3._n = false, n3 && !t3._h && k(t3);
+            });
+          }
+        }, k = function(t3) {
+          y.call(u, function() {
+            var n3, r2, e2, o2 = t3._v;
+            if (C(t3) && (n3 = T(function() {
+              b ? w.emit("unhandledRejection", o2, t3) : (r2 = u.onunhandledrejection) ? r2({ promise: t3, reason: o2 }) : (e2 = u.console) && e2.error && e2.error("Unhandled promise rejection", o2);
+            }), t3._h = b || C(t3) ? 2 : 1), t3._a = void 0, n3) throw n3.error;
+          });
+        }, C = function(t3) {
+          if (1 == t3._h) return false;
+          for (var n3, r2 = t3._a || t3._c, e2 = 0; r2.length > e2; ) if (n3 = r2[e2++], n3.fail || !C(n3.promise)) return false;
+          return true;
+        }, I = function(t3) {
+          y.call(u, function() {
+            var n3;
+            b ? w.emit("rejectionHandled", t3) : (n3 = u.onrejectionhandled) && n3({ promise: t3, reason: t3._v });
+          });
+        }, R = function(t3) {
+          var n3 = this;
+          n3._d || (n3._d = true, n3 = n3._w || n3, n3._v = t3, n3._s = 2, n3._a || (n3._a = n3._c.slice()), A(n3, true));
+        }, F = function(t3) {
+          var n3, r2 = this;
+          if (!r2._d) {
+            r2._d = true, r2 = r2._w || r2;
+            try {
+              if (r2 === t3) throw m("Promise can't be resolved itself");
+              (n3 = E(t3)) ? _(function() {
+                var e2 = { _w: r2, _d: false };
+                try {
+                  n3.call(t3, s(F, e2, 1), s(R, e2, 1));
+                } catch (t4) {
+                  R.call(e2, t4);
+                }
+              }) : (r2._v = t3, r2._s = 1, A(r2, false));
+            } catch (t4) {
+              R.call({ _w: r2, _d: false }, t4);
+            }
+          }
+        };
+        j || (g = function(t3) {
+          v(this, g, x, "_h"), l(t3), e.call(this);
+          try {
+            t3(s(F, this, 1), s(R, this, 1));
+          } catch (t4) {
+            R.call(this, t4);
+          }
+        }, e = function(t3) {
+          this._c = [], this._a = void 0, this._s = 0, this._d = false, this._v = void 0, this._h = 0, this._n = false;
+        }, e.prototype = r(56)(g.prototype, { then: function(t3, n3) {
+          var r2 = P(d(this, g));
+          return r2.ok = "function" != typeof t3 || t3, r2.fail = "function" == typeof n3 && n3, r2.domain = b ? w.domain : void 0, this._c.push(r2), this._a && this._a.push(r2), this._s && A(this, false), r2.promise;
+        }, catch: function(t3) {
+          return this.then(void 0, t3);
+        } }), M = function() {
+          var t3 = new e();
+          this.promise = t3, this.resolve = s(F, t3, 1), this.reject = s(R, t3, 1);
+        }), a(a.G + a.W + a.F * !j, { Promise: g }), r(18)(g, x), r(59)(x), i = r(6)[x], a(a.S + a.F * !j, x, { reject: function(t3) {
+          var n3 = P(this), r2 = n3.reject;
+          return r2(t3), n3.promise;
+        } }), a(a.S + a.F * (c || !j), x, { resolve: function(t3) {
+          if (t3 instanceof g && S(t3.constructor, this)) return t3;
+          var n3 = P(this), r2 = n3.resolve;
+          return r2(t3), n3.promise;
+        } }), a(a.S + a.F * !(j && r(46)(function(t3) {
+          g.all(t3).catch(O);
+        })), x, { all: function(t3) {
+          var n3 = this, r2 = P(n3), e2 = r2.resolve, o2 = r2.reject, i2 = T(function() {
+            var r3 = [], i3 = 0, c2 = 1;
+            h(t3, false, function(t4) {
+              var u2 = i3++, s2 = false;
+              r3.push(void 0), c2++, n3.resolve(t4).then(function(t5) {
+                s2 || (s2 = true, r3[u2] = t5, --c2 || e2(r3));
+              }, o2);
+            }), --c2 || e2(r3);
+          });
+          return i2 && o2(i2.error), r2.promise;
+        }, race: function(t3) {
+          var n3 = this, r2 = P(n3), e2 = r2.reject, o2 = T(function() {
+            h(t3, false, function(t4) {
+              n3.resolve(t4).then(r2.resolve, e2);
+            });
+          });
+          return o2 && e2(o2.error), r2.promise;
+        } });
+      }, function(t2, n2, r) {
+        "use strict";
+        var e = r(61)(true);
+        r(27)(String, "String", function(t3) {
+          this._t = String(t3), this._i = 0;
+        }, function() {
+          var t3, n3 = this._t, r2 = this._i;
+          return r2 >= n3.length ? { value: void 0, done: true } : (t3 = e(n3, r2), this._i += t3.length, { value: t3, done: false });
+        });
+      }, function(t2, n2, r) {
+        r(65);
+        for (var e = r(2), o = r(5), i = r(10), c = r(1)("toStringTag"), u = ["NodeList", "DOMTokenList", "MediaList", "StyleSheetList", "CSSRuleList"], s = 0; s < 5; s++) {
+          var f = u[s], a = e[f], p = a && a.prototype;
+          p && !p[c] && o(p, c, f), i[f] = i.Array;
+        }
+      }, function(t2, n2) {
+        t2.exports = require("child_process");
+      }, function(t2, n2) {
+        t2.exports = require("crypto");
+      }]);
+    });
+  }
+});
+
 // src/transport/server/local.ts
 var fs3 = __toESM(require("fs"));
 
@@ -18652,109 +19379,360 @@ var getRequestListener = (fetchCallback, options = {}) => {
 
 // src/transport/server/hono-server.ts
 var import_node_http = require("node:http");
-var HonoServer = class {
-  constructor(onActivity) {
-    this.onActivity = onActivity;
-    this.app = new Hono2();
-    this.setupRoutes();
+
+// src/config/index.ts
+function getArgValue(key) {
+  const keys = [key, key.toLowerCase()];
+  for (const k of keys) {
+    const prefix = `--${k}=`;
+    const arg = process.argv.find((a) => a.startsWith(prefix));
+    if (arg) return arg.slice(prefix.length);
+    const index = process.argv.indexOf(`--${k}`);
+    if (index !== -1 && index + 1 < process.argv.length && !process.argv[index + 1].startsWith("--")) {
+      return process.argv[index + 1];
+    }
   }
-  app;
-  handlers = /* @__PURE__ */ new Map();
-  server;
-  setupRoutes() {
-    this.app.use("*", async (c, next) => {
-      this.onActivity?.();
-      await next();
-    });
-    this.app.post("/", async (c) => {
-      const apiKey = c.req.header("x-api-key");
-      let body;
-      try {
-        body = await c.req.json();
-      } catch (e) {
-        return c.json({
-          jsonrpc: "2.0",
-          id: null,
-          error: { code: -32700 /* PARSE_ERROR */, message: "Parse error" }
-        }, 400);
-      }
-      Logger.getInstance().debug("Executing RPC handler", {
-        apiKey,
-        method: body?.method,
-        requestId: body?.id,
-        params: body?.params
-      });
-      if (!apiKey) {
-        Logger.getInstance().debug("Unauthorized: Invalid API Key");
-        return c.json({
-          jsonrpc: "2.0",
-          id: body?.id || null,
-          error: {
-            code: -32001 /* UNAUTHORIZED */,
-            message: "Unauthorized: Invalid API Key"
-          }
-        }, 401);
-      }
-      if (!body || body.jsonrpc !== "2.0" || !body.method || !body.id) {
-        Logger.getInstance().debug("Invalid Request: Not a standard JSON-RPC 2.0");
-        return c.json({
-          jsonrpc: "2.0",
-          id: body?.id || null,
-          error: { code: -32600 /* INVALID_REQUEST */, message: "Invalid Request: Not a standard JSON-RPC 2.0" }
-        }, 400);
-      }
-      const handler = this.handlers.get(body.method);
-      if (!handler) {
-        return c.json({
-          jsonrpc: "2.0",
-          id: body.id,
-          error: { code: -32601 /* METHOD_NOT_FOUND */, message: `Method not found: ${body.method}` }
-        });
-      }
-      try {
-        const result = await handler(body.params, apiKey);
-        Logger.getInstance().debug("RPC handler executed successfully", {
-          method: body.method,
-          requestId: body.id
-        });
-        return c.json({
-          jsonrpc: "2.0",
-          id: body.id,
-          result
-        });
-      } catch (err) {
-        Logger.getInstance().error(`RPC Handler Error for ${body.method}:`, err);
-        return c.json({
-          jsonrpc: "2.0",
-          id: body.id,
-          error: { code: -32603 /* INTERNAL_ERROR */, message: err.message || "Internal error" }
-        });
-      }
-    });
+  return void 0;
+}
+function hasArgFlag(key) {
+  const keys = [key, key.toLowerCase()];
+  return keys.some((k) => process.argv.includes(`--${k}`));
+}
+function parseConfigInt(key, defaultValue) {
+  const argValue = getArgValue(key);
+  if (argValue) {
+    const parsed2 = parseInt(argValue, 10);
+    if (!isNaN(parsed2)) return parsed2;
   }
-  registerHandler(method, handler) {
-    Logger.getInstance().info(`Register handler ${method}`);
-    this.handlers.set(method, handler);
+  const value = process.env[key];
+  if (!value) return defaultValue;
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function parseConfigBool(key, defaultValue) {
+  const argValue = getArgValue(key);
+  if (argValue !== void 0) {
+    const parsed2 = argValue.toLowerCase();
+    return parsed2 === "true" || parsed2 === "1";
   }
-  async listen(options) {
-    const requestListener = getRequestListener(this.app.fetch);
-    this.server = (0, import_node_http.createServer)(requestListener);
-    return new Promise((resolve, reject) => {
-      const onError = (err) => {
-        Logger.getInstance().error("Failed to start Hono Server", err);
-        reject(err);
-      };
-      this.server.once("error", onError);
-      if (options.path) {
-        this.server.listen(options.path, () => {
-          this.server.removeListener("error", onError);
-          Logger.getInstance().info(`Hono Server listening on pipe/socket: ${options.path}`);
-          resolve();
-        });
-      } else {
-        this.server.listen(options.port || 3e3, options.host || "127.0.0.1", () => {
-          this.server.removeListener("error", onError);
-          Logger.getInstance().info(`Hono Server listening on HTTP, port: ${options.port}, host: ${options.host}`);
+  if (hasArgFlag(key)) {
+    return true;
+  }
+  const value = process.env[key];
+  if (!value) return defaultValue;
+  const parsed = value.toLowerCase();
+  return parsed === "true" || parsed === "1";
+}
+function parseConfigString(key, defaultValue) {
+  return getArgValue(key) || process.env[key] || defaultValue;
+}
+function buildServerConfig() {
+  return {
+    mode: parseConfigString("MODE", "local").toLowerCase(),
+    autoShutdownMinutes: parseConfigInt("AUTO_SHUTDOWN_MINUTES", 5),
+    httpPort: parseConfigInt("HTTP_PORT", 8080)
+  };
+}
+function buildLogConfig() {
+  return {
+    logToConsole: parseConfigBool("LOG_TO_CONSOLE", false),
+    logLevel: parseConfigString("LOG_LEVEL", "info").toLowerCase()
+  };
+}
+function buildStorageConfig() {
+  return {
+    persistInterval: parseConfigInt("STORAGE_PERSIST_INTERVAL", 5e3),
+    // 5 second
+    maxTracesPerApp: parseConfigInt("STORAGE_MAX_TRACES_PER_APP", 250)
+  };
+}
+function buildServiceConfig() {
+  return {
+    proxyUrl: parseConfigString("SERVICE_PROXY_URL", "https://api.syn-cause.com/codeproxy"),
+    pollingInterval: parseConfigInt("SERVICE_POLLING_INTERVAL", 1e4),
+    // 10 second
+    bindingCheckInterval: parseConfigInt("SERVICE_BINDING_CHECK_INTERVAL", 6e4)
+    // 1 minute
+  };
+}
+var cachedConfig = null;
+function getConfig() {
+  if (!cachedConfig) {
+    cachedConfig = {
+      server: buildServerConfig(),
+      log: buildLogConfig(),
+      storage: buildStorageConfig(),
+      service: buildServiceConfig()
+    };
+  }
+  return cachedConfig;
+}
+
+// src/core/api/ProxyApi.ts
+var AuthInput = class _AuthInput {
+  apiKey;
+  jwtToken;
+  constructor(info) {
+    this.apiKey = info.apiKey;
+    this.jwtToken = info.jwtToken;
+  }
+  hasApiKey() {
+    return !!this.apiKey;
+  }
+  hasJwtToken() {
+    return !!this.jwtToken;
+  }
+  static fromApiKey(apiKey) {
+    return new _AuthInput({ apiKey });
+  }
+  static fromJwtToken(jwtToken) {
+    return new _AuthInput({ jwtToken });
+  }
+  getHeaders() {
+    const headers = {};
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    if (this.jwtToken) {
+      headers["Authorization"] = `Bearer ${this.jwtToken}`;
+    }
+    return headers;
+  }
+  /**
+   * Get the key to use for LLM API calls.
+   * Returns apiKey if available, otherwise returns jwtToken.
+   */
+  getLlmKey() {
+    return this.apiKey || this.jwtToken || "";
+  }
+};
+var ProxyAuth = class {
+  auth;
+  constructor(auth) {
+    this.auth = auth;
+  }
+  update(auth) {
+    const oldAuth = this.auth;
+    if (oldAuth.hasApiKey() && auth.hasJwtToken() && !auth.hasApiKey()) {
+      return false;
+    }
+    if (oldAuth.getLlmKey() === auth.getLlmKey()) {
+      return false;
+    }
+    this.auth = auth;
+    return true;
+  }
+  get() {
+    return this.auth;
+  }
+  getHeaders() {
+    return this.auth.getHeaders();
+  }
+  getLlmKey() {
+    return this.auth.getLlmKey();
+  }
+};
+var ProxyApi = class {
+  proxyUrl;
+  constructor(proxyUrl) {
+    this.proxyUrl = proxyUrl;
+  }
+  async fetchAppList(auth) {
+    try {
+      const response = await fetch(`${this.proxyUrl}/api/v1/apps`, {
+        headers: auth.getHeaders()
+      });
+      if (!response.ok) {
+        Logger.getInstance().warn(`Failed to fetch app list: ${response.status} ${response.statusText}`);
+        return null;
+      }
+      const data = await response.json();
+      if (data.code !== 200 || !data.data) {
+        Logger.getInstance().warn("Failed to fetch app list or no data returned");
+        return null;
+      }
+      return Array.isArray(data.data) ? data.data : [];
+    } catch (error) {
+      Logger.getInstance().error("Error fetching app list:", error);
+      return null;
+    }
+  }
+  async checkDeviceBinding(deviceId) {
+    try {
+      const response = await fetch(`${this.proxyUrl}/api/v1/devices/checkBind?deviceId=${deviceId}`);
+      if (!response.ok) {
+        Logger.getInstance().warn(`Failed to check device binding: ${response.status} ${response.statusText}`);
+        return null;
+      }
+      const result = await response.json();
+      if (result.success && result.data) {
+        if (typeof result.data.isBound === "string") {
+          result.data.isBound = result.data.isBound === "true";
+        }
+        return result.data;
+      }
+      return null;
+    } catch (error) {
+      Logger.getInstance().error("Error checking device binding:", error);
+      return null;
+    }
+  }
+  async pollRuntimeFacts(appId, auth) {
+    try {
+      const response = await fetch(`${this.proxyUrl}/api/v1/traces/${appId}`, {
+        headers: auth.getHeaders()
+      });
+      if (!response.ok) {
+        Logger.getInstance().warn(`Failed to fetch RuntimeFacts for ${appId}: ${response.status} ${response.statusText}`);
+        return [];
+      }
+      const data = await response.json();
+      if (!Array.isArray(data.data)) {
+        Logger.getInstance().warn("Fetched data is not an array:", data.data);
+        return [];
+      }
+      return data.data;
+    } catch (error) {
+      Logger.getInstance().error(`Error polling traces for ${appId}:`, error);
+      return [];
+    }
+  }
+  async fetchSession(auth) {
+    try {
+      const response = await fetch(`${this.proxyUrl}/api/v1/auth/session`, {
+        headers: auth.getHeaders()
+      });
+      if (!response.ok) {
+        Logger.getInstance().warn(`Failed to fetch session: ${response.status} ${response.statusText}`);
+        return null;
+      }
+      const result = await response.json();
+      const isSuccess = result.success === true || result.success === "true";
+      if (isSuccess && result.data && result.data.userId) {
+        return result.data.userId;
+      }
+      return null;
+    } catch (error) {
+      Logger.getInstance().error("Error fetching session:", error);
+      return null;
+    }
+  }
+};
+var proxyApi = new ProxyApi(getConfig().service.proxyUrl);
+
+// src/transport/server/hono-server.ts
+var HonoServer = class {
+  constructor(onActivity) {
+    this.onActivity = onActivity;
+    this.app = new Hono2();
+    this.setupRoutes();
+  }
+  app;
+  handlers = /* @__PURE__ */ new Map();
+  server;
+  setupRoutes() {
+    this.app.use("*", async (c, next) => {
+      this.onActivity?.();
+      await next();
+    });
+    this.app.post("/", async (c) => {
+      const apiKey = c.req.header("x-api-key");
+      const authHeader = c.req.header("authorization");
+      let auth;
+      if (apiKey) {
+        auth = AuthInput.fromApiKey(apiKey);
+      } else if (authHeader && authHeader.startsWith("Bearer ")) {
+        const jwtToken = authHeader.substring(7);
+        auth = AuthInput.fromJwtToken(jwtToken);
+      }
+      let body;
+      try {
+        body = await c.req.json();
+      } catch (e) {
+        return c.json({
+          jsonrpc: "2.0",
+          id: null,
+          error: { code: -32700 /* PARSE_ERROR */, message: "Parse error" }
+        }, 400);
+      }
+      Logger.getInstance().debug("Executing RPC handler", {
+        hasApiKey: !!apiKey,
+        hasJwtToken: !!authHeader,
+        method: body?.method,
+        requestId: body?.id,
+        params: body?.params
+      });
+      if (!auth) {
+        Logger.getInstance().debug("Unauthorized: No valid authentication provided");
+        return c.json({
+          jsonrpc: "2.0",
+          id: body?.id || null,
+          error: {
+            code: -32001 /* UNAUTHORIZED */,
+            message: "Unauthorized: Please provide either x-api-key or Authorization header"
+          }
+        }, 401);
+      }
+      if (!body || body.jsonrpc !== "2.0" || !body.method || !body.id) {
+        Logger.getInstance().debug("Invalid Request: Not a standard JSON-RPC 2.0");
+        return c.json({
+          jsonrpc: "2.0",
+          id: body?.id || null,
+          error: { code: -32600 /* INVALID_REQUEST */, message: "Invalid Request: Not a standard JSON-RPC 2.0" }
+        }, 400);
+      }
+      const handler = this.handlers.get(body.method);
+      if (!handler) {
+        return c.json({
+          jsonrpc: "2.0",
+          id: body.id,
+          error: { code: -32601 /* METHOD_NOT_FOUND */, message: `Method not found: ${body.method}` }
+        });
+      }
+      try {
+        const result = await handler(body.params, auth);
+        Logger.getInstance().debug("RPC handler executed successfully", {
+          method: body.method,
+          requestId: body.id
+        });
+        return c.json({
+          jsonrpc: "2.0",
+          id: body.id,
+          result
+        });
+      } catch (err) {
+        Logger.getInstance().error(`RPC Handler Error for ${body.method}:`, err);
+        return c.json({
+          jsonrpc: "2.0",
+          id: body.id,
+          error: { code: -32603 /* INTERNAL_ERROR */, message: err.message || "Internal error" }
+        });
+      }
+    });
+  }
+  registerHandler(method, handler) {
+    Logger.getInstance().info(`Register handler ${method}`);
+    this.handlers.set(method, handler);
+  }
+  async listen(options) {
+    const requestListener = getRequestListener(this.app.fetch);
+    this.server = (0, import_node_http.createServer)(requestListener);
+    return new Promise((resolve, reject) => {
+      const onError = (err) => {
+        Logger.getInstance().error("Failed to start Hono Server", err);
+        reject(err);
+      };
+      this.server.once("error", onError);
+      if (options.path) {
+        this.server.listen(options.path, () => {
+          this.server.removeListener("error", onError);
+          Logger.getInstance().info(`Hono Server listening on pipe/socket: ${options.path}`);
+          resolve();
+        });
+      } else {
+        this.server.listen(options.port || 3e3, options.host || "127.0.0.1", () => {
+          this.server.removeListener("error", onError);
+          Logger.getInstance().info(`Hono Server listening on HTTP, port: ${options.port}, host: ${options.host}`);
           resolve();
         });
       }
@@ -18792,13 +19770,13 @@ function __classPrivateFieldGet(receiver, state, kind, f) {
 
 // node_modules/openai/internal/utils/uuid.mjs
 var uuid4 = function() {
-  const { crypto: crypto5 } = globalThis;
-  if (crypto5?.randomUUID) {
-    uuid4 = crypto5.randomUUID.bind(crypto5);
-    return crypto5.randomUUID();
+  const { crypto: crypto6 } = globalThis;
+  if (crypto6?.randomUUID) {
+    uuid4 = crypto6.randomUUID.bind(crypto6);
+    return crypto6.randomUUID();
   }
   const u8 = new Uint8Array(1);
-  const randomByte = crypto5 ? () => crypto5.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
+  const randomByte = crypto6 ? () => crypto6.getRandomValues(u8)[0] : () => Math.random() * 255 & 255;
   return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (+c ^ randomByte() & 15 >> +c / 4).toString(16));
 };
 
@@ -25590,51 +26568,56 @@ var LLMService = class {
   limit = (0, import_p_limit.default)(5);
   // Concurrency limit for LLM calls
   LLMURL = "https://api.syn-cause.com/llm";
-  apiKey = "";
-  language = "en";
-  constructor(apiKey = "", language) {
-    this.apiKey = apiKey;
+  auth;
+  language = "English";
+  constructor(auth, language) {
+    this.auth = auth;
     this.language = language || this.detectLanguage();
   }
   detectLanguage() {
     try {
       const envLang = process.env.LANG || process.env.LANGUAGE || process.env.LC_ALL || process.env.LC_MESSAGES;
       if (envLang && envLang.toLowerCase().startsWith("zh")) {
-        return "zh";
+        return "Chinese";
       }
       const locale = Intl.DateTimeFormat().resolvedOptions().locale;
       if (locale.toLowerCase().startsWith("zh")) {
-        return "zh";
+        return "Chinese";
       }
     } catch (e) {
     }
-    return "en";
+    return "English";
   }
   async embedding(text) {
-    if (!this.apiKey) {
-      throw new Error("LLM API Key (userApiKey) is not set");
-    }
-    const llm = new OpenAI({
-      apiKey: this.apiKey,
-      baseURL: this.LLMURL
-    });
-    const embedding = await llm.embeddings.create({
-      model: "qwen3-embedding-8b",
-      input: text,
-      encoding_format: "float"
+    return this.limit(async () => {
+      const apiKey = this.auth.getLlmKey();
+      if (!apiKey) {
+        throw new Error("LLM API Key (userApiKey) is not set");
+      }
+      const llm = new OpenAI({
+        apiKey,
+        baseURL: this.LLMURL
+      });
+      const embedding = await llm.embeddings.create({
+        model: "qwen3-embedding-8b",
+        input: text,
+        encoding_format: "float"
+      });
+      return embedding.data[0].embedding;
     });
-    return embedding.data[0].embedding;
   }
   async processRuntimeFactWithLLM(trace) {
-    if (!this.apiKey) {
-      Logger.getInstance().error("LLM API Key is missing, skipping LLM processing");
-      return trace;
-    }
-    const temp_spans = trace.invokeTree;
-    const en_prompt = `
+    return this.limit(async () => {
+      const apiKey = this.auth.getLlmKey();
+      if (!apiKey) {
+        Logger.getInstance().error("LLM API Key is missing, skipping LLM processing");
+        return trace;
+      }
+      const temp_spans = trace.invokeTree;
+      let prompt = `
 <task>
 This is runtime data captured from a program.
-Please generate a JSON summary based on the data provided.
+Please generate a JSON summary based on the data provided. Output in ${this.language}.
 </task>
 <output_format>
 \`\`\`json
@@ -25651,57 +26634,37 @@ The data is as follows:
 ${JSON.stringify(temp_spans)}
 </data>
 `;
-    const zh_prompt = `
-<task>
-This is runtime data captured from a program.
-Please summarize it into a JSON object.
-</task>
-<output_format>
-\`\`\`json
-{
-  "title": "Short title",
-  "summary": "Detailed summary, one sentence description. Must be brief.",
-  "related_interface": "Related interface, just one",
-  "status": "Status, success/failure"
-}
-\`\`\`
-</output_format> 
-Data follows
-<data>
-${JSON.stringify(temp_spans)}
-</data>
-`;
-    let prompt = this.language === "en" ? en_prompt : zh_prompt;
-    try {
-      const llm = new OpenAI({
-        apiKey: this.apiKey,
-        baseURL: this.LLMURL
-      });
-      const res = await this.limit(() => llm.chat.completions.create({
-        model: "gpt-4.1-nano",
-        messages: [{ role: "user", content: prompt }],
-        temperature: 0.3
-      }));
-      const content = res.choices[0].message?.content || "";
-      trace.llmRawResponse = content;
-      const extracted = this.extractJsonFromString(content);
-      if (extracted) {
-        try {
-          trace.summaryEmbedding = await this.embedding(extracted.summary);
-        } catch (error) {
-          Logger.getInstance().error(`Failed to generate embedding for trace ${trace.traceId}:`, error);
+      try {
+        const llm = new OpenAI({
+          apiKey,
+          baseURL: this.LLMURL
+        });
+        const res = await llm.chat.completions.create({
+          model: "gpt-4.1-nano",
+          messages: [{ role: "user", content: prompt }],
+          temperature: 0.3
+        });
+        const content = res.choices[0].message?.content || "";
+        trace.llmRawResponse = content;
+        const extracted = this.extractJsonFromString(content);
+        if (extracted) {
+          try {
+            trace.summaryEmbedding = await this.embedding(extracted.summary);
+          } catch (error) {
+            Logger.getInstance().error(`Failed to generate embedding for trace ${trace.traceId}:`, error);
+          }
+          return { ...trace, ...extracted };
+        } else {
+          trace.llmError = "Failed to extract JSON from response";
+          Logger.getInstance().warn(`Failed to extract JSON for ${trace.traceId}. Content: ${content}`);
         }
-        return { ...trace, ...extracted };
-      } else {
-        trace.llmError = "Failed to extract JSON from response";
-        Logger.getInstance().warn(`Failed to extract JSON for ${trace.traceId}. Content: ${content}`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        Logger.getInstance().error(`LLM processing failed for trace ${trace.traceId}:`, error);
+        trace.llmError = errorMessage;
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      Logger.getInstance().error(`LLM processing failed for trace ${trace.traceId}:`, error);
-      trace.llmError = errorMessage;
-    }
-    return trace;
+      return trace;
+    });
   }
   extractJsonFromString(input) {
     const match2 = input.match(/```json\s*([\s\S]*?)\s*```/);
@@ -25721,12 +26684,10 @@ ${JSON.stringify(temp_spans)}
 
 // src/core/services/AppService.ts
 var AppService = class {
-  userApiKey = "";
-  proxyUrl = "";
+  auth;
   appCache = /* @__PURE__ */ new Map();
-  constructor(apiKey, proxyUrl) {
-    this.userApiKey = apiKey;
-    this.proxyUrl = proxyUrl;
+  constructor(auth) {
+    this.auth = auth;
   }
   /**
    * Convert AppResponse to App
@@ -25740,26 +26701,7 @@ var AppService = class {
     };
   }
   async fetchAppList() {
-    if (!this.userApiKey) {
-      Logger.getInstance().warn("No API key found for fetching app list.");
-      return [];
-    }
-    try {
-      const applist_response = await fetch(`${this.proxyUrl}/api/v1/apps?api_key=${this.userApiKey}`, {
-        headers: {
-          "X-API_Key": this.userApiKey
-        }
-      });
-      const applist_data = await applist_response.json();
-      if (applist_data.code !== 200 || !applist_data.data) {
-        Logger.getInstance().warn("Failed to fetch app list or no data returned");
-        return [];
-      }
-      return Array.isArray(applist_data.data) ? applist_data.data : [];
-    } catch (error) {
-      Logger.getInstance().error("Error fetching app list:", error);
-      return [];
-    }
+    return proxyApi.fetchAppList(this.auth.get());
   }
   /**
    * Refreshes the internal app cache by fetching the latest app list.
@@ -25767,6 +26709,9 @@ var AppService = class {
    */
   async refreshCache() {
     const appResponses = await this.fetchAppList();
+    if (appResponses === null) {
+      return Array.from(this.appCache.values()).filter((app) => app.isConnected).map((app) => app.id);
+    }
     const newCache = /* @__PURE__ */ new Map();
     const connectedAppIds = [];
     for (const appResponse of appResponses) {
@@ -25777,6 +26722,7 @@ var AppService = class {
       }
     }
     this.appCache = newCache;
+    Logger.getInstance().debug(`Found ${connectedAppIds.length} apps with key: ${this.auth.getLlmKey().substring(0, 10)}...`);
     return connectedAppIds;
   }
   getCachedApp(appId) {
@@ -25799,18 +26745,27 @@ var AppService = class {
   }
   async getActiveAppByProjectId(projectId) {
     const appResponses = await this.fetchAppList();
+    if (appResponses === null) {
+      const cachedApp = Array.from(this.appCache.values()).find((app) => app.projectId === projectId && app.isConnected);
+      if (cachedApp) return cachedApp;
+      return Array.from(this.appCache.values()).find((app) => app.projectId === projectId) || null;
+    }
     const currentApps = appResponses.filter((app) => app.project_id === projectId);
     if (currentApps.length === 0) {
       Logger.getInstance().warn(`No apps found with projectId: ${projectId}`);
       return null;
     }
     const connectedApps = currentApps.filter((app) => app.is_connected);
-    const appIds = connectedApps.length > 0 ? connectedApps.map((app) => app.id).filter((id) => id !== void 0) : currentApps.map((app) => app.id).filter((id) => id !== void 0);
     let selectedAppResponse = connectedApps.length > 0 ? connectedApps[0] : currentApps[0];
     return this.convertAppResponseToApp(selectedAppResponse);
   }
   async getAppStatus(projectId) {
     const appResponses = await this.fetchAppList();
+    if (appResponses === null) {
+      const projectApps2 = Array.from(this.appCache.values()).filter((app) => app.projectId === projectId);
+      if (projectApps2.length === 0) return "NOT_FOUND" /* NOT_FOUND */;
+      return projectApps2.some((app) => app.isConnected) ? "CONNECTED" /* CONNECTED */ : "DISCONNECTED" /* DISCONNECTED */;
+    }
     const projectApps = appResponses.filter((app) => app.project_id === projectId);
     if (projectApps.length === 0) {
       return "NOT_FOUND" /* NOT_FOUND */;
@@ -25820,152 +26775,6 @@ var AppService = class {
   }
 };
 
-// src/config/index.ts
-function getArgValue(key) {
-  const keys = [key, key.toLowerCase()];
-  for (const k of keys) {
-    const prefix = `--${k}=`;
-    const arg = process.argv.find((a) => a.startsWith(prefix));
-    if (arg) return arg.slice(prefix.length);
-    const index = process.argv.indexOf(`--${k}`);
-    if (index !== -1 && index + 1 < process.argv.length && !process.argv[index + 1].startsWith("--")) {
-      return process.argv[index + 1];
-    }
-  }
-  return void 0;
-}
-function hasArgFlag(key) {
-  const keys = [key, key.toLowerCase()];
-  return keys.some((k) => process.argv.includes(`--${k}`));
-}
-function parseConfigInt(key, defaultValue) {
-  const argValue = getArgValue(key);
-  if (argValue) {
-    const parsed2 = parseInt(argValue, 10);
-    if (!isNaN(parsed2)) return parsed2;
-  }
-  const value = process.env[key];
-  if (!value) return defaultValue;
-  const parsed = parseInt(value, 10);
-  return isNaN(parsed) ? defaultValue : parsed;
-}
-function parseConfigBool(key, defaultValue) {
-  const argValue = getArgValue(key);
-  if (argValue !== void 0) {
-    const parsed2 = argValue.toLowerCase();
-    return parsed2 === "true" || parsed2 === "1";
-  }
-  if (hasArgFlag(key)) {
-    return true;
-  }
-  const value = process.env[key];
-  if (!value) return defaultValue;
-  const parsed = value.toLowerCase();
-  return parsed === "true" || parsed === "1";
-}
-function parseConfigString(key, defaultValue) {
-  return getArgValue(key) || process.env[key] || defaultValue;
-}
-function buildServerConfig() {
-  return {
-    mode: parseConfigString("MODE", "local").toLowerCase(),
-    autoShutdownMinutes: parseConfigInt("AUTO_SHUTDOWN_MINUTES", 5),
-    httpPort: parseConfigInt("HTTP_PORT", 8080)
-  };
-}
-function buildLogConfig() {
-  return {
-    logToConsole: parseConfigBool("LOG_TO_CONSOLE", false),
-    logLevel: parseConfigString("LOG_LEVEL", "info").toLowerCase()
-  };
-}
-function buildStorageConfig() {
-  return {
-    persistInterval: parseConfigInt("STORAGE_PERSIST_INTERVAL", 5e3),
-    // 5 second
-    maxTracesPerApp: parseConfigInt("STORAGE_MAX_TRACES_PER_APP", 250)
-  };
-}
-function buildServiceConfig() {
-  return {
-    proxyUrl: parseConfigString("SERVICE_PROXY_URL", "https://api.syn-cause.com/codeproxy"),
-    pollingInterval: parseConfigInt("SERVICE_POLLING_INTERVAL", 1e4)
-    // 10 second
-  };
-}
-var cachedConfig = null;
-function getConfig() {
-  if (!cachedConfig) {
-    cachedConfig = {
-      server: buildServerConfig(),
-      log: buildLogConfig(),
-      storage: buildStorageConfig(),
-      service: buildServiceConfig()
-    };
-  }
-  return cachedConfig;
-}
-
-// src/core/services/TracePollingService.ts
-var TracePollingService = class {
-  userApiKey;
-  proxyUrl;
-  constructor(apiKey, proxyUrl) {
-    this.userApiKey = apiKey;
-    this.proxyUrl = proxyUrl;
-  }
-  /**
-   * Poll runtime facts for a specific appId
-   * @param appId The application ID to poll traces for
-   * @returns Array of runtime facts or empty array if failed
-   */
-  async pollRuntimeFacts(appId) {
-    try {
-      const response = await fetch(`${this.proxyUrl}/api/v1/traces/${appId}?api_key=${this.userApiKey}`, {
-        headers: {
-          "X-API_Key": this.userApiKey
-        }
-      });
-      if (!response.ok) {
-        Logger.getInstance().warn(`Failed to fetch RuntimeFacts for ${appId}: ${response.status} ${response.statusText}`);
-        return [];
-      }
-      const data = await response.json();
-      if (!Array.isArray(data.data)) {
-        Logger.getInstance().warn("Fetched data is not an array:", data.data);
-        return [];
-      }
-      if (data.data.length > 0) {
-        Logger.getInstance().info(`Fetched ${data.data.length} RuntimeFacts for ${appId}.`);
-      }
-      return data.data;
-    } catch (error) {
-      Logger.getInstance().error(`Error polling traces for ${appId}:`, error);
-      return [];
-    }
-  }
-  /**
-   * Poll runtime facts for multiple appIds in parallel
-   * @param appIds Array of application IDs to poll
-   * @returns Map of appId to runtime facts
-   */
-  async pollMultipleApps(appIds) {
-    const results = await Promise.all(
-      appIds.map(async (appId) => ({
-        appId,
-        facts: await this.pollRuntimeFacts(appId)
-      }))
-    );
-    const resultMap = /* @__PURE__ */ new Map();
-    for (const { appId, facts } of results) {
-      if (facts.length > 0) {
-        resultMap.set(appId, facts);
-      }
-    }
-    return resultMap;
-  }
-};
-
 // node_modules/uuid/dist/esm-node/rng.js
 var import_crypto2 = __toESM(require("crypto"));
 var rnds8Pool = new Uint8Array(256);
@@ -26345,12 +27154,10 @@ var FuzzySearchStrategy = class {
 // src/core/services/TraceSearchService.ts
 var TraceSearchService = class {
   diskStorage;
-  appService;
   embeddingStrategy;
   fuzzyStrategy;
-  constructor(diskStorage, llmService, appService) {
+  constructor(diskStorage, llmService) {
     this.diskStorage = diskStorage;
-    this.appService = appService;
     this.embeddingStrategy = new EmbeddingSearchStrategy(llmService);
     this.fuzzyStrategy = new FuzzySearchStrategy();
   }
@@ -26446,21 +27253,19 @@ var RuntimeFactService = class {
   llmService;
   appService;
   // Sub-services
-  pollingService;
   processingService;
   searchService;
-  userApiKey = "";
   proxyUrl;
-  constructor(apiKey, diskStorage) {
-    this.userApiKey = apiKey;
+  proxyAuth;
+  constructor(auth, diskStorage) {
     this.diskStorage = diskStorage;
     this.proxyUrl = getConfig().service.proxyUrl;
-    this.llmService = new LLMService(apiKey);
-    this.appService = new AppService(apiKey, this.proxyUrl);
-    this.pollingService = new TracePollingService(apiKey, this.proxyUrl);
+    this.proxyAuth = new ProxyAuth(auth);
+    this.llmService = new LLMService(this.proxyAuth);
+    this.appService = new AppService(this.proxyAuth);
     this.processingService = new TraceProcessingService(diskStorage, this.llmService);
-    this.searchService = new TraceSearchService(diskStorage, this.llmService, this.appService);
-    Logger.getInstance().info(`Registered RuntimeFactsService for apiKey: ${apiKey.substring(0, 8)}... with proxyUrl: ${this.proxyUrl}`);
+    this.searchService = new TraceSearchService(diskStorage, this.llmService);
+    Logger.getInstance().info(`Registered RuntimeFactsService with proxyUrl: ${this.proxyUrl}`);
   }
   getDiskStorage() {
     return this.diskStorage;
@@ -26474,18 +27279,27 @@ var RuntimeFactService = class {
   getAllApps() {
     return this.appService.getAllApps();
   }
-  async pollAllApps() {
+  async pollAllApps(processedAppIds) {
     try {
-      const connectedAppIds = await this.appService.refreshCache();
+      let connectedAppIds = await this.appService.refreshCache();
+      if (processedAppIds && processedAppIds.size > 0) {
+        const beforeCount = connectedAppIds.length;
+        connectedAppIds = connectedAppIds.filter((id) => !processedAppIds.has(id));
+        const afterCount = connectedAppIds.length;
+        if (beforeCount !== afterCount) {
+          Logger.getInstance().info(`Skipping ${beforeCount - afterCount} apps already processed in this cycle.`);
+        }
+      }
       await Promise.all(connectedAppIds.map((appId) => this.pollAndProcessApp(appId)));
-      const activeProjectIds = this.appService.getCachedProjectIds();
-      await this.diskStorage.cleanupInactiveProjects(activeProjectIds);
+      if (processedAppIds) {
+        connectedAppIds.forEach((id) => processedAppIds.add(id));
+      }
     } catch (error) {
       Logger.getInstance().error("Error polling all apps:", error);
     }
   }
   async pollAndProcessApp(appId) {
-    const facts = await this.pollingService.pollRuntimeFacts(appId);
+    const facts = await proxyApi.pollRuntimeFacts(appId, this.proxyAuth.get());
     if (facts.length > 0) {
       const app = this.appService.getCachedApp(appId);
       if (app && app.projectId) {
@@ -26501,20 +27315,59 @@ var RuntimeFactService = class {
     }
   }
   async getRuntimeFacts(projectId, searchText, matchMode = "embedding", limit2 = 10) {
+    if (!this.checkProjectAccess(projectId)) {
+      return [];
+    }
     return this.searchService.getRuntimeFacts(projectId, searchText, matchMode, limit2);
   }
   async getRuntimeEvents(projectId) {
+    if (!this.checkProjectAccess(projectId)) {
+      return [];
+    }
     return this.diskStorage.getProjectRuntimeEvents(projectId);
   }
   async findTraceById(traceId, projectId) {
+    if (!this.checkProjectAccess(projectId)) {
+      return null;
+    }
     return this.searchService.findTraceById(traceId, projectId);
   }
   async searchTraces(query, limit2 = 5, projectId, minSimilarity) {
+    if (!this.checkProjectAccess(projectId)) {
+      return [];
+    }
     return this.searchService.searchTraces(query, limit2, projectId, minSimilarity);
   }
   async getAppStatus(projectId) {
+    if (!this.checkProjectAccess(projectId)) {
+      return "NOT_FOUND" /* NOT_FOUND */;
+    }
     return this.appService.getAppStatus(projectId);
   }
+  /**
+   * Checks if the current user has access to the given projectId.
+   */
+  checkProjectAccess(projectId) {
+    const activeProjectIds = this.appService.getCachedProjectIds();
+    const hasAccess = activeProjectIds.includes(projectId);
+    if (!hasAccess) {
+      Logger.getInstance().warn(`Unauthorized access attempt to projectId: ${projectId} by user with key: ${this.proxyAuth.getLlmKey().substring(0, 10)}...`);
+    }
+    return hasAccess;
+  }
+  /**
+   * Get the list of project IDs that are currently active (in cache) for this user.
+   */
+  getActiveProjectIds() {
+    return this.appService.getCachedProjectIds();
+  }
+  /**
+   * Update the authentication information for this service and its components.
+   * Returns true if the authentication was actually changed.
+   */
+  updateAuth(auth) {
+    return this.proxyAuth.update(auth);
+  }
 };
 
 // src/core/storage/disk.ts
@@ -26583,6 +27436,8 @@ var DiskStorage = class {
   loadedProjectIds = /* @__PURE__ */ new Set();
   // Project IDs to Store: Tracks which projectIds need to be persisted to disk
   projectIdsToStore = /* @__PURE__ */ new Set();
+  // Last Access Map: Tracks the last time a projectId was accessed
+  lastAccessMap = /* @__PURE__ */ new Map();
   // Persistence Timer
   persistTimer;
   // ========== Concurrency Safety ==========
@@ -26646,13 +27501,20 @@ var DiskStorage = class {
     }
   }
   /**
-   * Clean up inactive caches (based on active list)
+   * Clean up inactive caches (based on active list and TTL)
    * @param activeProjectIds List of currently active projectIds
    */
   async cleanupInactiveProjects(activeProjectIds) {
     const activeSet = new Set(activeProjectIds);
+    const now = Date.now();
+    const CACHE_TTL = 2 * 60 * 1e3;
     const cachedProjectIds = Array.from(this.factsCache.keys());
-    const inactiveProjectIds = cachedProjectIds.filter((projectId) => !activeSet.has(projectId));
+    const inactiveProjectIds = cachedProjectIds.filter((projectId) => {
+      if (activeSet.has(projectId)) return false;
+      const lastAccess = this.lastAccessMap.get(projectId) || 0;
+      if (now - lastAccess < CACHE_TTL) return false;
+      return true;
+    });
     if (inactiveProjectIds.length > 0) {
       Logger.getInstance().info(`Cleaning up ${inactiveProjectIds.length} inactive project caches...`);
       await Promise.all(
@@ -26726,6 +27588,7 @@ var DiskStorage = class {
     this.runtimeEventsMap.delete(projectId);
     this.projectIdsToStore.delete(projectId);
     this.loadedProjectIds.delete(projectId);
+    this.lastAccessMap.delete(projectId);
     Logger.getInstance().info(`Cleared cache for project ${projectId}`);
   }
   getProjectRuntimeEvents(projectId) {
@@ -26790,6 +27653,7 @@ var DiskStorage = class {
    * Each projectId is loaded from disk only on first access; subsequent access uses cache.
    */
   async getRuntimeFacts(projectId) {
+    this.lastAccessMap.set(projectId, Date.now());
     if (this.factsCache.has(projectId)) {
       return [...this.factsCache.get(projectId)];
     }
@@ -26807,6 +27671,7 @@ var DiskStorage = class {
    * Use lock protection to avoid concurrency conflicts with updateRuntimeFact.
    */
   async saveRuntimeFacts(projectId, facts) {
+    this.lastAccessMap.set(projectId, Date.now());
     return this.withLock(projectId, async () => {
       const limitedFacts = this.limitTraces(facts);
       this.factsCache.set(projectId, limitedFacts);
@@ -26819,6 +27684,7 @@ var DiskStorage = class {
    * Use lock protection to avoid concurrency conflicts with saveRuntimeFacts.
    */
   async updateRuntimeFact(projectId, updatedTrace) {
+    this.lastAccessMap.set(projectId, Date.now());
     return this.withLock(projectId, async () => {
       let traces = this.factsCache.get(projectId);
       if (!traces) {
@@ -26841,14 +27707,114 @@ var DiskStorage = class {
   }
 };
 
+// src/core/services/AnonymousService.ts
+var import_crypto4 = __toESM(require("crypto"));
+var import_node_machine_id = __toESM(require_dist());
+var DEVICE_ID_SALT = "syncause-salt-";
+function getSystemDeviceId() {
+  try {
+    const rawDeviceId = (0, import_node_machine_id.machineIdSync)();
+    if (!rawDeviceId || rawDeviceId.trim().length === 0) {
+      throw new Error("Raw device ID is empty");
+    }
+    Logger.getInstance().info("Device ID obtained (hashed for privacy)");
+    return import_crypto4.default.createHash("sha256").update(DEVICE_ID_SALT + rawDeviceId).digest("hex");
+  } catch (error) {
+    Logger.getInstance().error("Failed to get system device ID", error);
+    throw new Error(`Failed to get device ID: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+var AnonymousBindingService = class {
+  // Anonymous account tracking
+  anonymousUserId = null;
+  boundUserId = null;
+  deviceId = getSystemDeviceId();
+  bindingCheckInterval = null;
+  isAnonymousBound = false;
+  constructor() {
+  }
+  /**
+   * Start periodic scanning for anonymous account binding status
+   * @param intervalMs Check interval in milliseconds
+   */
+  async startBindingScanner(intervalMs) {
+    this.stopBindingScanner();
+    this.isAnonymousBound = false;
+    Logger.getInstance().info(`Starting device binding scanner for deviceId: ${this.deviceId} with interval: ${intervalMs}ms`);
+    const checkBinding = async () => {
+      try {
+        if (!this.deviceId) {
+          Logger.getInstance().warn("Device binding scanner stopped: missing deviceId");
+          this.stopBindingScanner();
+          return;
+        }
+        const bindingData = await proxyApi.checkDeviceBinding(this.deviceId);
+        if (bindingData) {
+          if (this.anonymousUserId === null) {
+            Logger.getInstance().info(`Found Anonymous UserId: ${bindingData.anonymousUserId}, bind UserId: ${bindingData.bindUserId}`);
+          } else if (this.isAnonymousBound === false && bindingData.isBound) {
+            Logger.getInstance().info(`Detected Bind UserId: ${bindingData.bindUserId}`);
+          }
+          this.anonymousUserId = bindingData.anonymousUserId;
+          this.boundUserId = bindingData.bindUserId;
+          this.isAnonymousBound = bindingData.isBound;
+          if (this.isAnonymousBound) {
+            Logger.getInstance().info("Anonymous account is bound. Stopping binding scanner.");
+            this.stopBindingScanner();
+            return;
+          }
+        }
+        if (this.bindingCheckInterval) {
+          this.bindingCheckInterval = setTimeout(checkBinding, intervalMs);
+        }
+      } catch (error) {
+        Logger.getInstance().error("Error during device binding check:", error);
+        if (this.bindingCheckInterval) {
+          this.bindingCheckInterval = setTimeout(checkBinding, intervalMs);
+        }
+      }
+    };
+    this.bindingCheckInterval = setTimeout(checkBinding, 0);
+  }
+  /**
+   * Stop the device binding scanner
+   */
+  stopBindingScanner() {
+    if (this.bindingCheckInterval) {
+      clearTimeout(this.bindingCheckInterval);
+      this.bindingCheckInterval = null;
+      Logger.getInstance().info("Device binding scanner stopped.");
+    }
+  }
+  /**
+   * Resolve the effective userId.
+   * If the provided userId is the anonymous account:
+   *   - returns boundUserId if it's already bound
+   *   - returns current anonymousUserId otherwise
+   * If the provided userId is not the anonymous account, returns it as is.
+   */
+  resolveEffectiveUserId(userId) {
+    if (this.anonymousUserId === userId && this.isAnonymousBound && this.boundUserId) {
+      return this.boundUserId;
+    }
+    return userId;
+  }
+  getAnonymousUserId() {
+    return this.anonymousUserId;
+  }
+};
+
 // src/core/services/MultiUserRuntimeFactService.ts
 var MultiUserRuntimeFactService = class _MultiUserRuntimeFactService {
   static instance;
-  // <apiKey, service>
+  // <userId, service>
   services = /* @__PURE__ */ new Map();
+  // <llmKey, userId>
+  llmKeyToUserId = /* @__PURE__ */ new Map();
   pollingInterval = null;
   // Shared DiskStorage instance for all RuntimeFactService instances
   sharedDiskStorage = null;
+  anonymousBindingService = new AnonymousBindingService();
   constructor() {
   }
   initialize(basePath) {
@@ -26860,45 +27826,128 @@ var MultiUserRuntimeFactService = class _MultiUserRuntimeFactService {
     }
     return _MultiUserRuntimeFactService.instance;
   }
-  getOrCreateService(apiKey) {
-    let service = this.services.get(apiKey);
-    if (!service) {
-      if (!this.sharedDiskStorage) {
-        throw new Error("MultiUserRuntimeFactService not initialized. Call initialize() first.");
+  async getOrCreateService(auth) {
+    const llmKey = auth.getLlmKey();
+    let userId = this.llmKeyToUserId.get(llmKey);
+    if (!userId) {
+      userId = await proxyApi.fetchSession(auth) || void 0;
+      if (userId) {
+        Logger.getInstance().info(`Cache userId: ${userId} with key: ${llmKey.substring(0, 10)}...`);
+        this.llmKeyToUserId.set(llmKey, userId);
       }
-      service = new RuntimeFactService(apiKey, this.sharedDiskStorage);
-      this.services.set(apiKey, service);
     }
+    if (!userId) {
+      throw new Error(`Failed to fetch userId for auth`);
+    }
+    let resolvedUserId = this.anonymousBindingService.resolveEffectiveUserId(userId);
+    let service = this.services.get(resolvedUserId);
+    if (service) {
+      if (resolvedUserId === userId) {
+        if (service.updateAuth(auth)) {
+          Logger.getInstance().info(`Updated credentials for primary userId: ${resolvedUserId} with key: ${llmKey.substring(0, 10)}...`);
+        }
+      }
+      return service;
+    }
+    if (resolvedUserId !== userId) {
+      service = this.services.get(userId);
+      if (service) {
+        if (service.updateAuth(auth)) {
+          Logger.getInstance().info(`Updated credentials for anonymous userId: ${userId} with key: ${llmKey.substring(0, 10)}...`);
+        }
+        return service;
+      }
+    }
+    if (!this.sharedDiskStorage) {
+      throw new Error("MultiUserRuntimeFactService not initialized. Call initialize() first.");
+    }
+    service = new RuntimeFactService(auth, this.sharedDiskStorage);
+    this.services.set(userId, service);
+    Logger.getInstance().info(`Created RuntimeFactService for userId: ${userId}`);
     return service;
   }
   /**
-   * Registers an apiKey to the service. If a service for this apiKey doesn't exist, it will be created.
+   * Registers an auth to the service. If a service for this auth doesn't exist, it will be created.
    */
-  registerApiKey(apiKey) {
-    this.getOrCreateService(apiKey);
+  async registerAuth(auth) {
+    await this.getOrCreateService(auth);
   }
-  async startGlobalPolling(intervalMs) {
-    if (this.pollingInterval) {
-      clearInterval(this.pollingInterval);
-    }
-    Logger.getInstance().info(`Starting global RuntimeFact polling for all registered apiKeys with interval: ${intervalMs}ms...`);
-    const runPollCycle = async () => {
-      const apiKeys = Array.from(this.services.keys());
-      await Promise.all(apiKeys.map(async (apiKey) => {
-        const service = this.services.get(apiKey);
-        if (service) {
-          try {
-            await service.pollAllApps();
-          } catch (error) {
-            Logger.getInstance().error(`Error polling for apiKey ${apiKey.substring(0, 8)}...:`, error);
-          }
+  async startGlobalPolling(intervalMs, bindingCheckInterval) {
+    this.stopGlobalPolling();
+    if (bindingCheckInterval > 0) {
+      this.anonymousBindingService.startBindingScanner(bindingCheckInterval);
+    }
+    Logger.getInstance().info(`Starting global RuntimeFact polling... Interval: ${intervalMs}ms`);
+    const scheduleNext = () => {
+      this.pollingInterval = setTimeout(async () => {
+        try {
+          await this.executePollCycle();
+        } catch (error) {
+          Logger.getInstance().error("Critical error in poll cycle:", error);
+        } finally {
+          if (this.pollingInterval) scheduleNext();
         }
-      }));
-      if (this.pollingInterval) {
-        this.pollingInterval = setTimeout(runPollCycle, intervalMs);
-      }
+      }, intervalMs);
     };
-    this.pollingInterval = setTimeout(runPollCycle, 0);
+    this.pollingInterval = setTimeout(async () => {
+      await this.executePollCycle();
+      if (this.pollingInterval) scheduleNext();
+    }, 0);
+  }
+  /**
+   * Executes a single polling cycle with priority:
+   * 1. Categorize and cleanup redundant services
+   * 2. Poll primary services first and collect processed App IDs
+   * 3. Poll the anonymous service last, excluding already processed App IDs
+   */
+  async executePollCycle() {
+    const anonymousUserId = this.anonymousBindingService.getAnonymousUserId();
+    const primaryServices = [];
+    let anonymousService = null;
+    for (const [userId, service] of this.services.entries()) {
+      const resolvedUserId = this.anonymousBindingService.resolveEffectiveUserId(userId);
+      if (resolvedUserId !== userId && this.services.has(resolvedUserId)) {
+        this.services.delete(userId);
+        Logger.getInstance().info(`Polling: Pruned redundant anonymous service for ${userId}`);
+        continue;
+      }
+      if (userId === anonymousUserId) {
+        anonymousService = service;
+      } else {
+        primaryServices.push(service);
+      }
+    }
+    const processedAppIds = /* @__PURE__ */ new Set();
+    await Promise.all(primaryServices.map(async (service) => {
+      try {
+        await service.pollAllApps(processedAppIds);
+      } catch (error) {
+        Logger.getInstance().error("Error in primary service poll:", error);
+      }
+    }));
+    if (anonymousService) {
+      try {
+        await anonymousService.pollAllApps(processedAppIds);
+      } catch (error) {
+        Logger.getInstance().error("Error in anonymous service poll:", error);
+      }
+    }
+    if (this.sharedDiskStorage) {
+      const globalActiveProjectIds = this.getAllActiveProjectIds();
+      await this.sharedDiskStorage.cleanupInactiveProjects(globalActiveProjectIds);
+    }
+  }
+  /**
+   * Aggregates all active project IDs across all user services.
+   * Used for shared DiskStorage cache cleanup.
+   */
+  getAllActiveProjectIds() {
+    const allProjectIds = /* @__PURE__ */ new Set();
+    for (const service of this.services.values()) {
+      const projectIds = service.getActiveProjectIds();
+      projectIds.forEach((id) => allProjectIds.add(id));
+    }
+    return Array.from(allProjectIds);
   }
   stopGlobalPolling() {
     if (this.pollingInterval) {
@@ -26912,6 +27961,7 @@ var MultiUserRuntimeFactService = class _MultiUserRuntimeFactService {
    */
   async shutdown() {
     this.stopGlobalPolling();
+    this.anonymousBindingService.stopBindingScanner();
     if (this.sharedDiskStorage) {
       try {
         await this.sharedDiskStorage.shutdown();
@@ -26920,28 +27970,36 @@ var MultiUserRuntimeFactService = class _MultiUserRuntimeFactService {
       }
     }
   }
-  async getRuntimeFacts(apiKey, projectId, searchText, matchMode = "embedding", limit2 = 10) {
-    const service = this.getOrCreateService(apiKey);
+  async getRuntimeFacts(auth, projectId, searchText, matchMode = "embedding", limit2 = 10) {
+    const service = await this.getOrCreateService(auth);
     return await service.getRuntimeFacts(projectId, searchText, matchMode, limit2);
   }
-  async getAppList(apiKey) {
-    const service = this.getOrCreateService(apiKey);
+  async getAppList(auth) {
+    const service = await this.getOrCreateService(auth);
     return service.getAllApps();
   }
-  async getRuntimeEvents(apiKey, projectId) {
-    const service = this.getOrCreateService(apiKey);
+  async getRuntimeEvents(auth, projectId) {
+    const service = await this.getOrCreateService(auth);
     return await service.getRuntimeEvents(projectId);
   }
 };
 
 // src/rpc/handler/pingHandler.ts
-async function pingHandler(params, apiKey) {
-  if (apiKey) {
-    MultiUserRuntimeFactService.getInstance().registerApiKey(apiKey);
+async function pingHandler(params, auth) {
+  if (auth) {
+    await MultiUserRuntimeFactService.getInstance().registerAuth(auth);
   }
   return "pong";
 }
 
+// src/rpc/handler/getAppListHandler.ts
+async function getAppListHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
+  return await MultiUserRuntimeFactService.getInstance().getAppList(auth);
+}
+
 // src/rpc/utils/errors.ts
 var RpcError = class extends Error {
   constructor(code, message, field, details) {
@@ -26965,16 +28023,6 @@ var RpcError = class extends Error {
 };
 
 // src/rpc/utils/validation.ts
-function validateApiKey(apiKey) {
-  if (!apiKey) {
-    throw new RpcError(
-      "MISSING_API_KEY" /* MISSING_API_KEY */,
-      "API key is required",
-      "apiKey"
-    );
-  }
-  return apiKey;
-}
 function validateRequiredParams(params, requiredFields) {
   if (!params) {
     throw new RpcError(
@@ -26994,30 +28042,28 @@ function validateRequiredParams(params, requiredFields) {
   }
 }
 
-// src/rpc/handler/getAppListHandler.ts
-async function getAppListHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
-  return await MultiUserRuntimeFactService.getInstance().getAppList(validatedApiKey);
-}
-
 // src/rpc/handler/getRuntimeEventsHandler.ts
-async function getRuntimeEventsHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
+async function getRuntimeEventsHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
   const { projectId } = params;
   validateRequiredParams({ projectId }, ["projectId"]);
   return await MultiUserRuntimeFactService.getInstance().getRuntimeEvents(
-    validatedApiKey,
+    auth,
     projectId
   );
 }
 
 // src/rpc/handler/getRuntimeFactsHandler.ts
-async function getRuntimeFactsHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
+async function getRuntimeFactsHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
   const { projectId, searchText, matchMode } = params;
   validateRequiredParams({ projectId }, ["projectId"]);
   return await MultiUserRuntimeFactService.getInstance().getRuntimeFacts(
-    validatedApiKey,
+    auth,
     projectId,
     searchText,
     matchMode
@@ -27035,11 +28081,13 @@ function formatTimestamp(timestampMilli) {
   const seconds = String(date.getSeconds()).padStart(2, "0");
   return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
 }
-async function searchDebugTracesHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
+async function searchDebugTracesHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
   const { projectId, query, limit: limit2 } = params;
   validateRequiredParams({ projectId, query }, ["projectId", "query"]);
-  const service = MultiUserRuntimeFactService.getInstance().getOrCreateService(validatedApiKey);
+  const service = await MultiUserRuntimeFactService.getInstance().getOrCreateService(auth);
   const results = await service.searchTraces(
     query,
     limit2,
@@ -27260,11 +28308,13 @@ _No SQL queries found._
 }
 
 // src/rpc/handler/getTraceInsightHandler.ts
-async function getTraceInsightHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
+async function getTraceInsightHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
   const { projectId, traceId } = params;
   validateRequiredParams({ projectId, traceId }, ["projectId", "traceId"]);
-  const service = MultiUserRuntimeFactService.getInstance().getOrCreateService(validatedApiKey);
+  const service = await MultiUserRuntimeFactService.getInstance().getOrCreateService(auth);
   const trace = await service.findTraceById(traceId, projectId);
   if (!trace) {
     throw new RpcError(
@@ -27518,11 +28568,13 @@ ${Array.from(new Set(allSqls)).join("\n")}
 }
 
 // src/rpc/handler/inspectMethodSnapshotHandler.ts
-async function inspectMethodSnapshotHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
+async function inspectMethodSnapshotHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
   const { projectId, traceId, className, methodName, includeSubCalls = true } = params;
   validateRequiredParams({ projectId, traceId }, ["projectId", "traceId"]);
-  const service = MultiUserRuntimeFactService.getInstance().getOrCreateService(validatedApiKey);
+  const service = await MultiUserRuntimeFactService.getInstance().getOrCreateService(auth);
   const trace = await service.findTraceById(traceId, projectId);
   if (!trace) return `Trace ${traceId} not found.`;
   if (!trace.invokeTree) {
@@ -27792,11 +28844,13 @@ function generateSuggestedFix(baseTrace, compareTrace) {
 }
 
 // src/rpc/handler/diffTraceExecutionHandler.ts
-async function diffTraceExecutionHandler(params, apiKey) {
-  const validatedApiKey = validateApiKey(apiKey);
+async function diffTraceExecutionHandler(params, auth) {
+  if (!auth) {
+    throw new Error("Authentication required");
+  }
   const { projectId, baseTraceId, compareTraceId } = params;
   validateRequiredParams({ projectId, baseTraceId }, ["projectId", "baseTraceId"]);
-  const service = MultiUserRuntimeFactService.getInstance().getOrCreateService(validatedApiKey);
+  const service = await MultiUserRuntimeFactService.getInstance().getOrCreateService(auth);
   const baseTrace = await service.findTraceById(baseTraceId, projectId);
   if (!baseTrace) return `Base trace ${baseTraceId} not found.`;
   let compareTrace;
@@ -28083,7 +29137,7 @@ async function main() {
     autoShutdownMinutes: config.server.autoShutdownMinutes,
     httpPort: config.server.httpPort
   });
-  MultiUserRuntimeFactService.getInstance().startGlobalPolling(config.service.pollingInterval);
+  MultiUserRuntimeFactService.getInstance().startGlobalPolling(config.service.pollingInterval, config.service.bindingCheckInterval);
   let server;
   if (config.server.mode === "remote") {
     server = await startServer2(serverConfig, config.server.httpPort);