mezon-light-sdk 1.0.2

package/README.md

@@ -0,0 +1,46 @@
+# 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" />
+

package/dist/client.d.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,90 @@
+"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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,7 @@
+"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

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

package/dist/index.js

@@ -0,0 +1,20 @@
+"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

@@ -0,0 +1,19 @@
+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

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

package/dist/socket.d.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,65 @@
+"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");
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "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"
+  }
+}