@scriptdb/browser-client 1.0.8 → 1.1.0

package/README.md

@@ -193,6 +193,54 @@ const client = new ScriptDBClient('scriptdb://localhost:1234', options);
 await client.connect();
 ```
 
+## CLI Tool
+
+ScriptDB also provides a CLI tool for server management:
+
+```bash
+# Install CLI globally
+npm install -g @scriptdb/cli
+
+# Start server
+scriptdb start
+
+# Start server in background (daemon mode with PM2)
+scriptdb start -d
+
+# Check server status
+scriptdb status
+
+# View real-time logs
+scriptdb logs
+
+# Monitor performance
+scriptdb monit
+
+# Stop server
+scriptdb stop
+
+# Restart server
+scriptdb restart -d
+
+# Start interactive shell
+scriptdb shell
+```
+
+## Changelog
+
+### 1.1.0 (2025-01-16)
+
+**Added**
+- Native `scriptdb logs` command to view real-time logs
+- Native `scriptdb monit` command to monitor performance
+- Native `scriptdb restart` command to restart the server
+- Native `scriptdb stop` command to stop the server
+- ESLint configuration for TypeScript linting
+
+**Fixed**
+- Fixed TypeScript module resolution errors
+- Improved error handling and Windows compatibility
+
 ## License
 
 MIT

package/dist/index.js

@@ -5,417 +5,131 @@ var noopLogger = {
   warn: () => {},
   error: () => {}
 };
-async function createHmacSignature(message, secret, algorithm = "SHA-256") {
-  const encoder = new TextEncoder;
-  const keyData = encoder.encode(secret);
-  const messageData = encoder.encode(message);
-  const algoMap = {
-    sha256: "SHA-256",
-    sha384: "SHA-384",
-    sha512: "SHA-512",
-    "SHA-256": "SHA-256",
-    "SHA-384": "SHA-384",
-    "SHA-512": "SHA-512"
-  };
-  const cryptoAlgo = algoMap[algorithm] || "SHA-256";
-  const key = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: cryptoAlgo }, false, ["sign"]);
-  const signature = await crypto.subtle.sign("HMAC", key, messageData);
-  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
 
 class BrowserClient {
-  options;
   logger;
-  secure;
+  host;
+  port;
+  username;
+  password;
   requestTimeout;
-  retries;
-  retryDelay;
-  maxMessageSize;
-  uri = "";
-  protocolName = "";
-  username = null;
-  password = null;
-  host = "";
-  port = 0;
-  database = null;
+  secure;
   ws = null;
+  _connected = false;
   _nextId = 1;
   _pending = new Map;
-  _maxPending = 100;
-  _maxQueue = 1000;
-  _pendingQueue = [];
-  _connected = false;
-  _authenticating = false;
-  token = null;
-  _currentRetries = 0;
-  tokenExpiry = null;
-  _destroyed = false;
-  _reconnectTimer = null;
-  _authPendingId = null;
-  signing = null;
-  _stringify = JSON.stringify;
-  ready = Promise.resolve();
-  _resolveReadyFn = null;
-  _rejectReadyFn = null;
-  _connecting = null;
-  constructor(uri, options = {}) {
-    if (!uri || typeof uri !== "string")
-      throw new Error("uri required");
-    this.options = { ...options };
-    this.maxMessageSize = Number.isFinite(this.options.maxMessageSize) ? this.options.maxMessageSize : 5 * 1024 * 1024;
-    const rawLogger = this.options.logger || noopLogger;
-    this.logger = {
-      debug: (...args) => rawLogger.debug?.(...this._maskArgs(args)),
-      info: (...args) => rawLogger.info?.(...this._maskArgs(args)),
-      warn: (...args) => rawLogger.warn?.(...this._maskArgs(args)),
-      error: (...args) => rawLogger.error?.(...this._maskArgs(args))
-    };
-    this.secure = typeof this.options.secure === "boolean" ? this.options.secure : true;
-    if (!this.secure) {
-      this.logger.warn?.("Warning: connecting in insecure mode (secure=false). This is not recommended.");
-    }
-    this.requestTimeout = Number.isFinite(this.options.requestTimeout) ? this.options.requestTimeout : 0;
-    this.retries = Number.isFinite(this.options.retries) ? this.options.retries : 3;
-    this.retryDelay = Number.isFinite(this.options.retryDelay) ? this.options.retryDelay : 1000;
-    let parsed;
-    try {
-      parsed = new URL(uri);
-    } catch (e) {
-      throw new Error("Invalid uri");
-    }
-    if (parsed.protocol !== "scriptdb:") {
-      throw new Error("URI must use scriptdb:// protocol");
-    }
-    if (parsed.protocol !== "scriptdb:") {
-      throw new Error("URI must use scriptdb:// protocol");
-    }
-    this.uri = uri;
-    this.protocolName = parsed.protocol ? parsed.protocol.replace(":", "") : "scriptdb";
-    this.username = (typeof this.options.username === "string" ? this.options.username : decodeURIComponent(parsed.username)) || null;
-    this.password = (typeof this.options.password === "string" ? this.options.password : decodeURIComponent(parsed.password)) || null;
-    if (parsed.username && typeof this.options.username !== "string") {
-      this.logger.warn?.("Credentials found in URI — consider passing credentials via options instead of embedding in URI");
-    }
-    try {
-      parsed.username = "";
-      parsed.password = "";
-      this.uri = parsed.toString();
-    } catch (e) {
-      this.uri = uri;
-    }
-    this.host = parsed.hostname || "localhost";
-    this.port = parsed.port ? parseInt(parsed.port, 10) : 1234;
-    this.database = parsed.pathname && parsed.pathname.length > 1 ? parsed.pathname.slice(1) : null;
-    this._maxPending = Number.isFinite(this.options.maxPending) ? this.options.maxPending : 100;
-    this._maxQueue = Number.isFinite(this.options.maxQueue) ? this.options.maxQueue : 1000;
-    this.signing = this.options.signing && this.options.signing.secret ? this.options.signing : null;
-    this._stringify = typeof this.options.stringify === "function" ? this.options.stringify : JSON.stringify;
-    this._createReady();
-  }
-  _mask(obj) {
-    try {
-      if (!obj || typeof obj !== "object")
-        return obj;
-      const copy = Array.isArray(obj) ? [...obj] : { ...obj };
-      if (copy.token)
-        copy.token = "****";
-      if (copy.password)
-        copy.password = "****";
-      if (copy.data?.password)
-        copy.data.password = "****";
-      return copy;
-    } catch (e) {
-      return obj;
-    }
-  }
-  _maskArgs(args) {
-    return args.map((a) => {
-      if (!a || typeof a === "string")
-        return a;
-      return this._mask(a);
-    });
-  }
-  _createReady() {
-    this.ready = new Promise((resolve, reject) => {
-      this._resolveReadyFn = resolve;
-      this._rejectReadyFn = reject;
-    });
-  }
-  _resolveReady(value) {
-    if (this._resolveReadyFn) {
-      try {
-        this._resolveReadyFn(value);
-      } catch (e) {}
-      this._resolveReadyFn = null;
-      this._rejectReadyFn = null;
-    }
-  }
-  _rejectReady(err) {
-    if (this._rejectReadyFn) {
-      const rejectFn = this._rejectReadyFn;
-      this._resolveReadyFn = null;
-      this._rejectReadyFn = null;
-      setTimeout(() => {
-        try {
-          rejectFn(err);
-        } catch (e) {}
-      }, 0);
-    }
+  constructor(options) {
+    this.logger = options.logger || noopLogger;
+    this.host = options.host || "localhost";
+    this.port = options.port || 1234;
+    this.username = options.username || null;
+    this.password = options.password || null;
+    this.requestTimeout = Number.isFinite(options.requestTimeout) ? options.requestTimeout : 120000;
+    this.secure = options.secure !== undefined ? options.secure : false;
   }
   get connected() {
     return this._connected;
   }
-  connect() {
-    if (this._connecting)
-      return this._connecting;
-    this._connecting = new Promise((resolve, reject) => {
+  async connect() {
+    return new Promise((resolve, reject) => {
       const wsPort = this.port + 1;
-      const wsProtocol = this.secure ? "wss" : "ws";
-      const wsUrl = `${wsProtocol}://${this.host}:${wsPort}`;
+      const wsUrl = `ws://${this.host}:${wsPort}`;
       this.logger.info?.("Connecting to", wsUrl);
       try {
         this.ws = new WebSocket(wsUrl);
       } catch (e) {
         const error = e;
         this.logger.error?.("Connection failed", error.message);
-        this._rejectReady(error);
-        this._createReady();
-        this._connecting = null;
         return reject(error);
       }
