@scriptdb/browser-client 1.0.4

package/README.md

@@ -0,0 +1,198 @@
+# @scriptdb/browser-client
+
+Browser-compatible WebSocket client for ScriptDB. Provides the same API as `@scriptdb/client` but uses WebSocket instead of TCP, making it suitable for browser environments.
+
+## Installation
+
+```bash
+npm install @scriptdb/browser-client
+# or
+bun add @scriptdb/browser-client
+```
+
+## Usage
+
+```typescript
+import { BrowserClient } from '@scriptdb/browser-client';
+
+// Create client with URI (same format as @scriptdb/client)
+const client = new BrowserClient('scriptdb://localhost:1234', {
+  username: 'user',
+  password: 'pass',
+  secure: false,        // Use ws:// instead of wss://
+  requestTimeout: 30000,
+  retries: 3,
+});
+
+// Connect and authenticate
+await client.connect();
+
+// List databases
+const { databases } = await client.listDatabases();
+console.log('Databases:', databases);
+
+// Create a database
+await client.createDatabase('mydb');
+
+// Execute code
+const result = await client.run(`
+  export const greeting = "Hello, World!";
+`, 'mydb');
+console.log(result);
+
+// Close connection
+client.close();
+```
+
+## Constructor
+
+```typescript
+new BrowserClient(uri: string, options?: ClientOptions)
+```
+
+### URI Format
+
+Supports multiple URI formats:
+- `scriptdb://localhost:1234`
+- `ws://localhost:1235`
+- `http://localhost:1234` (converted to scriptdb://)
+
+Credentials can be embedded in the URI:
+```typescript
+new BrowserClient('scriptdb://user:pass@localhost:1234')
+```
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `secure` | `boolean` | `true` | Use secure WebSocket (wss://) |
+| `username` | `string` | - | Username for authentication |
+| `password` | `string` | - | Password for authentication |
+| `requestTimeout` | `number` | `120000` | Request timeout in ms (0 = disabled) |
+| `retries` | `number` | `3` | Number of reconnection attempts |
+| `retryDelay` | `number` | `1000` | Initial retry delay in ms |
+| `maxPending` | `number` | `100` | Max concurrent pending requests |
+| `maxQueue` | `number` | `1000` | Max queued requests |
+| `logger` | `Logger` | - | Custom logger with debug/info/warn/error |
+| `tokenRefresh` | `function` | - | Async function to refresh expired tokens |
+
+## API Methods
+
+### Connection
+
+```typescript
+// Connect to server
+await client.connect();
+
+// Check connection status
+client.connected; // boolean
+
+// Close connection
+client.close();
+
+// Disconnect (alias for close)
+await client.disconnect();
+
+// Destroy client completely (stops reconnection)
+client.destroy();
+```
+
+### Database Operations
+
+```typescript
+// List all databases
+const { databases, count } = await client.listDatabases();
+
+// Create a database
+await client.createDatabase('mydb');
+
+// Remove a database
+await client.removeDatabase('mydb');
+
+// Rename a database
+await client.renameDatabase('oldname', 'newname');
+
+// Save database to disk
+await client.saveDatabase('mydb');
+
+// Update database metadata
+await client.updateDatabase('mydb', { /* metadata */ });
+```
+
+### Code Execution
+
+```typescript
+// Execute code in a database
+const result = await client.run(`
+  export const data = { message: "Hello" };
+  console.log("Executed!");
+`, 'mydb');
+
+// Result contains:
+// - namespace: exported values
+// - logs: console output
+```
+
+### Authentication
+
+```typescript
+// Login with credentials
+await client.login('username', 'password');
+
+// Logout
+await client.logout();
+```
+
+### Server Info
+
+```typescript
+const info = await client.getInfo();
+```
+
+### Low-level Execute
+
+```typescript
+// Execute arbitrary command
+const result = await client.execute({
+  action: 'script-code',
+  data: { code: '...', databaseName: 'mydb' }
+});
+```
+
+## Features
+
+- **URI Parsing**: Supports scriptdb://, ws://, http:// URIs
+- **Auto-reconnect**: Automatic reconnection with exponential backoff
+- **Token Management**: Automatic token handling and refresh support
+- **Request Queue**: Handles concurrent requests with queue management
+- **Logging**: Configurable logging with automatic credential masking
+- **TypeScript**: Full TypeScript support
+
+## WebSocket Proxy
+
+This client connects to a WebSocket proxy server (typically running on TCP port + 1). The proxy handles communication with the ScriptDB TCP server.
+
+```
+Browser -> WebSocket (port 1235) -> Proxy -> TCP (port 1234) -> ScriptDB Server
+```
+
+## Compatibility with @scriptdb/client
+
+The API is designed to be compatible with `@scriptdb/client`:
+
+```typescript
+// Node.js (TCP)
+import { ScriptDBClient } from '@scriptdb/client';
+
+// Browser (WebSocket)
+import { ScriptDBClient } from '@scriptdb/browser-client';
+
+// Same API
+const client = new ScriptDBClient('scriptdb://localhost:1234', options);
+await client.connect();
+```
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,596 @@
+// src/index.ts
+var noopLogger = {
+  debug: () => {},
+  info: () => {},
+  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;
+  requestTimeout;
+  retries;
+  retryDelay;
+  maxMessageSize;
+  uri = "";
+  protocolName = "";
+  username = null;
+  password = null;
+  host = "";
+  port = 0;
+  database = null;
+  ws = null;
+  _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;
+    const normalized = uri.replace(/^https?:\/\//i, "scriptdb://").replace(/^wss?:\/\//i, "scriptdb://");
+    let parsed;
+    try {
+      parsed = new URL(normalized);
+    } catch (e) {
+      throw new Error("Invalid uri");
+    }
+    this.uri = normalized;
+    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 = normalized;
+    }
+    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);
+    }
+  }
+  get connected() {
+    return this._connected;
+  }
+  connect() {
+    if (this._connecting)
+      return this._connecting;
+    this._connecting = new Promise((resolve, reject) => {
+      const wsPort = this.port + 1;
+      const wsProtocol = this.secure ? "wss" : "ws";
+      const wsUrl = `${wsProtocol}://${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._connected = true;
+        this._currentRetries = 0;
+        this._setupListeners();
+        this.authenticate().then(() => {
+          this._processQueue();
+          resolve(this);
+        }).catch((err) => {
+          reject(err);
+        });
+      };
+      this.ws.onerror = (event) => {
+        this.logger.error?.("WebSocket error:", event);
+        this._handleDisconnect(new Error("WebSocket error"));
+      };
+      this.ws.onclose = (event) => {
+        this.logger.info?.("WebSocket closed", event.code, event.reason);
+        this._handleDisconnect(null);
+      };
+    }).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;
+      }
+      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;
+        }
+        this._handleMessage(msg);
+      } catch (error) {
+        this.logger.error?.("Failed to parse message:", error);
+      }
+    };
+  }
+  _handleMessage(msg) {
+    if (!msg || typeof msg !== "object")
+      return;
+    this.logger.debug?.("Received message:", msg);
+    if (typeof msg.id !== "undefined") {
+      const pending = this._pending.get(msg.id);
+      if (!pending) {
+        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") {
+        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") {
+        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) {}
+      }
+    }
+  }
+  async execute(payload) {
+    try {
+      await this.ready;
+    } catch (err) {
+      throw new Error("Not authenticated: " + (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(async (resolve, reject) => {
+      let timer = null;
+      if (this.requestTimeout > 0) {
+        timer = window.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 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);
+      } catch (e) {
+        if (timer)
+          clearTimeout(timer);
+        this._pending.delete(id);
+        reject(e);
+      }
+    });
+  }
+  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) => {
+      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"));
+      } catch (e) {}
+    }
+  }
+  close() {
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } 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();
+  }
+  async login(username, password) {
+    return this.sendRequest("login", { username, password });
+  }
+  async logout() {
+    return this.sendRequest("logout", {});
+  }
+  async listDatabases() {
+    return this.sendRequest("list-dbs", {});
+  }
+  async createDatabase(name) {
+    return this.sendRequest("create-db", { databaseName: name });
+  }
+  async removeDatabase(name) {
+    return this.sendRequest("remove-db", { databaseName: name });
+  }
+  async renameDatabase(oldName, newName) {
+    return this.sendRequest("rename-db", { databaseName: oldName, newName });
+  }
+  async run(code, databaseName) {
+    return this.sendRequest("script-code", { code, databaseName });
+  }
+  async saveDatabase(databaseName) {
+    return this.sendRequest("save-db", { databaseName });
+  }
+  async updateDatabase(databaseName, data) {
+    return this.sendRequest("update-db", { databaseName, ...data });
+  }
+  async getInfo() {
+    return this.sendRequest("get-info", {});
+  }
+  async executeShell(command) {
+    return this.sendRequest("shell-command", { command });
+  }
+}
+var src_default = BrowserClient;
+export {
+  src_default as default,
+  BrowserClient as ScriptDBClient,
+  BrowserClient
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@scriptdb/browser-client",
+  "version": "1.0.4",
+  "description": "Client module resolver for script database",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "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: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"
+  }
+}