@lazyneoaz/testfca 1.0.0

package/scripts/download-prebuilt.mjs

@@ -0,0 +1,119 @@
+import { createWriteStream } from "node:fs";
+import { mkdir, rename, unlink } from "node:fs/promises";
+import https from "node:https";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { detectPlatform } from "./detect-platform.mjs";
+import { packageJson as pkg } from "./package.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function defaultRepoSlug() {
+    const repo = pkg.repository;
+    if (typeof repo === "string") {
+        const m = repo.match(/github:(.+)/i);
+        if (m) return m[1];
+        if (/^[\w-]+\/[\w.-]+$/.test(repo)) return repo;
+    } else if (repo && typeof repo === "object" && repo.url) {
+        const m = repo.url.match(/github\.com[:/]+([^#]+?)(?:\.git)?$/i);
+        if (m) return m[1];
+    }
+    return "NeoKEX/nkxfca";
+}
+
+function buildBaseURL() {
+    const repo = defaultRepoSlug();
+    const versionTag = `v${pkg.version}`;
+    const baseURL = `https://github.com/${repo}/releases/download/${versionTag}`;
+    return baseURL.replace(/\/$/, "");
+}
+
+function httpGet(url, redirectCount = 0) {
+    console.log(`[${pkg.name}] HTTP GET: ${url}${redirectCount > 0 ? ` (redirect #${redirectCount})` : ""}`);
+    const reqStart = Date.now();
+    return new Promise((resolve, reject) => {
+        https
+            .get(url, res => {
+                console.log(`[${pkg.name}] Response: HTTP ${res.statusCode} in ${Date.now() - reqStart}ms`);
+                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    console.log(`[${pkg.name}] Following redirect to: ${res.headers.location}`);
+                    return resolve(httpGet(res.headers.location, redirectCount + 1));
+                }
+                if (res.statusCode !== 200) {
+                    return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+                }
+                resolve(res);
+            })
+            .on("error", err => {
+                console.log(`[${pkg.name}] HTTP error after ${Date.now() - reqStart}ms:`, err?.message);
+                reject(err);
+            });
+    });
+}
+
+async function downloadTo(url, dstPath) {
+    console.log(`[${pkg.name}] Downloading to: ${dstPath}`);
+    await mkdir(dirname(dstPath), { recursive: true });
+    const tmp = `${dstPath}.download`;
+    try {
+        await unlink(tmp);
+    } catch {
+        //
+    }
+    const res = await httpGet(url);
+    console.log(`[${pkg.name}] Starting file write...`);
+    const writeStart = Date.now();
+    let bytesWritten = 0;
+    await new Promise((resolve, reject) => {
+        const out = createWriteStream(tmp);
+        res.on("data", chunk => {
+            bytesWritten += chunk.length;
+        });
+        res.pipe(out);
+        res.on("error", reject);
+        out.on("error", reject);
+        out.on("finish", () => {
+            console.log(`[${pkg.name}] File write completed: ${bytesWritten} bytes in ${Date.now() - writeStart}ms`);
+            res.destroy();
+            resolve();
+        });
+    });
+    await rename(tmp, dstPath);
+    console.log(`[${pkg.name}] File renamed to final destination`);
+}
+
+export async function downloadPrebuilt() {
+    console.log(`[${pkg.name}] downloadPrebuilt() started`);
+    const { triplet, ext } = detectPlatform();
+    const baseURL = buildBaseURL();
+    const filename = `messagix-${triplet}.${ext}`;
+    const url = `${baseURL}/${filename}`;
+    console.log(`[${pkg.name}] Target URL: ${url}`);
+
+    const out = join(__dirname, "..", "build", `messagix.${ext}`);
+    const totalStart = Date.now();
+    try {
+        await downloadTo(url, out);
+        console.log(`[${pkg.name}] Downloaded prebuilt from ${url} in ${Date.now() - totalStart}ms`);
+        return true;
+    } catch (err) {
+        console.warn(
+            `[${pkg.name}] No remote prebuilt found at ${url} (after ${Date.now() - totalStart}ms):`,
+            err?.message || String(err),
+        );
+        return false;
+    }
+}
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isMain) {
+    downloadPrebuilt()
+        .then(ok => {
+            if (!ok) process.exit(1);
+        })
+        .catch(err => {
+            console.error(`[${pkg.name}] download-prebuilt failed:`, err?.message || String(err));
+            process.exit(1);
+        });
+}

package/scripts/package.mjs

@@ -0,0 +1,6 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const packageJson = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));

