@lazyneoaz/metachat 1.0.9 → 1.0.10

package/src/app/config.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const CONFIG_FILE = "fca-config.json";
+
+const DEFAULT_CONFIG = {
+    checkUpdate: {
+        enabled: false,
+        install: false,
+        notifyIfCurrent: false,
+        packageName: "@lazyneoaz/metachat",
+        registryUrl: "https://registry.npmjs.org",
+        timeoutMs: 10000,
+    },
+    mqtt: {
+        enabled: true,
+        reconnectInterval: 3600,
+    },
+    credentials: {
+        email: "",
+        password: "",
+        twofactor: "",
+    },
+    antiGetInfo: {
+        AntiGetThreadInfo: false,
+        AntiGetUserInfo: false,
+    },
+    remoteControl: {
+        enabled: false,
+        url: "",
+        token: "",
+        autoReconnect: true,
+    },
+};
+
+function defaultConfig() {
+    return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+}
+
+function loadConfig() {
+    const configPath = path.resolve(process.cwd(), CONFIG_FILE);
+    let fileConfig = {};
+    let created = false;
+
+    try {
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, "utf8");
+            fileConfig = JSON.parse(raw);
+        } else {
+            try {
+                fs.writeFileSync(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf8");
+                created = true;
+            } catch (_) {}
+        }
+    } catch (_) {}
+
+    const config = resolveConfig(fileConfig);
+    return { config, created };
+}
+
+function resolveConfig(partial = {}) {
+    const base = defaultConfig();
+    return deepMerge(base, partial);
+}
+
+function deepMerge(target, source) {
+    const out = Object.assign({}, target);
+    for (const key of Object.keys(source || {})) {
+        if (
+            source[key] !== null &&
+            typeof source[key] === "object" &&
+            !Array.isArray(source[key]) &&
+            typeof target[key] === "object" &&
+            target[key] !== null
+        ) {
+            out[key] = deepMerge(target[key], source[key]);
+        } else {
+            out[key] = source[key];
+        }
+    }
+    return out;
+}
+
+function writeConfigTemplate(destPath) {
+    const target = destPath || path.resolve(process.cwd(), "fca-config.example.json");
+    fs.writeFileSync(target, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf8");
+    return target;
+}
+
+module.exports = {
+    defaultConfig,
+    loadConfig,
+    resolveConfig,
+    writeConfigTemplate,
+};

package/src/app/createFcaClient.js

@@ -0,0 +1,179 @@
+"use strict";
+
+function compactNamespace(ns) {
+    if (!ns || typeof ns !== "object") return ns;
+    const out = {};
+    for (const [k, v] of Object.entries(ns)) {
+        if (typeof v === "function") out[k] = v;
+    }
+    return out;
+}
+
+function buildFallbackMessages(api) {
+    return {
+        send: api.sendMessage?.bind(api),
+        edit: api.editMessage?.bind(api),
+        unsend: api.unsendMessage?.bind(api),
+        delete: api.deleteMessage?.bind(api),
+        setReaction: api.setMessageReaction?.bind(api),
+        sendTyping: api.sendTypingIndicator?.bind(api),
+        markRead: api.markAsRead?.bind(api),
+        markDelivered: api.markAsDelivered?.bind(api),
+        markSeen: api.markAsSeen?.bind(api),
+        markReadAll: api.markAsReadAll?.bind(api),
+        upload: api.uploadAttachment?.bind(api),
+        forward: api.forwardAttachment?.bind(api),
+        forwardMessage: api.forwardMessage?.bind(api),
+        shareContact: api.shareContact?.bind(api),
+        changeColor: api.changeThreadColor?.bind(api),
+        changeEmoji: api.changeThreadEmoji?.bind(api),
+        getMessage: api.getMessage?.bind(api),
+        getEmojiUrl: api.getEmojiUrl?.bind(api),
+        resolvePhotoUrl: api.resolvePhotoUrl?.bind(api),
+        getThreadColors: api.getThreadColors?.bind(api),
+    };
+}
+
+function buildFallbackThreads(api) {
+    return {
+        getInfo: api.getThreadInfo?.bind(api),
+        getList: api.getThreadList?.bind(api),
+        getHistory: api.getThreadHistory?.bind(api),
+        getPictures: api.getThreadPictures?.bind(api),
+        getThemePictures: api.getThemePictures?.bind(api),
+        search: api.searchForThread?.bind(api),
+        createGroup: api.createNewGroup?.bind(api),
+        addUser: api.addUserToGroup?.bind(api),
+        removeUser: api.removeUserFromGroup?.bind(api),
+        changeAdmin: api.changeAdminStatus?.bind(api),
+        changeImage: api.changeGroupImage?.bind(api),
+        changeNickname: (api.setNickname || api.nickname || api.changeNickname)?.bind(api),
+        setTitle: api.setTitle?.bind(api),
+        createPoll: api.createPoll?.bind(api),
+        createThemeAI: api.createAITheme?.bind(api),
+        delete: api.deleteThread?.bind(api),
+        archive: api.changeArchivedStatus?.bind(api),
+        mute: api.muteThread?.bind(api),
+        handleRequest: api.handleMessageRequest?.bind(api),
+    };
+}
+
+function buildFallbackUsers(api) {
+    return {
+        getInfo: api.getUserInfo?.bind(api),
+        getInfoV2: api.getUserInfoV2?.bind(api),
+        getID: api.getUserID?.bind(api),
+        getFriendsList: api.getFriendsList?.bind(api),
+    };
+}
+
+function buildFallbackAccount(api) {
+    return {
+        getCurrentUserID: api.getCurrentUserID?.bind(api),
+        changeAvatar: api.changeAvatar?.bind(api),
+        changeBio: api.changeBio?.bind(api),
+        changeBlocked: api.changeBlockedStatus?.bind(api),
+        handleFriendReq: api.handleFriendRequest?.bind(api),
+        unfriend: api.unfriend?.bind(api),
+        setPostReaction: api.setPostReaction?.bind(api),
+        refreshDtsg: api.refreshFb_dtsg?.bind(api),
+        logout: api.logout?.bind(api),
+        addModule: api.addExternalModule?.bind(api),
+        enableAutoSave: api.enableAutoSaveAppState?.bind(api),
+    };
+}
+
+function buildFallbackRealtime(api) {
+    return {
+        listen: api.listenMqtt?.bind(api),
+        stopListening: api.stopListening?.bind(api),
+    };
+}
+
+function buildFallbackHttp(api) {
+    return {
+        get: api.httpGet?.bind(api),
+        post: api.httpPost?.bind(api),
+        postFormData: api.httpPostFormData?.bind(api),
+    };
+}
+
+function buildFallbackScheduler(api) {
+    return {
+        schedule: api.scheduler?.schedule?.bind(api.scheduler),
+    };
+}
+
+function createFcaClient(api) {
+    const messages = compactNamespace(buildFallbackMessages(api));
+    const threads = compactNamespace(buildFallbackThreads(api));
+    const users = compactNamespace(buildFallbackUsers(api));
+    const account = compactNamespace(buildFallbackAccount(api));
+    const realtime = compactNamespace(buildFallbackRealtime(api));
+    const http = compactNamespace(buildFallbackHttp(api));
+    const scheduler = compactNamespace(buildFallbackScheduler(api));
+
+    return {
+        raw: api,
+        messages,
+        threads,
+        users,
+        account,
+        realtime,
+        http,
+        scheduler,
+    };
+}
+
+function attachClientFacade(api) {
+    const client = createFcaClient(api);
+    api.client = client;
+    if (!api.messages) api.messages = client.messages;
+    if (!api.threads) api.threads = client.threads;
+    if (!api.users) api.users = client.users;
+    if (!api.account) api.account = client.account;
+    if (!api.realtime) api.realtime = client.realtime;
+    if (!api.http) api.http = client.http;
+    if (!api.scheduler) api.scheduler = client.scheduler;
+    return client;
+}
+
+function createMessagesDomain(api) {
+    return compactNamespace(buildFallbackMessages(api));
+}
+
+function createThreadsDomain(api) {
+    return compactNamespace(buildFallbackThreads(api));
+}
+
+function createUsersDomain(api) {
+    return compactNamespace(buildFallbackUsers(api));
+}
+
+function createAccountDomain(api) {
+    return compactNamespace(buildFallbackAccount(api));
+}
+
+function createRealtimeDomain(api) {
+    return compactNamespace(buildFallbackRealtime(api));
+}
+
+function createHttpDomain(api) {
+    return compactNamespace(buildFallbackHttp(api));
+}
+
+function createSchedulerDomain(api) {
+    return compactNamespace(buildFallbackScheduler(api));
+}
+
+module.exports = {
+    createFcaClient,
+    attachClientFacade,
+    createMessagesDomain,
+    createThreadsDomain,
+    createUsersDomain,
+    createAccountDomain,
+    createRealtimeDomain,
+    createHttpDomain,
+    createSchedulerDomain,
+};

package/src/app/state.js

@@ -0,0 +1,117 @@
+"use strict";
+
+const EventEmitter = require("events");
+
+/**
+ * Creates a blank FcaContext object (API compat with @dongdev/fca-unofficial).
+ * @returns {object}
+ */
+function createDefaultContext() {
+    return {
+        userID: "",
+        fbid: "",
+        cookieString: "",
+        jar: null,
+        clientID: undefined,
+        appID: undefined,
+        globalOptions: {},
+        options: {},
+        loggedIn: false,
+        access_token: "NONE",
+        clientMutationId: 0,
+        mqttClient: undefined,
+        lastSeqId: null,
+        syncToken: undefined,
+        mqttEndpoint: undefined,
+        wsReqNumber: 0,
+        wsTaskNumber: 0,
+        reqCallbacks: {},
+        callback_Task: {},
+        region: "PRN",
+        firstListen: true,
+        _emitter: new EventEmitter(),
+        fb_dtsg: undefined,
+        jazoest: undefined,
+        lsd: undefined,
+        ttstamp: undefined,
+        api: null,
+    };
+}
+
+/**
+ * Creates an initialized FCA state object from an existing ctx.
+ * @param {object} [ctx] - Existing context to extend.
+ * @returns {object}
+ */
+function createFcaState(ctx = {}) {
+    return Object.assign(createDefaultContext(), ctx);
+}
+
+/**
+ * Builds a minimal api facade from an existing ctx. Allows attaching methods.
+ * @param {object} ctx - FcaContext object.
+ * @returns {object}
+ */
+function createApiFacade(ctx = {}) {
+    const facade = {
+        ctx,
+        getCurrentUserID() {
+            return ctx.userID || ctx.fbid || "";
+        },
+        getAppState() {
+            if (!ctx.jar) return [];
+            try {
+                const appState = [];
+                const cookies = ctx.jar.getCookiesSync("https://www.facebook.com");
+                for (const c of cookies) {
+                    appState.push({
+                        key: c.key,
+                        value: c.value,
+                        domain: c.domain,
+                        path: c.path,
+                        hostOnly: c.hostOnly,
+                        creation: c.creation,
+                        lastAccessed: c.lastAccessed,
+                    });
+                }
+                return appState;
+            } catch {
+                return [];
+            }
+        },
+        setOptions(opts) {
+            Object.assign(ctx.globalOptions || {}, opts);
+        },
+    };
+    return facade;
+}
+
+/**
+ * Creates a minimal request helper (for API compat). Real HTTP is done via axios.js.
+ * @param {object} ctx - FcaContext
+ * @returns {object}
+ */
+function createRequestHelper(ctx = {}) {
+    return {
+        get(url, qs, options) {
+            const network = require("../utils/axios");
+            return network.get(url, ctx.jar, qs, options || ctx.globalOptions, ctx);
+        },
+        post(url, form, options) {
+            const network = require("../utils/axios");
+            return network.post(url, ctx.jar, form, options || ctx.globalOptions, ctx);
+        },
+        postFormData(url, form, options) {
+            const network = require("../utils/axios");
+            return network.postFormData(url, ctx.jar, form, options || ctx.globalOptions, ctx);
+        },
+        ctx,
+    };
+}
+
+module.exports = {
+    createDefaultContext,
+    createFcaState,
+    createApiFacade,
+    createRequestHelper,
+};

package/src/app/threadSync.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const INVALIDATE_TYPES = new Set([
+    "log:thread-name",
+    "log:thread-image",
+    "log:user-nicknames",
+    "log:thread-color",
+    "log:thread-icon",
+    "log:thread-admins",
+    "log:thread-approval-mode",
+    "log:thread-lock-join-link",
+    "log:group-poll",
+]);
+
+const PARTICIPANT_TYPES = new Set([
+    "log:subscribe",
+    "log:unsubscribe",
+]);
+
+/**
+ * Hooks into MQTT events to keep the thread info cache in sync.
+ * When a thread event comes in, invalidates or partially updates the cache.
+ *
+ * @param {object} ctx - FcaContext or ctx object with _emitter.
+ * @param {object} models - Sequelize models (optional). Expects models.Thread.
+ * @param {function} logger - Logger function (optional).
+ * @param {object} api - The API object (used for getUserInfo on participant changes).
+ */
+function attachThreadInfoRealtimeSync(ctx, models, logger, api) {
+    const log = (typeof logger === "function") ? logger : () => {};
+    const emitter = ctx && ctx._emitter;
+
+    if (!emitter || typeof emitter.on !== "function") {
+        log("attachThreadInfoRealtimeSync: no emitter on ctx, skipping", "warn");
+        return;
+    }
+
+    const Thread = models && models.Thread;
+
+    emitter.on("event", async (event) => {
+        try {
+            if (!event || !event.threadID || !event.logMessageType) return;
+            const tid = String(event.threadID);
+            const msgType = event.logMessageType;
+
+            if (!Thread) return;
+
+            if (INVALIDATE_TYPES.has(msgType)) {
+                try {
+                    await Thread.update({ data: null }, { where: { threadID: tid } });
+                    log(`threadSync: invalidated cache for thread ${tid} (${msgType})`, "info");
+                } catch (e) {
+                    log(`threadSync: error invalidating thread ${tid}: ${e.message}`, "warn");
+                }
+            } else if (PARTICIPANT_TYPES.has(msgType)) {
+                try {
+                    const row = await Thread.findOne({ where: { threadID: tid } });
+                    if (!row || !row.data) {
+                        await Thread.update({ data: null }, { where: { threadID: tid } });
+                        return;
+                    }
+
+                    let cached;
+                    try { cached = JSON.parse(row.data); } catch { cached = null; }
+                    if (!cached) return;
+
+                    const addedIDs = event.logMessageData?.addedParticipants?.map(p => String(p.userFbId || p.id)) || [];
+                    const removedIDs = event.logMessageData?.leftParticipantFbId
+                        ? [String(event.logMessageData.leftParticipantFbId)]
+                        : [];
+
+                    if (removedIDs.length > 0 && Array.isArray(cached.participantIDs)) {
+                        cached.participantIDs = cached.participantIDs.filter(id => !removedIDs.includes(String(id)));
+                    }
+
+                    if (addedIDs.length > 0) {
+                        if (!Array.isArray(cached.participantIDs)) cached.participantIDs = [];
+                        for (const id of addedIDs) {
+                            if (!cached.participantIDs.includes(id)) cached.participantIDs.push(id);
+                        }
+                        if (api && typeof api.getUserInfo === "function") {
+                            try {
+                                const userInfos = await new Promise((res, rej) => {
+                                    api.getUserInfo(addedIDs, (err, info) => err ? rej(err) : res(info));
+                                });
+                                if (!cached.userInfo) cached.userInfo = {};
+                                Object.assign(cached.userInfo, userInfos);
+                            } catch (_) {}
+                        }
+                    }
+
+                    await Thread.update({ data: JSON.stringify(cached) }, { where: { threadID: tid } });
+                    log(`threadSync: updated participants for thread ${tid} (${msgType})`, "info");
+                } catch (e) {
+                    log(`threadSync: error updating participants for ${tid}: ${e.message}`, "warn");
+                }
+            }
+        } catch (e) {
+            log(`threadSync: unhandled error: ${e.message}`, "warn");
+        }
+    });
+
+    log("attachThreadInfoRealtimeSync: listening for MQTT events", "info");
+}
+
+module.exports = { attachThreadInfoRealtimeSync };

package/src/app/updateCheck.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const https = require("https");
+const { execSync } = require("child_process");
+
+/**
+ * Checks npm registry for a newer version of the package.
+ * @param {string} packageName - The npm package name.
+ * @param {string} currentVersion - Current installed version.
+ * @param {object} [options] - Options.
+ * @param {string} [options.registryUrl] - npm registry URL.
+ * @param {number} [options.timeoutMs] - Request timeout in ms.
+ * @returns {Promise<{hasUpdate: boolean, latest: string, current: string}>}
+ */
+async function checkForPackageUpdate(packageName, currentVersion, options = {}) {
+    const registryUrl = options.registryUrl || "https://registry.npmjs.org";
+    const timeoutMs = options.timeoutMs || 10000;
+
+    return new Promise((resolve) => {
+        const url = `${registryUrl}/${encodeURIComponent(packageName)}/latest`;
+        const timer = setTimeout(() => resolve({ hasUpdate: false, latest: currentVersion, current: currentVersion }), timeoutMs);
+
+        https.get(url, { headers: { Accept: "application/json" } }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+                clearTimeout(timer);
+                try {
+                    const json = JSON.parse(data);
+                    const latest = json.version || currentVersion;
+                    const hasUpdate = latest !== currentVersion && compareVersions(latest, currentVersion) > 0;
+                    resolve({ hasUpdate, latest, current: currentVersion });
+                } catch {
+                    resolve({ hasUpdate: false, latest: currentVersion, current: currentVersion });
+                }
+            });
+        }).on("error", () => {
+            clearTimeout(timer);
+            resolve({ hasUpdate: false, latest: currentVersion, current: currentVersion });
+        });
+    });
+}
+
+function compareVersions(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const diff = (pa[i] || 0) - (pb[i] || 0);
+        if (diff !== 0) return diff;
+    }
+    return 0;
+}
+
+/**
+ * Runs the update check based on fca-config settings.
+ * @param {object} config - Config object (from loadConfig).
+ * @param {function} [logger] - Logger function.
+ */
+async function runConfiguredUpdateCheck(config, logger) {
+    const log = typeof logger === "function" ? logger : () => {};
+    if (!config || !config.checkUpdate || !config.checkUpdate.enabled) return;
+
+    const pkg = config.checkUpdate.packageName || "@lazyneoaz/metachat";
+    let currentVersion = "unknown";
+    try {
+        currentVersion = require("../../package.json").version;
+    } catch (_) {}
+
+    try {
+        const result = await checkForPackageUpdate(pkg, currentVersion, {
+            registryUrl: config.checkUpdate.registryUrl,
+            timeoutMs: config.checkUpdate.timeoutMs,
+        });
+
+        if (result.hasUpdate) {
+            log(`UPDATE : New version ${result.latest} available (current: ${result.current}). Run: npm install ${pkg}@latest`, "warn");
+            if (config.checkUpdate.install) {
+                try {
+                    execSync(`npm install ${pkg}@latest`, { stdio: "ignore" });
+                    log(`UPDATE : Auto-installed ${pkg}@${result.latest}`, "info");
+                } catch (_) {}
+            }
+        } else if (config.checkUpdate.notifyIfCurrent) {
+            log(`UPDATE : Already on latest version ${result.current}`, "info");
+        }
+    } catch (_) {}
+}
+
+module.exports = {
+    checkForPackageUpdate,
+    runConfiguredUpdateCheck,
+};