@mtkruto/node 0.0.832 → 0.0.835

package/esm/client/client.d.ts

@@ -1,10 +1,14 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 import * as types from "../tl/2_types.js";
 import * as functions from "../tl/3_functions.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { Storage } from "../storage/storage.js";
 import { DC, TransportProvider } from "../transport/transport_provider.js";
 import { MessageEntity } from "../types/0_message_entity.js";
+import { ReplyKeyboardRemove } from "../types/0_reply_keyboard_remove.js";
+import { ForceReply } from "../types/0_force_reply.js";
+import { ReplyKeyboardMarkup } from "../types/2_reply_keyboard_markup.js";
+import { InlineKeyboardMarkup } from "../types/2_inline_keyboard_markup.js";
 export declare const restartAuth: unique symbol;
 export declare enum ParseMode {
     None = "none",
@@ -136,5 +140,6 @@ export declare class Client extends ClientAbstract {
         replyToMessageId?: number;
         messageThreadId?: number;
         sendAs?: number | string;
-    }): Promise<types.TypeUpdates>;
+        replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+    }): Promise<import("../types/3_message.js").Message>;
 }

package/esm/client/client.js

@@ -1,6 +1,8 @@
-import { gunzip } from "../deps.js";
+import { debug, gunzip } from "../deps.js";
 import { ackThreshold, DEFAULT_APP_VERSION, DEFAULT_DEVICE_MODEL, DEFAULT_INITIAL_DC, DEFAULT_LANG_CODE, DEFAULT_LANG_PACK, DEFAULT_SYSTEM_LANG_CODE, DEFAULT_SYSTEM_VERSION, LAYER, MAX_CHANNEL_ID, MAX_CHAT_ID, USERNAME_TTL, ZERO_CHANNEL_ID } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, getRandomId } from "../utilities/0_bigint.js";
+import { UNREACHABLE } from "../utilities/0_control.js";
+import { sha1 } from "../utilities/0_hash.js";
 import { parseHtml } from "../utilities/0_html.js";
 import { decryptMessage, encryptMessage, getMessageId } from "../utilities/1_message.js";
 import { checkPassword } from "../utilities/1_password.js";
@@ -14,8 +16,13 @@ import { MessageContainer } from "../tl/6_message_container.js";
 import { ClientAbstract } from "./client_abstract.js";
 import { ClientPlain } from "./client_plain.js";
 import { StorageMemory } from "../storage/storage_memory.js";
-import { sha1 } from "../utilities/0_hash.js";
 import { messageEntityToTlObject } from "../types/0_message_entity.js";
