@itsonlyzenn/baileys 1.1.0

package/lib/libsignal-patched/src/session_record.js

@@ -0,0 +1,315 @@
+// vim: ts=4:sw=4
+
+const BaseKeyType = require('./base_key_type.js');
+
+const CLOSED_SESSIONS_MAX = 40;
+const SESSION_RECORD_VERSION = 'v1';
+
+function assertBuffer(value) {
+    if (!Buffer.isBuffer(value)) {
+        throw new TypeError("Buffer required");
+    }
+}
+
+
+class SessionEntry {
+
+    constructor() {
+        this._chains = {};
+    }
+
+    toString() {
+        const baseKey = this.indexInfo && this.indexInfo.baseKey &&
+            this.indexInfo.baseKey.toString('base64');
+        return `<SessionEntry [baseKey=${baseKey}]>`;
+    }
+
+    inspect() {
+        return this.toString();
+    }
+
+    addChain(key, value) {
+        assertBuffer(key);
+        const id = key.toString('base64');
+        if (this._chains.hasOwnProperty(id)) {
+            throw new Error("Overwrite attempt");
+        }
+        this._chains[id] = value;
+    }
+
+    getChain(key) {
+        assertBuffer(key);
+        return this._chains[key.toString('base64')];
+    }
+
+    deleteChain(key) {
+        assertBuffer(key);
+        const id = key.toString('base64');
+        if (!this._chains.hasOwnProperty(id)) {
+            throw new ReferenceError("Not Found");
+        }
+        delete this._chains[id];
+    }
+
+    *chains() {
+        for (const [k, v] of Object.entries(this._chains)) {
+            yield [Buffer.from(k, 'base64'), v];
+        }
+    }
+
+    serialize() {
+        const data = {
+            registrationId: this.registrationId,
+            currentRatchet: {
+                ephemeralKeyPair: {
+                    pubKey: this.currentRatchet.ephemeralKeyPair.pubKey.toString('base64'),
+                    privKey: this.currentRatchet.ephemeralKeyPair.privKey.toString('base64')
+                },
+                lastRemoteEphemeralKey: this.currentRatchet.lastRemoteEphemeralKey.toString('base64'),
+                previousCounter: this.currentRatchet.previousCounter,
+                rootKey: this.currentRatchet.rootKey.toString('base64')
+            },
+            indexInfo: {
+                baseKey: this.indexInfo.baseKey.toString('base64'),
+                baseKeyType: this.indexInfo.baseKeyType,
+                closed: this.indexInfo.closed,
+                used: this.indexInfo.used,
+                created: this.indexInfo.created,
+                remoteIdentityKey: this.indexInfo.remoteIdentityKey.toString('base64')
+            },
+            _chains: this._serialize_chains(this._chains)
+        };
+        if (this.pendingPreKey) {
+            data.pendingPreKey = Object.assign({}, this.pendingPreKey);
+            data.pendingPreKey.baseKey = this.pendingPreKey.baseKey.toString('base64');
+        }
+        return data;
+    }
+
+    static deserialize(data) {
+        const obj = new this();
+        obj.registrationId = data.registrationId;
+        obj.currentRatchet = {
+            ephemeralKeyPair: {
+                pubKey: Buffer.from(data.currentRatchet.ephemeralKeyPair.pubKey, 'base64'),
+                privKey: Buffer.from(data.currentRatchet.ephemeralKeyPair.privKey, 'base64')
+            },
+            lastRemoteEphemeralKey: Buffer.from(data.currentRatchet.lastRemoteEphemeralKey, 'base64'),
+            previousCounter: data.currentRatchet.previousCounter,
+            rootKey: Buffer.from(data.currentRatchet.rootKey, 'base64')
+        };
+        obj.indexInfo = {
+            baseKey: Buffer.from(data.indexInfo.baseKey, 'base64'),
+            baseKeyType: data.indexInfo.baseKeyType,
+            closed: data.indexInfo.closed,
+            used: data.indexInfo.used,
+            created: data.indexInfo.created,
+            remoteIdentityKey: Buffer.from(data.indexInfo.remoteIdentityKey, 'base64')
+        };
+        obj._chains = this._deserialize_chains(data._chains);
+        if (data.pendingPreKey) {
+            obj.pendingPreKey = Object.assign({}, data.pendingPreKey);
+            obj.pendingPreKey.baseKey = Buffer.from(data.pendingPreKey.baseKey, 'base64');
+        }
+        return obj;
+    }
+
+    _serialize_chains(chains) {
+        const r = {};
+        for (const key of Object.keys(chains)) {
+            const c = chains[key];
+            const messageKeys = {};
+            for (const [idx, key] of Object.entries(c.messageKeys)) {
+                messageKeys[idx] = key.toString('base64');
+            }
+            r[key] = {
+                chainKey: {
+                    counter: c.chainKey.counter,
+                    key: c.chainKey.key && c.chainKey.key.toString('base64')
+                },
+                chainType: c.chainType,
+                messageKeys: messageKeys
+            };
+        }
+        return r;
+    }
+
+    static _deserialize_chains(chains_data) {
+        const r = {};
+        for (const key of Object.keys(chains_data)) {
+            const c = chains_data[key];
+            const messageKeys = {};
+            for (const [idx, key] of Object.entries(c.messageKeys)) {
+                messageKeys[idx] = Buffer.from(key, 'base64');
+            }
+            r[key] = {
+                chainKey: {
+                    counter: c.chainKey.counter,
+                    key: c.chainKey.key && Buffer.from(c.chainKey.key, 'base64')
+                },
+                chainType: c.chainType,
+                messageKeys: messageKeys
+            };
+        }
+        return r;
+    }
+
+}
+
+
+const migrations = [{
+    version: 'v1',
+    migrate: function migrateV1(data) {
+        const sessions = data._sessions;
+        if (data.registrationId) {
+            for (const key in sessions) {
+                if (!sessions[key].registrationId) {
+                    sessions[key].registrationId = data.registrationId;
+                }
+            }
+        } else {
+            for (const key in sessions) {
+                if (sessions[key].indexInfo.closed === -1) {
+                    console.error('V1 session storage migration error: registrationId',
+                                  data.registrationId, 'for open session version',
+                                  data.version);
+                }
+            }
+        }
+    }
+}];
+
+
+class SessionRecord {
+
+    static createEntry() {
+        return new SessionEntry();
+    }
+
+    static migrate(data) {
+        let run = (data.version === undefined);
+        for (let i = 0; i < migrations.length; ++i) {
+            if (run) {
+                console.info("Migrating session to:", migrations[i].version);
+                migrations[i].migrate(data);
+            } else if (migrations[i].version === data.version) {
+                run = true;
+            }
+        }
+        if (!run) {
+            throw new Error("Error migrating SessionRecord");
+        }
+    }
+
+    static deserialize(data) {
+        if (data.version !== SESSION_RECORD_VERSION) {
+            this.migrate(data);
+        }
+        const obj = new this();
+        if (data._sessions) {
+            for (const [key, entry] of Object.entries(data._sessions)) {
+                obj.sessions[key] = SessionEntry.deserialize(entry);
+            }
+        }
+        return obj;
+    }
+
+    constructor() {
+        this.sessions = {};
+        this.version = SESSION_RECORD_VERSION;
+    }
+
+    serialize() {
+        const _sessions = {};
+        for (const [key, entry] of Object.entries(this.sessions)) {
+            _sessions[key] = entry.serialize();
+        }
+        return {
+            _sessions,
+            version: this.version
+        };
+    }
+
+    haveOpenSession() {
+        const openSession = this.getOpenSession();
+        return (!!openSession && typeof openSession.registrationId === 'number');
+    }
+
+    getSession(key) {
+        assertBuffer(key);
+        const session = this.sessions[key.toString('base64')];
+        if (session && session.indexInfo.baseKeyType === BaseKeyType.OURS) {
+            throw new Error("Tried to lookup a session using our basekey");
+        }
+        return session;
+    }
+
+    getOpenSession() {
+        for (const session of Object.values(this.sessions)) {
+            if (!this.isClosed(session)) {
+                return session;
+            }
+        }
+    }
+
+    setSession(session) {
+        this.sessions[session.indexInfo.baseKey.toString('base64')] = session;
+    }
+
+    getSessions() {
+        // Return sessions ordered with most recently used first.
+        return Array.from(Object.values(this.sessions)).sort((a, b) => {
+            const aUsed = a.indexInfo.used || 0;
+            const bUsed = b.indexInfo.used || 0;
+            return aUsed === bUsed ? 0 : aUsed < bUsed ? 1 : -1;
+        });
+    }
+
+    closeSession(session) {
+        if (this.isClosed(session)) {
+            console.warn("Session already closed", session);
+            return;
+        }
+        console.log("PATCH WORKS") // tambah ini sementara
+        session.indexInfo.closed = Date.now();
+    }
+
+    openSession(session) {
+        if (!this.isClosed(session)) {
+            console.warn("Session already open");
+        }
+        session.indexInfo.closed = -1;
+    }
+
+    isClosed(session) {
+        return session.indexInfo.closed !== -1;
+    }
+
+    removeOldSessions() {
+        while (Object.keys(this.sessions).length > CLOSED_SESSIONS_MAX) {
+            let oldestKey;
+            let oldestSession;
+            for (const [key, session] of Object.entries(this.sessions)) {
+                if (session.indexInfo.closed !== -1 &&
+                    (!oldestSession || session.indexInfo.closed < oldestSession.indexInfo.closed)) {
+                    oldestKey = key;
+                    oldestSession = session;
+                }
+            }
+            if (oldestKey) {
+                console.info("Removing old closed session:", oldestSession);
+                delete this.sessions[oldestKey];
+            } else {
+                throw new Error('Corrupt sessions object');
+            }
+        }
+    }
+
+    deleteAllSessions() {
+        for (const key of Object.keys(this.sessions)) {
+            delete this.sessions[key];
+        }
+    }
+}
+
+module.exports = SessionRecord;

