@softtynet/zplus-worker 1.0.0

package/dist/server/WorkerHttpServer.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * 🌐 ZPlus Worker HTTP Ingress Server
+ * Cung cấp các endpoint REST cho Desktop Client giao tiếp với 24/7 Cloud Worker:
+ * - GET  /health: Kiểm tra tình trạng nhịp tim & tài nguyên
+ * - POST /api/v1/sentinel/handover: Bàn giao session từ Desktop sang Worker khi tắt máy
+ * - POST /api/v1/sentinel/reclaim: Thu hồi quyền phiên khi Desktop mở lại máy tính
+ * - GET  /api/v1/sync/delta: Trả về tin nhắn phát sinh trong đêm (Delta Sync)
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerHttpServer = void 0;
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const core_1 = require("@zplus/core");
+const ZaloChannelRunner_1 = require("../channels/runners/ZaloChannelRunner");
+const FacebookChannelRunner_1 = require("../channels/runners/FacebookChannelRunner");
+const TelegramChannelRunner_1 = require("../channels/runners/TelegramChannelRunner");
+const WhatsAppChannelRunner_1 = require("../channels/runners/WhatsAppChannelRunner");
+class WorkerHttpServer {
+    port;
+    engine;
+    lockManager;
+    deltaQueue;
+    logger;
+    server = null;
+    constructor(port, engine, lockManager, deltaQueue, logger) {
+        this.port = port;
+        this.engine = engine;
+        this.lockManager = lockManager;
+        this.deltaQueue = deltaQueue;
+        this.logger = logger || (0, core_1.createLogger)("WorkerHttpServer");
+    }
+    async start() {
+        if (this.server)
+            return;
+        return new Promise((resolve, reject) => {
+            this.server = http_1.default.createServer((req, res) => {
+                this.handleRequest(req, res).catch((err) => {
+                    this.logger.error("Unhandled HTTP error:", err);
+                    if (!res.headersSent) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "Internal Server Error" }));
+                    }
+                });
+            });
+            this.server.listen(this.port, () => {
+                this.logger.info(`🚀 Worker HTTP Server listening on port ${this.port}`);
+                resolve();
+            });
+            this.server.on("error", (err) => {
+                this.logger.error(`Worker HTTP Server error on port ${this.port}:`, err);
+                reject(err);
+            });
+        });
+    }
+    async stop() {
+        if (!this.server)
+            return;
+        return new Promise((resolve) => {
+            this.server?.close(() => {
+                this.logger.info("Worker HTTP Server closed.");
+                this.server = null;
+                resolve();
+            });
+        });
+    }
+    async handleRequest(req, res) {
+        const parsedUrl = new url_1.URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+        const pathname = parsedUrl.pathname;
+        const method = (req.method || "GET").toUpperCase();
+        // CORS headers
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Softty-User-Id");
+        if (method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // 1. Healthcheck
+        if (method === "GET" && pathname === "/health") {
+            const metrics = this.engine.getMetrics();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                status: "healthy",
+                timestamp: Date.now(),
+                pendingDeltaMessages: this.deltaQueue.getCount(),
+                metrics,
+            }));
+            return;
+        }
+        // 2. Sentinel Handover (Desktop -> Worker)
+        if (method === "POST" && pathname === "/api/v1/sentinel/handover") {
+            const body = await this.readJsonBody(req);
+            const { deviceId, sessions } = body || {};
+            if (!Array.isArray(sessions)) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid sessions array payload" }));
+                return;
+            }
+            this.logger.info(`[Handover] Received handover request from device ${deviceId || "unknown"} with ${sessions.length} sessions.`);
+            let activatedCount = 0;
+            for (const item of sessions) {
+                if (!item.id || !item.nightWorkerEnabled)
+                    continue;
+                // Xin Distributed Lock cho Worker
+                const lockGranted = this.lockManager.acquireLock(item.id, `worker_${item.id}`);
+                if (!lockGranted) {
+                    this.logger.warn(`Skipping account ${item.id} because lock was not acquired.`);
+                    continue;
+                }
+                // Tạo Runner phù hợp
+                let runner;
+                const platform = item.platform || "zalo";
+                if (platform === "zalo") {
+                    runner = new ZaloChannelRunner_1.ZaloChannelRunner(item.id, item.sessionData);
+                }
+                else if (platform === "facebook") {
+                    runner = new FacebookChannelRunner_1.FacebookChannelRunner(item.id, item.sessionData);
+                }
+                else if (platform === "telegram") {
+                    runner = new TelegramChannelRunner_1.TelegramChannelRunner(item.id, item.sessionData);
+                }
+                else if (platform === "whatsapp") {
+                    runner = new WhatsAppChannelRunner_1.WhatsAppChannelRunner(item.id, item.sessionData);
+                }
+                if (runner) {
+                    this.engine.channelRunnerRegistry.register(runner);
+                    await runner.start();
+                    this.engine.registerAccount({
+                        id: item.id,
+                        platform,
+                        accountName: item.accountName || item.id,
+                        status: "active",
+                        nightWorkerEnabled: true,
+                    });
+                    activatedCount++;
+                }
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                success: true,
+                message: "Sessions handed over successfully",
+                activatedCount,
+                timestamp: Date.now(),
+            }));
+            return;
+        }
+        // 3. Sentinel Reclaim (Desktop wakes up, reclaims lock & forces worker to close WSS)
+        if (method === "POST" && pathname === "/api/v1/sentinel/reclaim") {
+            const body = await this.readJsonBody(req);
+            const { deviceId } = body || {};
+            this.logger.info(`[Reclaim] Master device ${deviceId || "desktop"} reclaiming all active sessions. Stopping cloud runners...`);
+            // Ngắt tất cả runners trên Cloud để nhường quyền kết nối cho Desktop
+            const count = this.engine.channelRunnerRegistry.getCount();
+            await this.engine.channelRunnerRegistry.stopAll();
+            // Giải phóng khóa
+            this.lockManager.releaseAllForOwner(`worker`);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                success: true,
+                reclaimedCount: count,
+                timestamp: Date.now(),
+            }));
+            return;
+        }
+        // 4. Delta Sync (Desktop kéo tin nhắn phát sinh trong đêm)
+        if (method === "GET" && pathname === "/api/v1/sync/delta") {
+            const accountId = parsedUrl.searchParams.get("accountId") || undefined;
+            const since = parseInt(parsedUrl.searchParams.get("since") || "0", 10);
+            const deltas = this.deltaQueue.getDeltas(accountId, since);
+            this.logger.info(`[DeltaSync] Serving ${deltas.length} night messages (since: ${since}, account: ${accountId || "all"})`);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+                success: true,
+                messages: deltas,
+                count: deltas.length,
+                syncedTimestamp: Date.now(),
+            }));
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Endpoint not found" }));
+    }
+    readJsonBody(req) {
+        return new Promise((resolve) => {
+            let bodyStr = "";
+            req.on("data", (chunk) => {
+                bodyStr += chunk;
+            });
+            req.on("end", () => {
+                try {
+                    resolve(JSON.parse(bodyStr));
+                }
+                catch {
+                    resolve({});
+                }
+            });
+        });
+    }
+}
+exports.WorkerHttpServer = WorkerHttpServer;

