@leemour/max-cli 0.13.0 → 0.15.0

package/dist/client.js

@@ -1,5 +1,5 @@
 import { CliError } from "@leemour/cli-core";
-import { namesFrom, SETTING_FLAGS, toChat, toContact, toFolder, toGroupCard, toMessage, toProfile, toReactions, toSession, } from "./domain/map.js";
+import { namesFrom, SETTING_FLAGS, toChat, toContact, toFolder, toGroupCard, toGroupMember, toMessage, toProfile, toReactions, toSession, } from "./domain/map.js";
 import { heldWindows } from "./export.js";
 import { wireClient } from "./generated/client.generated.js";
 import { parseMarkdown } from "./markdown.js";
@@ -14,7 +14,8 @@ import { loginPausedUntil, withLoginRefused, withoutLoginPause, } from "./sessio
 import { WEB_USER_AGENT } from "./spec/identity.js";
 import { buildRequest, checkResponse } from "./spec/index.js";
 import { ASSET_TYPES } from "./spec/operations/assets.js";
-import { isImage, readUpload, uploadFile, uploadPhoto } from "./upload.js";
+import { isImage, isVideo, readUpload, uploadFile, uploadMedia, uploadPhoto } from "./upload.js";
+import { voiceOf } from "./voice.js";
 /**
  * **The only thing above this line that knows MAX exists.** Commands speak the domain model; the
  * opcodes and the frames stop here, so a different transport underneath changes this file and
@@ -202,6 +203,69 @@ export class MaxClient {
             const raw = asArray(this.#session().chats).find((chat) => asId(chat.id) === chatId);
             return raw ? this.#partnerOf(raw) : undefined;
         },
+        /**
+         * The owner and admins of a group, from the chat as the login carried it (`owner`, `admins`,
+         * `adminParticipants` — measured 2026-09-24, `FIND-116`). `undefined` when the login did not
+         * carry this chat or its admins: the login carries only chats that changed lately, and the rest
+         * come from the local copy.
+         */
+        adminIds: async (chatId) => {
+            const roles = await this.#roles(chatId);
+            return roles && [...new Set([...(roles.owner ? [roles.owner] : []), ...roles.admins])];
+        },
+        /**
+         * Who joined, left, was added or removed since a point: the service messages in the chat's
+         * history, read forward from `since` without reactions. At most `EVENTS_READ` messages, the oldest.
+         */
+        events: async (reference, { since = Date.now() - EVENTS_DAYS * 86_400_000 } = {}) => {
+            if (this.#offline)
+                throw new CliError("validation_error", "`--offline` has no history to read events from");
+            const chatId = await this.chats.resolve(reference);
+            const { messages: read, more } = await this.chats.since(chatId, since);
+            const found = read.flatMap((message) => message.attachments
+                .filter((attachment) => attachment.kind === "control" && attachment.event !== undefined)
+                .map((attachment) => ({ message, attachment })));
+            const contacts = namesFrom(this.#session().contacts);
+            const ids = [
+                ...new Set([
+                    ...found.flatMap(({ attachment }) => attachment.userIds ?? []),
+                    ...found.flatMap(({ message }) => message.senderName === null && message.senderId ? [message.senderId] : []),
+                ]),
+            ];
+            const names = await this.#namesOf(ids.filter((id) => !contacts.has(id)));
+            const nameOf = (id) => contacts.get(id) ?? names.get(id) ?? null;
+            return {
+                chatId,
+                since: new Date(since).toISOString(),
+                more,
+                events: found.map(({ message, attachment }) => ({
+                    messageId: message.id,
+                    timestamp: message.timestamp,
+                    event: attachment.event ?? "",
+                    by: { id: message.senderId, name: message.senderName ?? (message.senderId && nameOf(message.senderId)) },
+                    people: (attachment.userIds ?? []).map((id) => ({ id, name: nameOf(id) })),
+                    ...(attachment.title ? { title: attachment.title } : {}),
+                })),
+            };
+        },
+        /**
+         * A chat's history after `since`, oldest first and without reactions, at most `EVENTS_READ`
+         * messages; `more` when there was more than that.
+         */
+        since: async (chatId, since) => {
+            const read = [];
+            let from = since;
+            while (true) {
+                const page = (await this.#history(chatId, { from, backward: 0, forward: REVIEW_PAGE + 1 }, { reactions: false })).filter((message) => Date.parse(message.timestamp) > from);
+                read.push(...page);
+                const last = page.at(-1);
+                if (page.length < REVIEW_PAGE || !last)
+                    return { messages: read, more: false };
+                if (read.length >= EVENTS_READ)
+                    return { messages: read, more: true };
+                from = Date.parse(last.timestamp);
+            }
+        },
         /** What a link leads to, without joining it. */
         inspect: async (link) => {
             if (this.#offline)
@@ -271,6 +335,43 @@ export class MaxClient {
             }, userIds);
         },
         members: {
+            /**
+             * Everyone in a group or channel, from MAX, page by page. Paging follows PyMax: each answer's
+             * `marker` asks for the next page, and none means the last. Stops at `MEMBERS_READ`, or when a
+             * page repeats its marker or brings nobody new, so a misread marker cannot loop.
+             */
+            list: async (reference) => {
+                if (this.#offline)
+                    throw new CliError("validation_error", "`--offline` has no member list; MAX has");
+                const chatId = await this.chats.resolve(reference);
+                await this.#connectOnce();
+                const members = new Map();
+                let marker = 0;
+                let complete = false;
+                while (members.size < MEMBERS_READ) {
+                    const answer = await this.#wire.chats.members({ chatId, type: "MEMBER", marker, count: MEMBERS_PAGE });
+                    const before = members.size;
+                    for (const raw of asArray(answer.members)) {
+                        const member = toGroupMember(raw);
+                        if (member.id)
+                            members.set(member.id, member);
+                    }
+                    const next = typeof answer.marker === "number" ? answer.marker : 0;
+                    if (!next || next === marker || members.size === before) {
+                        complete = !next;
+                        break;
+                    }
+                    marker = next;
+                }
+                const roles = await this.#roles(chatId);
+                const role = (id) => (id === roles?.owner ? "owner" : roles?.admins.has(id) ? "admin" : "member");
+                return {
+                    chatId,
+                    members: [...members.values()].map((member) => (roles ? { ...member, role: role(member.id) } : member)),
+                    complete,
+                    rolesKnown: roles !== undefined,
+                };
+            },
             /** No history unless asked (`NEED-272`): what was said before somebody joined is not theirs by default. */
             add: (reference, people, { history = false } = {}) => this.#updateMembers(reference, people, "members.add", { operation: "add", showHistory: history }),
             remove: (reference, people) => this.#updateMembers(reference, people, "members.remove", { operation: "remove", cleanMsgPeriod: 0 }),
@@ -284,13 +385,14 @@ export class MaxClient {
             remove: (reference, person) => this.#updateMembers(reference, [person], "admins.remove", { operation: "remove", type: "ADMIN" }),
         },
         requests: {
+            /** Each with the age of their account, read like a member's — the answer's `{contact}` is the same shape. */
             list: async (reference) => {
                 if (this.#offline)
                     throw new CliError("validation_error", "`--offline` reads what was recorded; join requests never are");
                 const chatId = await this.chats.resolve(reference);
                 await this.#connectOnce();
                 const answer = await this.#wire.chats.members({ chatId, type: "JOIN_REQUEST", count: JOIN_REQUESTS });
-                return asArray(answer.members).map((member) => toContact(record(member.contact) ?? {}));
+                return asArray(answer.members).map(toGroupMember);
             },
             accept: (reference, people) => this.#updateMembers(reference, people, "requests.accept", {
                 operation: "add",
@@ -693,6 +795,10 @@ export class MaxClient {
         send: async (chatId, text, options = {}) => {
             if (this.#offline)
                 throw new CliError("validation_error", "`--offline` reads what was recorded; it cannot send");
+            if (options.voice !== undefined && (text !== "" || (options.files ?? []).length > 0)) {
+                // MAX kept a caption beside a voice message (measured 2026-09-27), but web.max.ru never sends one; §34.
+                throw new CliError("validation_error", "a voice message goes alone — no text and no --file beside it");
+            }
             if (options.at !== undefined && options.notify === false) {
                 // The web client always sends a scheduled message with `notify: true`; §34.
                 throw new CliError("validation_error", "a scheduled message cannot be silent — MAX's own client never sends one");
@@ -704,11 +810,16 @@ export class MaxClient {
             const files = await Promise.all((options.files ?? []).map(async (path) => ({
                 path,
                 bytes: await readUpload(path, { anyFile: options.anyFile === true }),
-                photo: isImage(path),
+                kind: isImage(path) ? "photo" : isVideo(path) && options.asFile !== true ? "video" : "file",
             })));
+            if (options.voice !== undefined) {
+                const bytes = await readUpload(options.voice, { anyFile: options.anyFile === true });
+                files.push({ path: options.voice, bytes, kind: "voice", voice: await voiceOf(options.voice, bytes) });
+            }
             // Measured 2026-09-24: photos share a message, but a file with anything beside it is refused `proto.payload`.
-            if (files.some((file) => !file.photo) && files.length > 1) {
-                throw new CliError("validation_error", "a file goes in a message of its own — photos can share one; send them apart");
+            // A video is kept alone the same way; a mixed message was never measured.
+            if (files.some((file) => file.kind !== "photo") && files.length > 1) {
+                throw new CliError("validation_error", "a file or a video goes in a message of its own — photos can share one; send them apart");
             }
             // Before connecting: a refused send never opens a socket when the chat was given as an id.
             try {
@@ -724,10 +835,7 @@ export class MaxClient {
                 throw error;
             }
             const cid = options.cid ?? this.#nextCid();
-            const attachments = files.map(({ bytes, photo }) => ({
-                kind: photo ? "photo" : "file",
-                bytes: bytes.length,
-            }));
+            const attachments = files.map(({ bytes, kind }) => ({ kind, bytes: bytes.length }));
             const summary = {
                 ...(attachments.length > 0 ? { attachments } : {}),
                 ...(options.at === undefined ? {} : { scheduledFor: new Date(options.at).toISOString() }),
@@ -1003,8 +1111,9 @@ export class MaxClient {
          * forward from `since`; a chat with more than `REVIEW_PER_CHAT` in the window is cut short and
          * says so.
          */
-        review: async ({ since }) => {
-            const { chats, changed, cut } = await this.#changedSince(since);
+        review: async ({ since, chatId, }) => {
+            const { chats, changed: all, cut } = await this.#changedSince(since);
+            const changed = chatId === undefined ? all : all.filter((chat) => chat.id === chatId);
             const { read, skipped } = capped(changed, REVIEW_CHATS);
             const found = [];
             for (const { id, title, kind } of read) {
@@ -1594,6 +1703,32 @@ export class MaxClient {
         const ids = [...new Set([...messages, ...quoted].filter(needsName).map((message) => message.senderId))];
         if (ids.length === 0)
             return messages;
+        const names = await this.#namesOf(ids);
+        const name = (message) => needsName(message) && names.has(message.senderId)
+            ? { ...message, senderName: names.get(message.senderId) ?? null }
+            : message;
+        return messages.map((message) => ({
+            ...name(message),
+            replyTo: message.replyTo && name(message.replyTo),
+            forwardedFrom: message.forwardedFrom && name(message.forwardedFrom),
+        }));
+    }
+    /** The chat's owner and admins as the login carried them; `undefined` when it did not. */
+    async #roles(chatId) {
+        await this.#connectOnce();
+        const raw = asArray(this.#session().chats).find((chat) => asId(chat.id) === chatId);
+        if (!raw || (raw.owner === undefined && raw.admins === undefined && raw.adminParticipants === undefined)) {
+            return undefined;
+        }
+        const admins = [
+            ...(Array.isArray(raw.admins) ? raw.admins.map(asId) : []),
+            ...Object.keys(record(raw.adminParticipants) ?? {}),
+        ].filter((id) => id !== undefined);
+        const owner = asId(raw.owner);
+        return { ...(owner ? { owner } : {}), admins: new Set(admins.filter((id) => id !== owner)) };
+    }
+    /** Names we hold first, the rest from `CONTACT_INFO`, kept for next time. A refusal costs the names only. */
+    async #namesOf(ids) {
         const names = this.#cache?.people.names(ids) ?? new Map();
         const fetched = [];
         try {
@@ -1609,18 +1744,11 @@ export class MaxClient {
             }
         }
         catch (error) {
-            this.#warnAbout("names_unread", `some senders are shown by id: their names could not be looked up (${reasonOf(error)})`);
+            this.#warnAbout("names_unread", `some people are shown by id: their names could not be looked up (${reasonOf(error)})`);
         }
         if (fetched.length > 0)
             this.#cache?.people.upsert(fetched, "info");
-        const name = (message) => needsName(message) && names.has(message.senderId)
-            ? { ...message, senderName: names.get(message.senderId) ?? null }
-            : message;
-        return messages.map((message) => ({
-            ...name(message),
-            replyTo: message.replyTo && name(message.replyTo),
-            forwardedFrom: message.forwardedFrom && name(message.forwardedFrom),
-        }));
+        return names;
     }
     /** INIT with the profile's own device, which is the device MAX then issues the token to (bite 8). */
     async #beforeLogin(flow) {
@@ -1728,14 +1856,25 @@ export class MaxClient {
      * Uploads one file and answers what the message attaches (measured 2026-09-24). An upload is never
      * retried: a failure here happens before `MSG_SEND`, so nothing was sent.
      */
-    async #upload({ path, bytes, photo }) {
+    async #upload({ path, bytes, kind, voice }) {
         const request = { count: 1, type: 0, uploaderType: 0, profile: false };
-        if (photo) {
+        if (kind === "photo") {
             const { url } = await this.#wire.uploads.photo(request);
             if (typeof url !== "string")
                 throw new CliError("provider_error", "MAX gave no address to upload the photo to");
             return { _type: "PHOTO", photoToken: await uploadPhoto(url, path, bytes) };
         }
+        if (kind === "video" || kind === "voice") {
+            const slot = voice ? { ...request, type: 2, uploaderType: 1 } : request;
+            const info = record(asArray((await this.#wire.uploads.video(slot)).info)[0]) ?? {};
+            if (typeof info.url !== "string" || info.videoId === undefined) {
+                throw new CliError("provider_error", `MAX gave no address to upload the ${kind} to`);
+            }
+            await uploadMedia(voice ? "voice message" : "video", info.url, path, bytes);
+            return voice
+                ? { _type: "AUDIO", audioId: info.videoId, duration: voice.durationMs, wave: voice.wave, token: info.token }
+                : { _type: "VIDEO", videoId: info.videoId, token: info.token, videoType: 0 };
+        }
         const info = record(asArray((await this.#wire.uploads.file(request)).info)[0]) ?? {};
         if (typeof info.url !== "string" || info.fileId === undefined) {
             throw new CliError("provider_error", "MAX gave no address to upload the file to");
@@ -1987,6 +2126,9 @@ export const ADMIN_RIGHTS = {
 /** The most chats `max serve` holds from pushes before it logs in again instead. */
 const LIVE_CHATS = 10_000;
 const JOIN_REQUESTS = 100;
+/** PyMax's page, the one measured. */
+const MEMBERS_PAGE = 50;
+const MEMBERS_READ = 5000;
 /**
  * A private link goes as `join/<token>`, whatever came before it, as PyMax sends it and as
  * measured. A public one (`https://max.ru/<name>`) goes whole, which is PyMax's claim only.
@@ -2053,6 +2195,9 @@ const INBOX_CHATS = 20;
 const REVIEW_CHATS = 50;
 const REVIEW_PAGE = 100;
 const REVIEW_PER_CHAT = 500;
+const EVENTS_READ = 2000;
+/** How far back `chats events` looks without `since`. */
+export const EVENTS_DAYS = 7;
 export const FIRST_TAB_SYNC = { folders: 0, calls: 0, assets: {} };
 const numberOr = (value, fallback) => (typeof value === "number" ? value : fallback);
 const eventTime = (chat) => {