@cored-im/openapi-sdk 0.28.102

package/dist/index.js

@@ -0,0 +1,1463 @@
+// src/core/types.ts
+var LoggerLevel = /* @__PURE__ */ ((LoggerLevel2) => {
+  LoggerLevel2[LoggerLevel2["Debug"] = 0] = "Debug";
+  LoggerLevel2[LoggerLevel2["Info"] = 1] = "Info";
+  LoggerLevel2[LoggerLevel2["Warn"] = 2] = "Warn";
+  LoggerLevel2[LoggerLevel2["Error"] = 3] = "Error";
+  return LoggerLevel2;
+})(LoggerLevel || {});
+
+// src/core/version.ts
+var VERSION = "0.28.102";
+var USER_AGENT = "cored-openapi-sdk-js/0.28.102";
+
+// src/core/consts.ts
+var DEFAULT_PING_PATH = "/oapi/stat/v1/ping";
+var DEFAULT_TOKEN_PATH = "/oapi/auth/v1/app/token";
+var DEFAULT_GATEWAY_PATH = "/oapi/transport/v1/gateway";
+var DEFAULT_WS_PATH = "/oapi/transport/v1/ws";
+var DEFAULT_SECURE_VERSION = "1.0";
+
+// src/core/crypto.ts
+var ALPHANUMERIC = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var CryptoManager = class {
+  constructor(config) {
+    this.counter = [0, 0, 0, 0, 0];
+    this.config = config;
+    this.prefix = randomAlphanumeric(6);
+  }
+  async encryptMessage(secret, data) {
+    const timestamp = this.config.timeManager.getServerTimestamp();
+    const nonce = this.getNonce();
+    const initKey = await sha256Bytes(`${timestamp}:${secret}:${nonce}`);
+    const aesKey = randomBytes(32);
+    const compressed = await compressGzip(data);
+    const encryptedKey = await encryptAES256CBC(aesKey, initKey);
+    const encryptedData = await encryptAES256CBC(compressed, aesKey);
+    return {
+      version: DEFAULT_SECURE_VERSION,
+      timestamp,
+      nonce,
+      encryptedKey,
+      encryptedData
+    };
+  }
+  async decryptMessage(secret, message) {
+    if (message.version !== DEFAULT_SECURE_VERSION) {
+      throw new Error(`unsupported secure message version: ${message.version}`);
+    }
+    const initKey = await sha256Bytes(`${message.timestamp}:${secret}:${message.nonce}`);
+    const aesKey = await decryptAES256CBC(message.encryptedKey, initKey);
+    const compressed = await decryptAES256CBC(message.encryptedData, aesKey);
+    return await decompressGzip(compressed);
+  }
+  getNonce() {
+    const random = randomAlphanumeric(5);
+    const counter = this.formatCounter();
+    this.addCounter();
+    return this.prefix + random + counter;
+  }
+  formatCounter() {
+    let result = "";
+    for (let i = 0; i < 5; i++) {
+      result += ALPHANUMERIC[this.counter[i]];
+    }
+    return result;
+  }
+  addCounter() {
+    for (let i = 4; i >= 0; i--) {
+      this.counter[i]++;
+      if (this.counter[i] < 62) {
+        break;
+      }
+      this.counter[i] = 0;
+    }
+  }
+};
+async function sha256Bytes(input) {
+  const data = new TextEncoder().encode(input);
+  const hash = await crypto.subtle.digest("SHA-256", data);
+  return new Uint8Array(hash);
+}
+async function sha256Hex(input) {
+  const bytes = await sha256Bytes(input);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function encryptAES256CBC(data, key) {
+  const padded = pkcs7Pad(data);
+  const iv = randomBytes(16);
+  const cryptoKey = await crypto.subtle.importKey("raw", toBuffer(key), { name: "AES-CBC" }, false, ["encrypt"]);
+  const encrypted = await crypto.subtle.encrypt({ name: "AES-CBC", iv: toBuffer(iv) }, cryptoKey, toBuffer(padded));
+  const result = new Uint8Array(iv.length + encrypted.byteLength);
+  result.set(iv, 0);
+  result.set(new Uint8Array(encrypted), iv.length);
+  return result;
+}
+async function decryptAES256CBC(data, key) {
+  if (data.length < 16 || data.length % 16 !== 0) {
+    throw new Error("invalid encrypted data length");
+  }
+  const iv = data.slice(0, 16);
+  const ciphertext = data.slice(16);
+  const cryptoKey = await crypto.subtle.importKey("raw", toBuffer(key), { name: "AES-CBC" }, false, ["decrypt"]);
+  const decrypted = await crypto.subtle.decrypt({ name: "AES-CBC", iv: toBuffer(iv) }, cryptoKey, toBuffer(ciphertext));
+  return new Uint8Array(decrypted);
+}
+function pkcs7Pad(data) {
+  const blockSize = 16;
+  const padding = blockSize - data.length % blockSize;
+  const padded = new Uint8Array(data.length + padding);
+  padded.set(data);
+  padded.fill(padding, data.length);
+  return padded;
+}
+async function compressGzip(data) {
+  if (typeof CompressionStream !== "undefined") {
+    const stream = new CompressionStream("gzip");
+    const writer = stream.writable.getWriter();
+    void writer.write(toBuffer(data));
+    void writer.close();
+    const chunks = [];
+    const reader = stream.readable.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  throw new Error("CompressionStream not available. Please use a modern browser or Node.js 18+.");
+}
+async function decompressGzip(data) {
+  if (typeof DecompressionStream !== "undefined") {
+    const stream = new DecompressionStream("gzip");
+    const writer = stream.writable.getWriter();
+    void writer.write(toBuffer(data));
+    void writer.close();
+    const chunks = [];
+    const reader = stream.readable.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  throw new Error("DecompressionStream not available. Please use a modern browser or Node.js 18+.");
+}
+function toBuffer(data) {
+  return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+}
+function randomBytes(size) {
+  const bytes = new Uint8Array(size);
+  crypto.getRandomValues(bytes);
+  return bytes;
+}
+function randomAlphanumeric(size) {
+  const bytes = randomBytes(size);
+  let result = "";
+  for (let i = 0; i < size; i++) {
+    result += ALPHANUMERIC[bytes[i] % 62];
+  }
+  return result;
+}
+
+// src/internal/transport.ts
+var ProtoWriter = class {
+  constructor() {
+    this.pos = 0;
+    this.forkStack = [];
+    this.buf = new Uint8Array(256);
+  }
+  grow(need) {
+    if (this.pos + need <= this.buf.length) return;
+    let newLen = this.buf.length * 2;
+    while (newLen < this.pos + need) newLen *= 2;
+    const next = new Uint8Array(newLen);
+    next.set(this.buf);
+    this.buf = next;
+  }
+  uint32(value) {
+    this.grow(5);
+    value >>>= 0;
+    while (value > 127) {
+      this.buf[this.pos++] = value & 127 | 128;
+      value >>>= 7;
+    }
+    this.buf[this.pos++] = value;
+    return this;
+  }
+  uint64(value) {
+    this.grow(10);
+    let lo = value >>> 0;
+    let hi = (value - lo) / 4294967296 >>> 0;
+    while (hi > 0) {
+      this.buf[this.pos++] = lo & 127 | 128;
+      lo = (lo >>> 7 | hi << 25) >>> 0;
+      hi >>>= 7;
+    }
+    while (lo > 127) {
+      this.buf[this.pos++] = lo & 127 | 128;
+      lo >>>= 7;
+    }
+    this.buf[this.pos++] = lo;
+    return this;
+  }
+  int32(value) {
+    if (value >= 0) return this.uint32(value);
+    this.grow(10);
+    for (let i = 0; i < 9; i++) {
+      this.buf[this.pos++] = value & 127 | 128;
+      value >>= 7;
+    }
+    this.buf[this.pos++] = 1;
+    return this;
+  }
+  bytes(value) {
+    this.uint32(value.length);
+    this.grow(value.length);
+    this.buf.set(value, this.pos);
+    this.pos += value.length;
+    return this;
+  }
+  string(value) {
+    const encoded = textEncoder.encode(value);
+    return this.bytes(encoded);
+  }
+  /** Start a nested sub-message. Call ldelim() to close it. */
+  fork() {
+    this.forkStack.push(this.pos);
+    this.grow(5);
+    this.pos += 5;
+    return this;
+  }
+  /** Close a fork: writes the sub-message length prefix. */
+  ldelim() {
+    const startPos = this.forkStack.pop();
+    const contentStart = startPos + 5;
+    const contentLen = this.pos - contentStart;
+    const lenBytes = [];
+    let v = contentLen;
+    while (v > 127) {
+      lenBytes.push(v & 127 | 128);
+      v >>>= 7;
+    }
+    lenBytes.push(v);
+    const newContentStart = startPos + lenBytes.length;
+    this.buf.copyWithin(newContentStart, contentStart, this.pos);
+    for (let i = 0; i < lenBytes.length; i++) {
+      this.buf[startPos + i] = lenBytes[i];
+    }
+    this.pos = newContentStart + contentLen;
+    return this;
+  }
+  finish() {
+    return this.buf.slice(0, this.pos);
+  }
+};
+var ProtoReader = class {
+  constructor(data) {
+    this.buf = data;
+    this.pos = 0;
+    this.len = data.length;
+  }
+  uint32() {
+    let value = 0;
+    let shift = 0;
+    let b;
+    do {
+      b = this.buf[this.pos++];
+      value |= (b & 127) << shift;
+      shift += 7;
+    } while (b & 128);
+    return value >>> 0;
+  }
+  uint64() {
+    let lo = 0;
+    let hi = 0;
+    let shift = 0;
+    let b;
+    for (let i = 0; i < 4; i++) {
+      b = this.buf[this.pos++];
+      lo |= (b & 127) << shift;
+      shift += 7;
+      if (!(b & 128)) return lo >>> 0;
+    }
+    b = this.buf[this.pos++];
+    lo |= (b & 127) << 28;
+    hi = (b & 127) >> 4;
+    if (!(b & 128)) return hi * 4294967296 + (lo >>> 0);
+    shift = 3;
+    do {
+      b = this.buf[this.pos++];
+      hi |= (b & 127) << shift;
+      shift += 7;
+    } while (b & 128);
+    return (hi >>> 0) * 4294967296 + (lo >>> 0);
+  }
+  int32() {
+    return this.uint32() | 0;
+  }
+  bytes() {
+    const len = this.uint32();
+    const value = this.buf.slice(this.pos, this.pos + len);
+    this.pos += len;
+    return value;
+  }
+  string() {
+    const bytes = this.bytes();
+    return textDecoder.decode(bytes);
+  }
+  skipType(wireType) {
+    switch (wireType) {
+      case 0:
+        while (this.buf[this.pos++] & 128) {
+        }
+        break;
+      case 1:
+        this.pos += 8;
+        break;
+      case 2:
+        this.pos += this.uint32();
+        break;
+      case 5:
+        this.pos += 4;
+        break;
+      default:
+        throw new Error(`unknown wire type: ${wireType}`);
+    }
+  }
+};
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeSecureMessage(msg) {
+  const w = new ProtoWriter();
+  if (msg.version) w.uint32(10).string(msg.version);
+  if (msg.timestamp) w.uint32(16).uint64(msg.timestamp);
+  if (msg.nonce) w.uint32(26).string(msg.nonce);
+  if (msg.encryptedKey?.length) w.uint32(34).bytes(msg.encryptedKey);
+  if (msg.encryptedData?.length) w.uint32(42).bytes(msg.encryptedData);
+  return w.finish();
+}
+function decodeSecureMessage(data) {
+  const r = new ProtoReader(data);
+  const msg = { version: "", timestamp: 0, nonce: "", encryptedKey: new Uint8Array(0), encryptedData: new Uint8Array(0) };
+  while (r.pos < r.len) {
+    const tag = r.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.version = r.string();
+        break;
+      case 2:
+        msg.timestamp = r.uint64();
+        break;
+      case 3:
+        msg.nonce = r.string();
+        break;
+      case 4:
+        msg.encryptedKey = r.bytes();
+        break;
+      case 5:
+        msg.encryptedData = r.bytes();
+        break;
+      default:
+        r.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+}
+function encodeHttpRequest(msg) {
+  const w = new ProtoWriter();
+  if (msg.method) w.uint32(10).string(msg.method);
+  if (msg.path) w.uint32(18).string(msg.path);
+  if (msg.headers) {
+    for (const [k, v] of Object.entries(msg.headers)) {
+      w.uint32(26).fork().uint32(10).string(k).uint32(18).string(v).ldelim();
+    }
+  }
+  if (msg.body?.length) w.uint32(34).bytes(msg.body);
+  if (msg.reqId) w.uint32(42).string(msg.reqId);
+  return w.finish();
+}
+function decodeHttpRequest(data) {
+  const r = new ProtoReader(data);
+  const msg = { method: "", path: "", headers: {}, body: new Uint8Array(0), reqId: "" };
+  while (r.pos < r.len) {
+    const tag = r.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.method = r.string();
+        break;
+      case 2:
+        msg.path = r.string();
+        break;
+      case 3: {
+        const entryEnd = r.uint32() + r.pos;
+        let key = "", value = "";
+        while (r.pos < entryEnd) {
+          const entryTag = r.uint32();
+          switch (entryTag >>> 3) {
+            case 1:
+              key = r.string();
+              break;
+            case 2:
+              value = r.string();
+              break;
+            default:
+              r.skipType(entryTag & 7);
+              break;
+          }
+        }
+        msg.headers[key] = value;
+        break;
+      }
+      case 4:
+        msg.body = r.bytes();
+        break;
+      case 5:
+        msg.reqId = r.string();
+        break;
+      default:
+        r.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+}
+function decodeHttpResponse(data) {
+  const r = new ProtoReader(data);
+  const msg = { statusCode: 0, statusText: "", headers: {}, body: new Uint8Array(0), reqId: "" };
+  while (r.pos < r.len) {
+    const tag = r.uint32();
+    switch (tag >>> 3) {
+      case 1:
+        msg.statusCode = r.int32();
+        break;
+      case 2:
+        msg.statusText = r.string();
+        break;
+      case 3: {
+        const entryEnd = r.uint32() + r.pos;
+        let key = "", value = "";
+        while (r.pos < entryEnd) {
+          const entryTag = r.uint32();
+          switch (entryTag >>> 3) {
+            case 1:
+              key = r.string();
+              break;
+            case 2:
+              value = r.string();
+              break;
+            default:
+              r.skipType(entryTag & 7);
+              break;
+          }
+        }
+        msg.headers[key] = value;
+        break;
+      }
+      case 4:
+        msg.body = r.bytes();
+        break;
+      case 5:
+        msg.reqId = r.string();
+        break;
+      default:
+        r.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+}
+function encodeWebSocketMessage(msg) {
+  const w = new ProtoWriter();
+  if (msg.ping) {
+    w.uint32(10).fork();
+    if (msg.ping.timestamp) w.uint32(8).uint64(msg.ping.timestamp);
+    w.ldelim();
+  }
+  if (msg.pong) {
+    w.uint32(18).fork();
+    if (msg.pong.timestamp) w.uint32(8).uint64(msg.pong.timestamp);
+    w.ldelim();
+  }
+  if (msg.initRequest) {
+    w.uint32(26).fork();
+    if (msg.initRequest.userAgent) w.uint32(10).string(msg.initRequest.userAgent);
+    w.ldelim();
+  }
+  if (msg.initResponse) {
+    w.uint32(34).fork().ldelim();
+  }
+  if (msg.event) {
+    w.uint32(42).fork();
+    if (msg.event.eventHeader) {
+      w.uint32(10).fork();
+      if (msg.event.eventHeader.eventId) w.uint32(10).string(msg.event.eventHeader.eventId);
+      if (msg.event.eventHeader.eventType) w.uint32(18).string(msg.event.eventHeader.eventType);
+      if (msg.event.eventHeader.eventCreatedAt) w.uint32(24).uint64(msg.event.eventHeader.eventCreatedAt);
+      w.ldelim();
+    }
+    if (msg.event.eventBody?.length) w.uint32(18).bytes(msg.event.eventBody);
+    w.ldelim();
+  }
+  if (msg.eventAck) {
+    w.uint32(50).fork();
+    if (msg.eventAck.eventId) w.uint32(10).string(msg.eventAck.eventId);
+    w.ldelim();
+  }
+  if (msg.httpRequest) {
+    w.uint32(58).bytes(encodeHttpRequest(msg.httpRequest));
+  }
+  return w.finish();
+}
+function decodeWebSocketMessage(data) {
+  const r = new ProtoReader(data);
+  const msg = {};
+  while (r.pos < r.len) {
+    const tag = r.uint32();
+    switch (tag >>> 3) {
+      case 1: {
+        const subEnd = r.uint32() + r.pos;
+        const ping = { timestamp: 0 };
+        while (r.pos < subEnd) {
+          const subTag = r.uint32();
+          if (subTag >>> 3 === 1) ping.timestamp = r.uint64();
+          else r.skipType(subTag & 7);
+        }
+        msg.ping = ping;
+        break;
+      }
+      case 2: {
+        const subEnd = r.uint32() + r.pos;
+        const pong = { timestamp: 0 };
+        while (r.pos < subEnd) {
+          const subTag = r.uint32();
+          if (subTag >>> 3 === 1) pong.timestamp = r.uint64();
+          else r.skipType(subTag & 7);
+        }
+        msg.pong = pong;
+        break;
+      }
+      case 3: {
+        const subEnd = r.uint32() + r.pos;
+        const initReq = { userAgent: "" };
+        while (r.pos < subEnd) {
+          const subTag = r.uint32();
+          if (subTag >>> 3 === 1) initReq.userAgent = r.string();
+          else r.skipType(subTag & 7);
+        }
+        msg.initRequest = initReq;
+        break;
+      }
+      case 4: {
+        const subEnd = r.uint32() + r.pos;
+        r.pos = subEnd;
+        msg.initResponse = {};
+        break;
+      }
+      case 5: {
+        const subEnd = r.uint32() + r.pos;
+        const event = { eventBody: new Uint8Array(0) };
+        while (r.pos < subEnd) {
+          const subTag = r.uint32();
+          switch (subTag >>> 3) {
+            case 1: {
+              const headerEnd = r.uint32() + r.pos;
+              const header = { eventId: "", eventType: "", eventCreatedAt: 0 };
+              while (r.pos < headerEnd) {
+                const hTag = r.uint32();
+                switch (hTag >>> 3) {
+                  case 1:
+                    header.eventId = r.string();
+                    break;
+                  case 2:
+                    header.eventType = r.string();
+                    break;
+                  case 3:
+                    header.eventCreatedAt = r.uint64();
+                    break;
+                  default:
+                    r.skipType(hTag & 7);
+                    break;
+                }
+              }
+              event.eventHeader = header;
+              break;
+            }
+            case 2:
+              event.eventBody = r.bytes();
+              break;
+            default:
+              r.skipType(subTag & 7);
+              break;
+          }
+        }
+        msg.event = event;
+        break;
+      }
+      case 6: {
+        const subEnd = r.uint32() + r.pos;
+        const ack = { eventId: "" };
+        while (r.pos < subEnd) {
+          const subTag = r.uint32();
+          if (subTag >>> 3 === 1) ack.eventId = r.string();
+          else r.skipType(subTag & 7);
+        }
+        msg.eventAck = ack;
+        break;
+      }
+      case 7: {
+        const bytes = r.bytes();
+        msg.httpRequest = decodeHttpRequest(bytes);
+        break;
+      }
+      case 8: {
+        const bytes = r.bytes();
+        msg.httpResponse = decodeHttpResponse(bytes);
+        break;
+      }
+      default:
+        r.skipType(tag & 7);
+        break;
+    }
+  }
+  return msg;
+}
+
+// src/core/ws_client.ts
+var _WebSocketImpl;
+async function getWebSocket() {
+  if (_WebSocketImpl) return _WebSocketImpl;
+  if (typeof WebSocket !== "undefined") {
+    _WebSocketImpl = WebSocket;
+    return _WebSocketImpl;
+  }
+  try {
+    const mod = await Function('return import("ws")')();
+    _WebSocketImpl = mod.default || mod;
+    return _WebSocketImpl;
+  } catch {
+    throw new Error(
+      'No WebSocket implementation found. Install the "ws" package: npm install ws'
+    );
+  }
+}
+var RECONNECT_CHECK_INTERVAL = 1e4;
+var HEALTH_CHECK_INTERVAL = 2e4;
+var ALIVE_TIMEOUT = 4e4;
+var CONNECT_TIMEOUT = 5e3;
+var WRITE_TIMEOUT = 6e4;
+var WsClient = class {
+  constructor(options) {
+    this.eventHandlerMap = /* @__PURE__ */ new Map();
+    this.socket = null;
+    this.isConnecting = false;
+    this.isReconnecting = false;
+    this.shouldClose = false;
+    this.reqCount = 0;
+    this.reqCallbacks = /* @__PURE__ */ new Map();
+    this.reconnectAttempt = 0;
+    this.lastMessageAt = 0;
+    this.healthCheckTimer = null;
+    this.reconnectCheckTimer = null;
+    this.reconnectTimer = null;
+    this.initDone = false;
+    this.initPromise = null;
+    this.config = options.config;
+    this.getSecret = options.getSecret;
+    this.getToken = options.getToken;
+    this.ensurePing = options.ensurePing;
+    this.cryptoManager = options.cryptoManager;
+  }
+  onEvent(eventType, handler) {
+    this.ensureInit();
+    let handlers = this.eventHandlerMap.get(eventType);
+    if (!handlers) {
+      handlers = [];
+      this.eventHandlerMap.set(eventType, handlers);
+    }
+    handlers.push(handler);
+  }
+  offEvent(eventType, handler) {
+    const handlers = this.eventHandlerMap.get(eventType);
+    if (!handlers) return;
+    const idx = handlers.indexOf(handler);
+    if (idx >= 0) {
+      handlers.splice(idx, 1);
+    }
+  }
+  async httpRequest(req) {
+    await this.ensureInit();
+    const reqId = String(++this.reqCount);
+    req.reqId = reqId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.reqCallbacks.delete(reqId);
+        reject(new Error(`websocket request timeout: ${WRITE_TIMEOUT}ms`));
+      }, WRITE_TIMEOUT);
+      this.reqCallbacks.set(reqId, { resolve, reject, timer });
+      const reqBytes = encodeHttpRequest(req);
+      this.sendMessage({
+        httpRequest: {
+          method: req.method,
+          path: req.path,
+          headers: req.headers,
+          body: req.body,
+          reqId
+        }
+      }).catch((err) => {
+        clearTimeout(timer);
+        this.reqCallbacks.delete(reqId);
+        reject(err);
+      });
+    });
+  }
+  close() {
+    this.shouldClose = true;
+    this.clearTimers();
+    if (this.socket) {
+      try {
+        this.socket.close(1e3, "client close");
+      } catch {
+      }
+      this.socket = null;
+    }
+    for (const [, cb] of this.reqCallbacks) {
+      clearTimeout(cb.timer);
+      cb.reject(new Error("websocket closed"));
+    }
+    this.reqCallbacks.clear();
+  }
+  // --- Internal ---
+  ensureInit() {
+    if (this.initDone) return;
+    if (!this.initPromise) {
+      this.initPromise = this.doInit();
+    }
+  }
+  async doInit() {
+    if (this.initDone) return;
+    try {
+      await this.ensurePing();
+      await this.connect();
+      this.initDone = true;
+    } catch (err) {
+      this.config.logger.error("ws init failed", err);
+      this.reconnect();
+    }
+  }
+  async connect() {
+    if (this.isConnecting) return;
+    this.isConnecting = true;
+    try {
+      if (this.socket) {
+        try {
+          this.socket.close();
+        } catch {
+        }
+        this.socket = null;
+      }
+      for (const [, cb] of this.reqCallbacks) {
+        clearTimeout(cb.timer);
+        cb.reject(new Error("websocket reconnecting"));
+      }
+      this.reqCallbacks.clear();
+      await this.ensurePing();
+      const token = await this.getToken();
+      let wsUrl = this.config.backendUrl.replace(/^http/, "ws") + DEFAULT_WS_PATH + `?token=${encodeURIComponent(token)}`;
+      const WS = await getWebSocket();
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error("websocket connect timeout"));
+        }, CONNECT_TIMEOUT);
+        const ws = new WS(wsUrl);
+        ws.binaryType = "arraybuffer";
+        ws.onopen = async () => {
+          clearTimeout(timer);
+          this.socket = ws;
+          try {
+            await this.sendMessage({ initRequest: { userAgent: USER_AGENT } });
+            await new Promise((resolveInit, rejectInit) => {
+              const initTimer = setTimeout(() => {
+                rejectInit(new Error("init response timeout"));
+              }, CONNECT_TIMEOUT);
+              const origHandler = ws.onmessage;
+              ws.onmessage = async (event) => {
+                clearTimeout(initTimer);
+                try {
+                  const data = new Uint8Array(event.data);
+                  const secureMsg = decodeSecureMessage(data);
+                  const decrypted = await this.cryptoManager.decryptMessage(this.getSecret(), secureMsg);
+                  const wsMsg = decodeWebSocketMessage(decrypted);
+                  if (wsMsg.initResponse) {
+                    resolveInit();
+                  } else {
+                    rejectInit(new Error("unexpected message during init"));
+                  }
+                } catch (err) {
+                  rejectInit(err);
+                }
+              };
+            });
+            ws.onmessage = (event) => this.handleMessage(event);
+            ws.onclose = () => this.handleClose();
+            ws.onerror = (err) => {
+              this.config.logger.error("ws error", err);
+            };
+            this.lastMessageAt = Date.now();
+            this.startHealthCheck();
+            this.startReconnectCheck();
+            this.reconnectAttempt = 0;
+            this.isReconnecting = false;
+            resolve();
+          } catch (err) {
+            reject(err);
+          }
+        };
+        ws.onerror = () => {
+          clearTimeout(timer);
+          reject(new Error("websocket connect failed"));
+        };
+      });
+    } finally {
+      this.isConnecting = false;
+    }
+  }
+  handleClose() {
+    this.socket = null;
+    this.clearTimers();
+    if (!this.shouldClose) {
+      this.reconnect();
+    }
+  }
+  async handleMessage(event) {
+    this.lastMessageAt = Date.now();
+    try {
+      const data = new Uint8Array(event.data);
+      const secureMsg = decodeSecureMessage(data);
+      const decrypted = await this.cryptoManager.decryptMessage(this.getSecret(), secureMsg);
+      const wsMsg = decodeWebSocketMessage(decrypted);
+      if (wsMsg.pong) {
+        this.config.timeManager.syncServerTimestamp(Number(wsMsg.pong.timestamp));
+      } else if (wsMsg.event) {
+        const header = {
+          event_id: wsMsg.event.eventHeader?.eventId ?? "",
+          event_type: wsMsg.event.eventHeader?.eventType ?? "",
+          event_created_at: String(wsMsg.event.eventHeader?.eventCreatedAt ?? "0")
+        };
+        const handlers = this.eventHandlerMap.get(header.event_type);
+        if (handlers) {
+          for (const handler of handlers) {
+            try {
+              handler(header, wsMsg.event.eventBody ?? new Uint8Array(0));
+            } catch (err) {
+              this.config.logger.error("event handler error", err);
+            }
+          }
+        }
+        this.sendMessage({ eventAck: { eventId: header.event_id } }).catch(() => {
+        });
+      } else if (wsMsg.httpResponse) {
+        const reqId = wsMsg.httpResponse.reqId;
+        const cb = this.reqCallbacks.get(reqId);
+        if (cb) {
+          clearTimeout(cb.timer);
+          this.reqCallbacks.delete(reqId);
+          cb.resolve(wsMsg.httpResponse);
+        }
+      }
+    } catch (err) {
+      this.config.logger.error("ws message parse error", err);
+    }
+  }
+  async sendMessage(msg) {
+    const WS = await getWebSocket();
+    if (!this.socket || this.socket.readyState !== WS.OPEN) {
+      throw new Error("websocket not connected");
+    }
+    const msgBytes = encodeWebSocketMessage(msg);
+    const secureMsg = await this.cryptoManager.encryptMessage(this.getSecret(), msgBytes);
+    const data = encodeSecureMessage(secureMsg);
+    this.socket.send(data);
+  }
+  reconnect() {
+    if (this.shouldClose || this.isReconnecting) return;
+    this.isReconnecting = true;
+    const delay = this.getReconnectDelay();
+    this.config.logger.info(`ws reconnecting in ${delay}ms (attempt ${this.reconnectAttempt + 1})`);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectAttempt++;
+      try {
+        await this.connect();
+        this.config.logger.info("ws reconnected");
+      } catch (err) {
+        this.config.logger.error("ws reconnect failed", err);
+        this.isReconnecting = false;
+        this.reconnect();
+      }
+    }, delay);
+  }
+  getReconnectDelay() {
+    const attempt = this.reconnectAttempt;
+    if (attempt === 0) {
+      return 250 + Math.floor(Math.random() * 250);
+    }
+    if (attempt <= 4) {
+      return 750 + Math.floor(Math.random() * 500);
+    }
+    const base = Math.min(1e4, Math.max(750, (attempt - 4) * 2e3));
+    const jitter = Math.floor(Math.random() * 1e3);
+    return Math.min(15e3, base + jitter);
+  }
+  startHealthCheck() {
+    this.stopHealthCheck();
+    this.healthCheckTimer = setInterval(async () => {
+      try {
+        const timestamp = this.config.timeManager.getServerTimestamp();
+        await this.sendMessage({ ping: { timestamp } });
+      } catch {
+      }
+    }, HEALTH_CHECK_INTERVAL);
+  }
+  stopHealthCheck() {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+  }
+  startReconnectCheck() {
+    this.stopReconnectCheck();
+    this.reconnectCheckTimer = setInterval(() => {
+      if (Date.now() - this.lastMessageAt > ALIVE_TIMEOUT) {
+        this.config.logger.warn("ws alive timeout, reconnecting");
+        this.clearTimers();
+        if (this.socket) {
+          try {
+            this.socket.close();
+          } catch {
+          }
+          this.socket = null;
+        }
+        this.reconnect();
+      }
+    }, RECONNECT_CHECK_INTERVAL);
+  }
+  stopReconnectCheck() {
+    if (this.reconnectCheckTimer) {
+      clearInterval(this.reconnectCheckTimer);
+      this.reconnectCheckTimer = null;
+    }
+  }
+  clearTimers() {
+    this.stopHealthCheck();
+    this.stopReconnectCheck();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/core/api_client.ts
+var TIMESTAMP_HEADER = "X-Cored-Timestamp";
+var NONCE_HEADER = "X-Cored-Nonce";
+var DefaultApiClient = class {
+  constructor(config) {
+    this.secret = "";
+    this.token = "";
+    this.tokenRefreshAt = 0;
+    this.tokenExpiresAt = 0;
+    this.tokenFetching = false;
+    this.tokenPromise = null;
+    this.pingCalled = false;
+    this.pingExpiresAt = 0;
+    this.pingFetching = false;
+    this.pingPromise = null;
+    this.config = config;
+    this.cryptoManager = new CryptoManager(config);
+    this.ws = new WsClient({
+      config,
+      getSecret: () => this.secret,
+      getToken: () => this.getToken(),
+      ensurePing: () => this.ensurePing(),
+      cryptoManager: this.cryptoManager
+    });
+  }
+  async init() {
+    this.secret = await sha256Hex(`${this.config.appId}:${this.config.appSecret}`);
+  }
+  async preheat() {
+    await this.ensurePing();
+    await this.getToken();
+  }
+  async close() {
+    this.ws.close();
+  }
+  onEvent(eventType, handler) {
+    this.ws.onEvent(eventType, handler);
+  }
+  offEvent(eventType, handler) {
+    this.ws.offEvent(eventType, handler);
+  }
+  async request(req) {
+    await this.ensurePing();
+    let path = req.path;
+    if (req.pathParams) {
+      for (const [key, value] of Object.entries(req.pathParams)) {
+        path = path.replace(`:${key}`, encodeURIComponent(value));
+      }
+    }
+    let url = this.config.backendUrl + path;
+    if (req.queryParams) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(req.queryParams)) {
+        if (value) params.set(key, value);
+      }
+      const qs = params.toString();
+      if (qs) url += "?" + qs;
+    }
+    if (this.config.enableEncryption && req.withAppAccessToken) {
+      const token = await this.getToken();
+      const bodyBytes = req.body ? new TextEncoder().encode(this.config.jsonMarshal(req.body)) : new Uint8Array(0);
+      const headers2 = {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        [TIMESTAMP_HEADER]: String(this.config.timeManager.getServerTimestamp()),
+        [NONCE_HEADER]: randomAlphanumeric2(16)
+      };
+      if (req.headerParams) {
+        Object.assign(headers2, req.headerParams);
+      }
+      const httpReq = {
+        method: req.method,
+        path: url.replace(this.config.backendUrl, ""),
+        headers: headers2,
+        body: bodyBytes,
+        reqId: ""
+      };
+      if (req.withWebSocket) {
+        const httpResp2 = await this.ws.httpRequest(httpReq);
+        return {
+          json: async () => JSON.parse(new TextDecoder().decode(httpResp2.body)),
+          body: async () => httpResp2.body instanceof Uint8Array ? httpResp2.body : new Uint8Array(httpResp2.body)
+        };
+      }
+      const httpReqBytes = encodeHttpRequest(httpReq);
+      const secureMessage = await this.cryptoManager.encryptMessage(this.secret, httpReqBytes);
+      const secureBytes = encodeSecureMessage(secureMessage);
+      const gatewayUrl = this.config.backendUrl + DEFAULT_GATEWAY_PATH;
+      const resp2 = await this.config.httpClient.fetch(gatewayUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-protobuf",
+          "Authorization": `Bearer ${token}`,
+          "User-Agent": USER_AGENT
+        },
+        body: secureBytes
+      });
+      const respBytes = new Uint8Array(await resp2.arrayBuffer());
+      const respSecureMessage = decodeSecureMessage(respBytes);
+      const decryptedBytes = await this.cryptoManager.decryptMessage(this.secret, respSecureMessage);
+      const httpResp = decodeHttpResponse(decryptedBytes);
+      return {
+        json: async () => JSON.parse(new TextDecoder().decode(httpResp.body)),
+        body: async () => httpResp.body instanceof Uint8Array ? httpResp.body : new Uint8Array(httpResp.body)
+      };
+    }
+    const timestamp = String(this.config.timeManager.getServerTimestamp());
+    const nonce = randomAlphanumeric2(16);
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+      [TIMESTAMP_HEADER]: timestamp,
+      [NONCE_HEADER]: nonce
+    };
+    if (req.withAppAccessToken) {
+      const token = await this.getToken();
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (req.headerParams) {
+      for (const [key, value] of Object.entries(req.headerParams)) {
+        if (value) headers[key] = value;
+      }
+    }
+    const fetchInit = {
+      method: req.method,
+      headers
+    };
+    if (req.body && req.method !== "GET") {
+      fetchInit.body = this.config.jsonMarshal(req.body);
+    }
+    const resp = await this.config.httpClient.fetch(url, fetchInit);
+    return {
+      json: async () => resp.json(),
+      body: async () => new Uint8Array(await resp.arrayBuffer())
+    };
+  }
+  // --- Token management ---
+  async getToken() {
+    const now = this.config.timeManager.getServerTimestamp();
+    if (this.token && this.tokenRefreshAt > now) {
+      return this.token;
+    }
+    if (!this.token || this.tokenExpiresAt <= now) {
+      if (this.tokenPromise) {
+        await this.tokenPromise;
+        return this.token;
+      }
+      this.tokenPromise = this.fetchToken();
+      try {
+        await this.tokenPromise;
+      } finally {
+        this.tokenPromise = null;
+      }
+      return this.token;
+    }
+    if (!this.tokenFetching) {
+      this.tokenFetching = true;
+      this.fetchToken().finally(() => {
+        this.tokenFetching = false;
+      });
+    }
+    return this.token;
+  }
+  async fetchToken() {
+    const timestamp = String(this.config.timeManager.getServerTimestamp());
+    const nonce = randomAlphanumeric2(16);
+    const signPayload = `${this.config.appId}:${timestamp}:${this.config.appSecret}:${nonce}`;
+    const signature = await sha256Hex(signPayload);
+    const url = this.config.backendUrl + DEFAULT_TOKEN_PATH;
+    const resp = await this.config.httpClient.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT
+      },
+      body: JSON.stringify({
+        app_id: this.config.appId,
+        timestamp,
+        nonce,
+        signature: `v1:${signature}`
+      })
+    });
+    const data = await resp.json();
+    if (data.code !== 0 || !data.data) {
+      throw new Error(`fetch token failed: code=${data.code}, msg=${data.msg}`);
+    }
+    this.token = data.data.access_token;
+    const now = this.config.timeManager.getServerTimestamp();
+    this.tokenExpiresAt = now + (data.data.expires_in - 60) * 1e3;
+    this.tokenRefreshAt = this.tokenExpiresAt - 5 * 60 * 1e3;
+  }
+  // --- Ping / server time sync ---
+  async ensurePing() {
+    const now = Date.now();
+    if (this.pingCalled && this.pingExpiresAt > now) {
+      return;
+    }
+    if (!this.pingCalled || this.pingExpiresAt <= now) {
+      if (this.pingPromise) {
+        await this.pingPromise;
+        return;
+      }
+      this.pingPromise = this.fetchPing();
+      try {
+        await this.pingPromise;
+      } finally {
+        this.pingPromise = null;
+      }
+      return;
+    }
+    if (!this.pingFetching) {
+      this.pingFetching = true;
+      this.fetchPing().finally(() => {
+        this.pingFetching = false;
+      });
+    }
+  }
+  async fetchPing() {
+    const url = this.config.backendUrl + DEFAULT_PING_PATH;
+    const resp = await this.config.httpClient.fetch(url, {
+      method: "GET",
+      headers: { "User-Agent": USER_AGENT }
+    });
+    const data = await resp.json();
+    if (data.code !== 0 || !data.data) {
+      throw new Error(`ping failed: code=${data.code}, msg=${data.msg}`);
+    }
+    this.config.timeManager.syncServerTimestamp(data.data.timestamp);
+    this.pingCalled = true;
+    this.pingExpiresAt = Date.now() + 10 * 60 * 1e3;
+    this.config.logger.info(`ping ok, server version=${data.data.version}, org_code=${data.data.org_code}`);
+  }
+};
+var ALPHANUMERIC2 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function randomAlphanumeric2(size) {
+  const bytes = new Uint8Array(size);
+  crypto.getRandomValues(bytes);
+  let result = "";
+  for (let i = 0; i < size; i++) {
+    result += ALPHANUMERIC2[bytes[i] % 62];
+  }
+  return result;
+}
+
+// src/core/http_client.ts
+var DefaultHttpClient = class {
+  constructor(timeout = 6e4) {
+    this.timeout = timeout;
+  }
+  async fetch(url, init) {
+    if (this.timeout > 0) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      try {
+        return await fetch(url, { ...init, signal: controller.signal });
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    return fetch(url, init);
+  }
+};
+
+// src/core/logger.ts
+var DefaultLogger = class {
+  constructor(level = 1 /* Info */) {
+    this.level = level;
+  }
+  debug(msg, ...args) {
+    if (this.level <= 0 /* Debug */) {
+      console.debug(`[sdk] DEBUG ${msg}`, ...args);
+    }
+  }
+  info(msg, ...args) {
+    if (this.level <= 1 /* Info */) {
+      console.info(`[sdk] INFO ${msg}`, ...args);
+    }
+  }
+  warn(msg, ...args) {
+    if (this.level <= 2 /* Warn */) {
+      console.warn(`[sdk] WARN ${msg}`, ...args);
+    }
+  }
+  error(msg, ...args) {
+    if (this.level <= 3 /* Error */) {
+      console.error(`[sdk] ERROR ${msg}`, ...args);
+    }
+  }
+};
+
+// src/core/time_manager.ts
+var DefaultTimeManager = class {
+  constructor() {
+    this.serverTimeBase = 0;
+    this.systemTimeBase = 0;
+  }
+  getSystemTimestamp() {
+    return Date.now();
+  }
+  getServerTimestamp() {
+    if (this.serverTimeBase === 0) {
+      return this.getSystemTimestamp();
+    }
+    return this.getSystemTimestamp() - this.systemTimeBase + this.serverTimeBase;
+  }
+  syncServerTimestamp(timestamp) {
+    if (timestamp <= this.serverTimeBase) {
+      return;
+    }
+    this.serverTimeBase = timestamp;
+    this.systemTimeBase = this.getSystemTimestamp();
+  }
+};
+
+// src/service/im/v1/chat.ts
+var Chat = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Set typing status
+   * 
+   * Set the typing status, lasts only 5 seconds, direct messages only
+   */
+  async createTyping(req) {
+    const resp = await this.config.apiClient.request({
+      method: "POST",
+      path: `/oapi/im/v1/chats/${req.chat_id ?? ""}/typing`,
+      body: req,
+      withAppAccessToken: true
+    });
+    return await resp.json();
+  }
+  /**
+   * Clear typing status
+   * 
+   * Direct messages only
+   */
+  async deleteTyping(req) {
+    const resp = await this.config.apiClient.request({
+      method: "DELETE",
+      path: `/oapi/im/v1/chats/${req.chat_id ?? ""}/typing`,
+      body: req,
+      withAppAccessToken: true
+    });
+    return await resp.json();
+  }
+};
+
+// src/service/im/v1/message_event.ts
+var MessageEvent = class {
+  constructor(config) {
+    this.handlerMap = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  /** Message received */
+  onMessageReceive(handler) {
+    const wrappedHandler = (header, body) => {
+      const event = {
+        header,
+        body: typeof body === "string" ? JSON.parse(body) : JSON.parse(new TextDecoder().decode(body))
+      };
+      handler(event);
+    };
+    this.handlerMap.set(handler, wrappedHandler);
+    this.config.apiClient.onEvent("im.v1.message.receive", wrappedHandler);
+  }
+  offMessageReceive(handler) {
+    const wrappedHandler = this.handlerMap.get(handler);
+    if (wrappedHandler) {
+      this.config.apiClient.offEvent("im.v1.message.receive", wrappedHandler);
+      this.handlerMap.delete(handler);
+    }
+  }
+};
+
+// src/service/im/v1/message.ts
+var Message = class {
+  constructor(config) {
+    this.config = config;
+    this.Event = new MessageEvent(config);
+  }
+  /** Send a message */
+  async sendMessage(req) {
+    const resp = await this.config.apiClient.request({
+      method: "POST",
+      path: "/oapi/im/v1/messages",
+      body: req,
+      withAppAccessToken: true,
+      withWebSocket: true
+    });
+    return await resp.json();
+  }
+  /** Get a message */
+  async getMessage(req) {
+    const resp = await this.config.apiClient.request({
+      method: "GET",
+      path: `/oapi/im/v1/messages/${req.message_id ?? ""}`,
+      body: req,
+      withAppAccessToken: true
+    });
+    return await resp.json();
+  }
+  /** Recall a message */
+  async recallMessage(req) {
+    const resp = await this.config.apiClient.request({
+      method: "POST",
+      path: `/oapi/im/v1/messages/${req.message_id ?? ""}/recall`,
+      body: req,
+      withAppAccessToken: true
+    });
+    return await resp.json();
+  }
+  /** Mark message as read */
+  async readMessage(req) {
+    const resp = await this.config.apiClient.request({
+      method: "POST",
+      path: `/oapi/im/v1/messages/${req.message_id ?? ""}/read`,
+      body: req,
+      withAppAccessToken: true
+    });
+    return await resp.json();
+  }
+};
+
+// src/service/im/v1/v1.ts
+var V1 = class {
+  constructor(config) {
+    this.Chat = new Chat(config);
+    this.Message = new Message(config);
+  }
+};
+
+// src/service/im/index.ts
+var Service = class {
+  constructor(config) {
+    this.v1 = new V1(config);
+  }
+};
+
+// src/client.ts
+var CoredClient = class _CoredClient {
+  constructor(config) {
+    this.config = config;
+    this.apiClient = config.apiClient;
+    this.Im = new Service(config);
+  }
+  static async create(backendUrl, appId, appSecret, options = {}) {
+    backendUrl = backendUrl.replace(/\/+$/, "");
+    const logger = options.logger ?? new DefaultLogger(options.logLevel ?? 1 /* Info */);
+    const httpClient = options.httpClient ?? new DefaultHttpClient(options.requestTimeout ?? 6e4);
+    const timeManager = options.timeManager ?? new DefaultTimeManager();
+    const jsonMarshal = options.jsonMarshal ?? ((v) => JSON.stringify(v));
+    const jsonUnmarshal = options.jsonUnmarshal ?? ((s) => JSON.parse(s));
+    const config = {
+      appId,
+      appSecret,
+      backendUrl,
+      httpClient,
+      apiClient: null,
+      // will be set below
+      enableEncryption: options.enableEncryption ?? true,
+      requestTimeout: options.requestTimeout ?? 6e4,
+      timeManager,
+      logger,
+      jsonMarshal,
+      jsonUnmarshal
+    };
+    const apiClient = new DefaultApiClient(config);
+    await apiClient.init();
+    config.apiClient = apiClient;
+    return new _CoredClient(config);
+  }
+  async preheat() {
+    await this.apiClient.preheat();
+  }
+  async close() {
+    await this.apiClient.close();
+  }
+};
+export {
+  CoredClient,
+  LoggerLevel,
+  USER_AGENT,
+  VERSION
+};
+//# sourceMappingURL=index.js.map