package/dist/sync/CloudPendingMessageQueue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 📥 Cloud Pending Message Queue
+ * Hàng đợi lưu tạm thời các tin nhắn khách hàng gửi đến trong lúc tắt máy tính (ca đêm)
+ * để cung cấp cho API GET /api/v1/sync/delta khi Desktop khởi động lại.
+ */
+import { UnifiedMessage } from "@zplus/contracts";
+import { ILogger } from "@zplus/core";
+export declare class CloudPendingMessageQueue {
+    private readonly logger;
+    private readonly queue;
+    private readonly maxCapacity;
+    constructor(maxCapacity?: number, logger?: ILogger);
+    /**
+     * Đưa tin nhắn mới nhận được trong lúc gác đền vào hàng đợi
+     */
+    enqueue(message: UnifiedMessage): void;
+    /**
+     * Lấy danh sách tin nhắn phát sinh kể từ mốc thời gian sinceTimestamp
+     */
+    getDeltas(accountId?: string, sinceTimestamp?: number): UnifiedMessage[];
+    /**
+     * Đánh dấu đã đồng bộ và dọn dẹp các tin nhắn cũ hơn upToTimestamp
+     */
+    purgeSynced(upToTimestamp: number, accountId?: string): number;
+    getCount(): number;
+    clear(): void;
+}

