mezon-light-sdk 1.0.2 → 1.0.4

package/README.md

@@ -1,46 +1,259 @@
-# mezon-p2p-chat-sdk
-
-SDK chat P2P cho mezon-js.
-
-# Version SDK Example using to demo 
-` pip install p2p-chat-sdk `
-# Frontend (Client) use SDK
-
-## 1: Import
-
-``` 
-import { P2PClient, P2PSocket, P2PMessage } from 'p2p-chat-sdk';
-```
-
-## 2: Create P2PClient:
-```
-const p2p_client = await P2PClient.authenticate({ id_token, user_id, username, serverkey });
-```
-## 3: Connect Socket:
-```
-  const p2p_socket = new P2PSocket(p2p_client.getClient(), p2p_client.getSession());
-  await p2p_socket.connect();
-```
-## 4: Listen Message:
-```
-p2p_socket.setChannelMessageHandler((msg: P2PMessage) => {
-console.log('New message:', msg);
-});
-
-```
-
-## 5: Start DM
-
-```
-const channel = await p2p_client.createDM(peerId);
-await p2p_socket.joinDMChannel(channel.channel_id);
-
-```
-
-## 6: Send Message:
-
-```
-await p2p_socket.sendDM(channelId, { t: inputMsg });
-```
-<img width="767" height="775" alt="Screenshot 2025-12-15 132741" src="https://github.com/user-attachments/assets/3019ca86-de5f-49b7-a05a-3895c754029d" />
-
+# Mezon Light SDK
+
+A lightweight SDK for Mezon chat integration, providing simple APIs for authentication, real-time messaging, and direct message management.
+
+## Installation
+
+```bash
+npm install mezon-light-sdk
+```
+
+## Features
+
+- 🔐 Simple authentication with ID tokens
+- 💬 Real-time messaging via WebSocket (protobuf-based)
+- 📨 Direct message (DM) and group DM support
+- 🔄 Automatic session management with token refresh
+- 📎 Attachment support for messages
+- 🎯 TypeScript-first with full type definitions
+- ⚡ Exponential backoff for socket connection reliability
+
+## Quick Start
+
+### 1. Authenticate with ID Token
+
+```typescript
+import { LightClient, AuthenticationError } from 'mezon-light-sdk';
+
+try {
+  const client = await LightClient.authenticate({
+    id_token: 'your-id-token',
+    user_id: 'user-123',
+    username: 'johndoe',
+    serverkey: 'your-server-key',     // optional, uses DEFAULT_SERVER_KEY
+    gateway_url: 'https://gw.mezon.ai' // optional, uses MEZON_GW_URL
+  });
+  
+  console.log('Authenticated as:', client.userId);
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    console.error('Auth failed:', error.message, error.statusCode);
+  }
+}
+```
+
+### 2. Restore Session from Storage
+
+After login, persist the session data and restore it later:
+
+```typescript
+import { LightClient, SessionError } from 'mezon-light-sdk';
+
+// Export session for storage
+const sessionData = client.exportSession();
+// Returns: { token, refresh_token, api_url, user_id }
+localStorage.setItem('mezon_session', JSON.stringify(sessionData));
+
+// Later: restore from storage
+try {
+  const savedData = JSON.parse(localStorage.getItem('mezon_session')!);
+  const client = LightClient.initClient(savedData);
+} catch (error) {
+  if (error instanceof SessionError) {
+    console.error('Session restore failed:', error.message);
+  }
+}
+```
+
+### 3. Session Management
+
+Check and refresh the session before connecting:
+
+```typescript
+// Check if session token is expired
+if (client.isSessionExpired()) {
+  // Check if refresh token is still valid
+  if (!client.isRefreshSessionExpired()) {
+    await client.refreshSession();
+    // Update stored session data
+    localStorage.setItem('mezon_session', JSON.stringify(client.exportSession()));
+  } else {
+    // Both tokens expired - need to re-authenticate
+    console.log('Session fully expired, please login again');
+  }
+}
+
+// Access tokens and session directly if needed
+const token = client.getToken();
+const refreshToken = client.getRefreshToken();
+const session = client.getSession();
+```
+
+### 4. Connect to Real-time Socket
+
+```typescript
+import { LightSocket, SocketError } from 'mezon-light-sdk';
+
+const socket = new LightSocket(client, client.session);
+
+await socket.connect({
+  onError: (error) => console.error('Socket error:', error),
+  onDisconnect: () => console.log('Socket disconnected'),
+  verbose: false // set to true for debug logging
+});
+
+// Check connection status
+console.log('Connected:', socket.isConnected);
+```
+
+### 5. Listen for Messages
+
+```typescript
+// Register a message handler (returns unsubscribe function)
+const unsubscribe = socket.onChannelMessage((message) => {
+  console.log(`Message from ${message.sender_id}: ${message.content}`);
+  console.log('Channel:', message.channel_id);
+  console.log('Timestamp:', message.create_time_seconds);
+});
+
+// Alternative: use setChannelMessageHandler (does not return unsubscribe)
+socket.setChannelMessageHandler((message) => {
+  console.log('Received:', message.content);
+});
+
+// Multiple handlers can be registered
+const unsubscribe2 = socket.onChannelMessage((message) => {
+  // Another handler for the same messages
+});
+
+// Unsubscribe when no longer needed
+unsubscribe();
+unsubscribe2();
+```
+
+### 6. Create and Join Channels
+
+```typescript
+// Create a DM with a single user
+const dmChannel = await client.createDM('peer-user-id');
+await socket.joinDMChannel(dmChannel.channel_id!);
+
+// Create a group DM with multiple users
+const groupDM = await client.createGroupDM(['user-1', 'user-2', 'user-3']);
+await socket.joinGroupChannel(groupDM.channel_id!);
+
+// Leave channels
+await socket.leaveDMChannel(dmChannel.channel_id!);
+await socket.leaveGroupChannel(groupDM.channel_id!);
+```
+
+### 7. Send Messages
+
+```typescript
+// Send a DM message
+await socket.sendDM({
+  channelId: 'channel-123',
+  content: { t: 'Hello, world!' },
+  hideLink: false // optional, whether to hide link previews
+});
+
+// Send a group message
+await socket.sendGroup({
+  channelId: 'group-channel-456',
+  content: { t: 'Hello everyone!' },
+  attachments: [
+    {
+      filename: 'image.png',
+      url: 'https://cdn.mezon.ai/path/to/image.png',
+      filetype: 'image/png',
+      size: 42439,
+      width: 716,
+      height: 522
+    }
+  ],
+  hideLink: true
+});
+```
+
+### 8. Disconnect
+
+```typescript
+// Disconnect when done
+socket.disconnect();
+```
+
+## API Reference
+
+### LightClient
+
+| Property/Method | Description |
+|-----------------|-------------|
+| `LightClient.authenticate(config)` | Static: Authenticate with ID token |
+| `LightClient.initClient(config)` | Static: Initialize from existing tokens |
+| `client.userId` | Get current user ID |
+| `client.session` | Get underlying Session object |
+| `client.client` | Get underlying MezonApi client |
+| `client.createDM(peerId)` | Create a DM channel with one user |
+| `client.createGroupDM(userIds)` | Create a group DM with multiple users |
+| `client.refreshSession()` | Refresh the session using refresh token |
+| `client.isSessionExpired()` | Check if session token is expired |
+| `client.isRefreshSessionExpired()` | Check if refresh token is expired |
+| `client.getToken()` | Get the current auth token |
+| `client.getRefreshToken()` | Get the refresh token |
+| `client.getSession()` | Get the current session object |
+| `client.exportSession()` | Export session data for persistence |
+| `client.createSocket(verbose?, adapter?, timeout?)` | Create a raw socket instance |
+
+### LightSocket
+
+| Property/Method | Description |
+|-----------------|-------------|
+| `new LightSocket(client, session)` | Create a new socket instance |
+| `socket.connect(options?)` | Connect to real-time server |
+| `socket.disconnect()` | Disconnect from server |
+| `socket.isConnected` | Check if socket is connected |
+| `socket.socket` | Get underlying Socket (throws if not connected) |
+| `socket.onChannelMessage(handler)` | Register message handler, returns unsubscribe fn |
+| `socket.setChannelMessageHandler(handler)` | Register message handler (alias) |
+| `socket.joinDMChannel(channelId)` | Join a DM channel |
+| `socket.joinGroupChannel(channelId)` | Join a group channel |
+| `socket.leaveDMChannel(channelId)` | Leave a DM channel |
+| `socket.leaveGroupChannel(channelId)` | Leave a group channel |
+| `socket.sendDM(payload)` | Send a DM message |
+| `socket.sendGroup(payload)` | Send a group message |
+| `socket.setErrorHandler(handler)` | Set custom error handler |
+
+### Types
+
+```typescript
+interface ClientInitConfig {
+  token: string;           // Auth token
+  refresh_token: string;   // Refresh token
+  api_url: string;         // API URL
+  user_id: string;         // User ID
+  serverkey?: string;      // Optional server key
+}
+
+interface AuthenticateConfig {
+  id_token: string;        // ID token from provider
+  user_id: string;         // User ID
+  username: string;        // Username
+  serverkey?: string;      // Optional server key
+  gateway_url?: string;    // Optional gateway URL
+}
+
+interface SendMessagePayload {
+  channelId: string;                  // Target channel
+  content: unknown;                   // Message content
+  attachments?: ApiMessageAttachment[]; // Optional attachments
+  hideLink?: boolean;                 // Hide link previews
+}
+
+interface SocketConnectOptions {
+  onError?: (error: unknown) => void;  // Error callback
+  onDisconnect?: () => void;           // Disconnect callback
+  verbose?: boolean;                    // Enable debug logging
+}
+```
+
+---

