@leemour/max-cli 0.14.0 → 0.16.0

package/dist/client.js

@@ -1,5 +1,5 @@
 import { CliError } from "@leemour/cli-core";
-import { namesFrom, SETTING_FLAGS, toChat, toContact, toFolder, toGroupCard, toGroupMember, toMessage, toProfile, toReactions, toSession, } from "./domain/map.js";
+import { namesFrom, POLL_CLOSED, pollSettings, SETTING_FLAGS, toChat, toContact, toFolder, toGroupCard, toGroupMember, toMessage, toPoll, 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
@@ -209,41 +210,18 @@ export class MaxClient {
          * come from the local copy.
          */
         adminIds: async (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 ids = [
-                asId(raw.owner),
-                ...(Array.isArray(raw.admins) ? raw.admins.map(asId) : []),
-                ...Object.keys(record(raw.adminParticipants) ?? {}),
-            ];
-            return [...new Set(ids.filter((id) => id !== undefined))];
+            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 }) => {
+        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 read = [];
-            let from = since;
-            let more = false;
-            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)
-                    break;
-                if (read.length >= EVENTS_READ) {
-                    more = true;
-                    break;
-                }
-                from = Date.parse(last.timestamp);
-            }
+            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 })));
@@ -270,6 +248,24 @@ export class MaxClient {
                 })),
             };
         },