package/scripts/postinstall.mjs

@@ -0,0 +1,113 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { detectPlatform } from "./detect-platform.mjs";
+import { downloadPrebuilt } from "./download-prebuilt.mjs";
+import { packageJson as pkg } from "./package.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+async function copyIfExists(src, dst) {
+    try {
+        await mkdir(dirname(dst), { recursive: true });
+        await copyFile(src, dst);
+        return true;
+    } catch (err) {
+        if (err?.code === "ENOENT") return false;
+        throw err;
+    }
+}
+
+async function run() {
+    console.log(`[${pkg.name}] postinstall started`);
+    const startTime = Date.now();
+
+    if (process.env.MESSAGIX_SKIP_POSTINSTALL === "true") {
+        console.log(`[${pkg.name}] Skipping postinstall (MESSAGIX_SKIP_POSTINSTALL=true)`);
+        return;
+    }
+
+    console.log(`[${pkg.name}] Detecting platform...`);
+    const { triplet, ext } = detectPlatform();
+    console.log(`[${pkg.name}] Platform: ${triplet}, ext: ${ext}`);
+
+    const buildOut = join(__dirname, "..", "build", `messagix.${ext}`);
+    console.log(`[${pkg.name}] Build output path: ${buildOut}`);
+
+    if (existsSync(buildOut)) {
+        console.log(`[${pkg.name}] Native library already present at build/messagix.${ext}`);
+        console.log(`[${pkg.name}] postinstall completed in ${Date.now() - startTime}ms`);
+        return;
+    }
+
+    // 1) Prefer local prebuilt shipped in npm tarball
+    const prebuiltDir = join(__dirname, "..", "prebuilt", triplet);
+    const prebuilt = join(prebuiltDir, `messagix.${ext}`);
+    console.log(`[${pkg.name}] Checking local prebuilt at: ${prebuilt}`);
+    if (await copyIfExists(prebuilt, buildOut)) {
+        console.log(`[${pkg.name}] Using local prebuilt for ${triplet}`);
+        if (process.env.MESSAGIX_KEEP_PREBUILT !== "true") {
+            try {
+                await rm(prebuiltDir, { recursive: true, force: true });
+            } catch {
+                //
+            }
+        }
+        console.log(`[${pkg.name}] postinstall completed in ${Date.now() - startTime}ms`);
+        return;
+    }
+    console.log(`[${pkg.name}] No local prebuilt found`);
+
+    // 2) Try remote prebuilt from GitHub Releases
+    console.log(`[${pkg.name}] Attempting to download remote prebuilt...`);
+    const downloadStart = Date.now();
+    try {
+        if (await downloadPrebuilt()) {
+            console.log(`[${pkg.name}] Download completed in ${Date.now() - downloadStart}ms`);
+            console.log(`[${pkg.name}] postinstall completed in ${Date.now() - startTime}ms`);
+            return;
+        }
+    } catch (err) {
+        console.log(
+            `[${pkg.name}] Download failed after ${Date.now() - downloadStart}ms:`,
+            err?.message || String(err),
+        );
+    }
+
+    // 3) No prebuilt available. Try local build if allowed
+    if (process.env.MESSAGIX_BUILD_FROM_SOURCE === "true") {
+        console.log(`[${pkg.name}] No prebuilt found. Attempting local build...`);
+        try {
+            const res = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build:go"], {
+                cwd: join(__dirname, ".."),
+                stdio: "inherit",
+                env: process.env,
+            });
+            if (res.status === 0 && existsSync(buildOut)) {
+                console.log(`[${pkg.name}] postinstall completed in ${Date.now() - startTime}ms`);
+                return;
+            }
+            console.warn(`[${pkg.name}] Local build did not produce the native library.`);
+        } catch (err) {
+            console.warn(`[${pkg.name}] Local build failed:`, err?.message || String(err));
+        }
+    }
+
+    console.warn(`[${pkg.name}] No prebuilt found (local/remote) and no local build completed.`);
+    console.warn(`[${pkg.name}] Expected triplet: ${triplet}, file: messagix-${triplet}.${ext}`);
+    console.warn(
+        `[${pkg.name}] You can:\n` +
+            "  - set MESSAGIX_BUILD_FROM_SOURCE=true and re-run install\n" +
+            "  - or build manually with: npm run build:go",
+    );
+}
+
+run()
+    .then(() => process.exit(0))
+    .catch(err => {
+        console.error(`[${pkg.name}] postinstall failed:`, err?.message || String(err));
+        process.exit(1);
+    });