+import { replyKeyboardRemoveToTlObject } from "../types/0_reply_keyboard_remove.js";
+import { forceReplyToTlObject } from "../types/0_force_reply.js";
+import { replyKeyboardMarkupToTlObject } from "../types/2_reply_keyboard_markup.js";
+import { inlineKeyboardMarkupToTlObject } from "../types/2_inline_keyboard_markup.js";
+import { constructMessage } from "../types/3_message.js";
+const d = debug("client");
 export const restartAuth = Symbol();
 export var ParseMode;
 (function (ParseMode) {
@@ -200,7 +207,7 @@ export class Client extends ClientAbstract {
         if (dc == null) {
             await this.storage.setDc(DEFAULT_INITIAL_DC);
         }
-        // logger().debug("Client connected");
+        d("enrypted client connected");
         this.receiveLoop();
         this.pingLoop();
     }
@@ -228,6 +235,7 @@ export class Client extends ClientAbstract {
         if (!this.apiHash) {
             throw new Error("apiHash not set");
         }
+        d("authorizing with %s", typeof params === "string" ? "bot token" : params instanceof types.AuthExportedAuthorization ? "exported authorization" : "AuthorizeUserParams");
         await this.invoke(new functions.InitConnection({
             apiId: this.apiId,
             appVersion: this.appVersion,
@@ -241,6 +249,7 @@ export class Client extends ClientAbstract {
             systemLangCode: this.systemLangCode,
             systemVersion: this.systemVersion,
         }));
+        d("connection inited");
         const handlePassword = async (err) => {
             params = params;
             if (err instanceof types.RPCError && err.errorMessage == "SESSION_PASSWORD_NEEDED") {
@@ -251,6 +260,7 @@ export class Client extends ClientAbstract {
                             const password = typeof params.password === "string" ? params.password : await params.password();
                             const input = await checkPassword(password, ap);
                             await this.invoke(new functions.AuthCheckPassword({ password: input }));
+                            d("authorized as user");
                             break;
                         }
                         catch (err) {
@@ -273,6 +283,7 @@ export class Client extends ClientAbstract {
         };
         try {
             await this.invoke(new functions.UpdatesGetState());
+            d("already authorized");
             return;
         }
         catch (err) {
@@ -285,6 +296,7 @@ export class Client extends ClientAbstract {
         try {
             if (params instanceof types.AuthExportedAuthorization) {
                 await this.invoke(new functions.AuthImportAuthorization({ id: params.id, bytes: params.bytes }));
+                d("authorization imported");
             }
             else if (typeof params == "object") {
                 while (true) {
@@ -300,6 +312,7 @@ export class Client extends ClientAbstract {
                                 phoneNumber,
                                 settings: new types.CodeSettings(),
                             }));
+                            d("verification code sent");
                             if (sentCode instanceof types.AuthSentCode) {
                                 while (true) {
                                     const phoneCode = typeof params.code === "string" ? params.code : await params.code();
@@ -310,6 +323,7 @@ export class Client extends ClientAbstract {
                                         }
                                         else {
                                             signedIn = true;
+                                            d("authorized as user");
                                             break;
                                         }
                                     }
@@ -343,6 +357,7 @@ export class Client extends ClientAbstract {
             }
             else {
                 await this.invoke(new functions.AuthImportBotAuthorization({ apiId: this.apiId, apiHash: this.apiHash, botAuthToken: params, flags: 0 }));
+                d("authorized as bot");
             }
         }
         catch (err) {
@@ -354,6 +369,7 @@ export class Client extends ClientAbstract {
                         newDc += "-test";
                     }
                     await this.reconnect(newDc);
+                    d("migrated to DC%s", newDc);
                     if (typeof params === "object" && phoneNumber != null) {
                         params = Object.assign({}, params);
                         params.phone = phoneNumber;
@@ -394,8 +410,8 @@ export class Client extends ClientAbstract {
             try {
                 decrypted = await decryptMessage(buffer, this.auth.key, this.auth.id, this.sessionId);
             }
-            catch (_err) {
-                // logger().error(`Failed to decrypt message: ${err}`);
+            catch (err) {
+                d("failed to decrypt message: %o", err);
                 continue;
             }
             const messages = decrypted instanceof MessageContainer ? decrypted.messages : [decrypted];
@@ -404,7 +420,7 @@ export class Client extends ClientAbstract {
                 if (body instanceof types.GZIPPacked) {
                     body = new TLReader(gunzip(body.packedData)).readObject();
                 }
-                // logger().debug(`Received ${body.constructor.name}`);
+                d("received %s", body.constructor.name);
                 if (body instanceof types.Updates) {
                     this.processUpdates(body);
                 }
@@ -413,6 +429,12 @@ export class Client extends ClientAbstract {
                     if (result instanceof types.GZIPPacked) {
                         result = new TLReader(gunzip(result.packedData)).readObject();
                     }
+                    if (result instanceof types.RPCError) {
+                        d("RPCResult: %d %s", result.errorCode, result.errorMessage);
+                    }
+                    else {
+                        d("RPCResult: %s", result.constructor.name);
+                    }
                     const promise = this.promises.get(message.body.messageId);
                     if (promise) {
                         if (result instanceof types.RPCError) {
@@ -454,8 +476,8 @@ export class Client extends ClientAbstract {
             try {
                 await this.invoke(new functions.Ping({ pingId: getRandomBigInt(8, true, false) }));
             }
-            catch (_err) {
-                // logger().error(`Failed to invoke ping: ${err}`);
+            catch (err) {
+                d("ping loop error: %o", err);
             }
             await new Promise((r) => setTimeout(r, 60 * 1000));
         }
@@ -471,7 +493,7 @@ export class Client extends ClientAbstract {
         }
         const message = new Message(getMessageId(), seqNo, function_);
         await this.transport.send(await encryptMessage(message, this.auth.key, this.auth.id, this.state.salt, this.sessionId));
-        // logger().debug(`Invoked ${function_.constructor.name}`);
+        d("invoked %s", function_.constructor.name);
         if (noWait) {
             return;
         }
@@ -565,7 +587,7 @@ export class Client extends ClientAbstract {
                         channelId = resolved.peer.channelId;
                     }
                     else {
-                        throw new Error("Unreachable");
+                        UNREACHABLE();
                     }
                 }
                 if (userId) {
@@ -577,7 +599,7 @@ export class Client extends ClientAbstract {
                     return new types.InputPeerChannel({ channelId, accessHash: accessHash ?? 0n });
                 }
                 else {
-                    throw new Error("Unreachable");
+                    UNREACHABLE();
                 }
             }
         }
@@ -612,6 +634,27 @@ export class Client extends ClientAbstract {
                 }
             }
         }
+        let replyMarkup = undefined;
+        if (params?.replyMarkup) {
+            if ("inlineKeyboard" in params.replyMarkup) {
+                replyMarkup = await inlineKeyboardMarkupToTlObject(params.replyMarkup, async (v) => {
+                    const inputPeer = await this.getInputPeer(v).then((v) => v[as](types.InputPeerUser));
+                    return new types.InputUser({ userId: inputPeer.userId, accessHash: inputPeer.accessHash });
+                });
+            }
+            else if ("keyboard" in params.replyMarkup) {
+                replyMarkup = replyKeyboardMarkupToTlObject(params.replyMarkup);
+            }
+            else if ("removeKeyboard" in params.replyMarkup) {
+                replyMarkup = replyKeyboardRemoveToTlObject(params.replyMarkup);
+            }
+            else if ("forceReply" in params.replyMarkup) {
+                replyMarkup = forceReplyToTlObject(params.replyMarkup);
+            }
+            else {
+                throw new Error("The replyMarkup parameter has an unexpected type");
+            }
+        }
         const peer = await this.getInputPeer(chatId);
         const randomId = getRandomId();
         const message = text;
@@ -622,7 +665,7 @@ export class Client extends ClientAbstract {
         const topMsgId = params?.messageThreadId;
         const sendAs = params?.sendAs ? await this.getInputPeer(params.sendAs) : undefined;
         const entities = entities_?.length > 0 ? entities_.map((v) => messageEntityToTlObject(v)) : undefined;
-        return await this.invoke(new functions.MessagesSendMessage({
+        const updates = await this.invoke(new functions.MessagesSendMessage({
             peer,
             randomId,
             message,
@@ -633,6 +676,16 @@ export class Client extends ClientAbstract {
             topMsgId,
             sendAs,
             entities,
-        }));
+            replyMarkup,
+        })).then((v) => v[as](types.Updates));
+        for (const update of updates.updates) {
+            if (update instanceof types.UpdateNewMessage) {
+                return constructMessage(update.message[as](types.Message), updates.users, updates.chats);
+            }
+            else if (update instanceof types.UpdateNewChannelMessage) {
+                return constructMessage(update.message[as](types.Message), updates.users, updates.chats);
+            }
+        }
+        UNREACHABLE();
     }
 }

package/esm/client/client_abstract.d.ts

@@ -1,16 +1,16 @@
+import { MaybePromise } from "../utilities/0_types.js";
 import { Connection } from "../connection/connection.js";
 import { Transport } from "../transport/transport.js";
 import { DC } from "../transport/transport_provider.js";
-import { MaybePromise } from "../types.js";
 export declare abstract class ClientAbstract {
     protected transportProvider: import("../transport/transport_provider.js").TransportProvider;
     protected connection: Connection;
     protected transport: Transport;
     private _dcId;
-    protected connected: boolean;
     constructor(transportProvider?: import("../transport/transport_provider.js").TransportProvider);
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;
+    get connected(): boolean;
     connect(): Promise<void>;
     reconnect(dc?: DC): Promise<void>;
     disconnect(): Promise<void>;

package/esm/client/client_abstract.js

@@ -27,12 +27,6 @@ export class ClientAbstract {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "connected", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
         const { connection, transport, dcId } = transportProvider({ cdn: false });
         this.connection = connection;
         this.transport = transport;
@@ -48,11 +42,13 @@ export class ClientAbstract {
         this.transport = transport;
         this._dcId = dcId;
     }
+    get connected() {
+        return this.connection.connected;
+    }
     async connect() {
         await initTgCrypto();
         await this.connection.open();
         await this.transport.initialize();
-        this.connected = true;
     }
     async reconnect(dc) {
         await this.disconnect();
@@ -64,6 +60,5 @@ export class ClientAbstract {
     async disconnect() {
         await this.transport.deinitialize();
         await this.connection.close();
-        this.connected = false;
     }
 }

package/esm/client/client_plain.js

@@ -1,4 +1,4 @@
-import { assertEquals, assertInstanceOf, factorize, ige256Decrypt, ige256Encrypt } from "../deps.js";
+import { assertEquals, assertInstanceOf, debug, factorize, ige256Decrypt, ige256Encrypt } from "../deps.js";
 import { publicKeys } from "../constants.js";
 import { bigIntFromBuffer, getRandomBigInt, modExp } from "../utilities/0_bigint.js";
 import { bufferFromBigInt, concat } from "../utilities/0_buffer.js";
@@ -10,6 +10,7 @@ import { ClientDHInnerData, DHGenOK, PQInnerDataDC, ResPQ, ServerDHInnerData, Se
 import { ReqDHParams, ReqPQMulti, SetClientDHParams } from "../tl/3_functions.js";
 import { TLReader } from "../tl/3_tl_reader.js";
 import { ClientAbstract } from "./client_abstract.js";
+const d = debug("auth_key_creation");
 export class ClientPlain extends ClientAbstract {
     async invoke(function_) {
         await this.transport.send(packUnencryptedMessage(function_[serialize]()));
@@ -26,14 +27,14 @@ export class ClientPlain extends ClientAbstract {
     }
     async createAuthKey() {
         const nonce = getRandomBigInt(16, false, true);
-        // logger().debug("Auth key creation started");
+        d("auth key creation started");
         const resPq = await this.invoke(new ReqPQMulti({ nonce }));
         assertInstanceOf(resPq, ResPQ);
         assertEquals(resPq.nonce, nonce);
-        // logger().debug("Got res_pq");
+        d("got res_pq");
         const pq_ = bigIntFromBuffer(resPq.pq, false, false);
         const [p_, q_] = factorize(pq_);
-        // logger().debug("Factorized pq");
+        d("factorized pq");
         const p = bufferFromBigInt(p_, 4, false, false);
         const q = bufferFromBigInt(q_, 4, false, false);
         let publicKeyFingerprint;
@@ -71,7 +72,7 @@ export class ClientPlain extends ClientAbstract {
             encryptedData,
         }));
         assertInstanceOf(dhParams, ServerDHParamsOK);
-        // logger().debug("Got server_DH_params_ok");
+        d("got server_DH_params_ok");
         const newNonce_ = bufferFromBigInt(newNonce, 32, true, true);
         const serverNonce_ = bufferFromBigInt(serverNonce, 16, true, true);
         const tmpAesKey = concat(await sha1(concat(newNonce_, serverNonce_)), (await sha1(concat(serverNonce_, newNonce_))).slice(0, 0 + 12));
@@ -97,12 +98,12 @@ export class ClientPlain extends ClientAbstract {
         encryptedData = ige256Encrypt(dataWithHash, tmpAesKey, tmpAesIv);
         const dhGenOk = await this.invoke(new SetClientDHParams({ nonce, serverNonce, encryptedData }));
         assertInstanceOf(dhGenOk, DHGenOK);
-        // logger().debug("Got dh_gen_ok");
+        d("got dh_gen_ok");
         const serverNonceSlice = serverNonce_.slice(0, 8);
         const salt = newNonce_.slice(0, 0 + 8).map((v, i) => v ^ serverNonceSlice[i]);
         const authKey_ = modExp(gA, b, dhPrime);
         const authKey = bufferFromBigInt(authKey_, 256, false, false);
-        // logger().debug("Auth key created");
+        d("auth key created");
         return {
             authKey,
             salt: bigIntFromBuffer(salt, true, false),

package/esm/connection/connection.d.ts

@@ -1,5 +1,6 @@
-import { MaybePromise } from "../types.js";
+import { MaybePromise } from "../utilities/0_types.js";
 export declare abstract class Connection {
+    abstract get connected(): boolean;
     abstract open(): MaybePromise<void>;
     abstract read(p: Uint8Array): MaybePromise<void>;
     abstract write(p: Uint8Array): MaybePromise<void>;

package/esm/connection/connection_web_socket.d.ts

@@ -6,6 +6,7 @@ export declare class ConnectionWebSocket implements Connection {
     private buffer;
     private nextResolve;
     constructor(url: string | URL);
+    get connected(): boolean;
     open(): Promise<void>;
     read(p: Uint8Array): Promise<void>;
     write(p: Uint8Array): Promise<void>;

package/esm/connection/connection_web_socket.js

@@ -46,6 +46,9 @@ export class ConnectionWebSocket {
         };
         this.webSocket.onerror = console.error;
     }
+    get connected() {
+        return this.webSocket.readyState == dntShim.WebSocket.OPEN;
+    }
     async open() {
         while (this.webSocket.readyState != dntShim.WebSocket.OPEN) {
             if (this.webSocket.readyState == dntShim.WebSocket.CLOSED) {

package/esm/deps/deno.land/std@0.69.0/fmt/colors.d.ts

@@ -0,0 +1,77 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare function setColorEnabled(value: boolean): void;
+export declare function getColorEnabled(): boolean;
+export declare function reset(str: string): string;
+export declare function bold(str: string): string;
+export declare function dim(str: string): string;
+export declare function italic(str: string): string;
+export declare function underline(str: string): string;
+export declare function inverse(str: string): string;
+export declare function hidden(str: string): string;
+export declare function strikethrough(str: string): string;
+export declare function black(str: string): string;
+export declare function red(str: string): string;
+export declare function green(str: string): string;
+export declare function yellow(str: string): string;
+export declare function blue(str: string): string;
+export declare function magenta(str: string): string;
+export declare function cyan(str: string): string;
+export declare function white(str: string): string;
+export declare function gray(str: string): string;
+export declare function brightBlack(str: string): string;
+export declare function brightRed(str: string): string;
+export declare function brightGreen(str: string): string;
+export declare function brightYellow(str: string): string;
+export declare function brightBlue(str: string): string;
+export declare function brightMagenta(str: string): string;
+export declare function brightCyan(str: string): string;
+export declare function brightWhite(str: string): string;
+export declare function bgBlack(str: string): string;
+export declare function bgRed(str: string): string;
+export declare function bgGreen(str: string): string;
+export declare function bgYellow(str: string): string;
+export declare function bgBlue(str: string): string;
+export declare function bgMagenta(str: string): string;
+export declare function bgCyan(str: string): string;
+export declare function bgWhite(str: string): string;
+export declare function bgBrightBlack(str: string): string;
+export declare function bgBrightRed(str: string): string;
+export declare function bgBrightGreen(str: string): string;
+export declare function bgBrightYellow(str: string): string;
+export declare function bgBrightBlue(str: string): string;
+export declare function bgBrightMagenta(str: string): string;
+export declare function bgBrightCyan(str: string): string;
+export declare function bgBrightWhite(str: string): string;
+/** Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit */
+export declare function rgb8(str: string, color: number): string;
+/** Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit */
+export declare function bgRgb8(str: string, color: number): string;
+/** Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ *      rgba24("foo", 0xff00ff);
+ *      rgba24("foo", {r: 255, g: 0, b: 255});
+ */
+export declare function rgb24(str: string, color: number | Rgb): string;
+/** Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ *      bgRgba24("foo", 0xff00ff);
+ *      bgRgba24("foo", {r: 255, g: 0, b: 255});
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+export declare function stripColor(string: string): string;
+export {};