@scriptdb/client 1.0.9 → 1.1.1

package/dist/index.mjs

@@ -0,0 +1,837 @@
+// src/index.ts
+import * as net from "net";
+import * as tls from "tls";
+import { URL } from "url";
+import * as crypto from "crypto";
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  }
+};
+var ScriptDBClient = class {
+  /**
+   * Create a new client. Do NOT auto-connect in constructor — call connect()
+   * @param uri - Connection URI
+   * @param options - Client options
+   * @param options.secure - use TLS
+   * @param options.logger - { debug, info, warn, error }
+   * @param options.requestTimeout - Request timeout in ms
+   * @param options.retries - Reconnection retries
+   * @param options.retryDelay - Initial retry delay in ms
+   * @param options.tlsOptions - Passed to tls.connect when secure
+   */
+  constructor(uri, options = {}) {
+    this.socketTimeout = 0;
+    this.maxMessageSize = 0;
+    this._mask = () => {
+    };
+    this._maskArgs = () => [];
+    this.logger = {};
+    this.secure = true;
+    this.requestTimeout = 0;
+    this.retries = 0;
+    this.retryDelay = 0;
+    this.frame = "ndjson";
+    this.uri = "";
+    this.protocolName = "";
+    this.username = null;
+    this.password = null;
+    this.host = "";
+    this.port = 0;
+    this.database = null;
+    this.client = null;
+    this.buffer = Buffer.alloc(0);
+    this._nextId = 1;
+    this._pending = /* @__PURE__ */ new Map();
+    this._maxPending = 0;
+    this._maxQueue = 0;
+    this._pendingQueue = [];
+    this._connected = false;
+    this._authenticating = false;
+    this.token = null;
+    this._currentRetries = 0;
+    this.tokenExpiry = null;
+    this._destroyed = false;
+    this._reconnectTimer = null;
+    this.signing = null;
+    this._stringify = JSON.stringify;
+    this.ready = Promise.resolve();
+    this._resolveReadyFn = null;
+    this._rejectReadyFn = null;
+    this._connecting = null;
+    this._authPendingId = null;
+    if (!uri || typeof uri !== "string") throw new Error("uri required");
+    this.options = Object.assign({}, options);
+    this.socketTimeout = Number.isFinite(this.options.socketTimeout) ? this.options.socketTimeout : 0;
+    this.maxMessageSize = Number.isFinite(this.options.maxMessageSize) ? this.options.maxMessageSize : 5 * 1024 * 1024;
+    this._mask = (obj) => {
+      try {
+        if (!obj || typeof obj !== "object") return obj;
+        const copy = Array.isArray(obj) ? obj.slice() : Object.assign({}, obj);
+        if (copy.token) copy.token = "****";
+        if (copy.password) copy.password = "****";
+        if (copy.data && copy.data.password) copy.data.password = "****";
+        return copy;
+      } catch (e) {
+        return obj;
+      }
+    };
+    const rawLogger = this.options.logger && typeof this.options.logger === "object" ? this.options.logger : noopLogger;
+    this._maskArgs = (args) => {
+      return args.map((a) => {
+        if (!a) return a;
+        if (typeof a === "string") return a;
+        return this._mask(a);
+      });
+    };
+    this.logger = {
+      debug: (...args) => rawLogger.debug && rawLogger.debug(...this._maskArgs(args)),
+      info: (...args) => rawLogger.info && rawLogger.info(...this._maskArgs(args)),
+      warn: (...args) => rawLogger.warn && rawLogger.warn(...this._maskArgs(args)),
+      error: (...args) => rawLogger.error && 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 : 1e3;
+    this.frame = this.options.frame === "length-prefix" || this.options.preferLengthPrefix ? "length-prefix" : "ndjson";
+    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");
+    }
+    this.uri = uri;
+    this.protocolName = parsed.protocol ? parsed.protocol.replace(":", "") : "scriptdb";
+    this.username = (typeof this.options.username === "string" ? this.options.username : parsed.username) || null;
+    this.password = (typeof this.options.password === "string" ? this.options.password : parsed.password) || null;
+    if (parsed.username && !(typeof this.options.username === "string")) {
+      this.logger.warn?.(
+        "Credentials found in URI \u2014 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.client = null;
+    this.buffer = Buffer.alloc(0);
+    this._nextId = 1;
+    this._pending = /* @__PURE__ */ new Map();
+    this._maxPending = Number.isFinite(this.options.maxPending) ? this.options.maxPending : 100;
+    this._maxQueue = Number.isFinite(this.options.maxQueue) ? this.options.maxQueue : 1e3;
+    this._pendingQueue = [];
+    this._connected = false;
+    this._authenticating = false;
+    this.token = null;
+    this._currentRetries = 0;
+    this.tokenExpiry = null;
+    this._destroyed = false;
+    this._reconnectTimer = null;
+    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();
+  }
+  _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;
+      process.nextTick(() => {
+        try {
+          rejectFn(err);
+        } catch (e) {
+        }
+      });
+    }
+  }
+  /**
+   * Check if connected
+   */
+  get connected() {
+    return this._connected;
+  }
+  /**
+   * Connect to server and authenticate. Returns a Promise that resolves when authenticated.
+   */
+  connect() {
+    if (this._connecting) return this._connecting;
+    this._connecting = new Promise((resolve, reject) => {
+      const opts = { host: this.host, port: this.port };
+      const onConnect = () => {
+        console.log("ScriptDBClient: Connected to server at", opts.host, opts.port);
+        this.logger?.info?.("Connected to server");
+        this._connected = true;
+        this._currentRetries = 0;
+        console.log("ScriptDBClient: Setting up listeners...");
+        this._setupListeners();
+        console.log("ScriptDBClient: Authenticating...");
+        this.authenticate().then(() => {
+          this._processQueue();
+          resolve(this);
+        }).catch((err) => {
+          reject(err);
+        });
+      };
+      try {
+        if (this.secure) {
+          const connectionOpts = { host: opts.host, port: opts.port };
+          const tlsOptions = Object.assign(
+            {},
+            this.options.tlsOptions || {},
+            connectionOpts
+          );
+          if (typeof tlsOptions.rejectUnauthorized === "undefined")
+            tlsOptions.rejectUnauthorized = true;
+          this.client = tls.connect(tlsOptions, onConnect);
+        } else {
+          this.client = net.createConnection(opts, onConnect);
+        }
+      } catch (e) {
+        const error = e;
+        this.logger?.error?.("Connection failed", error.message);
+        this._rejectReady(error);
+        this._createReady();
+        this._connecting = null;
+        return reject(error);
+      }
+      if (!this.client) {
+        const error = new Error("Failed to create client socket");
+        this.logger?.error?.("Connection failed", error.message);
+        this._connecting = null;
+        return reject(error);
+      }
+      const onError = (err) => {
+        this.logger?.error?.(
+          "Client socket error:",
+          err && err.message ? err.message : err
+        );
+        this._handleDisconnect(err);
+      };
+      const onClose = (hadError) => {
+        this.logger?.info?.("Server closed connection");
+        this._handleDisconnect(null);
+      };
+      this.client.on("error", onError);
+      this.client.on("close", onClose);
+      if (this.socketTimeout > 0 && this.client) {
+        this.client.setTimeout(this.socketTimeout);
+        this.client.on("timeout", () => {
+          this.logger?.warn?.("Socket timeout, destroying connection");
+          try {
+            this.client?.destroy();
+          } catch (e) {
+          }
+        });
+      }
+    }).catch((err) => {
+      this._connecting = null;
+      throw err;
+    });
+    return this._connecting;
+  }
+  _setupListeners() {
+    if (!this.client) return;
+    console.log("ScriptDBClient _setupListeners: called, client exists:", !!this.client);
+    this.client.removeAllListeners("data");
+    this.buffer = Buffer.alloc(0);
+    console.log("ScriptDBClient _setupListeners: frame mode:", this.frame);
+    if (this.frame === "length-prefix") {
+      this.client.on("data", (chunk) => {
+        if (!Buffer.isBuffer(chunk)) {
+          try {
+            chunk = Buffer.from(chunk);
+          } catch (e) {
+            return;
+          }
+        }
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 4) {
+          const len = this.buffer.readUInt32BE(0);
+          if (len > this.maxMessageSize) {
+            this.logger?.error?.(
+              "Incoming length-prefixed frame exceeds maxMessageSize \u2014 closing connection"
+            );
+            try {
+              this.client?.destroy();
+            } catch (e) {
+            }
+            return;
+          }
+          if (this.buffer.length < 4 + len) break;
+          const payload = this.buffer.slice(4, 4 + len);
+          this.buffer = this.buffer.slice(4 + len);
+          let msg;
+          try {
+            msg = JSON.parse(payload.toString("utf8"));
+          } catch (e) {
+            this.logger?.error?.(
+              "Invalid JSON frame",
+              e && e.message ? e.message : e
+            );
+            continue;
+          }
+          if (!msg || typeof msg !== "object") continue;
+          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 \u2014 ignoring");
+            continue;
+          }
+          this._handleMessage(msg);
+        }
+      });
+    } else {
+      console.log("ScriptDBClient _setupListeners: Setting up NDJSON data listener");
+      this.client.on("data", (chunk) => {
+        console.log("ScriptDBClient: Received data chunk, length:", chunk.length);
+        if (!Buffer.isBuffer(chunk)) {
+          try {
+            chunk = Buffer.from(chunk);
+          } catch (e) {
+            return;
+          }
+        }
+        const idxLastNewline = chunk.indexOf(10);
+        if (this.buffer.length === 0 && idxLastNewline === chunk.length - 1) {
+          let start = 0;
+          let idx2;
+          while ((idx2 = chunk.indexOf(10, start)) !== -1) {
+            const lineBuf = chunk.slice(start, idx2);
+            start = idx2 + 1;
+            if (lineBuf.length === 0) continue;
+            let msg;
+            try {
+              msg = JSON.parse(lineBuf.toString("utf8"));
+            } catch (e) {
+              this.logger?.error?.(
+                "Invalid JSON from server",
+                e && e.message ? e.message : e
+              );
+              continue;
+            }
+            if (!msg || typeof msg !== "object") continue;
+            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");
+            if (!validSchema) continue;
+            this._handleMessage(msg);
+          }
+          return;
+        }
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        if (this.buffer.length > this.maxMessageSize) {
+          this.logger?.error?.(
+            "Incoming message exceeds maxMessageSize \u2014 closing connection"
+          );
+          try {
+            this.client?.destroy();
+          } catch (e) {
+          }
+          return;
+        }
+        let idx;
+        while ((idx = this.buffer.indexOf(10)) !== -1) {
+          const lineBuf = this.buffer.slice(0, idx);
+          this.buffer = this.buffer.slice(idx + 1);
+          if (lineBuf.length === 0) continue;
+          let msg;
+          try {
+            msg = JSON.parse(lineBuf.toString("utf8"));
+          } catch (e) {
+            this.logger?.error?.(
+              "Invalid JSON from server",
+              e && e.message ? e.message : e
+            );
+            continue;
+          }
+          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");
+          if (!validSchema) {
+            this.logger?.warn?.("Message failed schema validation \u2014 ignoring");
+            continue;
+          }
+          this._handleMessage(msg);
+        }
+      });
+    }
+  }
+  // build the final buffer for sending using current token and signing settings
+  _buildFinalBuffer(payloadBase, id) {
+    const payloadObj = Object.assign(
+      { id, action: payloadBase.action },
+      payloadBase.data !== void 0 ? { data: payloadBase.data } : {}
+    );
+    if (this.token) payloadObj.token = this.token;
+    const payloadStr = this._stringify(payloadObj);
+    if (this.signing && this.signing.secret) {
+      const hmac = crypto.createHmac(
+        this.signing.algorithm || "sha256",
+        this.signing.secret
+      );
+      hmac.update(payloadStr);
+      const sig = hmac.digest("hex");
+      const envelope = { id, signature: sig, payload: payloadObj };
+      const envelopeStr = this._stringify(envelope);
+      if (this.frame === "length-prefix") {
+        const body = Buffer.from(envelopeStr, "utf8");
+        const buf = Buffer.allocUnsafe(4 + body.length);
+        buf.writeUInt32BE(body.length, 0);
+        body.copy(buf, 4);
+        return buf;
+      }
+      return Buffer.from(envelopeStr + "\n", "utf8");
+    }
+    if (this.frame === "length-prefix") {
+      const body = Buffer.from(payloadStr, "utf8");
+      const buf = Buffer.allocUnsafe(4 + body.length);
+      buf.writeUInt32BE(body.length, 0);
+      body.copy(buf, 4);
+      return buf;
+    }
+    return Buffer.from(payloadStr + "\n", "utf8");
+  }
+  _handleMessage(msg) {
+    console.log("ScriptDBClient _handleMessage:", JSON.stringify(msg));
+    console.log("ScriptDBClient _handleMessage msg.id:", msg.id, "msg.action:", msg.action, "msg.command:", msg.command, "msg.message:", msg.message);
+    if (msg && typeof msg.id !== "undefined") {
+      console.log("Handling message with id:", msg.id, "action:", msg.action, "message:", msg.message);
+      const pending = this._pending.get(msg.id);
+      if (!pending) {
+        console.log("No pending request for id", msg.id, "pending map size:", this._pending.size);
+        this.logger?.debug?.("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") {
+        console.log("Processing login response with id");
+        if (msg.message === "AUTH OK") {
+          console.log("AUTH OK - setting token and resolving");
+          this.token = msg.data && msg.data.token ? msg.data.token : null;
+          this._resolveReady(null);
+          return resolve(msg.data);
+        } else {
+          console.log("AUTH FAILED:", msg.data);
+          this._rejectReady(new Error("Authentication failed"));
+          const errorMsg = msg.data || "Authentication failed";
+          try {
+            this.client?.end();
+          } 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") {
+        return reject(new Error(typeof msg.data === "string" ? msg.data : "Request failed"));
+      }
+      return reject(new Error("Invalid response from server"));
+    }
+    console.log("Unhandled message:", msg);
+    this.logger?.debug?.("Unhandled message from server", this._mask(msg));
+  }
+  authenticate() {
+    if (this._authenticating)
+      return Promise.reject(new Error("Already authenticating"));
+    this._authenticating = true;
+    return new Promise((resolve, reject) => {
+      const id = this._nextId++;
+      const payload = {
+        id,
+        action: "login",
+        data: { username: this.username, password: this.password }
+      };
+      let timer = null;
+      if (this.requestTimeout > 0) {
+        timer = setTimeout(() => {
+          this._pending.delete(id);
+          this._authenticating = false;
+          reject(new Error("Auth timeout"));
+          this.close();
+        }, this.requestTimeout);
+      }
+      this._pending.set(id, {
+        resolve: (data) => {
+          if (timer) clearTimeout(timer);
+          this._authenticating = false;
+          if (data && data.token) this.token = data.token;
+          resolve(data);
+        },
+        reject: (err) => {
+          if (timer) clearTimeout(timer);
+          this._authenticating = false;
+          reject(err);
+        },
+        timer
+      });
+      try {
+        const buf = Buffer.from(JSON.stringify(payload) + "\n", "utf8");
+        this._write(buf).catch((err) => {
+          if (timer) clearTimeout(timer);
+          this._pending.delete(id);
+          this._authenticating = false;
+          reject(err);
+        });
+      } catch (e) {
+        clearTimeout(timer);
+        this._pending.delete(id);
+        this._authenticating = false;
+        reject(e);
+      }
+    }).then((data) => {
+      if (data && data.token) {
+        this.token = data.token;
+        this._resolveReady(null);
+      }
+      return data;
+    }).catch((err) => {
+      this._rejectReady(err);
+      throw err;
+    });
+  }
+  // internal write helper that respects backpressure
+  _write(buf) {
+    return new Promise((resolve, reject) => {
+      if (!this.client || !this._connected)
+        return reject(new Error("Not connected"));
+      try {
+        const ok = this.client.write(buf, (err) => {
+          if (err) return reject(err);
+          resolve(void 0);
+        });
+        if (!ok) {
+          this.client.once("drain", () => resolve(void 0));
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  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) {
+          clearTimeout(timer);
+          try {
+            reject(new Error("Token expired and refresh failed"));
+          } catch (e) {
+          }
+          continue;
+        }
+      }
+      let buf;
+      try {
+        buf = this._buildFinalBuffer(payloadBase, id);
+      } catch (e) {
+        clearTimeout(timer);
+        try {
+          reject(e);
+        } catch (er) {
+        }
+        continue;
+      }
+      this._pending.set(id, { resolve, reject, timer });
+      try {
+        await this._write(buf);
+      } catch (e) {
+        clearTimeout(timer);
+        this._pending.delete(id);
+        try {
+          reject(e);
+        } catch (er) {
+        }
+      }
+    }
+  }
+  /**
+   * Execute a command. Supports concurrent requests via request id mapping.
+   * Returns a Promise resolved with response.data or rejected on ERROR/timeout.
+   */
+  async execute(payload) {
+    try {
+      await this.ready;
+    } catch (err) {
+      throw new Error(
+        "Not authenticated: " + (err && err.message ? err.message : err)
+      );
+    }
+    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((resolve, reject) => {
+      let timer = null;
+      if (this.requestTimeout > 0) {
+        timer = setTimeout(() => {
+          if (this._pending.has(id)) {
+            this._pending.delete(id);
+            reject(new Error("Request timeout"));
+          }
+        }, 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 finalBuf;
+      try {
+        finalBuf = this._buildFinalBuffer(payloadBase, id);
+      } catch (e) {
+        clearTimeout(timer);
+        return reject(e);
+      }
+      this._pending.set(id, { resolve, reject, timer });
+      this._write(finalBuf).catch((e) => {
+        if (timer) clearTimeout(timer);
+        this._pending.delete(id);
+        reject(e);
+      });
+    });
+  }
+  /**
+   * Attempt to refresh token using provided tokenRefresh option if token expired.
+   * options.tokenRefresh should be async function that returns { token, expiresAt }
+   */
+  async _maybeRefreshToken() {
+    if (!this.options.tokenRefresh || typeof this.options.tokenRefresh !== "function")
+      return false;
+    try {
+      const res = await this.options.tokenRefresh();
+      if (res && res.token) {
+        this.token = res.token;
+        if (res.expiresAt) this.tokenExpiry = res.expiresAt;
+        return true;
+      }
+    } catch (e) {
+      this.logger?.error?.(
+        "Token refresh failed",
+        e && e.message ? e.message : String(e)
+      );
+    }
+    return false;
+  }
+  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 = [];
+    try {
+      if (this.client) this.client.destroy();
+    } catch (e) {
+    }
+    this.client = null;
+  }
+  _handleDisconnect(err) {
+    if (!this._connected && !this._authenticating) {
+      return;
+    }
+    const wasAuthenticating = this._authenticating;
+    this._pending.forEach((pending, id) => {
+      if (pending.timer) clearTimeout(pending.timer);
+      const errorMsg = wasAuthenticating ? "Authentication failed - credentials may be required" : err && err.message ? err.message : "Disconnected";
+      process.nextTick(() => {
+        try {
+          pending.reject(new Error(errorMsg));
+        } catch (e) {
+        }
+      });
+      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._createReady();
+      const base = Math.min(
+        this.retryDelay * Math.pow(2, this._currentRetries),
+        3e4
+      );
+      const jitter = Math.floor(Math.random() * Math.min(1e3, base));
+      const delay = base + jitter;
+      this._currentRetries += 1;
+      this.logger?.info?.(
+        "Attempting reconnect in " + delay + "ms (attempt " + this._currentRetries + ")"
+      );
+      this.token = null;
+      setTimeout(() => {
+        this.connect().catch((e) => {
+          this.logger?.error?.("Reconnect failed", e && e.message ? e.message : e);
+        });
+      }, delay);
+    } else {
+      try {
+        this._rejectReady(err || new Error("Disconnected and no retries left"));
+      } catch (e) {
+      }
+    }
+  }
+  close() {
+    if (!this.client) return;
+    try {
+      this.client.removeAllListeners("data");
+      this.client.removeAllListeners("error");
+      this.client.removeAllListeners("close");
+      this.client.end();
+    } catch (e) {
+    }
+    this.client = null;
+  }
+  /**
+   * Disconnect (alias for close)
+   */
+  disconnect() {
+    this.close();
+  }
+  /**
+   * Send request helper (for public API methods)
+   */
+  async sendRequest(action, data = {}) {
+    return this.execute({ action, data });
+  }
+  // ========== Public API Methods ==========
+  /**
+   * Login with username and password
+   */
+  async login(username, password) {
+    return this.sendRequest("login", { username, password });
+  }
+  /**
+   * Logout from server
+   */
+  async logout() {
+    return this.sendRequest("logout", {});
+  }
+  /**
+   * List all databases
+   */
+  async listDatabases() {
+    return this.sendRequest("list-dbs", {});
+  }
+  /**
+   * Create a new database
+   */
+  async createDatabase(name) {
+    return this.sendRequest("create-db", { databaseName: name });
+  }
+  /**
+   * Remove a database
+   */
+  async removeDatabase(name) {
+    return this.sendRequest("remove-db", { databaseName: name });
+  }
+  /**
+   * Rename a database
+   */
+  async renameDatabase(oldName, newName) {
+    return this.sendRequest("rename-db", { databaseName: oldName, newName });
+  }
+  /**
+   * Execute code in a database
+   */
+  async run(code, databaseName) {
+    return this.sendRequest("script-code", { code, databaseName });
+  }
+  /**
+   * Save a database to disk
+   */
+  async saveDatabase(databaseName) {
+    return this.sendRequest("save-db", { databaseName });
+  }
+  /**
+   * Update database metadata
+   */
+  async updateDatabase(databaseName, data) {
+    return this.sendRequest("update-db", { databaseName, ...data });
+  }
+  /**
+   * Get server information
+   */
+  async getInfo() {
+    return this.sendRequest("get-info", {});
+  }
+  /**
+   * Execute shell command on server
+   */
+  async executeShell(command) {
+    return this.sendRequest("shell-command", { command });
+  }
+};
+var index_default = ScriptDBClient;
+export {
+  ScriptDBClient,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map