@softtynet/zplus-worker 1.0.0

package/dist/config/WorkerConfig.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 🏛️ Worker Configuration Loader
+ */
+export interface WorkerEnvironmentConfig {
+    workerId: string;
+    port: number;
+    appwriteEndpoint?: string;
+    appwriteProjectId?: string;
+    appwriteApiKey?: string;
+    databaseId?: string;
+    heartbeatIntervalMs: number;
+    logLevel: "debug" | "info" | "warn" | "error";
+}
+export declare class WorkerConfig {
+    static loadFromEnv(): WorkerEnvironmentConfig;
+}

package/dist/config/WorkerConfig.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * 🏛️ Worker Configuration Loader
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerConfig = void 0;
+class WorkerConfig {
+    static loadFromEnv() {
+        return {
+            workerId: process.env.WORKER_ID || `worker_${process.pid}`,
+            port: Number(process.env.PORT || 8080),
+            appwriteEndpoint: process.env.APPWRITE_ENDPOINT,
+            appwriteProjectId: process.env.APPWRITE_PROJECT_ID,
+            appwriteApiKey: process.env.APPWRITE_API_KEY,
+            databaseId: process.env.APPWRITE_DATABASE_ID || "zplus_app",
+            heartbeatIntervalMs: Number(process.env.HEARTBEAT_INTERVAL_MS || 30000),
+            logLevel: process.env.LOG_LEVEL || "info",
+        };
+    }
+}
+exports.WorkerConfig = WorkerConfig;