package/package.json

@@ -1,23 +1,43 @@
-{
-  "name": "mezon-light-sdk",
-  "version": "1.0.2",
-  "description": "Lightweigth SDK for mezon chat.",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "js-base64": "^3.7.8",
-    "mezon-js": "^2.13.58",
-    "mezon-js-protobuf": "^1.8.66"
-  },
-  "author": "mezonai",
-  "license": "MIT",
-  "devDependencies": {
-    "typescript": "^5.4.3"
-  }
-}
+{
+  "name": "mezon-light-sdk",
+  "version": "1.0.4",
+  "description": "lightweight SDK for mezon chat.",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.mjs",
+      "require": "./dist/index.cjs.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "node build.mjs && tsc --emitDeclarationOnly",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:bundle": "node build.mjs"
+  },
+  "dependencies": {
+    "js-base64": "^3.7.8",
+    "protobufjs": "^8.0.0"
+  },
+  "peerDependencies": {
+    "long": "^5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "long": {
+      "optional": true
+    }
+  },
+  "author": "mezonai",
+  "license": "MIT",
+  "devDependencies": {
+    "esbuild": "^0.24.0",
+    "typescript": "^5.4.3"
+  }
+}

package/dist/client.d.ts

@@ -1,26 +0,0 @@
-import { Session, Client } from 'mezon-js';
-export declare class LightClient {
-    private session;
-    private client;
-    user_id: string;
-    private constructor();
-    static initClient({ token, refresh_token, api_url, user_id, serverkey }: {
-        token: string;
-        refresh_token: string;
-        api_url: string;
-        user_id: string;
-        serverkey: string;
-    }): LightClient;
-    static authenticate({ id_token, user_id, username, serverkey }: {
-        id_token: string;
-        user_id: string;
-        username: string;
-        serverkey: string;
-    }): Promise<LightClient>;
-    createDM(peer_id: string): Promise<import("mezon-js/dist/api.gen").ApiChannelDescription>;
-    refreshSession(): Promise<void>;
-    isSessionExpired(): Promise<boolean>;
-    isRefreshSessionExpired(): Promise<boolean>;
-    getSession(): Session;
-    getClient(): Client;
-}