+        /**
+         * 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)
@@ -367,7 +363,14 @@ export class MaxClient {
                     }
                     marker = next;
                 }
-                return { chatId, members: [...members.values()], complete };
+                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 }),
@@ -382,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",
@@ -791,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");
@@ -802,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 {
@@ -822,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() }),
@@ -992,6 +1002,160 @@ export class MaxClient {
             }
         },
     };
+    /**
+     * **Polls: vote, take a vote back, close one's own, create one.** Every one of them is a write
+     * somebody else can see, so it passes the send guard and the journal under the kind of what it is:
+     * a vote is a `reaction`, closing is an `edit` of the owner's message, a new poll is a `message`.
+     * A vote is never retried — nothing measured makes a blind repeat safe.
+     *
+     * The shapes were measured in Saved messages on 2026-09-27 (`pnpm probe:polls`, `FIND-247`). The
+     * checks before sending are the web client's, so what it would refuse never reaches MAX.
+     */
+    polls = {
+        vote: async (chatId, messageId, answerIds) => {
+            if (this.#offline)
+                throw new CliError("validation_error", "`--offline` reads what was recorded; it cannot vote");
+            this.#guard({ chatId, kind: "reaction" }, messageId);
+            try {
+                await this.#connectOnce();
+                const { attach, poll } = await this.#poll(chatId, messageId);
+                const voted = poll.answers.some((answer) => answer.mine);
+                if (answerIds.length === 0 && !voted) {
+                    throw new CliError("validation_error", `you have not voted in the poll of message ${messageId}`);
+                }
+                if (answerIds.length === 0 && !poll.revote) {
+                    throw new CliError("validation_error", `the poll of message ${messageId} does not let a vote be taken back`);
+                }
+                if (answerIds.length > 0 && voted && !poll.revote) {
+                    throw new CliError("validation_error", `you have voted in the poll of message ${messageId}, and it does not let a vote change`);
+                }
+                if (answerIds.length > 1 && !poll.multiple) {
+                    throw new CliError("validation_error", `the poll of message ${messageId} takes one answer, not ${answerIds.length}`);
+                }
+                const unknown = answerIds.find((id) => !poll.answers.some((answer) => answer.id === id));
+                if (unknown !== undefined) {
+                    throw new CliError("validation_error", `the poll of message ${messageId} has no answer ${unknown} — its answers are ${poll.answers.map((answer) => answer.id).join(", ")}`);
+                }
+                const answer = await this.#wire.messages.pollVote({
+                    chatId,
+                    messageId,
+                    pollId: poll.id,
+                    answersIds: answerIds.map(Number),
+                });
+                this.#cache?.messages.invalidate(chatId);
+                this.#sends?.record({ chatId, kind: "reaction", outcome: "sent", messageId });
+                const state = record(answer.state);
+                return { chatId, messageId, poll: (state && toPoll({ ...attach, state })) ?? poll };
+            }
+            catch (error) {
+                this.#sends?.record({
+                    chatId,
+                    kind: "reaction",
+                    outcome: "failed",
+                    messageId,
+                    errorCode: asCliError(error).code,
+                });
+                throw error;
+            }
+        },
+        /** Closes the owner's own poll: the web client edits the message with the `closed` bit raised. */
+        close: async (chatId, messageId) => {
+            if (this.#offline)
+                throw new CliError("validation_error", "`--offline` reads what was recorded; it cannot close a poll");
+            this.#guard({ chatId, kind: "edit" }, messageId);
+            try {
+                await this.#connectOnce();
+                const { attach, poll, outgoing } = await this.#poll(chatId, messageId);
+                if (!outgoing)
+                    throw new CliError("validation_error", `the poll of message ${messageId} is not yours to close`);
+                // What the web client sends back: the answers' text only, no ids and no votes.
+                const closed = {
+                    _type: "POLL",
+                    pollId: attach.pollId,
+                    title: attach.title,
+                    answers: asArray(attach.answers).map((each) => ({ text: each.text })),
+                    settings: (typeof attach.settings === "number" ? attach.settings : 0) | POLL_CLOSED,
+                };
+                const answer = await this.#wire.messages.edit({ chatId, messageId, attachments: [closed] });
+                this.#cache?.messages.invalidate(chatId);
+                this.#sends?.record({ chatId, kind: "edit", outcome: "sent", messageId });
+                const after = asArray(record(answer.message)?.attaches).find((each) => each._type === "POLL");
+                return { chatId, messageId, poll: (after && toPoll(after)) ?? { ...poll, closed: true } };
+            }
+            catch (error) {
+                this.#sends?.record({ chatId, kind: "edit", outcome: "failed", messageId, errorCode: asCliError(error).code });
+                throw error;
+            }
+        },
+        /**
+         * A new message whose one attachment is the poll — so it goes through `#deliver`, with its `cid`
+         * and its one retry, like any message.
+         */
+        create: async (chatId, question, answers, options = {}) => {
+            if (this.#offline)
+                throw new CliError("validation_error", "`--offline` reads what was recorded; it cannot create a poll");
+            if (question.trim() === "")
+                throw new CliError("validation_error", "a poll needs a question");
+            if (answers.length < 2 || answers.some((answer) => answer.trim() === "")) {
+                throw new CliError("validation_error", "a poll needs at least two answers, none of them empty");
+            }
+            try {
+                this.#sends?.check({ chatId, kind: "message", ...(options.cid === undefined ? {} : { cid: options.cid }) });
+            }
+            catch (error) {
+                this.#sends?.record({ chatId, kind: "message", outcome: "refused", errorCode: asCliError(error).code });
+                throw error;
+            }
+            const cid = options.cid ?? this.#nextCid();
+            const attach = {
+                _type: "POLL",
+                title: question,
+                answers: answers.map((text) => ({ text })),
+                settings: pollSettings(options),
+            };
+            try {
+                const sent = await this.#deliver(chatId, "", cid, {
+                    ...options,
+                    attaches: [attach],
+                    repeat: `max polls create ${chatId} …`,
+                });
+                this.#sends?.record({
+                    chatId,
+                    kind: "message",
+                    outcome: "sent",
+                    messageId: sent.id,
+                    cid,
+                    length: question.length,
+                });
+                return sent;
+            }
+            catch (error) {
+                const failure = asCliError(error);
+                this.#sends?.record({
+                    chatId,
+                    kind: "message",
+                    outcome: failure.code === "outcome_unknown" ? "outcome_unknown" : "failed",
+                    cid,
+                    errorCode: failure.code,
+                });
+                throw error;
+            }
+        },
+    };
+    /** The poll of one message, whole as MAX sends it and read, or a refusal that says why there is none. */
+    async #poll(chatId, messageId) {
+        const raw = await this.#rawMessage(chatId, messageId);
+        const attach = asArray(raw.attaches).find((each) => each._type === "POLL");
+        if (!attach)
+            throw new CliError("validation_error", `message ${messageId} carries no poll`);
+        const poll = toPoll(attach);
+        if (!poll)
+            throw new CliError("validation_error", `the poll of message ${messageId} is a newer kind this version cannot read`);
+        if (poll.closed)
+            throw new CliError("validation_error", `the poll of message ${messageId} is closed`);
+        const lookup = { names: namesFrom(this.#session().contacts), ...viewer(this.#store) };
+        return { attach, poll, outgoing: toMessage(raw, chatId, lookup).outgoing === true };
+    }
     folders = {
         list: async () => (await this.#folders()).map(toFolder),
         create: (title, chats = []) => this.#change("folder-create", async () => {
@@ -1208,7 +1372,7 @@ export class MaxClient {
     async #deliver(chatId, text, cid, options) {
         await this.#connectOnce();
         const session = this.#session();
-        const attaches = [];
+        const attaches = [...(options.attaches ?? [])];
         for (const file of options.files ?? [])
             attaches.push(await this.#upload(file));
         const { text: plain, markup } = options.markdown ? parseMarkdown(text) : { text, markup: [] };
@@ -1703,6 +1867,20 @@ export class MaxClient {
             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();
@@ -1832,14 +2010,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");
@@ -2161,6 +2350,8 @@ 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) => {