package/package.json

@@ -0,0 +1,138 @@
+{
+  "name": "@itsonlyzenn/baileys",
+  "type": "module",
+  "version": "1.1.0",
+  "description": "A WebSockets library for interacting with WhatsApp Web",
+  "keywords": [
+    "whatsapp",
+    "automation"
+  ],
+  "homepage": "https://github.com/WhiskeySockets/Baileys/",
+  "repository": {
+    "url": "git@github.com:WhiskeySockets/Baileys.git"
+  },
+  "license": "MIT",
+  "author": "Rajeh Taher",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*",
+    "WAProto/**/*",
+    "engine-requirements.js"
+  ],
+  "scripts": {
+    "build:all": "npm run build && npm run build:docs",
+    "build:docs": "typedoc",
+    "build": "tsc -P tsconfig.build.json && tsc-esm-fix --tsconfig=tsconfig.build.json --ext=.js",
+    "changelog:last": "conventional-changelog -p angular -r 2",
+    "changelog:preview": "conventional-changelog -p angular -u",
+    "changelog:update": "conventional-changelog -p angular -i CHANGELOG.md -s -r 0",
+    "example": "tsx ./Example/example.ts",
+    "gen:protobuf": "sh WAProto/GenerateStatics.sh",
+    "format": "prettier --write \"src/**/*.{ts,js,json,md}\"",
+    "lint": "tsc && eslint src --ext .js,.ts",
+    "lint:fix": "npm run format && npm run lint -- --fix",
+    "prepack": "npm run build",
+    "prepare": "npm run build",
+    "preinstall": "node ./engine-requirements.js",
+    "release": "release-it",
+    "test": "node --experimental-vm-modules ./node_modules/.bin/jest --testMatch '**/*.test.ts'",
+    "test:e2e": "NODE_TLS_REJECT_UNAUTHORIZED=0 node --experimental-vm-modules ./node_modules/.bin/jest --runInBand --forceExit --testMatch '**/*.test-e2e.ts'",
+    "update:version": "tsx ./scripts/update-version.ts"
+  },
+  "dependencies": {
+    "@cacheable/node-cache": "^1.4.0",
+    "@hapi/boom": "^9.1.3",
+    "async-mutex": "^0.5.0",
+    "libsignal": "^6.0.0",
+    "music-metadata": "^11.12.3",
+    "p-queue": "^9.2.0",
+    "pino": "^9.6",
+    "protobufjs": "^7.5.6",
+    "whatsapp-rust-bridge": "0.5.4",
+    "ws": "^8.13.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.31.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.9.0",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "@whiskeysockets/eslint-config": "^1.0.0",
+    "conventional-changelog": "^7.1.1",
+    "conventional-changelog-angular": "^8.0.0",
+    "esbuild-register": "^3.6.0",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-prettier": "^5.4.0",
+    "jest": "^30.0.5",
+    "jimp": "^1.6.1",
+    "jiti": "^2.4.2",
+    "json": "^11.0.0",
+    "link-preview-js": "^3.2.0",
+    "lru-cache": "^11.3.6",
+    "open": "^8.4.2",
+    "pino-pretty": "^13.1.1",
+    "prettier": "^3.5.3",
+    "protobufjs-cli": "^1.1.3",
+    "release-it": "^20.0.1",
+    "ts-jest": "^29.4.0",
+    "tsc-esm-fix": "^3.1.2",
+    "tsx": "^4.20.3",
+    "typedoc": "^0.27.9",
+    "typedoc-plugin-markdown": "4.4.2",
+    "typescript": "^5.8.2"
+  },
+  "peerDependencies": {
+    "audio-decode": "^2.1.3",
+    "jimp": "^1.6.1",
+    "link-preview-js": "^3.0.0",
+    "sharp": "*"
+  },
+  "resolutions": {
+    "ajv@npm:^6.12.4": "^6.14.0",
+    "basic-ftp": "^5.2.4",
+    "brace-expansion@npm:^1.1.7": "^1.1.13",
+    "brace-expansion@npm:^2.0.1": "^2.0.3",
+    "flatted": "^3.4.2",
+    "glob@npm:^10.2.2": "^10.5.0",
+    "glob@npm:^10.3.10": "^10.5.0",
+    "glob@npm:^10.5.0": "^10.5.0",
+    "handlebars": "^4.7.9",
+    "ip-address": "^10.1.1",
+    "js-yaml@npm:^3.13.1": "^3.14.2",
+    "js-yaml@npm:^4.1.0": "^4.1.1",
+    "markdown-it": "^14.1.1",
+    "minimatch@npm:^3.0.4": "^3.1.5",
+    "minimatch@npm:^3.1.2": "^3.1.5",
+    "minimatch@npm:^5.0.1": "^5.1.8",
+    "minimatch@npm:^9.0.4": "^9.0.9",
+    "minimatch@npm:^9.0.5": "^9.0.9",
+    "picomatch@npm:^2.0.4": "^2.3.2",
+    "picomatch@npm:^2.3.1": "^2.3.2",
+    "picomatch@npm:^4.0.0": "^4.0.4",
+    "picomatch@npm:^4.0.2": "^4.0.4",
+    "socks": "^2.8.8",
+    "tar": "^7.5.11",
+    "tmp": "^0.2.5",
+    "underscore": "^1.13.8",
+    "yaml@npm:^2.6.1": "^2.8.4"
+  },
+  "peerDependenciesMeta": {
+    "audio-decode": {
+      "optional": true
+    },
+    "jimp": {
+      "optional": true
+    },
+    "link-preview-js": {
+      "optional": true
+    }
+  },
+  "packageManager": "yarn@4.9.2",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}