package/dist/client.js

@@ -1,90 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightClient = void 0;
-const mezon_js_1 = require("mezon-js");
-const constants_1 = require("./constants");
-const base64 = __importStar(require("js-base64"));
-class LightClient {
-    constructor(session, client, user_id) {
-        this.session = session;
-        this.client = client;
-        this.user_id = user_id;
-    }
-    static initClient({ token, refresh_token, api_url, user_id, serverkey }) {
-        if (!token || !refresh_token || !api_url || !user_id) {
-            throw new Error('Missing required fields to restore session from storage');
-        }
-        const session = mezon_js_1.Session.restore(token, refresh_token, api_url, true);
-        const url = new URL(api_url);
-        const client = new mezon_js_1.Client(serverkey || 'DefaultServerKey', url.hostname, url.port || '', url.protocol === 'https:');
-        return new LightClient(session, client, user_id);
-    }
-    static async authenticate({ id_token, user_id, username, serverkey }) {
-        const res = await fetch(constants_1.MEZON_GW_URL + '/v2/account/authenticate/idtoken', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': 'Basic ' + base64.encode(serverkey || 'DefaultServerKey')
-            },
-            body: JSON.stringify({ id_token, user_id, username })
-        });
-        if (!res.ok) {
-            const errData = await res.json().catch(() => ({}));
-            throw new Error(errData.message || 'Error during authentication request');
-        }
-        const data = await res.json();
-        if (data && data.token && data.refresh_token && data.api_url && data.user_id) {
-            const session = mezon_js_1.Session.restore(data.token, data.refresh_token, data.api_url, true);
-            const url = new URL(data.api_url);
-            const client = new mezon_js_1.Client(serverkey || 'DefaultServerKey', url.hostname, url.port || '', url.protocol === 'https:');
-            return new LightClient(session, client, data.user_id);
-        }
-        else {
-            throw new Error('Error during authentication or missing data fields!');
-        }
-    }
-    async createDM(peer_id) {
-        const req = { type: mezon_js_1.ChannelType.CHANNEL_TYPE_DM, channel_private: 1, user_ids: [peer_id] };
-        const channel = await this.client.createChannelDesc(this.session, req);
-        return channel;
-    }
-    async refreshSession() {
-        await this.client.sessionRefresh(this.session);
-    }
-    async isSessionExpired() {
-        return this.session.isexpired(Date.now() / 1000);
-    }
-    async isRefreshSessionExpired() {
-        return this.session.isrefreshexpired(Date.now() / 1000);
-    }
-    getSession() {
-        return this.session;
-    }
-    getClient() {
-        return this.client;
-    }
-}
-exports.LightClient = LightClient;

