@mtcute/core 0.28.2 → 0.29.0

package/highlevel/worker/worker.cjs

@@ -7,30 +7,77 @@ if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WAR
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const errors = require("./errors.cjs");
 const protocol = require("./protocol.cjs");
+const WORKER_HEARTBEAT_TIMEOUT = 6e4;
+const WORKER_HEARTBEAT_SWEEP_INTERVAL = 1e4;
 class TelegramWorker {
   constructor(params) {
     this.params = params;
     this.workerId = params.workerId ?? protocol.DEFAULT_WORKER_ID;
+    this.client = params.client;
+  }
+  client;
+  broadcast = () => {
+  };
+  _cleanup = [];
+  _heartbeatSweep;
+  _mounted = false;
+  activeConnections = /* @__PURE__ */ new Set();
+  connectionLastSeen = /* @__PURE__ */ new Map();
+  pendingAborts = /* @__PURE__ */ new Map();
+  workerId;
+  _disconnecting;
+  _destroying;
+  mount() {
+    if (this._mounted) return this;
     const [broadcast, cleanup] = this.registerWorker((message, respond) => {
       if (message._mtcuteWorkerId !== this.workerId) return;
       switch (message.type) {
+        case "connect":
+          this.touchConnection(message.connectionId, true);
+          break;
+        case "heartbeat":
+          if (!this.activeConnections.has(message.connectionId)) {
+            this.respondConnectionExpired(respond, message.connectionId);
+            break;
+          }
+          this.touchConnection(message.connectionId);
+          break;
+        case "release":
+          this.onRelease(message.connectionId);
+          break;
         case "invoke":
+          if (!this.activeConnections.has(message.connectionId)) {
+            this.respondConnectionExpired(respond, message.connectionId);
+            break;
+          }
+          this.touchConnection(message.connectionId);
           this.onInvoke(message, respond);
           break;
         case "abort": {
-          const abort = this.pendingAborts.get(message.id);
-          if (abort) {
-            abort.abort();
-            this.pendingAborts.delete(message.id);
+          if (!this.activeConnections.has(message.connectionId)) {
+            this.respondConnectionExpired(respond, message.connectionId);
+            break;
           }
+          this.touchConnection(message.connectionId);
+          const pending = this.pendingAborts.get(message.connectionId);
+          const abort = pending?.get(message.id);
+          if (!abort) break;
+          abort.abort();
+          pending.delete(message.id);
+          if (!pending.size) {
+            this.pendingAborts.delete(message.connectionId);
+          }
+          break;
         }
       }
     });
     this.broadcast = broadcast;
-    this._cleanup = cleanup;
-    const client = params.client;
-    this.client = client;
-    client.log.mgr.handler = (color, level, tag, fmt, args) => this.broadcast({
+    this._cleanup.push(cleanup);
+    this._heartbeatSweep = setInterval(this.sweepExpiredConnections, WORKER_HEARTBEAT_SWEEP_INTERVAL);
+    this._mounted = true;
+    const client = this.client;
+    const prevLogHandler = client.log.mgr.handler;
+    const onLog = (color, level, tag, fmt, args) => this.broadcast({
       _mtcuteWorkerId: this.workerId,
       type: "log",
       color,
@@ -39,56 +86,201 @@ class TelegramWorker {
       fmt,
       args
     });
-    client.onError.add(
-      (err) => this.broadcast({
-        _mtcuteWorkerId: this.workerId,
-        type: "error",
-        error: errors.serializeError(err)
-      })
-    );
-    client.onConnectionState.add(
-      (state) => this.broadcast({
-        _mtcuteWorkerId: this.workerId,
-        type: "conn_state",
-        state
-      })
-    );
-    client.stopSignal.addEventListener("abort", () => this.broadcast({
+    const onError = (err) => this.broadcast({
+      _mtcuteWorkerId: this.workerId,
+      type: "error",
+      error: errors.serializeError(err)
+    });
+    const onConnectionState = (state) => this.broadcast({
+      _mtcuteWorkerId: this.workerId,
+      type: "conn_state",
+      state
+    });
+    const onStop = () => this.broadcast({
       _mtcuteWorkerId: this.workerId,
       type: "stop"
-    }));
+    });
+    client.log.mgr.handler = onLog;
+    client.onError.add(onError);
+    client.onConnectionState.add(onConnectionState);
+    client.stopSignal.addEventListener("abort", onStop);
+    this._cleanup.push(
+      () => {
+        client.log.mgr.handler = prevLogHandler;
+      },
+      () => client.onError.remove(onError),
+      () => client.onConnectionState.remove(onConnectionState),
+      () => client.stopSignal.removeEventListener("abort", onStop)
+    );
     if (client.updates) {
-      client.onRawUpdate.add(
-        ({ update, peers }) => this.broadcast({
-          _mtcuteWorkerId: this.workerId,
-          type: "update",
-          update: protocol.serializeResult(update),
-          users: protocol.serializeResult(peers.users),
-          chats: protocol.serializeResult(peers.chats),
-          hasMin: peers.hasMin
-        })
-      );
+      const onRawUpdate = ({ update, peers }) => this.broadcast({
+        _mtcuteWorkerId: this.workerId,
+        type: "update",
+        update: protocol.serializeResult(update),
+        users: protocol.serializeResult(peers.users),
+        chats: protocol.serializeResult(peers.chats),
+        hasMin: peers.hasMin
+      });
+      client.onRawUpdate.add(onRawUpdate);
+      this._cleanup.push(() => client.onRawUpdate.remove(onRawUpdate));
     } else {
-      client.onServerUpdate.add(
-        (update) => this.broadcast({
-          _mtcuteWorkerId: this.workerId,
-          type: "server_update",
-          update: protocol.serializeResult(update)
-        })
-      );
+      const onServerUpdate = (update) => this.broadcast({
+        _mtcuteWorkerId: this.workerId,
+        type: "server_update",
+        update: protocol.serializeResult(update)
+      });
+      client.onServerUpdate.add(onServerUpdate);
+      this._cleanup.push(() => client.onServerUpdate.remove(onServerUpdate));
     }
+    return this;
+  }
+  getConnectionAborts(connectionId) {
+    const existing = this.pendingAborts.get(connectionId);
+    if (existing) return existing;
+    const created = /* @__PURE__ */ new Map();
+    this.pendingAborts.set(connectionId, created);
+    return created;
+  }
+  deletePendingAbort(connectionId, id) {
+    const pending = this.pendingAborts.get(connectionId);
+    if (!pending) return;
+    pending.delete(id);
+    if (!pending.size) {
+      this.pendingAborts.delete(connectionId);
+    }
+  }
+  touchConnection(connectionId, activate = false) {
+    if (activate) {
+      this.activeConnections.add(connectionId);
+    } else if (!this.activeConnections.has(connectionId)) {
+      return;
+    }
+    this.connectionLastSeen.set(connectionId, Date.now());
+  }
+  respondConnectionExpired(respond, connectionId) {
+    respond({
+      _mtcuteWorkerId: this.workerId,
+      connectionId,
+      type: "connection_expired"
+    });
+  }
+  sweepExpiredConnections = () => {
+    const now = Date.now();
+    for (const [connectionId, lastSeen] of this.connectionLastSeen) {
+      if (now - lastSeen < WORKER_HEARTBEAT_TIMEOUT) continue;
+      this.respondConnectionExpired(this.broadcast, connectionId);
+      this.onRelease(connectionId);
+    }
+  };
+  onRelease(connectionId) {
+    const wasActive = this.activeConnections.delete(connectionId);
+    const hadLastSeen = this.connectionLastSeen.delete(connectionId);
+    this.client.timers.clearOwner(connectionId);
+    const pending = this.pendingAborts.get(connectionId);
+    if (pending) {
+      for (const abort of pending.values()) {
+        abort.abort();
+      }
+      this.pendingAborts.delete(connectionId);
+    }
+    if (!wasActive && !hadLastSeen && !pending) return;
+    if (this.activeConnections.size !== 0) return;
+    switch (this.params.onLastDisconnected ?? "nothing") {
+      case "nothing":
+        return;
+      case "disconnect":
+        if (this._disconnecting || this._destroying) return;
+        void this.disconnectSharedClient().catch(() => {
+        });
+        return;
+      case "destroy":
+        if (this._destroying) return;
+        void this.forceDestroy().catch(() => {
+        });
+    }
+  }
+  disconnectSharedClient() {
+    if (this._destroying) return this._destroying;
+    if (this._disconnecting) return this._disconnecting;
+    this._disconnecting = this.client.disconnect().finally(() => {
+      this._disconnecting = void 0;
+    });
+    return this._disconnecting;
+  }
+  forceDestroy() {
+    this.activeConnections.clear();
+    this.connectionLastSeen.clear();
+    for (const pending of this.pendingAborts.values()) {
+      for (const abort of pending.values()) {
+        abort.abort();
+      }
+    }
+    this.pendingAborts.clear();
+    if (!this._destroying) {
+      this._destroying = (this._disconnecting ?? Promise.resolve()).catch(() => {
+      }).then(() => this.client.destroy());
+    }
+    return this._destroying;
+  }
+  shouldSyncCurrentUser(msg) {
+    if (msg.target === "storage-self") {
+      return msg.method === "store" || msg.method === "storeFrom" || msg.method === "update";
+    }
+    return msg.target === "client" && (msg.method === "notifyLoggedIn" || msg.method === "notifyLoggedOut" || msg.method === "importSession");
   }
-  client;
-  broadcast;
-  _cleanup;
-  pendingAborts = /* @__PURE__ */ new Map();
-  workerId;
   onInvoke(msg, respond) {
+    if (msg.target === "client" && msg.method === "destroy") {
+      this.forceDestroy().then(() => {
+        if (msg.void) return;
+        respond({
+          _mtcuteWorkerId: this.workerId,
+          connectionId: msg.connectionId,
+          type: "result",
+          id: msg.id
+        });
+      }).catch((err) => {
+        respond({
+          _mtcuteWorkerId: this.workerId,
+          connectionId: msg.connectionId,
+          type: "result",
+          id: msg.id,
+          error: errors.serializeError(err)
+        });
+      });
+      return;
+    }
+    if (msg.target === "client" && msg.method === "disconnect") {
+      this.disconnectSharedClient().then(() => {
+        if (msg.void) return;
+        respond({
+          _mtcuteWorkerId: this.workerId,
+          connectionId: msg.connectionId,
+          type: "result",
+          id: msg.id
+        });
+      }).catch((err) => {
+        respond({
+          _mtcuteWorkerId: this.workerId,
+          connectionId: msg.connectionId,
+          type: "result",
+          id: msg.id,
+          error: errors.serializeError(err)
+        });
+      });
+      return;
+    }
     let target;
     switch (msg.target) {
       case "custom":
         target = this.params.customMethods;
         break;
+      case "timers":
+        target = {
+          upsert: (spec) => Promise.resolve(this.client.timers.upsertOwned(msg.connectionId, spec)),
+          cancel: (key) => this.client.timers.cancel(key),
+          exists: (key) => this.client.timers.exists(key)
+        };
+        break;
       case "client":
         target = this.client;
         break;
@@ -107,9 +299,10 @@ class TelegramWorker {
       default: {
         respond({
           _mtcuteWorkerId: this.workerId,
+          connectionId: msg.connectionId,
           type: "result",
           id: msg.id,
-          error: new Error(`Unknown target ${msg.target}`)
+          error: errors.serializeError(new Error(`Unknown target ${msg.target}`))
         });
         return;
       }
@@ -118,16 +311,17 @@ class TelegramWorker {
     if (!method) {
       respond({
         _mtcuteWorkerId: this.workerId,
+        connectionId: msg.connectionId,
         type: "result",
         id: msg.id,
-        error: new Error(`Method ${msg.method} not found on ${msg.target}`)
+        error: errors.serializeError(new Error(`Method ${msg.method} not found on ${msg.target}`))
       });
       return;
     }
     let args;
     if (msg.target === "client" && msg.method === "call" && msg.withAbort) {
       const abort = new AbortController();
-      this.pendingAborts.set(msg.id, abort);
+      this.getConnectionAborts(msg.connectionId).set(msg.id, abort);
       args = [
         protocol.deserializeResult(msg.args[0]),
         {
@@ -138,23 +332,36 @@ class TelegramWorker {
     } else {
       args = protocol.deserializeResult(msg.args);
     }
-    Promise.resolve(method.apply(target, args)).then((res) => {
+    const syncCurrentUser = this.shouldSyncCurrentUser(msg);
+    Promise.resolve(method.apply(target, args)).then(async (res) => {
       if (msg.withAbort) {
-        this.pendingAborts.delete(msg.id);
+        this.deletePendingAbort(msg.connectionId, msg.id);
+      }
+      if (syncCurrentUser) {
+        try {
+          this.broadcast({
+            _mtcuteWorkerId: this.workerId,
+            type: "self_sync",
+            self: protocol.serializeResult(await this.client.storage.self.fetch())
+          });
+        } catch {
+        }
       }
       if (msg.void) return;
       respond({
         _mtcuteWorkerId: this.workerId,
+        connectionId: msg.connectionId,
         type: "result",
         id: msg.id,
         result: protocol.serializeResult(res)
       });
     }).catch((err) => {
       if (msg.withAbort) {
-        this.pendingAborts.delete(msg.id);
+        this.deletePendingAbort(msg.connectionId, msg.id);
       }
       respond({
         _mtcuteWorkerId: this.workerId,
+        connectionId: msg.connectionId,
         type: "result",
         id: msg.id,
         error: errors.serializeError(err)
@@ -162,7 +369,13 @@ class TelegramWorker {
     });
   }
   destroy() {
-    this._cleanup?.();
+    if (this._heartbeatSweep !== void 0) {
+      clearInterval(this._heartbeatSweep);
+    }
+    for (const cleanup of this._cleanup) {
+      cleanup();
+    }
+    this._mounted = false;
   }
 }
 exports.TelegramWorker = TelegramWorker;

package/highlevel/worker/worker.d.cts

@@ -2,18 +2,46 @@ import { BaseTelegramClient } from '../base.js';
 import { RespondFn, WorkerCustomMethods, WorkerMessageHandler } from './protocol.js';
 export interface TelegramWorkerOptions<T extends WorkerCustomMethods> {
     client: BaseTelegramClient;
+    /** mtcute worker ID to disambiguate multiple clients within the same underlying worker */
     workerId?: string;
+    /**
+     * What to do when the last connection to the worker is closed?
+     *
+     * - `destroy`: destroy the client, terminating the worker
+     * - `disconnect`: disconnect the client, but keep the worker running until `forceDestroy` is called
+     * - `nothing`: do nothing, lifecycle is managed manually
+     *
+     * @default 'nothing'
+     */
+    onLastDisconnected?: 'destroy' | 'disconnect' | 'nothing';
+    /** additional custom methods to expose */
     customMethods?: T;
 }
 export declare abstract class TelegramWorker<T extends WorkerCustomMethods> {
     readonly params: TelegramWorkerOptions<T>;
     readonly client: BaseTelegramClient;
-    readonly broadcast: RespondFn;
+    broadcast: RespondFn;
     private _cleanup;
+    private _heartbeatSweep;
+    private _mounted;
     abstract registerWorker(handler: WorkerMessageHandler): [RespondFn, VoidFunction];
-    readonly pendingAborts: Map<number, AbortController>;
+    readonly activeConnections: Set<string>;
+    readonly connectionLastSeen: Map<string, number>;
+    readonly pendingAborts: Map<string, Map<number, AbortController>>;
     readonly workerId: string;
+    private _disconnecting?;
+    private _destroying?;
     constructor(params: TelegramWorkerOptions<T>);
+    mount(): this;
+    private getConnectionAborts;
+    private deletePendingAbort;
+    private touchConnection;
+    private respondConnectionExpired;
+    private sweepExpiredConnections;
+    private onRelease;
+    private disconnectSharedClient;
+    private forceDestroy;
+    private shouldSyncCurrentUser;
     private onInvoke;
     destroy(): void;
 }

package/highlevel/worker/worker.d.ts

@@ -2,18 +2,46 @@ import { BaseTelegramClient } from '../base.js';
 import { RespondFn, WorkerCustomMethods, WorkerMessageHandler } from './protocol.js';
 export interface TelegramWorkerOptions<T extends WorkerCustomMethods> {
     client: BaseTelegramClient;
+    /** mtcute worker ID to disambiguate multiple clients within the same underlying worker */
     workerId?: string;
+    /**
+     * What to do when the last connection to the worker is closed?
+     *
+     * - `destroy`: destroy the client, terminating the worker
+     * - `disconnect`: disconnect the client, but keep the worker running until `forceDestroy` is called
+     * - `nothing`: do nothing, lifecycle is managed manually
+     *
+     * @default 'nothing'
+     */
+    onLastDisconnected?: 'destroy' | 'disconnect' | 'nothing';
+    /** additional custom methods to expose */
     customMethods?: T;
 }
 export declare abstract class TelegramWorker<T extends WorkerCustomMethods> {
     readonly params: TelegramWorkerOptions<T>;
     readonly client: BaseTelegramClient;
-    readonly broadcast: RespondFn;
+    broadcast: RespondFn;
     private _cleanup;
+    private _heartbeatSweep;
+    private _mounted;
     abstract registerWorker(handler: WorkerMessageHandler): [RespondFn, VoidFunction];
-    readonly pendingAborts: Map<number, AbortController>;
+    readonly activeConnections: Set<string>;
+    readonly connectionLastSeen: Map<string, number>;
+    readonly pendingAborts: Map<string, Map<number, AbortController>>;
     readonly workerId: string;
+    private _disconnecting?;
+    private _destroying?;
     constructor(params: TelegramWorkerOptions<T>);
+    mount(): this;
+    private getConnectionAborts;
+    private deletePendingAbort;
+    private touchConnection;
+    private respondConnectionExpired;
+    private sweepExpiredConnections;
+    private onRelease;
+    private disconnectSharedClient;
+    private forceDestroy;
+    private shouldSyncCurrentUser;
     private onInvoke;
     destroy(): void;
 }