package/dist/engine/WorkerEngine.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 🏛️ ZPlus Headless Worker Engine
+ * Quản lý vòng đời chạy ngầm 24/7 (WSS listeners, HTTP Ingress, Distributed Lock, Delta Sync, AI automation, Heartbeats)
+ */
+import { WorkerMetrics, ChannelAccount, UnifiedMessage } from "@zplus/contracts";
+import { WorkerEnvironmentConfig } from "../config/WorkerConfig";
+import { ChannelRunnerRegistry } from "../channels/ChannelRunnerRegistry";
+import { DistributedLockManager } from "../lock/DistributedLockManager";
+import { CloudPendingMessageQueue } from "../sync/CloudPendingMessageQueue";
+import { HeadlessAutomationEngine } from "../automation/HeadlessAutomationEngine";
+import { PushNotificationDispatcher } from "../notifications/PushNotificationDispatcher";
+import { WorkerHttpServer } from "../server/WorkerHttpServer";
+import { IChannelRunner } from "../channels/IChannelRunner";
+export declare class WorkerEngine {
+    private config;
+    private logger;
+    readonly channelRunnerRegistry: ChannelRunnerRegistry;
+    readonly lockManager: DistributedLockManager;
+    readonly deltaQueue: CloudPendingMessageQueue;
+    readonly automationEngine: HeadlessAutomationEngine;
+    readonly pushDispatcher: PushNotificationDispatcher;
+    readonly httpServer: WorkerHttpServer;
+    private status;
+    private startTime;
+    private activeAccounts;
+    private messagesProcessed;
+    private heartbeatTimer?;
+    constructor(config: WorkerEnvironmentConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    registerRunner(runner: IChannelRunner): void;
+    registerAccount(account: ChannelAccount): void;
+    unregisterAccount(accountId: string): void;
+    recordMessageProcessed(): void;
+    handleIncomingMessage(message: UnifiedMessage, runner?: IChannelRunner): Promise<void>;
+    getMetrics(): WorkerMetrics;
+    private sendHeartbeat;
+}

package/dist/engine/WorkerEngine.js

@@ -0,0 +1,157 @@
+"use strict";
+/**
+ * 🏛️ ZPlus Headless Worker Engine
+ * Quản lý vòng đời chạy ngầm 24/7 (WSS listeners, HTTP Ingress, Distributed Lock, Delta Sync, AI automation, Heartbeats)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerEngine = void 0;
+const core_1 = require("@zplus/core");
+const ChannelRunnerRegistry_1 = require("../channels/ChannelRunnerRegistry");
+const DistributedLockManager_1 = require("../lock/DistributedLockManager");
+const CloudPendingMessageQueue_1 = require("../sync/CloudPendingMessageQueue");
+const HeadlessAutomationEngine_1 = require("../automation/HeadlessAutomationEngine");
+const PushNotificationDispatcher_1 = require("../notifications/PushNotificationDispatcher");
+const WorkerHttpServer_1 = require("../server/WorkerHttpServer");
+class WorkerEngine {
+    config;
+    logger;
+    channelRunnerRegistry;
+    lockManager;
+    deltaQueue;
+    automationEngine;
+    pushDispatcher;
+    httpServer;
+    status = "idle";
+    startTime = 0;
+    activeAccounts = new Map();
+    messagesProcessed = 0;
+    heartbeatTimer;
+    constructor(config) {
+        this.config = config;
+        this.logger = (0, core_1.createLogger)(`WorkerEngine:${config.workerId}`);
+        this.channelRunnerRegistry = new ChannelRunnerRegistry_1.ChannelRunnerRegistry(this.logger);
+        this.lockManager = new DistributedLockManager_1.DistributedLockManager(60000, this.logger);
+        this.deltaQueue = new CloudPendingMessageQueue_1.CloudPendingMessageQueue(10000, this.logger);
+        this.automationEngine = new HeadlessAutomationEngine_1.HeadlessAutomationEngine(this.logger);
+        this.pushDispatcher = new PushNotificationDispatcher_1.PushNotificationDispatcher(this.logger);
+        this.httpServer = new WorkerHttpServer_1.WorkerHttpServer(config.port, this, this.lockManager, this.deltaQueue, this.logger);
+        // Khi Master Preemption xảy ra, buộc Worker ngắt WSS lập tức
+        this.lockManager.onPreempt(async (accountId) => {
+            this.logger.info(`Preemption callback: stopping WSS for account ${accountId}...`);
+            const allRunners = this.channelRunnerRegistry.getAll();
+            for (const r of allRunners) {
+                if (r.accountId === accountId) {
+                    await r.stop();
+                }
+            }
+        });
+    }
+    async start() {
+        if (this.status === "running") {
+            this.logger.warn("Worker is already running.");
+            return;
+        }
+        this.logger.info("Starting ZPlus 24/7 Headless Worker Engine...");
+        this.status = "initializing";
+        this.startTime = Date.now();
+        // 1. Khởi động HTTP Ingress Server
+        try {
+            await this.httpServer.start();
+        }
+        catch (err) {
+            this.logger.error("Failed to start Worker HTTP Ingress Server:", err);
+        }
+        // 2. Khởi tạo vòng lặp heartbeat định kỳ
+        this.heartbeatTimer = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.config.heartbeatIntervalMs);
+        this.status = "running";
+        this.logger.info(`✅ ZPlus Worker Engine started successfully [ID: ${this.config.workerId}, Port: ${this.config.port}]`);
+    }
+    async stop() {
+        this.logger.info("Stopping ZPlus Worker Engine...");
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = undefined;
+        }
+        // Dừng HTTP Ingress
+        await this.httpServer.stop();
+        // Dừng tất cả runners
+        await this.channelRunnerRegistry.stopAll();
+        this.status = "stopped";
+        this.logger.info("ZPlus Worker Engine stopped.");
+    }
+    registerRunner(runner) {
+        runner.onMessage?.((msg) => {
+            this.handleIncomingMessage(msg, runner);
+        });
+        this.channelRunnerRegistry.register(runner);
+    }
+    registerAccount(account) {
+        this.activeAccounts.set(account.id, account);
+        this.logger.info(`Registered active account: ${account.accountName} [${account.platform}]`);
+    }
+    unregisterAccount(accountId) {
+        this.activeAccounts.delete(accountId);
+        this.logger.info(`Unregistered account: ${accountId}`);
+    }
+    recordMessageProcessed() {
+        this.messagesProcessed++;
+    }
+    async handleIncomingMessage(message, runner) {
+        this.recordMessageProcessed();
+        // 1. Lưu vào hàng đợi Delta Sync để Desktop sáng mai kéo về
+        this.deltaQueue.enqueue(message);
+        // 2. Đánh giá AI Auto-reply ca đêm
+        try {
+            const autoReplyText = await this.automationEngine.evaluateIncomingMessage(message);
+            if (autoReplyText && runner) {
+                this.logger.info(`[NightAutoReply] Sending automated reply to thread ${message.threadId}: "${autoReplyText}"`);
+                const replyMsg = {
+                    id: `reply_${Date.now()}`,
+                    platform: message.platform,
+                    conversationId: message.conversationId,
+                    threadId: message.threadId,
+                    accountId: message.accountId,
+                    senderId: message.accountId,
+                    senderName: "ZPlus Night Assistant",
+                    senderType: "agent",
+                    messageType: "text",
+                    content: autoReplyText,
+                    timestamp: Date.now(),
+                    isSelf: true,
+                    status: "sent",
+                };
+                await runner.sendMessage(replyMsg);
+            }
+        }
+        catch (err) {
+            this.logger.warn("Auto-reply evaluation notice:", err);
+        }
+        // 3. Bắn Push Notification về ZPlus Mobile
+        try {
+            await this.pushDispatcher.dispatchMessageAlert("fcm_token_mobile_owner", message);
+        }
+        catch (err) {
+            this.logger.debug("Push notification dispatch notice:", err);
+        }
+    }
+    getMetrics() {
+        const uptime = this.startTime > 0 ? Math.floor((Date.now() - this.startTime) / 1000) : 0;
+        const memUsage = process.memoryUsage().rss / (1024 * 1024);
+        return {
+            workerId: this.config.workerId,
+            status: this.status,
+            uptimeSeconds: uptime,
+            activeAccountsCount: this.activeAccounts.size,
+            totalMessagesProcessed: this.messagesProcessed,
+            memoryUsageMb: Math.round(memUsage * 100) / 100,
+            lastHeartbeat: new Date().toISOString(),
+        };
+    }
+    sendHeartbeat() {
+        const metrics = this.getMetrics();
+        this.logger.info(`💓 Heartbeat: status=${metrics.status}, accounts=${metrics.activeAccountsCount}, msgs=${metrics.totalMessagesProcessed}, pendingDelta=${this.deltaQueue.getCount()}, uptime=${metrics.uptimeSeconds}s`);
+    }
+}
+exports.WorkerEngine = WorkerEngine;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./engine/WorkerEngine";
+export * from "./config/WorkerConfig";
+export * from "./channels";
+export * from "./lock/DistributedLockManager";
+export * from "./sync/CloudSyncWorker";
+export * from "./sync/CloudPendingMessageQueue";
+export * from "./server/WorkerHttpServer";
+export * from "./automation/HeadlessAutomationEngine";
+export * from "./notifications/PushNotificationDispatcher";

package/dist/index.js

@@ -0,0 +1,25 @@
+"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("./engine/WorkerEngine"), exports);
+__exportStar(require("./config/WorkerConfig"), exports);
+__exportStar(require("./channels"), exports);
+__exportStar(require("./lock/DistributedLockManager"), exports);
+__exportStar(require("./sync/CloudSyncWorker"), exports);
+__exportStar(require("./sync/CloudPendingMessageQueue"), exports);
+__exportStar(require("./server/WorkerHttpServer"), exports);
+__exportStar(require("./automation/HeadlessAutomationEngine"), exports);
+__exportStar(require("./notifications/PushNotificationDispatcher"), exports);

package/dist/lock/DistributedLockManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 🔐 Distributed Mutex Lock Manager
+ * Quản lý khóa loại trừ tương hỗ, chống xung đột 2 kết nối WSS song song (Desktop & Worker)
+ * Hỗ trợ Master Preemption: Desktop luôn có quyền tối thượng thu hồi lock trong < 1.000ms.
+ */
+import { ILogger } from "@zplus/core";
+export interface LockRecord {
+    accountId: string;
+    ownerId: string;
+    acquiredAt: number;
+    expiresAt: number;
+}
+export type LockPreemptCallback = (accountId: string, newOwnerId: string) => Promise<void> | void;
+export declare class DistributedLockManager {
+    private readonly defaultTtlMs;
+    private readonly logger;
+    private readonly locks;
+    private readonly preemptCallbacks;
+    constructor(defaultTtlMs?: number, logger?: ILogger);
+    onPreempt(cb: LockPreemptCallback): void;
+    /**
+     * Xin giữ lock cho tài khoản
+     */
+    acquireLock(accountId: string, ownerId: string, ttlMs?: number): boolean;
+    /**
+     * Desktop chiếm lại quyền tối thượng (Master Preemption)
+     * Buộc Worker nhả socket WSS trong vòng tối đa 1.000ms
+     */
+    preemptLock(accountId: string, preemptorId: string): Promise<boolean>;
+    /**
+     * Giải phóng khóa
+     */
+    releaseLock(accountId: string, ownerId?: string): boolean;
+    /**
+     * Giải phóng toàn bộ khóa thuộc sở hữu của ownerId
+     */
+    releaseAllForOwner(ownerId: string): number;
+    isLocked(accountId: string): boolean;
+    getLockOwner(accountId: string): string | null;
+}

package/dist/lock/DistributedLockManager.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * 🔐 Distributed Mutex Lock Manager
+ * Quản lý khóa loại trừ tương hỗ, chống xung đột 2 kết nối WSS song song (Desktop & Worker)
+ * Hỗ trợ Master Preemption: Desktop luôn có quyền tối thượng thu hồi lock trong < 1.000ms.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedLockManager = void 0;
+const core_1 = require("@zplus/core");
+class DistributedLockManager {
+    defaultTtlMs;
+    logger;
+    locks = new Map();
+    preemptCallbacks = [];
+    constructor(defaultTtlMs = 60000, logger) {
+        this.defaultTtlMs = defaultTtlMs;
+        this.logger = logger || (0, core_1.createLogger)("DistributedLockManager");
+    }
+    onPreempt(cb) {
+        this.preemptCallbacks.push(cb);
+    }
+    /**
+     * Xin giữ lock cho tài khoản
+     */
+    acquireLock(accountId, ownerId, ttlMs = this.defaultTtlMs) {
+        const now = Date.now();
+        const existing = this.locks.get(accountId);
+        if (existing && existing.expiresAt > now && existing.ownerId !== ownerId) {
+            this.logger.warn(`Lock denied for account ${accountId}: currently held by ${existing.ownerId} (expires in ${existing.expiresAt - now}ms)`);
+            return false;
+        }
+        this.locks.set(accountId, {
+            accountId,
+            ownerId,
+            acquiredAt: now,
+            expiresAt: now + ttlMs,
+        });
+        this.logger.info(`✅ Lock granted: account=${accountId}, owner=${ownerId}, ttl=${ttlMs}ms`);
+        return true;
+    }
+    /**
+     * Desktop chiếm lại quyền tối thượng (Master Preemption)
+     * Buộc Worker nhả socket WSS trong vòng tối đa 1.000ms
+     */
+    async preemptLock(accountId, preemptorId) {
+        const existing = this.locks.get(accountId);
+        this.logger.info(`⚡ Preemption triggered for account ${accountId} by master ${preemptorId} (previous owner: ${existing?.ownerId || "none"})`);
+        // Kích hoạt tất cả callback giải phóng socket WSS khẩn cấp
+        const callbackPromises = this.preemptCallbacks.map((cb) => {
+            try {
+                return Promise.resolve(cb(accountId, preemptorId));
+            }
+            catch (err) {
+                this.logger.error(`Error in preempt callback for ${accountId}:`, err);
+                return Promise.resolve();
+            }
+        });
+        await Promise.race([
+            Promise.all(callbackPromises),
+            new Promise((resolve) => setTimeout(resolve, 1000)),
+        ]);
+        const now = Date.now();
+        this.locks.set(accountId, {
+            accountId,
+            ownerId: preemptorId,
+            acquiredAt: now,
+            expiresAt: now + this.defaultTtlMs,
+        });
+        this.logger.info(`✅ Account ${accountId} preempted successfully by ${preemptorId}.`);
+        return true;
+    }
+    /**
+     * Giải phóng khóa
+     */
+    releaseLock(accountId, ownerId) {
+        const existing = this.locks.get(accountId);
+        if (!existing)
+            return true;
+        if (ownerId && existing.ownerId !== ownerId) {
+            this.logger.warn(`Attempted unauthorized lock release for ${accountId} by ${ownerId} (real owner: ${existing.ownerId})`);
+            return false;
+        }
+        this.locks.delete(accountId);
+        this.logger.info(`🔓 Lock released for account ${accountId}.`);
+        return true;
+    }
+    /**
+     * Giải phóng toàn bộ khóa thuộc sở hữu của ownerId
+     */
+    releaseAllForOwner(ownerId) {
+        let released = 0;
+        for (const [accountId, lock] of this.locks.entries()) {
+            if (lock.ownerId === ownerId) {
+                this.locks.delete(accountId);
+                released++;
+            }
+        }
+        return released;
+    }
+    isLocked(accountId) {
+        const existing = this.locks.get(accountId);
+        if (!existing)
+            return false;
+        return existing.expiresAt > Date.now();
+    }
+    getLockOwner(accountId) {
+        const existing = this.locks.get(accountId);
+        if (!existing || existing.expiresAt <= Date.now())
+            return null;
+        return existing.ownerId;
+    }
+}
+exports.DistributedLockManager = DistributedLockManager;

package/dist/notifications/PushNotificationDispatcher.d.ts

@@ -0,0 +1,14 @@
+import { ILogger } from "@zplus/core";
+import { UnifiedMessage } from "@zplus/contracts";
+export interface PushNotificationPayload {
+    recipientToken: string;
+    title: string;
+    body: string;
+    data?: Record<string, any>;
+}
+export declare class PushNotificationDispatcher {
+    private readonly logger;
+    constructor(logger?: ILogger);
+    dispatchMessageAlert(token: string, message: UnifiedMessage): Promise<boolean>;
+    sendNotification(payload: PushNotificationPayload): Promise<boolean>;
+}

package/dist/notifications/PushNotificationDispatcher.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PushNotificationDispatcher = void 0;
+const core_1 = require("@zplus/core");
+class PushNotificationDispatcher {
+    logger;
+    constructor(logger) {
+        this.logger = logger || (0, core_1.createLogger)("PushNotificationDispatcher");
+    }
+    async dispatchMessageAlert(token, message) {
+        const title = `${message.senderName} (${message.platform.toUpperCase()})`;
+        const body = message.content || "New multimedia message received";
+        return this.sendNotification({
+            recipientToken: token,
+            title,
+            body,
+            data: {
+                messageId: message.id,
+                threadId: message.threadId,
+                platform: message.platform,
+                accountId: message.accountId,
+            },
+        });
+    }
+    async sendNotification(payload) {
+        this.logger.debug(`Dispatching push notification to device token: ${payload.recipientToken.slice(0, 8)}...`);
+        // Integrates with Firebase Cloud Messaging / APNs gateway
+        return true;
+    }
+}
+exports.PushNotificationDispatcher = PushNotificationDispatcher;

package/dist/server/WorkerHttpServer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 🌐 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)
+ */
+import { ILogger } from "@zplus/core";
+import { WorkerEngine } from "../engine/WorkerEngine";
+import { DistributedLockManager } from "../lock/DistributedLockManager";
+import { CloudPendingMessageQueue } from "../sync/CloudPendingMessageQueue";
+export declare class WorkerHttpServer {
+    private readonly port;
+    private readonly engine;
+    private readonly lockManager;
+    private readonly deltaQueue;
+    private readonly logger;
+    private server;
+    constructor(port: number, engine: WorkerEngine, lockManager: DistributedLockManager, deltaQueue: CloudPendingMessageQueue, logger?: ILogger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private readJsonBody;
+}