package/dist/sync/CloudPendingMessageQueue.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * 📥 Cloud Pending Message Queue
+ * Hàng đợi lưu tạm thời các tin nhắn khách hàng gửi đến trong lúc tắt máy tính (ca đêm)
+ * để cung cấp cho API GET /api/v1/sync/delta khi Desktop khởi động lại.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudPendingMessageQueue = void 0;
+const core_1 = require("@zplus/core");
+class CloudPendingMessageQueue {
+    logger;
+    queue = [];
+    maxCapacity;
+    constructor(maxCapacity = 10000, logger) {
+        this.maxCapacity = maxCapacity;
+        this.logger = logger || (0, core_1.createLogger)("CloudPendingMessageQueue");
+    }
+    /**
+     * Đưa tin nhắn mới nhận được trong lúc gác đền vào hàng đợi
+     */
+    enqueue(message) {
+        if (this.queue.length >= this.maxCapacity) {
+            const removed = this.queue.shift();
+            this.logger.warn(`Queue capacity reached (${this.maxCapacity}). Dropped oldest message: ${removed?.id}`);
+        }
+        this.queue.push(message);
+        this.logger.debug(`Enqueued pending message ${message.id} for account ${message.accountId} (Total pending: ${this.queue.length})`);
+    }
+    /**
+     * Lấy danh sách tin nhắn phát sinh kể từ mốc thời gian sinceTimestamp
+     */
+    getDeltas(accountId, sinceTimestamp = 0) {
+        return this.queue.filter((msg) => {
+            const matchAccount = !accountId || msg.accountId === accountId;
+            const matchTime = msg.timestamp >= sinceTimestamp;
+            return matchAccount && matchTime;
+        });
+    }
+    /**
+     * Đánh dấu đã đồng bộ và dọn dẹp các tin nhắn cũ hơn upToTimestamp
+     */
+    purgeSynced(upToTimestamp, accountId) {
+        const initialLen = this.queue.length;
+        const removeIndices = [];
+        for (let i = 0; i < this.queue.length; i++) {
+            const msg = this.queue[i];
+            if (msg.timestamp <= upToTimestamp &&
+                (!accountId || msg.accountId === accountId)) {
+                removeIndices.push(i);
+            }
+        }
+        // Xóa từ cuối về đầu
+        for (let i = removeIndices.length - 1; i >= 0; i--) {
+            this.queue.splice(removeIndices[i], 1);
+        }
+        const removedCount = initialLen - this.queue.length;
+        if (removedCount > 0) {
+            this.logger.info(`Purged ${removedCount} synced delta messages from queue.`);
+        }
+        return removedCount;
+    }
+    getCount() {
+        return this.queue.length;
+    }
+    clear() {
+        this.queue.length = 0;
+    }
+}
+exports.CloudPendingMessageQueue = CloudPendingMessageQueue;

package/dist/sync/CloudSyncWorker.d.ts

@@ -0,0 +1,19 @@
+import { ILogger } from "@zplus/core";
+import { SyncOutboxRecord } from "@zplus/contracts";
+export interface CloudSyncWorkerConfig {
+    endpoint: string;
+    projectId: string;
+    pollIntervalMs?: number;
+}
+export declare class CloudSyncWorker {
+    private readonly config;
+    private readonly logger;
+    private isRunning;
+    private timer;
+    constructor(config: CloudSyncWorkerConfig, logger?: ILogger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    pushOutboxRecord(record: SyncOutboxRecord): Promise<boolean>;
+    private scheduleNextPoll;
+    private syncPendingDeltas;
+}

package/dist/sync/CloudSyncWorker.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudSyncWorker = void 0;
+const core_1 = require("@zplus/core");
+class CloudSyncWorker {
+    config;
+    logger;
+    isRunning = false;
+    timer = null;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger || (0, core_1.createLogger)("CloudSyncWorker");
+    }
+    async start() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        this.logger.info(`Starting 24/7 Cloud Sync Worker (Endpoint: ${this.config.endpoint})...`);
+        this.scheduleNextPoll();
+    }
+    async stop() {
+        this.isRunning = false;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.logger.info("Cloud Sync Worker stopped.");
+    }
+    async pushOutboxRecord(record) {
+        this.logger.debug(`Queued outbox record for sync: ${record.id} (${record.tableName})`);
+        return true;
+    }
+    scheduleNextPoll() {
+        if (!this.isRunning)
+            return;
+        const interval = this.config.pollIntervalMs || 10000;
+        this.timer = setTimeout(async () => {
+            try {
+                await this.syncPendingDeltas();
+            }
+            catch (err) {
+                this.logger.error("Error during delta sync poll:", err);
+            }
+            finally {
+                this.scheduleNextPoll();
+            }
+        }, interval);
+    }
+    async syncPendingDeltas() {
+        // Polls or checks incoming cloud delta changes
+    }
+}
+exports.CloudSyncWorker = CloudSyncWorker;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@softtynet/zplus-worker",
+  "version": "1.0.0",
+  "description": "ZPlus 24/7 Headless Automation & Omnichannel Worker Engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "zplus-worker": "dist/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && npm run bundle",
+    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node18 --outfile=dist/cli.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "start": "node dist/cli.js",
+    "dev": "node --loader ts-node/esm src/cli.ts"
+  },
+  "dependencies": {
+    "@zplus/contracts": "^1.0.0",
+    "@zplus/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.12",
+    "vitest": "^4.0.0"
+  }
+}