-      this.ws.onopen = () => {
-        this.logger.info?.("Connected to server");
+      this.ws.onopen = async () => {
+        console.log("WebSocket onopen - browserClient.ts");
+        this.logger.info?.("WebSocket connected");
         this._connected = true;
-        this._currentRetries = 0;
         this._setupListeners();
-        this.authenticate().then(() => {
-          this._processQueue();
+        try {
+          console.log("Sending login request with credentials:", { username: this.username || "", hasPassword: !!this.password, secure: this.secure });
+          await this.sendRequest("login", {
+            username: this.username || "",
+            password: this.password || "",
+            secure: this.secure
+          });
+          console.log("Authenticated successfully");
+          this.logger.info?.("Authenticated successfully");
           resolve(this);
-        }).catch((err) => {
+        } catch (err) {
+          console.error("Login failed:", err);
           reject(err);
-        });
+        }
       };
-      this.ws.onerror = (event) => {
-        this.logger.error?.("WebSocket error:", event);
-        this._handleDisconnect(new Error("WebSocket error"));
+      this.ws.onerror = (error) => {
+        console.error("WebSocket onerror:", error);
+        this.logger.error?.("WebSocket error:", error);
+        reject(new Error("WebSocket connection failed"));
       };
-      this.ws.onclose = (event) => {
-        this.logger.info?.("WebSocket closed", event.code, event.reason);
-        this._handleDisconnect(null);
+      this.ws.onclose = () => {
+        console.log("WebSocket onclose");
+        this.logger.info?.("WebSocket disconnected");
+        this._connected = false;
+        this._cleanup();
       };
-    }).catch((err) => {
-      this._connecting = null;
-      throw err;
     });
-    return this._connecting;
   }
   _setupListeners() {
     if (!this.ws)
       return;
     this.ws.onmessage = (event) => {
-      if (typeof event.data === "string" && event.data.length > this.maxMessageSize) {
-        this.logger.error?.("Incoming message exceeds maxMessageSize — ignoring");
-        return;
-      }
+      console.log("WebSocket onmessage fired - browserClient.ts", event.data);
       try {
         const msg = JSON.parse(event.data);
-        if (!msg || typeof msg !== "object")
-          return;
-        const validSchema = (typeof msg.id === "undefined" || typeof msg.id === "number") && (typeof msg.action === "string" || typeof msg.action === "undefined") && (typeof msg.command === "string" || typeof msg.command === "undefined") && (typeof msg.message === "string" || typeof msg.message === "undefined") && (typeof msg.data === "object" || typeof msg.data === "undefined" || msg.data === null);
-        if (!validSchema) {
-          this.logger.warn?.("Message failed schema validation — ignoring");
-          return;
-        }
+        console.log("Parsed message:", msg);
         this._handleMessage(msg);
       } catch (error) {
+        console.error("Failed to parse message:", error, event.data);
         this.logger.error?.("Failed to parse message:", error);
       }
     };
   }
   _handleMessage(msg) {
-    if (!msg || typeof msg !== "object")
+    console.log("_handleMessage called with:", msg);
+    if (!msg || typeof msg !== "object") {
+      console.log("Invalid message - not an object");
       return;
+    }
     this.logger.debug?.("Received message:", msg);
     if (typeof msg.id !== "undefined") {
+      console.log("Message has id:", msg.id);
       const pending = this._pending.get(msg.id);
+      console.log("Pending request found:", !!pending, "total pending:", this._pending.size);
       if (!pending) {
         this.logger.debug?.("No pending request for id", msg.id);
+        console.log("No pending request for id", msg.id);
         return;
       }
       const { resolve, reject, timer } = pending;
       if (timer)
         clearTimeout(timer);
       this._pending.delete(msg.id);
-      this._processQueue();
-      if (msg.action === "login" || msg.command === "login") {
-        if (msg.message === "AUTH OK") {
-          this.token = msg.data?.token || null;
-          this._resolveReady(null);
-          return resolve(msg.data);
-        } else {
-          this._rejectReady(new Error("Authentication failed"));
-          const errorMsg = msg.data || "Authentication failed";
-          try {
-            this.ws?.close();
-          } catch (e) {}
-          return reject(new Error(typeof errorMsg === "string" ? errorMsg : "Authentication failed"));
-        }
-      }
-      if ((msg.action === "script-code" || msg.command === "script-code") && msg.message === "OK") {
-        return resolve(msg.data);
-      }
-      if ((msg.action === "script-code" || msg.command === "script-code") && msg.message === "ERROR") {
-        return reject(new Error(typeof msg.data === "string" ? msg.data : "Server returned ERROR"));
-      }
-      if (msg.action === "create-db" && msg.message === "SUCCESS") {
-        return resolve(msg.data);
-      }
-      if (msg.action === "create-db" && msg.message === "ERROR") {
-        return reject(new Error(typeof msg.data === "string" ? msg.data : "Failed to create database"));
-      }
-      if (msg.message === "OK" || msg.message === "SUCCESS") {
-        return resolve(msg.data);
-      } else if (msg.message === "ERROR" || msg.message === "AUTH FAIL" || msg.message === "AUTH FAILED") {
+      console.log("Resolving request with message:", msg.message, "data:", msg.data);
+      if (msg.message === "ERROR" || msg.message === "AUTH FAILED" || msg.message === "AUTH FAIL") {
         return reject(new Error(typeof msg.data === "string" ? msg.data : "Request failed"));
       }
-      return reject(new Error("Invalid response from server"));
-    }
-    this.logger.debug?.("Unhandled message from server", this._mask(msg));
-  }
-  async _buildFinalMessage(payloadBase, id) {
-    const payloadObj = {
-      id,
-      action: payloadBase.action,
-      ...payloadBase.data !== undefined ? { data: payloadBase.data } : {}
-    };
-    if (this.token)
-      payloadObj.token = this.token;
-    const payloadStr = this._stringify(payloadObj);
-    if (this.signing && this.signing.secret) {
-      const sig = await createHmacSignature(payloadStr, this.signing.secret, this.signing.algorithm || "sha256");
-      const envelope = { id, signature: sig, payload: payloadObj };
-      return this._stringify(envelope);
-    }
-    return payloadStr;
-  }
-  authenticate() {
-    if (this._authenticating) {
-      return Promise.reject(new Error("Already authenticating"));
-    }
-    this._authenticating = true;
-    return new Promise((resolve, reject) => {
-      const id = this._nextId++;
-      this._authPendingId = id;
-      const payload = {
-        id,
-        action: "login",
-        data: { username: this.username, password: this.password }
-      };
-      let timer = null;
-      if (this.requestTimeout > 0) {
-        timer = window.setTimeout(() => {
-          this._pending.delete(id);
-          this._authenticating = false;
-          this._authPendingId = null;
-          reject(new Error("Auth timeout"));
-          this.close();
-        }, this.requestTimeout);
-      }
-      this._pending.set(id, {
-        resolve: (data) => {
-          if (timer)
-            clearTimeout(timer);
-          this._authenticating = false;
-          this._authPendingId = null;
-          if (data?.token)
-            this.token = data.token;
-          resolve(data);
-        },
-        reject: (err) => {
-          if (timer)
-            clearTimeout(timer);
-          this._authenticating = false;
-          this._authPendingId = null;
-          reject(err);
-        },
-        timer
-      });
-      try {
-        this.ws?.send(JSON.stringify(payload));
-      } catch (e) {
-        if (timer)
-          clearTimeout(timer);
-        this._pending.delete(id);
-        this._authenticating = false;
-        this._authPendingId = null;
-        reject(e);
-      }
-    }).then((data) => {
-      if (data?.token) {
-        this.token = data.token;
-        this._resolveReady(null);
-      }
-      return data;
-    }).catch((err) => {
-      this._rejectReady(err);
-      throw err;
-    });
-  }
-  async _processQueue() {
-    while (this._pending.size < this._maxPending && this._pendingQueue.length > 0) {
-      const item = this._pendingQueue.shift();
-      const { payloadBase, id, resolve, reject, timer } = item;
-      if (this.tokenExpiry && Date.now() >= this.tokenExpiry) {
-        const refreshed = await this._maybeRefreshToken();
-        if (!refreshed) {
-          if (timer)
-            clearTimeout(timer);
-          try {
-            reject(new Error("Token expired and refresh failed"));
-          } catch (e) {}
-          continue;
-        }
-      }
-      let messageStr;
-      try {
-        messageStr = await this._buildFinalMessage(payloadBase, id);
-      } catch (e) {
-        if (timer)
-          clearTimeout(timer);
-        try {
-          reject(e);
-        } catch (er) {}
-        continue;
-      }
-      this._pending.set(id, { resolve, reject, timer });
-      try {
-        this.ws?.send(messageStr);
-      } catch (e) {
-        if (timer)
-          clearTimeout(timer);
-        this._pending.delete(id);
-        try {
-          reject(e);
-        } catch (er) {}
+      if (msg.message === "AUTH OK" || msg.message === "OK" || msg.message === "SUCCESS") {
+        console.log("Calling resolve with data:", msg.data);
+        return resolve(msg.data);
       }
+      console.log("Default resolve with data:", msg.data);
+      return resolve(msg.data);
     }
+    console.log("Message has no id, ignoring");
   }
-  async execute(payload) {
-    try {
-      await this.ready;
-    } catch (err) {
-      throw new Error("Not authenticated: " + (err?.message || err));
+  async sendRequest(action, data = {}) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected");
     }
-    if (!this.token)
-      throw new Error("Not authenticated");
     const id = this._nextId++;
-    const payloadBase = { action: payload.action, data: payload.data };
-    if (this.tokenExpiry && Date.now() >= this.tokenExpiry) {
-      const refreshed = await this._maybeRefreshToken();
-      if (!refreshed)
-        throw new Error("Token expired");
-    }
-    return new Promise(async (resolve, reject) => {
+    const request = { id, action, data };
+    return new Promise((resolve, reject) => {
       let timer = null;
       if (this.requestTimeout > 0) {
         timer = window.setTimeout(() => {
@@ -425,27 +139,9 @@ class BrowserClient {
           }
         }, this.requestTimeout);
       }
-      if (this._pending.size >= this._maxPending) {
-        if (this._pendingQueue.length >= this._maxQueue) {
-          if (timer)
-            clearTimeout(timer);
-          return reject(new Error("Pending queue full"));
-        }
-        this._pendingQueue.push({ payloadBase, id, resolve, reject, timer });
-        this._processQueue().catch(() => {});
-        return;
-      }
-      let messageStr;
-      try {
-        messageStr = await this._buildFinalMessage(payloadBase, id);
-      } catch (e) {
-        if (timer)
-          clearTimeout(timer);
-        return reject(e);
-      }
       this._pending.set(id, { resolve, reject, timer });
       try {
-        this.ws?.send(messageStr);
+        this.ws?.send(JSON.stringify(request));
       } catch (e) {
         if (timer)
           clearTimeout(timer);
@@ -454,69 +150,15 @@ class BrowserClient {
       }
     });
   }
-  async sendRequest(action, data = {}) {
-    return this.execute({ action, data });
-  }
-  async _maybeRefreshToken() {
-    if (!this.options.tokenRefresh || typeof this.options.tokenRefresh !== "function") {
-      return false;
-    }
-    try {
-      const res = await this.options.tokenRefresh();
-      if (res?.token) {
-        this.token = res.token;
-        if (res.expiresAt)
-          this.tokenExpiry = res.expiresAt;
-        return true;
-      }
-    } catch (e) {
-      this.logger.error?.("Token refresh failed", e?.message || String(e));
-    }
-    return false;
-  }
-  _handleDisconnect(err) {
-    if (!this._connected && !this._authenticating)
-      return;
-    const wasAuthenticating = this._authenticating;
-    this._pending.forEach((pending, id) => {
+  _cleanup() {
+    this._pending.forEach((pending) => {
       if (pending.timer)
         clearTimeout(pending.timer);
-      const errorMsg = wasAuthenticating ? "Authentication failed - credentials may be required" : err?.message || "Disconnected";
-      setTimeout(() => {
-        try {
-          pending.reject(new Error(errorMsg));
-        } catch (e) {}
-      }, 0);
-      this._pending.delete(id);
-    });
-    this._connected = false;
-    this._connecting = null;
-    this._authenticating = false;
-    if (wasAuthenticating && this.retries === 0) {
-      const rejectErr = err || new Error("Authentication failed and no retries configured");
-      try {
-        this._rejectReady(rejectErr);
-      } catch (e) {}
-      return;
-    }
-    if (this._currentRetries < this.retries && !this._destroyed) {
-      this._createReady();
-      const base = Math.min(this.retryDelay * Math.pow(2, this._currentRetries), 30000);
-      const jitter = Math.floor(Math.random() * Math.min(1000, base));
-      const delay = base + jitter;
-      this._currentRetries += 1;
-      this.logger.info?.(`Attempting reconnect in ${delay}ms (attempt ${this._currentRetries})`);
-      this.token = null;
-      this._reconnectTimer = window.setTimeout(() => {
-        this.connect().catch((e) => {
-          this.logger.error?.("Reconnect failed", e?.message || e);
-        });
-      }, delay);
-    } else {
       try {
-        this._rejectReady(err || new Error("Disconnected and no retries left"));
+        pending.reject(new Error("Disconnected"));
       } catch (e) {}
-    }
+    });
+    this._pending.clear();
   }
   close() {
     if (this.ws) {
@@ -525,37 +167,8 @@ class BrowserClient {
       } catch (e) {}
       this.ws = null;
     }
-    this._connected = false;
     this._cleanup();
   }
-  destroy() {
-    this._destroyed = true;
-    if (this._reconnectTimer) {
-      clearTimeout(this._reconnectTimer);
-      this._reconnectTimer = null;
-    }
-    this._rejectReady(new Error("Client destroyed"));
-    this._pending.forEach((pending, id) => {
-      if (pending.timer)
-        clearTimeout(pending.timer);
-      try {
-        pending.reject(new Error("Client destroyed"));
-      } catch (e) {}
-      this._pending.delete(id);
-    });
-    this._pendingQueue = [];
-    this.close();
-  }
-  _cleanup() {
-    this._pending.forEach((pending) => {
-      if (pending.timer)
-        clearTimeout(pending.timer);
-      try {
-        pending.reject(new Error("Disconnected"));
-      } catch (e) {}
-    });
-    this._pending.clear();
-  }
   async disconnect() {
     this.close();
   }
@@ -596,6 +209,5 @@ class BrowserClient {
 var src_default = BrowserClient;
 export {
   src_default as default,
-  BrowserClient as ScriptDBClient,
   BrowserClient
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scriptdb/browser-client",
-  "version": "1.0.8",
-  "description": "Client module resolver for script database",
+  "version": "1.1.0",
+  "description": "Browser WebSocket client for ScriptDB",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -17,33 +17,15 @@
   ],
   "scripts": {
     "dev": "bun --watch src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --splitting --external bcryptjs --external bottleneck --external jsonwebtoken --external lru-cache",
-    "build:cjs": "bun build src/index.ts --outdir dist --target node --format cjs --outfile dist/index.js --external bcryptjs --external bottleneck --external jsonwebtoken --external lru-cache",
+    "build": "bun build src/index.ts --outdir dist --target browser --format esm --splitting",
+    "build:cjs": "bun build src/index.ts --outdir dist --target browser --format cjs --outfile dist/index.js",
     "build:types": "tsc --emitDeclarationOnly",
     "build:all": "bun run build && bun run build:cjs && bun run build:types",
-    "test": "bun test",
-    "lint": "bun run lint:src",
-    "lint:src": "eslint src --ext .ts,.tsx",
-    "lint:fix": "eslint src --ext .ts,.tsx --fix",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
   "devDependencies": {
-    "@types/bcryptjs": "^3.0.0",
-    "@types/bun": "^1.3.2",
-    "@types/jsonwebtoken": "^9.0.10",
-    "@types/lru-cache": "^7.10.10",
-    "@types/node": "^24.10.1",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "bun-types": "latest",
-    "eslint": "^8.0.0",
-    "typescript": "^5.0.0"
-  },
-  "dependencies": {
-    "bcryptjs": "^3.0.3",
-    "bottleneck": "^2.19.5",
-    "jsonwebtoken": "^9.0.2",
-    "lru-cache": "^11.2.2"
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.3"
   }
-}
+}