package/src/apis/addExternalModule.js

@@ -0,0 +1,24 @@
+"use strict";
+const utils = require('../utils');
+
+module.exports = function (defaultFuncs, api, ctx) {
+  return function addExternalModule(moduleObj) {
+    if (utils.getType(moduleObj) == "Object") {
+      for (const apiName in moduleObj) {
+        if (utils.getType(moduleObj[apiName]) == "Function") {
+          api[apiName] = moduleObj[apiName](defaultFuncs, api, ctx);
+        } else {
+          throw new Error(
+            `Item "${apiName}" in moduleObj must be a function, not ${utils.getType(
+              moduleObj[apiName],
+            )}!`,
+          );
+        }
+      }
+    } else {
+      throw new Error(
+        `moduleObj must be an object, not ${utils.getType(moduleObj)}!`,
+      );
+    }
+  };
+};

package/src/apis/addUserToGroup.js

@@ -0,0 +1,108 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function addUserToGroup(userID, threadID, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (!ctx.mqttClient) {
+        throw new Error("Not connected to MQTT. Please use listenMqtt first.");
+      }
+
+      if (utils.getType(threadID) !== "Number" && utils.getType(threadID) !== "String") {
+        throw new Error("ThreadID should be of type Number or String");
+      }
+
+      if (utils.getType(userID) !== "Array") {
+        userID = [userID];
+      }
+
+      const reqID = ++ctx.wsReqNumber;
+      const taskID = ++ctx.wsTaskNumber;
+
+      const payload = {
+        epoch_id: utils.generateOfflineThreadingID(),
+        tasks: [
+          {
+            failure_count: null,
+            label: "23",
+            payload: JSON.stringify({
+              thread_key: threadID,
+              contact_ids: userID,
+              sync_group: 1
+            }),
+            queue_name: threadID.toString(),
+            task_id: taskID
+          }
+        ],
+        version_id: "24502707779384158"
+      };
+
+      const form = JSON.stringify({
+        app_id: "772021112871879",
+        payload: JSON.stringify(payload),
+        request_id: reqID,
+        type: 3
+      });
+
+      let responseHandled = false;
+      const handleRes = (topic, message) => {
+        if (topic !== "/ls_resp" || responseHandled) return;
+        let jsonMsg;
+        try {
+          jsonMsg = JSON.parse(message.toString());
+          jsonMsg.payload = JSON.parse(jsonMsg.payload);
+        } catch {
+          return;
+        }
+        if (jsonMsg.request_id !== reqID) return;
+        responseHandled = true;
+        clearTimeout(timeout);
+        ctx.mqttClient.removeListener("message", handleRes);
+        callback(null, { success: true, response: jsonMsg.payload });
+        resolveFunc({ success: true, response: jsonMsg.payload });
+      };
+
+      const timeout = setTimeout(() => {
+        if (!responseHandled) {
+          responseHandled = true;
+          ctx.mqttClient.removeListener("message", handleRes);
+          const err = new Error("MQTT request timeout");
+          callback(err);
+          rejectFunc(err);
+        }
+      }, 30000);
+
+      ctx.mqttClient.on("message", handleRes);
+      ctx.mqttClient.publish("/ls_req", form, { qos: 1, retain: false }, (err) => {
+        if (err && !responseHandled) {
+          responseHandled = true;
+          clearTimeout(timeout);
+          ctx.mqttClient.removeListener("message", handleRes);
+          callback(err);
+          rejectFunc(err);
+        }
+      });
+    } catch (err) {
+      utils.error("addUserToGroup", err);
+      callback(err);
+      rejectFunc(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeAdminStatus.js

@@ -0,0 +1,148 @@
+"use strict";
+
+const utils = require('../utils');
+
+function generateOfflineThreadingID() {
+    return Date.now().toString() + Math.floor(Math.random() * 1000000).toString();
+}
+
+function getType(obj) {
+    return Object.prototype.toString.call(obj).slice(8, -1);
+}
+
+module.exports = function (defaultFuncs, api, ctx) {
+    return function changeAdminStatus(threadID, adminID, adminStatus, callback) {
+        let resolveFunc = function() {};
+        let rejectFunc = function() {};
+        const returnPromise = new Promise(function(resolve, reject) {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+
+        if (!callback) {
+            callback = function(err, data) {
+                if (err) return rejectFunc(err);
+                resolveFunc(data);
+            };
+        }
+
+        if (getType(threadID) !== "String") {
+            return callback({ error: "changeAdminStatus: threadID must be a string" });
+        }
+        if (getType(adminID) !== "String" && getType(adminID) !== "Array") {
+            return callback({ error: "changeAdminStatus: adminID must be a string or an array" });
+        }
+        if (getType(adminStatus) !== "Boolean") {
+            return callback({ error: "changeAdminStatus: adminStatus must be true or false" });
+        }
+
+        if (ctx.mqttClient) {
+            const tasks = [];
+            const isAdmin = adminStatus ? 1 : 0;
+            const epochID = generateOfflineThreadingID();
+
+            if (getType(adminID) === "Array") {
+                adminID.forEach((id, index) => {
+                    tasks.push({
+                        failure_count: null,
+                        label: "25",
+                        payload: JSON.stringify({
+                            thread_key: threadID,
+                            contact_id: id,
+                            is_admin: isAdmin
+                        }),
+                        queue_name: "admin_status",
+                        task_id: index + 1
+                    });
+                });
+            } else {
+                tasks.push({
+                    failure_count: null,
+                    label: "25",
+                    payload: JSON.stringify({
+                        thread_key: threadID,
+                        contact_id: adminID,
+                        is_admin: isAdmin
+                    }),
+                    queue_name: "admin_status",
+                    task_id: 1
+                });
+            }
+
+            let count_req = 0;
+            const form = JSON.stringify({
+                app_id: "2220391788200892",
+                payload: JSON.stringify({
+                    epoch_id: epochID,
+                    tasks: tasks,
+                    version_id: "8798795233522156"
+                }),
+                request_id: ++count_req,
+                type: 3
+            });
+
+            ctx.mqttClient.publish("/ls_req", form, {}, (err, _packet) => {
+                if (err) {
+                    utils.error("changeAdminStatus (MQTT)", err);
+                    return callback(err);
+                } else {
+                    utils.log("Admin status changed successfully via MQTT");
+                    return callback(null, { success: true });
+                }
+            });
+        } else {
+            utils.warn("MQTT client not available, using HTTP fallback for changeAdminStatus");
+            const tasks = [];
+            const epochID = generateOfflineThreadingID();
+
+            if (getType(adminID) === "Array") {
+                adminID.forEach((id, index) => {
+                    tasks.push({
+                        label: '25',
+                        payload: JSON.stringify({ thread_key: threadID, contact_id: id, is_admin: adminStatus }),
+                        queue_name: 'admin_status',
+                        task_id: index + 1,
+                        failure_count: null
+                    });
+                });
+            } else {
+                tasks.push({
+                    label: '25',
+                    payload: JSON.stringify({ thread_key: threadID, contact_id: adminID, is_admin: adminStatus }),
+                    queue_name: 'admin_status',
+                    task_id: 1,
+                    failure_count: null
+                });
+            }
+
+            const form = {
+                fb_dtsg: ctx.fb_dtsg,
+                request_id: 1,
+                type: 3,
+                payload: {
+                    version_id: '3816854585040595',
+                    tasks: tasks,
+                    epoch_id: epochID,
+                    data_trace_id: null
+                },
+                app_id: '772021112871879'
+            };
+
+            form.payload = JSON.stringify(form.payload);
+
+            defaultFuncs
+                .post("https://www.facebook.com/api/graphqlbatch/", ctx.jar, form)
+                .then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+                .then(() => {
+                    utils.log("Admin status changed successfully via HTTP");
+                    callback(null, { success: true });
+                })
+                .catch(err => {
+                    utils.error("changeAdminStatus (HTTP)", err);
+                    callback(err);
+                });
+        }
+
+        return returnPromise;
+    };
+};

package/src/apis/changeArchivedStatus.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  return async function changeArchivedStatus(threadIDs, archive, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!callback) {
+      callback = (err, result) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(result);
+      };
+    }
+
+    try {
+      if (utils.getType(archive) === "Function") {
+        callback = archive;
+        archive = true;
+      }
+
+      if (utils.getType(archive) !== "Boolean") {
+        throw new Error("archive parameter must be a boolean");
+      }
+
+      if (!Array.isArray(threadIDs)) {
+        threadIDs = [threadIDs];
+      }
+
+      const form = {
+        should_archive: archive
+      };
+      
+      threadIDs.forEach(id => {
+        form[`thread_fbids[${id}]`] = true;
+      });
+
+      const res = await defaultFuncs.post(
+        "https://www.facebook.com/ajax/mercury/change_archived_status.php",
+        ctx.jar,
+        form
+      ).then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res && res.error) {
+        throw res;
+      }
+
+      callback(null, { success: true });
+    } catch (err) {
+      utils.error("changeArchivedStatus", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};

package/src/apis/changeAvatar.js

@@ -0,0 +1,103 @@
+"use strict";
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  async function handleUpload(image) {
+    const form = {
+      profile_id: ctx.userID,
+      photo_source: 57,
+      av: ctx.userID,
+      file: image
+    };
+
+    return defaultFuncs.postFormData(
+      "https://www.facebook.com/profile/picture/upload/",
+      ctx.jar,
+      form,
+      {}
+    ).then(utils.parseAndCheckLogin(ctx, defaultFuncs))
+    .then(resData => {
+      if (resData.error) throw resData;
+      return resData;
+    });
+  }
+
+  return async function changeAvatar(image, caption, timestamp, callback) {
+    let resolveFunc = () => {};
+    let rejectFunc = () => {};
+    const returnPromise = new Promise((resolve, reject) => {
+      resolveFunc = resolve;
+      rejectFunc = reject;
+    });
+
+    if (!timestamp && utils.getType(caption) === "Number") {
+      timestamp = caption;
+      caption = "";
+    }
+
+    if (!timestamp && !callback && (utils.getType(caption) === "Function")) {
+      callback = caption;
+      caption = "";
+      timestamp = null;
+    }
+
+    if (!callback) {
+      callback = (err, data) => {
+        if (err) return rejectFunc(err);
+        resolveFunc(data);
+      };
+    }
+
+    try {
+      if (!utils.isReadableStream(image)) {
+        throw new Error("Image is not a readable stream");
+      }
+
+      const payload = await handleUpload(image);
+      
+      const form = {
+        av: ctx.i_userID || ctx.userID,
+        fb_api_req_friendly_name: "ProfileCometProfilePictureSetMutation",
+        fb_api_caller_class: "RelayModern",
+        doc_id: "5066134240065849",
+        variables: JSON.stringify({
+          input: {
+            caption: caption || "",
+            existing_photo_id: payload.payload.fbid,
+            expiration_time: timestamp,
+            profile_id: ctx.i_userID || ctx.userID,
+            profile_pic_method: "EXISTING",
+            profile_pic_source: "TIMELINE",
+            scaled_crop_rect: {
+              height: 1,
+              width: 1,
+              x: 0,
+              y: 0
+            },
+            skip_cropping: true,
+            actor_id: ctx.i_userID || ctx.userID,
+            client_mutation_id: Math.round(Math.random() * 19).toString()
+          },
+          isPage: false,
+          isProfile: true,
+          scale: 3
+        })
+      };
+
+      const res = await defaultFuncs.post("https://www.facebook.com/api/graphql/", ctx.jar, form)
+        .then(utils.parseAndCheckLogin(ctx, defaultFuncs));
+
+      if (res.errors) {
+        throw res;
+      }
+
+      callback(null, res[0].data.profile_picture_set);
+    } catch (err) {
+      utils.error("changeAvatar", err);
+      callback(err);
+    }
+
+    return returnPromise;
+  };
+};