package/dist/constants.d.ts

@@ -1,4 +0,0 @@
-export declare const MEZON_GW_URL = "https://gw.mezon.ai";
-export declare const SOCKET_READY_MAX_RETRY = 20;
-export declare const SOCKET_READY_RETRY_DELAY = 100;
-export declare const CLAN_DM = "0";

package/dist/constants.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLAN_DM = exports.SOCKET_READY_RETRY_DELAY = exports.SOCKET_READY_MAX_RETRY = exports.MEZON_GW_URL = void 0;
-exports.MEZON_GW_URL = 'https://gw.mezon.ai';
-exports.SOCKET_READY_MAX_RETRY = 20;
-exports.SOCKET_READY_RETRY_DELAY = 100;
-exports.CLAN_DM = '0';

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from './constants';
-export * from './message';
-export * from './client';
-export * from './socket';

package/dist/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./constants"), exports);
-__exportStar(require("./message"), exports);
-__exportStar(require("./client"), exports);
-__exportStar(require("./socket"), exports);

package/dist/message.d.ts

@@ -1,19 +0,0 @@
-export interface ChannelMessage {
-    clan_id: string;
-    channel_id: string;
-    message_id: string;
-    code: number;
-    sender_id: string;
-    username: string;
-    avatar: string;
-    content: any;
-    create_time: string;
-    update_time: string;
-    display_name: string;
-    mentions: any[];
-    attachments: any[];
-    references: any[];
-    create_time_seconds: number;
-    update_time_seconds: number;
-    hide_editted: boolean;
-}

package/dist/message.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/socket.d.ts

@@ -1,13 +0,0 @@
-import { Client, Session } from "mezon-js";
-import { ChannelMessage } from "./message";
-export declare class LightSocket {
-    private client;
-    private session;
-    private socket;
-    onError?: (err: any) => void;
-    constructor(client: Client, session: Session);
-    connect(onError?: (err: any) => void): Promise<void>;
-    setChannelMessageHandler(cb: (msg: ChannelMessage) => void): void;
-    joinDMChannel(channel_id: string): Promise<void>;
-    sendDM(channelId: string, content: any, attachments?: any[]): Promise<void>;
-}

package/dist/socket.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightSocket = void 0;
-const mezon_js_protobuf_1 = require("mezon-js-protobuf");
-const mezon_js_1 = require("mezon-js");
-const constants_1 = require("./constants");
-class LightSocket {
-    constructor(client, session) {
-        this.client = client;
-        this.session = session;
-    }
-    async connect(onError) {
-        this.socket = this.client.createSocket(this.client.useSSL, false, new mezon_js_protobuf_1.WebSocketAdapterPb());
-        this.socket.onerror = onError || (() => { });
-        await this.socket.connect(this.session, true, "0");
-    }
-    setChannelMessageHandler(cb) {
-        this.socket.onchannelmessage = (msg) => {
-            if (msg && msg.error) {
-                if (this.onError)
-                    this.onError(msg.error);
-                return;
-            }
-            cb({
-                clan_id: msg.clan_id,
-                channel_id: msg.channel_id,
-                message_id: msg.message_id || msg.id,
-                code: msg.code,
-                sender_id: msg.sender_id,
-                username: msg.username,
-                avatar: msg.avatar,
-                content: msg.content,
-                create_time: msg.create_time,
-                update_time: msg.update_time,
-                display_name: msg.display_name,
-                mentions: msg.mentions || [],
-                attachments: msg.attachments || [],
-                references: msg.references || [],
-                create_time_seconds: msg.create_time_seconds,
-                update_time_seconds: msg.update_time_seconds,
-                hide_editted: msg.hide_editted,
-            });
-        };
-    }
-    async joinDMChannel(channel_id) {
-        await waitForSocketReady(this.socket);
-        await this.socket.joinChat(constants_1.CLAN_DM, channel_id, mezon_js_1.ChannelType.CHANNEL_TYPE_DM, false);
-    }
-    async sendDM(channelId, content, attachments = []) {
-        this.socket.writeChatMessage(constants_1.CLAN_DM, channelId, mezon_js_1.ChannelStreamMode.STREAM_MODE_DM, false, content, attachments, [], [], false, false, "", 0);
-    }
-}
-exports.LightSocket = LightSocket;
-async function waitForSocketReady(socket) {
-    let count = 0;
-    let delay = constants_1.SOCKET_READY_RETRY_DELAY;
-    while (!(socket.adapter && socket.adapter.isOpen()) &&
-        count < constants_1.SOCKET_READY_MAX_RETRY) {
-        await new Promise((r) => setTimeout(r, delay));
-        delay *= 2;
-        count++;
-    }
-    if (!(socket.adapter && socket.adapter.isOpen()))
-        throw new Error("Socket not open");
-}